import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid } from '../../lib/data';
import { loginAsAdmin, selectWorkspaceProject } from '../../lib/ui';
import { CATALOG_URL, openNode, catalogFrame, deployToVm, appStatus, vmTarget } from '../../lib/iv5';

// IV5_S01 : SW Catalogs: Infra에 SW 설치 [정상, CSP별]
// Applications > SW Catalogs(iframe) → Deploy → Application Installation 모달(VM / mc{n} / g{n}-1 / SW) → Deploy
// 선행: IV3 Infra mc{n} 의 g{n}-1 Running. 같은 VM 에 IV5_S03(Nginx)도 설치하므로 여기서는 Apache HTTP Server(포트 8081)를 쓴다.
const APP = 'Apache HTTP Server';
const PORT = '8081';

for (const c of activeCsps()) {
  test(`${tid('IV5_S01', c)} SW Catalogs: Infra에 SW 설치`, async ({ page, dialogs }) => {
    await loginAsAdmin(page);
    // 선행 확인: 대상 node Running
    const st = await openNode(page, c);
    expect(st, '선행조건: 대상 node Running').toMatch(/Running/i);

    await page.goto(CATALOG_URL);
    await selectWorkspaceProject(page, 'ws01', 'default', true);
    const f = await catalogFrame(page);
    const r = await deployToVm(page, f, c, { app: APP, port: PORT });

    // 기대결과: 설치 요청 접수(오류 알럿/문구 없음)
    const errs = [...dialogs, ...r.msgs, r.after].filter((s) => /error|fail|invalid|오류|실패/i.test(s));
    expect(errs, '설치 요청 오류 없음').toEqual([]);
    // 2026-10-05 첫 실행: 요청은 접수됐으나 App Status=Failed(SSH Docker 준비 실패, g1-1 Public IP 없음)인데 통과 처리됨 → 상태까지 판정
    const s = await appStatus(page, vmTarget(c), APP);
    expect(s, 'App Status 설치 완료(Failed 면 deployment-logs 어노테이션 참조)').toMatch(/^Running$/i);
  });
}

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, k8sName, k8sProject } from '../../lib/data';
import { loginAsAdmin, selectWorkspaceProject } from '../../lib/ui';
import { gotoK8s, clusterCells } from '../../lib/iv3-k8s';
import { CATALOG_URL, catalogFrame, deployToK8s, appStatus } from '../../lib/iv5';

// IV5_S02 : SW Catalogs: K8s에 SW/workload 배포 [정상, CSP별]
// Applications > SW Catalogs(iframe) → Deploy → Application Installation 모달 Target Infra=K8S(namespace=Project 고정, Cluster, Helm chart)
// → Nginx Helm chart, Port 80 → Spec Check → Deploy → Applications > App Status 에서 상태 확인
// 대상: 기본 k{n} / p{n}. Azure 는 사용자 지시(2026-10-06)로 IV3_S18 클러스터 k2e(NodeGroup g2e, p2). 환경변수 K8S_CLUSTER 로 덮어쓸 수 있음.
const APP = 'Nginx';
const PORT = '80';
const CLUSTER: Record<string, string> = { Azure: 'k2e' };

for (const c of activeCsps()) {
  test(`${tid('IV5_S02', c)} SW Catalogs: K8s에 SW/workload 배포`, async ({ page, dialogs }) => {
    const prj = process.env.K8S_PROJECT || k8sProject(c); // K8S_PROJECT 로 프로젝트 지정 가능(2026-10-13 NHN: default 의 기존 vNet 사용)
    const cluster = process.env.K8S_CLUSTER || CLUSTER[c.code] || k8sName(c);
    await loginAsAdmin(page, 'ws01', prj);

    // 선행 확인: 클러스터 Active
    await gotoK8s(page, prj);
    // 목록이 늦게 채워짐(2026-10-06: 진입 직후 읽으면 행 없음) → 행이 나올 때까지 대기
    let cells: Record<string, string> = {};
    await expect.poll(async () => (cells = await clusterCells(page, cluster)).status ?? '', { timeout: 60_000, intervals: [3000] }).not.toBe('');
    test.info().annotations.push({ type: 'cluster', description: `${prj}/${cluster}: status=${cells.status ?? '(목록에 없음)'} version=${cells.version ?? ''} nodegroup=${cells.nodegroup ?? ''}` });
    expect(cells.status, `선행조건: 클러스터 ${cluster} Active`).toMatch(/Active/i);

    await page.goto(CATALOG_URL);
    await selectWorkspaceProject(page, 'ws01', prj, true);
    const f = await catalogFrame(page, prj);
    const r = await deployToK8s(page, f, cluster, { app: APP, port: PORT });

    const errs = [...dialogs, ...r.msgs, r.after].filter((s) => /error|fail|invalid|오류|실패/i.test(s));
    expect(errs, '배포 요청 오류 없음').toEqual([]);
    // 기대결과: 배포 요청 접수 + App Status Running
    const s = await appStatus(page, { key: cluster, project: prj }, APP);
    expect(s, 'App Status 에 배포 SW 행 표시').not.toBe('');
    expect(s, 'App Status 배포 완료(Failed 면 deployment-logs 어노테이션 참조)').toMatch(/^Running$/i);
  });
}

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { openNode, installFromNode, appStatus, vmTarget } from '../../lib/iv5';

// IV5_S03 : Infra 상세 Install SW 버튼으로 SW 설치 [정상, CSP별]
// Infra Workloads > mc{n} > node g{n}-1 > Node Info 'Install SW' → "Install SW — Node [g{n} / g{n}-1]" 모달(대상 고정)
// → Nginx 선택 → Spec Check → Deploy → Applications > App Status 에서 상태 확인
const APP = 'Nginx';
const PORT = '8082';

for (const c of activeCsps()) {
  test(`${tid('IV5_S03', c)} Infra 상세 Install SW 버튼으로 SW 설치`, async ({ page, dialogs }) => {
    await loginAsAdmin(page);
    const st = await openNode(page, c);
    expect(st, '선행조건: 대상 node Running').toMatch(/Running/i);

    const r = await installFromNode(page, c, { app: APP, port: PORT });

    const errs = [...dialogs, ...r.msgs, r.after].filter((s) => /error|fail|invalid|오류|실패/i.test(s));
    expect(errs, '설치 요청 오류 없음').toEqual([]);
    // 기대결과: 진행/완료 상태 표시
    const s = await appStatus(page, vmTarget(c), APP);
    expect(s, 'App Status 에 설치 SW 행 표시').not.toBe('');
    expect(s, 'App Status 설치 완료(Failed 면 deployment-logs 어노테이션 참조)').toMatch(/^Running$/i);
  });
}

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { openNode, termRunLong } from '../../lib/iv5';
import { openNodeTerminal, termRun } from '../../lib/iv4-infra';

// IV5_S04 : Terminal 로 VM 접속·Docker 확인 (SW 설치 후) [정상, CSP별]
// Infra Workloads > mc{n} > node g{n}-1 > Node Info Public IP 옆 'Terminal' → Confirm → Remote Terminal(xterm)
// 1) 접속 확인: echo hello / whoami / hostname   2) Docker 확인: which docker / docker version 2>&1 / sudo docker version 2>&1
// 선행: IV5_S03 으로 SW 설치 완료(App Status Running) → Docker 가 준비되어 있어야 함.
// 2026-10-06 배경: Public IP 가 Tumblebug 에 없을 때 Terminal 명령 출력이 비어 있었고 SW 설치도 실패했다(설치 전 docker: command not found 는 정상).
for (const c of activeCsps()) {
  test(`${tid('IV5_S04', c)} Terminal 로 VM 접속·Docker 확인`, async ({ page }) => {
    await loginAsAdmin(page);
    const st = await openNode(page, c);
    expect(st, '선행조건: 대상 node Running').toMatch(/Running/i);
    await openNodeTerminal(page);

    // 1) 접속 확인 — 출력이 비어 있으면 원격 명령 경로(SSH/Public IP) 문제
    expect(await termRun(page, 'echo hello'), 'echo 출력').toContain('hello');
    const who = await termRun(page, 'whoami');
    expect(who, 'whoami 출력').not.toBe('');
    expect(await termRun(page, 'hostname'), 'hostname 출력').not.toBe('');

    // 2) Docker 확인 — 오류 출력도 보이도록 2>&1
    const which = await termRun(page, 'which docker');
    expect(which, 'docker 설치 경로(IV5_S03 설치로 준비됨)').toMatch(/\/docker\b/);
    // 출력이 길어 termRunLong 사용(앞부분은 화면 밖으로 밀릴 수 있어 끝부분 Server 섹션으로 판정)
    const plain = await termRunLong(page, 'docker version 2>&1');
    // sudo 없이: docker 그룹이 아니면 permission denied 가 날 수 있음 → 판정에 쓰지 않고 기록만
    test.info().annotations.push({ type: 'docker-no-sudo', description: /permission denied/i.test(plain) ? `권한 오류(${who} 가 docker 그룹 아님)` : /Server/.test(plain) ? 'Server 응답' : '기타(terminal 어노테이션 참조)' });
    const sudo = await termRunLong(page, 'sudo docker version 2>&1');
    expect(sudo, 'sudo docker version: Server(데몬 응답)').toMatch(/Server/);
    expect(sudo, 'sudo docker version: Engine 버전').toMatch(/Version:\s*\d+\.\d+/);
  });
}

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { openNode, appStatus, vmTarget, termRunLong, appAction } from '../../lib/iv5';
import { openNodeTerminal } from '../../lib/iv4-infra';

// IV5_S05 : [Infra] 설치된 SW 호출 확인 — Apache(8081)·Nginx(8082) HTTP 응답 [정상, CSP별]  (사용자 지시 2026-10-07)
// 대상: Infra node (K8s 아님). 선행: IV5_S01(Apache 8081)·IV5_S03(Nginx 8082) 설치, 대상 node Running (Suspend 상태면 Resume 후)
// 화면: Infra Workloads > mc{n} > node g{n}-1 > Node Info Terminal(Remote Terminal) + Applications > App Status
// 절차: 1.node Running 확인 2.App Status 에서 두 SW 상태 확인(기록) 3.Terminal 에서 curl http://localhost:{port}/ → HTTP 200 + 기본 페이지 본문 4.공인 IP:{port} 외부 호출 결과 기록
// 기대결과: Apache(8081)·Nginx(8082) 가 HTTP 200 과 기본 페이지 본문으로 응답
// 판정: HTTP 200 + 응답 헤더 Server 값. 본문은 Nginx 만 기본 페이지 문구로 확인(Apache 컨테이너의 기본 응답은 'It works!' 가 아니라 HTML 4.01 형식 페이지였음, 2026-10-07 → 본문 앞부분은 기록만)
const APPS = [
  { name: 'Apache HTTP Server', port: '8081', server: /Server:\s*Apache/i, sign: null as RegExp | null },
  { name: 'Nginx', port: '8082', server: /Server:\s*nginx/i, sign: /Welcome to nginx/i },
];

for (const c of activeCsps()) {
  test(`${tid('IV5_S05', c)} [Infra] 설치된 SW 호출 확인: Apache(8081)·Nginx(8082) HTTP 응답`, async ({ page, request }) => {
    test.setTimeout(30 * 60_000);
    test.info().annotations.push({ type: 'target', description: 'Infra node (K8s 아님): mc/g-1 의 Docker 컨테이너 SW' });
    await loginAsAdmin(page);
    const st = await openNode(page, c);
    expect(st, '선행조건: 대상 node Running').toMatch(/Running/i);
    const pip = (await page.getByText('Public IP(IPv4)', { exact: true }).locator('xpath=following-sibling::*[1]').first().innerText().catch(() => '')).trim();

    // 2. App Status 상태 기록. VM 을 Suspend→Resume 하면 Docker 컨테이너가 다시 올라오지 않아 Stopped(Resume 직후에는 Error)로 보인다(2026-10-07 AWS 관찰).
    //    Stopped 이면 App Status 의 'Start' 로 기동한 뒤 호출한다.
    const statuses: Record<string, string> = {};
    for (const a of APPS) {
      statuses[a.name] = await appStatus(page, vmTarget(c), a.name, 3 * 60_000);
      if (/stopped/i.test(statuses[a.name])) {
        await appAction(page, vmTarget(c), a.name, 'Start');
        statuses[a.name] += ` → Start → ${await appStatus(page, vmTarget(c), a.name, 5 * 60_000)}`;
      }
    }
    test.info().annotations.push({ type: 'app-status-summary', description: JSON.stringify(statuses) });

    // 3. Terminal 에서 호출(localhost)
    await openNode(page, c);
    await openNodeTerminal(page);
    const dock = await termRunLong(page, 'sudo docker ps --format "{{.Names}} {{.Status}} {{.Ports}}"');
    test.info().annotations.push({ type: 'docker-ps', description: dock.replace(/\s+/g, ' ').slice(0, 300) });
    const results: string[] = [];
    for (const a of APPS) {
      const code = await termRunLong(page, `curl -s -o /dev/null -w "HTTP_%{http_code}" -m 5 http://localhost:${a.port}/`);
      const hdr = await termRunLong(page, `curl -sI -m 5 http://localhost:${a.port}/ | grep -i "^server"`);
      const body = await termRunLong(page, `curl -s -m 5 http://localhost:${a.port}/ | head -c 100`);
      results.push(`${a.name}(:${a.port}) code=${code.replace(/\s+/g, ' ').slice(-12)} ${hdr.replace(/\s+/g, ' ').slice(-30)} body=${body.replace(/\s+/g, ' ').slice(0, 70)}`);
      expect.soft(code, `${a.name} localhost:${a.port} HTTP 200`).toContain('HTTP_200');
      expect.soft(hdr, `${a.name} 응답 헤더 Server`).toMatch(a.server);
      if (a.sign) expect.soft(body, `${a.name} 본문`).toMatch(a.sign);
    }
    test.info().annotations.push({ type: 'localhost-call', description: results.join(' | ') });

    // 4. 외부 호출(공인 IP) — 보안그룹 등으로 차단될 수 있어 기록만
    const ext: string[] = [];
    for (const a of APPS) {
      try {
        const r = await request.get(`http://${pip}:${a.port}/`, { timeout: 10_000, failOnStatusCode: false });
        ext.push(`${a.name}(:${a.port}) ${r.status()} ${(await r.text()).replace(/\s+/g, ' ').slice(0, 50)}`);
      } catch (e) {
        ext.push(`${a.name}(:${a.port}) 외부 호출 불가(${String(e).split('\n')[0].slice(0, 60)})`);
      }
    }
    test.info().annotations.push({ type: 'external-call', description: `${pip}: ${ext.join(' | ')}` });
  });
}

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, k8sName, k8sProject } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { appStatus } from '../../lib/iv5';

// IV5_S06 : [K8s] 설치된 Nginx(Helm) 동작 확인 — 상태·Health Check·Pod [정상, CSP별]  (사용자 지시 2026-10-07)
// 대상: K8s cluster (Infra 아님). 선행: IV5_S02(Nginx Helm 배포) 완료, K8s Active (Project p{n})
// 화면: Applications > App Status(Project p{n}) > K8S 행 선택 > Application Detail(Status, Health Check, Network & Service Information)
// 절차: 1.App Status 에서 K8S (p{n} / {cluster}) Nginx for Kubernetes Running 확인 2.행 선택 → Application Detail: Status Running, Health Check Healthy, Pod n/n running, Service Port 80
// 기대결과: Nginx(Helm) 가 Running / Healthy 이고 Pod 가 모두 running. PUBLIC IP 가 있으면 호출 확인(AWS 는 비어 있음 → 상태/Health 로 확인)
// 대상 클러스터: 기본 k{n}, K8S_CLUSTER 로 변경(v07 AWS: k1d)
const APP = 'Nginx for Kubernetes';

for (const c of activeCsps()) {
  test(`${tid('IV5_S06', c)} [K8s] 설치된 Nginx(Helm) 동작 확인: 상태·Health Check·Pod`, async ({ page, request }) => {
    const prj = process.env.K8S_PROJECT || k8sProject(c); // K8S_PROJECT 로 프로젝트 지정 가능(2026-10-13 NHN: default 의 기존 vNet 사용)
    const cluster = process.env.K8S_CLUSTER || k8sName(c);
    test.info().annotations.push({ type: 'target', description: `K8s cluster (Infra 아님): ${prj} / ${cluster}` });
    await loginAsAdmin(page, 'ws01', prj);
    const s = await appStatus(page, { key: cluster, project: prj }, APP, 3 * 60_000);
    expect(s, `App Status ${APP} Running`).toMatch(/^Running$/i);

    // 상세: 행(앱 이름) 클릭 → Application Detail
    const f = page.frames().find((x) => x.url().includes('/applications/status'))!;
    await f.getByText(APP, { exact: true }).first().click();
    await expect(f.getByText('Application Detail').first()).toBeVisible({ timeout: 30_000 });
    await page.waitForTimeout(3000);
    const body = (await f.locator('body').innerText()).replace(/\s+/g, ' ');
    const detail = body.slice(body.indexOf('Application Detail'), body.indexOf('Application Detail') + 1600);
    test.info().annotations.push({ type: 'app-detail', description: detail.slice(0, 700) });
    expect(detail, 'Status Running').toMatch(/Status:\s*Running/i);
    expect(detail, 'Health Check Healthy').toMatch(/Health Check:\s*Healthy/i);
    const pod = detail.match(/(\d+)\/(\d+) running/);
    test.info().annotations.push({ type: 'pods', description: pod ? pod[0] : '(Pod 정보 없음)' });
    expect(pod, 'Pod running 표시').not.toBeNull();
    expect(pod![1], 'Pod 모두 running').toBe(pod![2]);
    // PUBLIC IP 가 있으면 호출(없으면 기록만)
    const pubIp = detail.match(/PUBLIC IP[^0-9]{0,40}(\d+\.\d+\.\d+\.\d+)/)?.[1];
    if (pubIp) {
      const r = await request.get(`http://${pubIp}/`, { timeout: 10_000, failOnStatusCode: false }).catch((e) => e);
      test.info().annotations.push({ type: 'external-call', description: `${pubIp}: ${typeof r.status === 'function' ? r.status() : String(r).split('\n')[0].slice(0, 80)}` });
    } else {
      test.info().annotations.push({ type: 'external-call', description: '서비스 PUBLIC IP 없음 → 외부 호출 불가(상태/Health Check 로 확인)' });
    }
  });
}

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { openNode, appStatus, vmTarget, termRunLong, appAction, waitUninstalled } from '../../lib/iv5';
import { openNodeTerminal } from '../../lib/iv4-infra';

// IV5_S07 : [Infra] 설치 SW Uninstall → 삭제 확인: Apache(8081)·Nginx(8082) [정상, CSP별]  (사용자 지시 2026-10-07)
// 대상: Infra node (K8s 아님). 선행: IV5_S05 완료, 대상 node Running (Suspend 상태면 Resume 후)
// 절차: 1.App Status 에서 두 SW 가 Running 인지 확인(Stopped 면 Start) 2.각 SW 행 Uninstall → 확인 3.행 제거(또는 Uninstalled) 확인
//       4.Terminal: docker ps 에 해당 컨테이너 없음, curl localhost:{port} 연결 실패(HTTP_000)
// 기대결과: Uninstall 후 App Status 에서 제거되고 컨테이너/포트가 정리된다
const APPS = [
  { name: 'Apache HTTP Server', port: '8081', ctr: /apache/i },
  { name: 'Nginx', port: '8082', ctr: /nginx/i },
];

for (const c of activeCsps()) {
  test(`${tid('IV5_S07', c)} [Infra] 설치 SW Uninstall → 삭제 확인: Apache·Nginx`, async ({ page }) => {
    test.setTimeout(60 * 60_000);
    test.info().annotations.push({ type: 'target', description: 'Infra node (K8s 아님): mc/g-1 의 Docker 컨테이너 SW' });
    await loginAsAdmin(page);
    const st = await openNode(page, c);
    expect(st, '선행조건: 대상 node Running').toMatch(/Running/i);

    // 1. 사전 상태: Running 이 아니면(Resume 후 Stopped) Start
    for (const a of APPS) {
      let s = await appStatus(page, vmTarget(c), a.name, 3 * 60_000);
      if (/stopped/i.test(s)) { await appAction(page, vmTarget(c), a.name, 'Start'); s += ` → Start → ${await appStatus(page, vmTarget(c), a.name, 5 * 60_000)}`; }
      test.info().annotations.push({ type: 'pre-status', description: `${a.name}: ${s}` });
    }

    // 2~3. Uninstall → 제거 확인
    const progress: string[] = [];
    for (const a of APPS) {
      await appAction(page, vmTarget(c), a.name, 'Uninstall');
      const r = await waitUninstalled(page, vmTarget(c), a.name, 5 * 60_000);
      progress.push(`${a.name}: ${r.seen.join(' → ')}${r.done ? '' : ' (시간 내 제거 안 됨)'}`);
      expect.soft(r.done, `${a.name} App Status 에서 제거/Uninstalled`).toBe(true);
    }
    test.info().annotations.push({ type: 'uninstall-progress', description: progress.join(' | ') });

    // 4. Terminal 확인 (Resume 직후에는 bastion 공인 IP 갱신 지연으로 연결 실패할 수 있어 재시도)
    let first = '';
    for (let i = 0; i < 8; i++) {
      await openNode(page, c);
      try { first = await openNodeTerminal(page); } catch (e) { first = 'ERR ' + String(e).split('\n')[0].slice(0, 80); }
      if (!/Error|ERR/i.test(first)) break;
      test.info().annotations.push({ type: 'terminal-retry', description: `${i + 1}회차 실패: ${first.replace(/\s+/g, ' ').slice(0, 100)}` });
      await page.waitForTimeout(150_000);
    }
    expect(first, 'Terminal 접속').not.toMatch(/Error|ERR/i);
    const dock = (await termRunLong(page, 'sudo docker ps -a --format "{{.Names}} {{.Status}}"')).replace(/\s+/g, ' ');
    test.info().annotations.push({ type: 'docker-ps-a', description: dock.slice(-300) });
    const res: string[] = [];
    for (const a of APPS) {
      const code = (await termRunLong(page, `curl -s -o /dev/null -w "HTTP_%{http_code}" -m 5 http://localhost:${a.port}/`)).replace(/\s+/g, ' ');
      const tail = code.slice(-14);
      res.push(`${a.name}(:${a.port}) ${tail}`);
      expect.soft(code, `${a.name} 호출 실패(HTTP_000)`).toMatch(/HTTP_000\s*@@L\d+@@\s*$|HTTP_000/);
      expect.soft(code.endsWith('HTTP_200') || /HTTP_200@@L\d+@@\s*$/.test(code), `${a.name} 200 응답 아님`).toBe(false);
    }
    // docker ps -a 출력 끝부분만(명령 에코 제외) 보고 컨테이너 잔존 여부 확인
    const after = dock.split('@@')[1] ?? dock;
    for (const a of APPS) expect.soft(after, `${a.name} 컨테이너 잔존 없음`).not.toMatch(a.ctr);
    test.info().annotations.push({ type: 'curl-after', description: res.join(' | ') });
  });
}

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, k8sName, k8sProject } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { appStatus, appAction, waitUninstalled } from '../../lib/iv5';

// IV5_S08 : [K8s] Nginx(Helm) Uninstall → 삭제 확인 [정상, CSP별]  (사용자 지시 2026-10-07)
// 대상: K8s cluster (Infra 아님). 선행: IV5_S06 완료, K8s Active (Project p{n}). 대상 클러스터는 K8S_CLUSTER(v07 AWS: k1d)
// 절차: 1.App Status(Project p{n}) 에서 K8S 행 Nginx for Kubernetes Running 확인 2.Uninstall → 확인 3.행 제거(또는 Uninstalled) 확인
// 기대결과: Uninstall 후 App Status 에서 제거된다(Helm release/Pod 정리는 화면으로 직접 확인할 수 없어 행 제거로 판단 — 필요 시 별도 확인)
const APP = 'Nginx for Kubernetes';

for (const c of activeCsps()) {
  test(`${tid('IV5_S08', c)} [K8s] Nginx(Helm) Uninstall → 삭제 확인`, async ({ page }) => {
    test.setTimeout(30 * 60_000);
    const prj = process.env.K8S_PROJECT || k8sProject(c); // K8S_PROJECT 로 프로젝트 지정 가능(2026-10-13 NHN: default 의 기존 vNet 사용)
    const cluster = process.env.K8S_CLUSTER || k8sName(c);
    const t = { key: cluster, project: prj };
    test.info().annotations.push({ type: 'target', description: `K8s cluster (Infra 아님): ${prj} / ${cluster}` });
    await loginAsAdmin(page, 'ws01', prj);
    const s = await appStatus(page, t, APP, 3 * 60_000);
    expect(s, `선행조건: ${APP} Running`).toMatch(/^Running$/i);
    await appAction(page, t, APP, 'Uninstall');
    const r = await waitUninstalled(page, t, APP, 10 * 60_000);
    test.info().annotations.push({ type: 'uninstall-progress', description: `${APP}: ${r.seen.join(' → ')}${r.done ? '' : ' (시간 내 제거 안 됨)'}` });
    expect(r.done, 'App Status 에서 제거/Uninstalled').toBe(true);
  });
}

// IV5_S09: TC-APP-001 Repository 목록 조회 [정상, 공통]
// v0.6 TC-ID: TC-APP-REP-01 — 기존 spec(mcmp-e2e mc-web-console/specs/sw/TC-APP-REP-01-repository-목록-조회.spec.ts)은 절차만 참고(사용자 결정 2026-10-14: 동작 코드는 재사용하지 않음)
// 화면: Applications > Repository (iframe :18084/web/applications/repository)
// 시작 상태: admin(mcmp) 로그인, Workspace=ws01 / Project=default
// 절차: 1.Repository 메뉴 진입 2.목록 컬럼(Name/Format/URL/Type(hosted)/Action) 확인 3.등록된 Nexus repository 표시 = GET /oss/v1/repositories/nexus/list 4.목록 없음이면 오류 없이 빈 목록
// 기대결과: Repository 목록 화면 표시, 등록된 Nexus repository 정보 표시, 목록 없음 상태도 오류 없이 표시
// 비고: 시트 절차는 'SW Catalogs > Repository 탭'이나 v0.7 화면은 사이드바 Applications > Repository 별도 메뉴(2026-10-14)

import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { gotoApp, REPO_URL, repoList, showAllRows, clean } from '../../lib/iv5-app';

test('IV5_S09 TC-APP-001 Repository 목록 조회', async ({ page }) => {
  await loginAsAdmin(page);
  const f = await test.step('1. Applications > Repository 진입', () => gotoApp(page, REPO_URL, /repository/));
  await test.step('2. 컬럼 Name / Format / URL / Type(hosted) / Action', async () => {
    for (const h of ['Name', 'Format', 'URL', 'Type(hosted)', 'Action']) await expect(f.getByText(h, { exact: true }).first()).toBeVisible();
  });
  await test.step('3~4. 화면 목록 = Nexus repository 목록 API (없으면 빈 목록, 오류 없음)', async () => {
    await showAllRows(f);
    const api = await repoList(page);
    const names = (await f.locator('.tabulator-row .tabulator-cell:first-child').allInnerTexts()).map(clean);
    test.info().annotations.push({ type: 'rows', description: `화면 ${names.length}건: ${names.join(', ') || '(없음)'} / API ${api.length}건: ${api.map((r) => `${r.name}(${r.format})`).join(', ')}` });
    expect(names.sort()).toEqual(api.map((r) => r.name).sort());
    await expect(f.getByText(/Unable to fetch data/)).toHaveCount(0);
  });
});

// IV5_S10: TC-APP-002 Repository 신규 생성 [정상, 공통]
// v0.6 TC-ID: TC-APP-REP-02 — 기존 spec(mcmp-e2e mc-web-console/specs/sw/TC-APP-REP-02-repository-신규-생성-*.spec.ts)은 절차만 참고(사용자 결정 2026-10-14)
// 화면: Applications > Repository → New Repository 모달(#repositoryForm "Repository Create")
// 시작 상태: admin(mcmp) 로그인, ws01/default. IV5_S09 완료, Nexus 생성 권한
// 절차: 1.New Repository 클릭 2.생성 화면(모달) 표시 3.Name am-test-docker-hosted, Format docker (Type 은 hosted 고정) 4.Create 5.목록에 신규 표시
// 기대결과: Repository 생성 성공 메시지, 목록에 신규 항목, Nexus 에 동일 repository 생성(목록 API 로 확인)
// 비고: 이미 있으면(재실행) 먼저 삭제

import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { createRepository, deleteRepository, repoList, gotoApp, REPO_URL, repoRow, showAllRows } from '../../lib/iv5-app';

export const REPO = 'am-test-docker-hosted';

test('IV5_S10 TC-APP-002 Repository 신규 생성', async ({ page }) => {
  await loginAsAdmin(page);
  if ((await repoList(page)).some((r) => r.name === REPO)) test.info().annotations.push({ type: 'pre-clean', description: (await deleteRepository(page, REPO)).toasts.join(' | ') });
  await test.step(`1~4. New Repository → ${REPO} / docker → Create`, async () => {
    const { toasts } = await createRepository(page, REPO, 'docker');
    test.info().annotations.push({ type: 'create', description: toasts.join(' | ') || '(토스트 없음)' });
    expect(toasts.join(' ')).toMatch(/Repository created successfully/);
  });
  await test.step('5. 목록 표시 · Nexus 목록 API 에 생성', async () => {
    const f = await gotoApp(page, REPO_URL, /repository/);
    await showAllRows(f);
    await expect(repoRow(f, REPO)).toHaveCount(1);
    const r = (await repoList(page)).find((x) => x.name === REPO);
    test.info().annotations.push({ type: 'nexus', description: JSON.stringify(r) });
    expect(r?.format).toBe('docker');
  });
});

// IV5_S11: TC-APP-003 Repository 상세 진입 [정상, 공통]
// v0.6 TC-ID: TC-APP-REP-03 — 기존 spec(mcmp-e2e mc-web-console/specs/sw/TC-APP-REP-03-repository-상세-진입.spec.ts)은 절차만 참고(사용자 결정 2026-10-14)
// 화면: Applications > Repository → 행의 이름 셀 클릭 → Repository Detail
// 시작 상태: admin(mcmp) 로그인, ws01/default. IV5_S10 완료
// 절차: 1.목록에서 am-test-docker-hosted 선택(이름 셀 클릭) 2.상세 화면 표시 3.Name / Format / URL(Path) / Type(hosted) 확인
// 기대결과: Repository 상세 화면 표시(Name, Format, Type, URL)

import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { openRepositoryDetail, repoList } from '../../lib/iv5-app';

const REPO = 'am-test-docker-hosted';

test('IV5_S11 TC-APP-003 Repository 상세 진입', async ({ page }) => {
  await loginAsAdmin(page);
  const r = (await repoList(page)).find((x) => x.name === REPO);
  test.skip(!r, `선행 IV5_S10 의 ${REPO} 없음`);
  const f = await test.step(`1~2. ${REPO} 이름 클릭 → Repository Detail`, () => openRepositoryDetail(page, REPO));
  await test.step('3. Name / Format / URL(Path) / Type(hosted)', async () => {
    const vals = await f.locator('input[disabled]').evaluateAll((els) => els.map((e) => (e as HTMLInputElement).value));
    test.info().annotations.push({ type: 'detail', description: vals.join(' | ') });
    for (const l of ['Name', 'Format', 'URL(Path)', 'Type(hosted)']) await expect(f.getByText(l, { exact: true }).first()).toBeVisible();
    expect(vals).toContain(REPO);
    expect(vals.join(' ')).toMatch(/docker/i);
    for (const h of ['Name', 'URL(Path)', 'Size', 'Action']) await expect(f.getByText(h, { exact: true }).first()).toBeVisible();
  });
});

// IV5_S12: TC-APP-006 빌트인 Catalog 목록 표시 [정상, 공통]
// v0.6 TC-ID: TC-APP-CAT-01 — 기존 spec(mcmp-e2e mc-web-console/specs/sw/TC-APP-CAT-01-빌트인-catalog-목록-표시.spec.ts)은 절차만 참고(사용자 결정 2026-10-14)
// 화면: Applications > SW Catalogs (iframe :18084/web/applications/swcatalog)
// 시작 상태: admin(mcmp) 로그인, ws01/default. Built-in Catalog seed 등록
// 절차: 1.SW Catalogs 진입 2.Built-in Catalog 목록 표시 3.테스트 대상(Elasticsearch, Grafana 등) 표시 4.항목마다 이름·요약·Category·Rating
// 기대결과: Built-in Catalog 목록 표시, 이름·요약·Category·Rating 영역 표시
// 비고: VM/K8s 멤버는 한 카드로 묶여 API 13건 → 화면 12건(Nginx for Kubernetes 는 Nginx 카드). 시트 예시의 Loki 는 2026-10-14 stage 빌트인 목록에 없음(12종: Tomcat, Redis, Nginx, Apache HTTP Server, Nexus, MariaDB, Grafana, Prometheus, Elasticsearch, Rclone GUI, JupyterLab for Object Storage, PostgreSQL)

import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { gotoApp, CATALOG_URL, catalogList, clean } from '../../lib/iv5-app';

const MUST = ['Elasticsearch', 'Grafana', 'Nginx', 'MariaDB'];

test('IV5_S12 TC-APP-006 빌트인 Catalog 목록 표시', async ({ page }) => {
  await loginAsAdmin(page);
  const f = await test.step('1. SW Catalogs 진입', () => gotoApp(page, CATALOG_URL, /swcatalog/));
  await test.step('2~4. 목록 = GET /catalog/software · 대상 Catalog 표시 · 이름/요약/Category/Rating', async () => {
    const items = f.locator('#sc-list-group .list-group-item');
    await expect(items.first()).toBeVisible();
    const api = await catalogList(page);
    const n = await items.count();
    const shown: string[] = [];
    for (let i = 0; i < n; i++) shown.push(clean(await items.nth(i).innerText()).slice(0, 90));
    test.info().annotations.push({ type: 'items', description: `${n}건: ${shown.join(' || ')}` });
    test.info().annotations.push({ type: 'api', description: `${api.length}건: ${api.map((c) => c.title ?? c.name).join(', ')}` });
    // VM/K8s 멤버는 한 카드로 묶인다(예: Nginx + Nginx for Kubernetes → Nginx 카드, 2026-10-14) → API 항목은 그대로 보이거나 base 이름 카드에 묶여야 한다
    const titles = api.map((c) => String(c.title ?? c.name));
    const hidden = titles.filter((t) => !shown.some((s) => s.startsWith(t)));
    test.info().annotations.push({ type: 'grouped', description: hidden.join(', ') || '없음' });
    for (const t of hidden) expect(shown.some((s) => s.startsWith(t.replace(/ for Kubernetes$/i, ''))), `${t} → 묶인 카드 표시`).toBe(true);
    for (const t of MUST) expect(shown.some((s) => s.startsWith(t)), `${t} 표시`).toBe(true);
    const first = clean(await items.first().innerText());
    expect(first, 'Rating 형식 "평균 (건수)"').toMatch(/\d+(\.\d+)? \(\d+\)/);
    test.info().annotations.push({ type: 'loki', description: `Loki 표시 ${shown.some((s) => /Loki/i.test(s))} (시트 예시)` });
  });
});

// IV5_S13: TC-APP-007 Catalog 상세 펼침/접힘 [정상, 공통]
// v0.6 TC-ID: TC-APP-CAT-02 — 기존 spec(mcmp-e2e mc-web-console/specs/sw/TC-APP-CAT-02-catalog-상세-펼침-접힘.spec.ts)은 절차만 참고(사용자 결정 2026-10-14)
// 화면: Applications > SW Catalogs → 목록 항목 이름 클릭(펼침 #accordion_{id}) → 다시 클릭(접힘)
// 시작 상태: admin(mcmp) 로그인, ws01/default. IV5_S12 완료
// 절차: 1.대상 Catalog(Elasticsearch) 선택 2.이름 클릭 → 상세 펼침 3.Description·Ref Information·TAGS·Recommended Spec·Deployment Status 표시 4.다시 클릭 → 접힘, 목록 레이아웃 유지
// 기대결과: 상세 정보 펼쳐짐, Ref Information·Recommended Spec·Deployment Status 표시, 접힘 후 목록 유지

import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { gotoApp, CATALOG_URL, catalogItem, clean } from '../../lib/iv5-app';

const TARGET = 'Elasticsearch';

test('IV5_S13 TC-APP-007 Catalog 상세 펼침/접힘', async ({ page }) => {
  await loginAsAdmin(page);
  const f = await gotoApp(page, CATALOG_URL, /swcatalog/);
  const item = catalogItem(f, TARGET);
  const count = await f.locator('#sc-list-group .list-group-item').count();
  const acc = item.locator('[id^="accordion_"]').first();

  await test.step(`1~2. ${TARGET} 이름 클릭 → 펼침`, async () => {
    await item.locator('.col-5').first().click();
    await expect(acc).toBeVisible();
  });
  await test.step('3. Ref Information · TAGS · Recommended Spec · Deployment Status', async () => {
    const t = clean(await acc.innerText());
    test.info().annotations.push({ type: 'detail', description: t.slice(0, 600) });
    for (const s of ['Ref Information', 'Recommended Spec', 'Deployment Status']) expect(t, s).toContain(s);
    expect(t).toMatch(/CPU : [\d.]+ Core/);
  });
  await test.step('4. 다시 클릭 → 접힘 · 목록 항목 수 유지', async () => {
    await item.locator('.col-5').first().click();
    await expect(acc).toBeHidden();
    await expect(f.locator('#sc-list-group .list-group-item')).toHaveCount(count);
  });
});

// IV5_S14: TC-APP-008 외부 검색 결과 표시 (DockerHub/ArtifactHub) [정상, 공통]
// v0.6 TC-ID: TC-APP-CAT-03 — 기존 spec(mcmp-e2e mc-web-console/specs/sw/TC-APP-CAT-03-외부-검색-결과-표시.spec.ts)은 절차만 참고(사용자 결정 2026-10-14)
// 화면: Applications > SW Catalogs → Register → Application Registration 1. Source & Package → Public Registry
// 시작 상태: admin(mcmp) 로그인, ws01/default. 외부망(Docker Hub / Artifact Hub API) 접근 가능
// 절차: 1.Register → Public Registry 2.Target VM(Docker Hub)에서 ghost 검색 → 결과 목록 3.Target K8S(Artifact Hub)에서 ghost 검색 → 결과 목록 4.Cancel(등록 안 함)
// 입력값(시트): ghost
// 기대결과: 외부 검색 결과 목록 표시
// 비고: v0.7 화면에는 목록의 외부 검색창이 없고 Register 마법사의 Public Registry 가 외부 검색(2026-10-14 확인). VM=Docker Hub, K8S=Artifact Hub

import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { openRegister, publicSearch } from '../../lib/iv5-app';

test('IV5_S14 TC-APP-008 외부 검색 결과 표시 (DockerHub/ArtifactHub)', async ({ page }) => {
  await loginAsAdmin(page);
  const { m } = await openRegister(page);
  await test.step('1~2. Public Registry · VM(Docker Hub) → ghost 검색', async () => {
    const r = await publicSearch(page, m, 'ghost');
    test.info().annotations.push({ type: 'dockerhub', description: r.join(', ') || '(결과 없음)' });
    expect(r.length, 'Docker Hub 결과').toBeGreaterThan(0);
    expect(r.join(' ')).toMatch(/ghost/i);
  });
  await test.step('3. K8S(Artifact Hub) → ghost 검색', async () => {
    await m.locator('#targetK8S').check();
    await m.locator('#registrySearchInput').fill('ghost');
    await m.getByRole('button', { name: 'Search', exact: true }).click();
    await expect(m.locator('.registry-results button.list-group-item').first().or(m.getByText('No matching packages found.'))).toBeVisible({ timeout: 60_000 });
    const r = (await m.locator('.registry-results button.list-group-item .fw-semibold').allInnerTexts()).map((s) => s.trim());
    test.info().annotations.push({ type: 'artifacthub', description: r.join(', ') || '(결과 없음)' });
    expect(r.length, 'Artifact Hub 결과').toBeGreaterThan(0);
  });
  await test.step('4. Cancel', async () => { await m.getByRole('button', { name: 'Cancel' }).first().click(); });
});

// IV5_S15: TC-APP-009 외부 검색 결과 업로드 (Public Registry → Import & Create) [정상, 공통]
// v0.6 TC-ID: TC-APP-CAT-04 — 기존 spec(mcmp-e2e mc-web-console/specs/sw/TC-APP-CAT-04-외부-검색-결과-업로드.spec.ts)은 절차만 참고(사용자 결정 2026-10-14)
// 화면: Applications > SW Catalogs → Register → 1. Source & Package(Public Registry) → 2~4단계 → Import & Create
// 시작 상태: admin(mcmp) 로그인, ws01/default. **IV5_S10(Nexus docker repository, :5000) 완료 필수**, Docker Hub 접근 가능
// 절차: 1.Public Registry · Target VM 에서 ghost 검색 → 결과 ghost 선택 2.Version(Tag) 6.44.0-bookworm 선택 · Category 선택 3.General/Resource/Network 입력 4.Import & Create
//   5.결과 메시지 확인 · 카탈로그 목록에 반입 항목 표시
// 입력값(시트): Source DockerHub / Package ghost / Tag 6.44.0-bookworm (화면 Version 목록에 없으면 bookworm) / Category CONTENT_MANAGEMENT_SYSTEM
// 기대결과: 업로드(반입) 요청 접수, 성공 또는 실패 메시지 표시
// 비고: 외부 검색 결과를 저장소로 올리는 별도 업로드 화면(uploadForm)은 v0.7 FE 에서 쓰이지 않고 Import & Create 가 반입(POST /catalog/docker/register)을 겸함(2026-10-14 소스 확인)
//   반입으로 생긴 카탈로그(ghost-import-test)는 IV5_S19(삭제) 단계에서 함께 정리
//   2026-10-14 stage: Nexus docker 레지스트리(:5000)가 'You must accept the End User License Agreement' 403 → 반입 실패(메시지 표시). EULA 수락은 콘솔 밖 사전 설정
// 선행 조건(2026-10-16 확인): Nexus 에 5000 커넥터를 가진 docker hosted 저장소가 있어야 한다 — IV5_S10(Repository 신규 생성, docker)이 콘솔에서 만들면 httpPort 5000 으로 생성.
//   Docker Hub 반입 경로(DockerHubService.registerDockerHubImage → pushImageToNexus)는 저장소 존재를 확인하지 않는다(자동 생성 ensureDockerRepositoryExists 는 registerToInternalNexus 경로에서만 호출).
//   저장소가 없으면(예: stage 재시작으로 Nexus 초기화) :5000 미기동 → 'Failed to copy image to Nexus … connection refused' 로 실패. S15 단독 실행 전 S10 선행 필요
//   2026-10-16: EULA 는 이미 수락 상태(accepted:true). Nexus 초기화로 docker 저장소가 없어 실패 → IV5_S10 재실행 후 반입·등록 성공(PASS)

import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { openRegister, publicSearch, selectByText, fillWizardRest, catalogList, collectToasts, clean } from '../../lib/iv5-app';

const NAME = 'ghost-import-test';
const TAG = '6.44.0-bookworm';

test('IV5_S15 TC-APP-009 외부 검색 결과 업로드 (Public Registry → Import & Create)', async ({ page }) => {
  test.setTimeout(15 * 60_000);
  await loginAsAdmin(page);
  test.skip((await catalogList(page)).some((c) => (c.title ?? c.name) === NAME), `${NAME} 이미 있음(이전 실행 잔여) → IV5_S19 로 정리 후 재실행`);
  const imports: string[] = [];
  page.on('response', async (r) => { if (/\/catalog\/(docker|helm)\/register|\/catalog\/software$/.test(r.url()) && r.request().method() === 'POST') { const b = clean(await r.text().catch(() => '')); imports.push(`${r.status()} ${r.url().replace(/^https?:\/\/[^/]+/, '')} :: ${b.slice(0, 200)} … ${b.slice(-700)}`); } });
  const { f, m } = await openRegister(page);

  await test.step('1. Public Registry · VM(Docker Hub) → ghost 검색 → ghost 선택', async () => {
    const r = await publicSearch(page, m, 'ghost');
    test.info().annotations.push({ type: 'results', description: r.join(', ') });
    await m.locator('.registry-results button.list-group-item').filter({ has: f.locator('.fw-semibold', { hasText: /^ghost$/ }) }).first().click();
  });
  await test.step(`2. Version ${TAG} · Category 선택`, async () => {
    const selects = m.locator('select');
    // Version 목록은 Docker Hub 최근 태그 10개만 나온다(2026-10-14: latest, next-*, bookworm, alpine, 6.70.0-next-*) → 시트 값이 없으면 같은 계열 'bookworm' 으로(지침: 화면 값으로 실행·비고 기록)
    const verSel = selects.filter({ has: f.locator('option', { hasText: 'Select Version' }) }).first();
    await expect.poll(async () => (await verSel.locator('option').count()) > 1, { timeout: 60_000 }).toBe(true);
    const opts = (await verSel.locator('option').allInnerTexts()).map((o) => o.trim());
    const ver = await selectByText(verSel, opts.includes(TAG) ? new RegExp(`^${TAG}$`) : /^bookworm$/);
    test.info().annotations.push({ type: 'versions', description: `${opts.join(', ')} → ${ver}${ver !== TAG ? ` (시트 ${TAG} 목록에 없음)` : ''}` });
    const catSel = selects.filter({ has: f.locator('option', { hasText: /Select Category/ }) }).first();
    const cat = await selectByText(catSel, /CONTENT_MANAGEMENT/i);
    test.info().annotations.push({ type: 'selected', description: `version ${ver} / category ${cat}` });
  });
  let toasts: string[] = [];
  await test.step('3~4. General · Resource · Network 입력 → Import & Create', async () => {
    // 반입(이미지 push)이 성공하면 30초를 넘길 수 있어(2026-10-16: 6개 이미지 복사) 카탈로그 생성 응답(POST /catalog/software)까지 기다린 뒤 토스트를 다시 모은다
    const created = page.waitForResponse((r) => /\/catalog\/software$/.test(r.url()) && r.request().method() === 'POST', { timeout: 10 * 60_000 }).catch(() => null);
    toasts = await fillWizardRest(page, f, m, { name: NAME, summary: 'ghost import test', desc: 'Imported from Docker Hub by IV5_S15', cpu: [1, 2], mem: [1, 2], disk: [1, 5], port: '2368' }, /Import & Create/);
    if (!toasts.length && (await created)) toasts = await collectToasts(page, f, 15_000);
    test.info().annotations.push({ type: 'toasts', description: toasts.join(' | ') || '(토스트 없음)' });
    test.info().annotations.push({ type: 'api', description: imports.join(' || ') || '(기록 없음)' });
  });
  await test.step('5. 반입 요청 접수 · 결과 메시지 · 목록', async () => {
    expect(imports.some((x) => /\/catalog\/docker\/register/.test(x)), '반입 요청(POST /catalog/docker/register) 접수').toBe(true);
    expect(toasts.length, '성공 또는 실패 메시지 표시').toBeGreaterThan(0);
    const inList = (await catalogList(page)).some((c) => (c.title ?? c.name) === NAME);
    test.info().annotations.push({ type: 'catalog', description: `목록에 ${NAME}: ${inList}` });
    // 시트 기대결과는 '성공 또는 실패 메시지 표시' → 메시지 표시로 판정하고 반입 성공 여부는 기록(2026-10-14: Nexus :5000 이 EULA 미수락 403 으로 push 거부)
    const push = imports.find((x) => /docker\/register/.test(x)) ?? '';
    test.info().annotations.push({ type: 'import-result', description: /"success":\s*false/.test(push) ? `반입 실패: ${(push.match(/StatusCode: \d+[^"\\]*/) ?? [''])[0]}` : (/Registration Success/.test(toasts.join(' ')) ? '반입·등록 성공' : '(판단 불가)') });
    expect(toasts.join(' '), '성공 또는 실패 메시지').toMatch(/Registration Success|Failed to import|Registration Failed|Failed/);
  });
});