// IV3_S01: Workflow로 단일 CSP Infra 생성 [정상, CSP별]
// 화면: Workflows(iframe) → multi-csp-vm-deploy RUN 팝업(Run Workflow, 파라미터 입력) → 실행 상태
// 시작 상태: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default 선택된 상태에서 시작
// 절차 (예: AWS 기준): 1.Workflows 진입(iframe) 2.multi-csp-vm-deploy RUN: Spec=t3.micro, Image=Ubuntu 22.04(ami-0efae34c528c68a9c),
//   INFRA_ID=mw1, CSP_LIST=aws, INFRA_NODEGROUP_PREFIX=g1, INFRA_NODEGROUP_SIZE=1 3.Run 4.Infra Workloads 에서 mw1 Running 도달까지 대기
//   5.mw1 선택 → Infra Info > Node List 에서 NodeGroup g1-aws 의 node g1-aws-1 선택 → Node Info 상세 확인
// 기대결과: Infra mw1 Running, Node Info [ g1-aws / g1-aws-1 ] 에 CSP=aws, Node Status=Running, Spec=t3.micro, Image ID, Connection, Public/Private IP 표시
// 멱등: mw1 이 이미 있으면 Run 은 건너뛰고(annotation preexisting) 상태만 검증한다(이름 중복 Run 은 IV3_S09 대상).
// 2026-10-16 수정(9 CSP 실행): lib/workflow VM_DEPLOY_INPUT 에 Azure~KT 입력값 추가, runVmDeploy 가 상단 CSP 를 먼저 선택.
//   기존 Infra 가 Suspended 면 Resume → 검증 → 다시 Suspend(사용자 지시 2026-10-16, lib/iv3-mc10 withResumed). 기존 Infra 는 Image ID 값만 기록. 새 이름은 WF_INFRA_NAME. 테스트 시간 40분
//   만든 mw{n} 은 이후 TC(INFRA-028 Terminal·032 Scale Policy·052 전체 중지)용으로 삭제하지 않는다

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, wfInfraName } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { gotoInfraList, infraRow, nodeField, openInfraDetail, openNodeInfo, rowCells, statusOf, waitInfraRunning } from '../../lib/infra';
import { VM_DEPLOY_INPUT as WF_INPUT, runVmDeploy } from '../../lib/workflow';
import { withResumed } from '../../lib/iv3-mc10';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  test(`${tid("IV3_S01", c)} ` + "Workflow로 단일 CSP Infra 생성", async ({ page }) => {
    const inp = WF_INPUT[c.code];
    test.skip(!inp, `${c.name}: Workflow Run 입력값 미확정(사전점검 필요) → AWS 확정 후 확장`);
    test.setTimeout(40 * 60_000);
    // WF_INFRA_NAME: 기존 mw{n} 을 다른 세션이 중지(Suspended)해 둔 경우 등 새 이름으로 생성할 때(2026-10-16, AWS mw1 Suspended → mw1b)
    const name = process.env.WF_INFRA_NAME || wfInfraName(c);
    const ng = `g${c.n}`;
    await loginAsAdmin(page);
    await gotoInfraList(page);
    if (await infraRow(page, name).count()) {
      const pre = await rowCells(infraRow(page, name).first());
      test.info().annotations.push({ type: 'preexisting', description: `${name} 이미 존재 → Run 건너뜀: ${JSON.stringify(pre)}` });
      // 2026-10-16 사용자 지시: "Test에 필요한 infra가 suspended 상태면 resume 후 테스트 한다. 테스트 완료 후 다시 suspended 한다." → withResumed
      // 목록 status 는 'Stopped' 로 보이고 statusCount.countSuspended 가 node 수(2026-10-16 mw1) → Suspended 로 본다
      if (/suspend/i.test(statusOf(pre)) || (Number(pre['statusCount.countSuspended'] ?? 0) > 0 && Number(pre['statusCount.countSuspended']) === Number(pre['statusCount.countTotal']))) {
        await withResumed(page, { infra: name, ng: '', node: '', why: `기존 ${name} Suspended → Resume`, resume: true, origStatus: statusOf(pre) }, () => verify(true));
        return;
      }
      test.skip(/terminat|fail/i.test(statusOf(pre)), `${name} 이 ${statusOf(pre)} 상태 — 검증 불가`);
      await verify(true);
      return;
    } else {
      const { toasts } = await runVmDeploy(page, inp!, name, ng);
      const err = toasts.find((t) => /fail|error|invalid|not found/i.test(t));
      expect(err, `Run 직후 오류 토스트 없음`).toBeUndefined();
    }
    await verify(false);

    async function verify(preexisting: boolean) {
    const cells = await waitInfraRunning(page, name, 25 * 60_000);
    test.info().annotations.push({ type: 'list-row', description: JSON.stringify(cells) });
    await openInfraDetail(page, name);
    const body = (await page.locator('body').innerText()).replace(/\s+/g, ' ');
    const i = body.indexOf('Infra Info');
    test.info().annotations.push({ type: 'detail', description: body.slice(i, i + 400) });

    // NodeGroup 의 node 선택 → Node Info 상세 확인. nodegroup 이름은 {INFRA_NODEGROUP_PREFIX}-{csp} (예: g1-aws)
    const wfNg = `${ng}-${inp!.csp}`;
    const node = `${wfNg}-1`;
    const info = await openNodeInfo(page, wfNg, node);
    test.info().annotations.push({ type: 'node-info', description: info.slice(0, 900) });
    expect(nodeField(info, 'CSP'), 'CSP').toBe(inp!.csp);
    expect(nodeField(info, 'Node Status'), 'Node Status').toBe('Running');
    expect(nodeField(info, 'Node Spec'), 'Node Spec').toBe(inp!.specQuery);
    // 기존 Infra(이전 실행에서 생성)는 생성 당시 이미지라 현재 입력값과 다를 수 있음 → 값만 기록
    if (preexisting) {
      test.info().annotations.push({ type: 'preexisting-image', description: `Image ID ${nodeField(info, 'Image ID')} (현재 입력값 ${inp!.imageQuery})` });
      expect(nodeField(info, 'Image ID'), 'Image ID').not.toBe('');
    } else expect(nodeField(info, 'Image ID'), 'Image ID').toBe(inp!.imageQuery);
    expect(nodeField(info, 'Config Name'), 'Connection').toBe(c.infra.conn);
    expect(nodeField(info, 'Public IP\\(IPv4\\)'), 'Public IP').toMatch(/^\d+\.\d+\.\d+\.\d+$/);
    expect(nodeField(info, 'Private IP'), 'Private IP').toMatch(/^\d+\.\d+\.\d+\.\d+$/);
    }
  });
}

// IV3_S02: 직접 Infra 생성 (Add Infra) [정상, CSP별]
// 화면: Workloads > Infra Workloads > Add Infra (Create Infra 폼: Name, Description, Deployment Algorithm, Policy on Partial Failure, Labels, + NodeGroup → Deploy)
// 시작 상태: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default 선택된 상태에서 시작
// 절차 (예: AWS 기준): 1.Infra Workloads 진입 2.Add Infra: Name=mc1, Deployment Algorithm=Express, Policy on Partial Failure=Continue 3.+ NodeGroup: g1 (연결=aws-ap-northeast-2, Spec=t3.micro, Image=Ubuntu 22.04 기본 이미지, node 1) → Done 4.Deploy 5.Running 도달까지 대기
//   6.mc1 선택 → Infra Info > Node List 에서 NodeGroup g1 의 node g1-1 선택 → Node Info 상세 확인 7.Group 탭에 g1(1)
// 기대결과: Infra mc1 Running (nodegroup g1, node 1), Node Info [ g1 / g1-1 ] 에 CSP, Node Status=Running, Spec, Image ID, Connection, Public/Private IP 표시
// 멱등: 같은 이름 Infra 가 이미 있으면 생성은 건너뛰고(annotation preexisting) 상태만 검증한다(이름 중복 생성은 IV3_S10 대상).

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, infraName, infraNodegroups } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { INFRA_INPUT, createInfra, gotoInfraList, infraInputBlocker, infraRow, nodeField, openInfraDetail, openNodeInfo, rowCells, waitInfraRunning } from '../../lib/infra';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  test(`${tid("IV3_S02", c)} ` + "직접 Infra 생성 (Add Infra)", async ({ page }) => {
    const why = infraInputBlocker(c);
    test.skip(!!why, why);
    const name = infraName(c);
    const ng = infraNodegroups(c)[0];
    await loginAsAdmin(page);
    await gotoInfraList(page);
    if (await infraRow(page, name).count()) {
      test.info().annotations.push({ type: 'preexisting', description: `${name} 이미 존재 → 생성 건너뜀: ${JSON.stringify(await rowCells(infraRow(page, name).first()))}` });
    } else {
      await createInfra(page, c, name, ng);
    }
    const cells = await waitInfraRunning(page, name);
    test.info().annotations.push({ type: 'list-row', description: JSON.stringify(cells) });

    // 상세: NodeGroup {ng} 의 node {ng}-1 선택 → Node Info 상세 확인
    await openInfraDetail(page, name);
    const inp = INFRA_INPUT[c.code]!;
    const info = await openNodeInfo(page, ng, `${ng}-1`);
    test.info().annotations.push({ type: 'node-info', description: info.slice(0, 900) });
    expect(nodeField(info, 'CSP'), 'CSP').toBe(inp.provider);
    expect(nodeField(info, 'Node Status'), 'Node Status').toBe('Running');
    expect(nodeField(info, 'Node Spec'), 'Node Spec').toBe(inp.spec);
    expect(nodeField(info, 'Config Name'), 'Connection').toBe(c.infra.conn);
    expect(nodeField(info, 'Image ID'), 'Image ID').not.toBe('');
    expect(nodeField(info, 'Public IP\\(IPv4\\)'), 'Public IP').toMatch(/^\d+\.\d+\.\d+\.\d+$/);
    expect(nodeField(info, 'Private IP'), 'Private IP').toMatch(/^\d+\.\d+\.\d+\.\d+$/);
    // Group 탭 NodeGroup List 에 {ng}(1)
    await page.getByText('Group', { exact: true }).first().click();
    await expect(page.getByText(`${ng}(1)`).first(), `nodegroup ${ng}(1) 표시`).toBeVisible({ timeout: 30_000 });
  });
}

// IV3_S03: 생성한 Infra에 nodegroup 추가 [정상, CSP별]
// 화면: Workloads > Infra Workloads > Infra 선택 > 상세 Node List 'Add server'(⌄ 메뉴 'New' 와 같은 화면, #addserver) → '+ Node' → Node Configuration → Done → Deploy
// 시작 상태: admin(mcmp) 로그인, ws01/default. mc{n} Running(nodegroup g{n})
// 절차(AWS): 1.Infra 목록에서 mc1 선택 2.NodeGroup g1b 추가(Spec t3.micro, Image Ubuntu 22.04 ami-0efae34c528c68a9c — 계획서 ami-0afe1fd15675c3f15 는 카탈로그에 없음, node 1)
//   3.Deploy → mc1 노드 2개 Running 대기 4.상세 Group 탭에 g1, g1b 표시 확인 5.Default 탭 Node List 에서 g1b-1 선택 → Node Info 상세(CSP, Running, Spec, Image ID, Connection, IP)
// 기대결과: mc1 에 nodegroup 2개(g1, g1b), 신규 node g1b-1 Running, Node Info 상세 표시
// 멱등: g1b 가 이미 있으면 추가는 건너뛰고(preexisting) 확인만 한다.

import { test, expect } from '../../lib/fixtures';
import { CSPS, activeCsps, tid, infraName, infraNodegroups } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { INFRA_INPUT, addNodeGroupToInfra, gotoInfraList, infraInputBlocker, infraRow, nodeField, openInfraDetail, openNodeInfo, rowCells, waitInfraNodes } from '../../lib/infra';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  test(`${tid("IV3_S03", c)} ` + "생성한 Infra에 nodegroup 추가", async ({ page }) => {
    const why = infraInputBlocker(c);
    test.skip(!!why, why);
    const inp = INFRA_INPUT[c.code]!;
    const name = infraName(c);
    const [ng, ngB] = infraNodegroups(c);
    await loginAsAdmin(page);
    await gotoInfraList(page);
    test.skip(!(await infraRow(page, name).count()), `선행 IV3_S02 의 ${name} 없음`);
    const before = await rowCells(infraRow(page, name).first());
    test.info().annotations.push({ type: 'before', description: JSON.stringify(before) });

    // g1b 존재 여부: 상세 Node List 의 node 카드 #server_status_icon_{ngB}-1
    await openInfraDetail(page, name);
    let image = inp.image ?? '';
    let expectNodes = Number(before['statusCount.countTotal']);
    if (await page.locator(`[id^="server_status_icon_${ngB}-"]`).count()) {
      test.info().annotations.push({ type: 'preexisting', description: `${ngB} 이미 존재 → 추가 건너뜀` });
    } else {
      ({ image } = await addNodeGroupToInfra(page, c, name, ngB, 1));
      expectNodes += 1;
    }
    const cells = await waitInfraNodes(page, name, expectNodes);
    test.info().annotations.push({ type: 'after', description: JSON.stringify(cells) });

    // Group 탭: g1, g1b
    await openInfraDetail(page, name);
    await page.getByText('Group', { exact: true }).first().click();
    await expect(page.getByText(new RegExp(`^${ng}\\(\\d+\\)$`)).first(), `nodegroup ${ng} 표시`).toBeVisible({ timeout: 30_000 });
    await expect(page.getByText(new RegExp(`^${ngB}\\(\\d+\\)$`)).first(), `nodegroup ${ngB} 표시`).toBeVisible({ timeout: 30_000 });

    // Default 탭: g1b-1 Node Info
    await page.getByText('Default', { exact: true }).first().click();
    // 추가한 NodeGroup 의 node id 는 {ng}-1 이 아닐 수 있다(KT: Infra 전체 번호를 이어서 g9b-2) → 카드 id 로 찾는다
    const cardB = page.locator(`[id^="server_status_icon_${ngB}-"]`).first();
    await cardB.waitFor({ state: 'visible', timeout: 60_000 });
    const nodeB = ((await cardB.getAttribute('id')) ?? '').replace('server_status_icon_', '');
    test.info().annotations.push({ type: 'node-id', description: `${ngB} 의 node: ${nodeB}` });
    const info = await openNodeInfo(page, ngB, nodeB);
    test.info().annotations.push({ type: 'node-info', description: info.slice(0, 900) });
    expect(nodeField(info, 'CSP'), 'CSP').toBe(inp.provider);
    expect(nodeField(info, 'Node Status'), 'Node Status').toBe('Running');
    expect(nodeField(info, 'Node Spec'), 'Node Spec').toBe(inp.spec);
    expect(nodeField(info, 'Image ID'), 'Image ID').toBe(image);
    expect(nodeField(info, 'Config Name'), 'Connection').toBe(c.infra.conn);
    expect(nodeField(info, 'Public IP\\(IPv4\\)'), 'Public IP').toMatch(/^\d+\.\d+\.\d+\.\d+$/);
    expect(nodeField(info, 'Private IP'), 'Private IP').toMatch(/^\d+\.\d+\.\d+\.\d+$/);
  });
}

// IV3_S03_AWS-GCP: 같은 시나리오로 AWS Infra mc1 에 provider=gcp nodegroup g1c(node 2개) 추가 → 멀티 CSP Infra (사용자 지시 2026-10-05)
// 절차: mc1 선택 → Add server → + Node: g1c(GCP e2-small, Ubuntu 22.04, size 2) → Done → Deploy → mc1 노드 +2 Running 대기
//   → Group 탭 g1, g1b, g1c 표시 → g1c-1, g1c-2 Node Info(CSP gcp, Running, Spec, Image ID, Connection, IP)
if (activeCsps(['AWS']).length) {
  test('IV3_S03_AWS-GCP 생성한 Infra에 다른 CSP(GCP) nodegroup 추가', async ({ page }) => {
    const aws = CSPS.find((x) => x.code === 'AWS')!;
    const gcp = CSPS.find((x) => x.code === 'GCP')!;
    const inp = INFRA_INPUT.GCP!;
    const name = infraName(aws);
    const ngC = `g${aws.n}c`;
    const size = 2;
    await loginAsAdmin(page);
    await gotoInfraList(page);
    test.skip(!(await infraRow(page, name).count()), `선행 ${name} 없음`);
    const before = await rowCells(infraRow(page, name).first());
    test.info().annotations.push({ type: 'before', description: JSON.stringify(before) });

    await openInfraDetail(page, name);
    let expectNodes = Number(before['statusCount.countTotal']);
    if (await page.locator(`#server_status_icon_${ngC}-1`).count()) {
      test.info().annotations.push({ type: 'preexisting', description: `${ngC} 이미 존재 → 추가 건너뜀` });
    } else {
      await addNodeGroupToInfra(page, gcp, name, ngC, size);
      expectNodes += size;
    }
    const cells = await waitInfraNodes(page, name, expectNodes, 25 * 60_000);
    test.info().annotations.push({ type: 'after', description: JSON.stringify(cells) });

    await openInfraDetail(page, name);
    await page.getByText('Group', { exact: true }).first().click();
    for (const g of infraNodegroups(aws).concat(ngC)) {
      await expect(page.getByText(new RegExp(`^${g}\\(\\d+\\)$`)).first(), `nodegroup ${g} 표시`).toBeVisible({ timeout: 30_000 });
    }
    await expect(page.getByText(`${ngC}(${size})`).first(), `${ngC} 노드 ${size}개`).toBeVisible();

    await page.getByText('Default', { exact: true }).first().click();
    for (let k = 1; k <= size; k++) {
      const info = await openNodeInfo(page, ngC, `${ngC}-${k}`);
      test.info().annotations.push({ type: `node-info:${ngC}-${k}`, description: info.slice(0, 900) });
      expect(nodeField(info, 'CSP'), 'CSP').toBe(inp.provider);
      expect(nodeField(info, 'Node Status'), 'Node Status').toBe('Running');
      expect(nodeField(info, 'Node Spec'), 'Node Spec').toBe(inp.spec);
      expect(nodeField(info, 'Image ID'), 'Image ID').not.toBe('');
      expect(nodeField(info, 'Config Name'), 'Connection').toBe(gcp.infra.conn);
      expect(nodeField(info, 'Public IP\\(IPv4\\)'), 'Public IP').toMatch(/^\d+\.\d+\.\d+\.\d+$/);
      expect(nodeField(info, 'Private IP'), 'Private IP').toMatch(/^\d+\.\d+\.\d+\.\d+$/);
    }
  });
}

// IV3_S04: Disk attach/detach — Infra 상세(Node Info)에서 [정상, CSP별] (생성→attach→detach 통합. 개별 동작은 IV3_S14~S16)
// 화면: Cloud Resources > Disks(Create Data Disk) → Infra Workloads > Infra 선택 > Node List 에서 node 선택 > Node Info > Block Device '+ Attach Disk' / 'Detach'
// 절차(AWS): 1.Disks 에서 disk1c 생성(aws-ap-northeast-2, 10GB) 2.mc1 → Running node(g1b-2) → Node Info 3.+ Attach Disk → Existing Disk disk1c → Attach
//   4.Disks 목록 Attached / Attached To 'mc1 / g1b-2', Block Device 에 disk1c 5.Block Device disk1c Detach → Confirm 6.Disks 목록 Available, Block Device 에서 사라짐
// 기대결과: disk1c 가 node 에 attach 되고 detach 후 해제(Available)

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { DISK_TARGET, attachExistingDisk, blockDevice, createDisk, detachDisk, diskTargetBlocker, openInfraDetail, openNodeInfo, pickRunningNode, waitDiskState } from '../../lib/infra';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  test(`${tid("IV3_S04", c)} ` + "Disk attach/detach: Infra 상세에서", async ({ page }) => {
    const why = diskTargetBlocker(c);
    test.skip(!!why, why);
    const tg = DISK_TARGET[c.code]!;
    await loginAsAdmin(page);
    await createDisk(page, c.infra.conn, tg.disk, tg.size, tg.diskType);
    await waitDiskState(page, tg.disk, 'available');

    const node = await pickRunningNode(page, tg.infra, tg.node);
    const ng = node.replace(/-\d+$/, '');
    let info = await openNodeInfo(page, ng, node);
    expect(blockDevice(info), '시작 시 disk 미연결').not.toContain(tg.disk);
    const target = await attachExistingDisk(page, tg.disk);
    expect(target, '대상 노드 표시').toContain(node);
    await waitDiskState(page, tg.disk, 'attached', node);
    await openInfraDetail(page, tg.infra);
    info = await openNodeInfo(page, ng, node);
    expect(blockDevice(info), 'Block Device 에 disk 표시').toContain(tg.disk);

    await detachDisk(page, tg.disk);
    await waitDiskState(page, tg.disk, 'available');
    await openInfraDetail(page, tg.infra);
    info = await openNodeInfo(page, ng, node);
    expect(blockDevice(info), 'Block Device 에서 disk 해제').not.toContain(tg.disk);
  });
}

// IV3_S05: Disk attach/detach: Disks 화면 action item에서 [정상, CSP별] — Disk 테스트 (Infra 상세에서 하는 S04 와 구분)
// 화면: Cloud Resources > Disks (Create Data Disk 팝업) → Disk 행 선택 → 목록 상단 'Attach selected Data Disk' → attach, 행 선택 시 열리는 Data Disk Detail 의 Detach
// 전제: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default. IV3_S02 mc1 Running
// 절차(AWS): 1.Disks 진입 2.Create Data Disk: Connection=aws-ap-northeast-2, Disk Name=disk1b, 10GB 3.disk1b 행 선택 → Attach selected Data Disk: Infra mc1 / NodeGroup / Node 선택
//   4.attach 확인(Disks 목록 Attached, Attached To) 5.행 선택 → Data Disk Detail 의 Detach → Confirm 6.detach 확인(Available, Attached To '-')
// 기대결과: disk1b 가 mc1 의 node 에 attach/detach
// 화면 확인(2026-10-08 AWS 프로브): Attach Data Disk 모달(#attach-disk-mci Infra / #attach-disk-nodegroup / #attach-disk-vm / #attach-disk-execute-btn),
//   Detach 버튼 #detail-detach-btn. disk 의 AZ 가 node 와 다르면 attach 가 거부될 수 있다(IV3_S15 참고) → 결과 그대로 기록
import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid } from '../../lib/data';
import { loginAsAdmin, toasts } from '../../lib/ui';
import { DISK_TARGET, createDisk, diskCells, diskRow, diskTargetBlocker, gotoDisks, nodeField, openNodeInfo, pickRunningNode, waitDiskState } from '../../lib/infra';

const DISK_B = process.env.TARGET_DISK_B ?? 'disk1b'; // node 와 같은 AZ 의 disk 로 바꿀 때 지정(2026-10-12)
for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  test(`${tid("IV3_S05", c)} ` + "Disk attach/detach: Disks 화면 action item에서", async ({ page }) => {
    const why = diskTargetBlocker(c);
    test.skip(!!why, why);
    const tg = DISK_TARGET[c.code]!;
    await loginAsAdmin(page);
    await createDisk(page, c.infra.conn, DISK_B, tg.size, tg.diskType);
    const node = await pickRunningNode(page, tg.infra, tg.node);
    const ng = node.replace(/-\d+$/, '');
    const info = await openNodeInfo(page, ng, node);
    test.info().annotations.push({ type: 'node-zone', description: `${node}: Zone ${nodeField(info, 'Zone')}` });

    // 3. Disks 목록에서 행 선택 → Attach selected Data Disk
    await gotoDisks(page);
    await diskRow(page, DISK_B).first().getByRole('checkbox').check();
    await page.locator('[title="Attach selected Data Disk"], [data-bs-original-title="Attach selected Data Disk"]').first().click();
    const m = page.locator('.modal.show').last();
    await expect(m).toBeVisible();
    await m.locator('#attach-disk-mci').selectOption({ label: tg.infra });
    await m.locator('#attach-disk-nodegroup').selectOption({ label: ng });
    // node 목록은 NodeGroup 선택 후 채워지고 표시는 'g1-1 (Running)'
    await expect.poll(async () => (await m.locator('#attach-disk-vm option').allInnerTexts()).length, { timeout: 30_000 }).toBeGreaterThan(1);
    const vmLabel = (await m.locator('#attach-disk-vm option').allInnerTexts()).find((s) => s.trim().startsWith(node))!;
    await m.locator('#attach-disk-vm').selectOption({ label: vmLabel });
    await m.locator('#attach-disk-execute-btn').click();
    // 거부되면(AZ 불일치 등) 모달이 닫히지 않고 오류 표시도 없다(IV3_S15 와 같은 증상) → 닫히지 않으면 기록 후 취소하고 Disks 상태로 판정
    const closed = await m.waitFor({ state: 'hidden', timeout: 90_000 }).then(() => true).catch(() => false);
    if (!closed) {
      test.info().annotations.push({ type: 'attach-modal-open', description: `Attach 후 90초 넘게 모달이 닫히지 않음: ${(await m.innerText()).replace(/\s+/g, ' ').slice(0, 120)}` });
      await m.getByRole('button', { name: 'Cancel' }).click();
      const st = await diskCells(page, DISK_B);
      test.info().annotations.push({ type: 'disk-after-attach', description: JSON.stringify(st) });
      expect(st.status, `attach 실패(disk1b 기본 AZ 와 ${node}(${nodeField(info, 'Zone')}) 불일치 추정, IV3_S15 참고)`).toMatch(/attached/i);
    }
    await page.waitForTimeout(3000);
    const t1 = (await toasts(page)).map((s) => s.replace(/\s+/g, ' ')).filter(Boolean);
    test.info().annotations.push({ type: 'attach', description: `target=${tg.infra} / ${node} disk=${DISK_B} / ${t1.join(' | ').slice(0, 300) || '(토스트 없음)'}` });
    await waitDiskState(page, DISK_B, 'attached');
    test.info().annotations.push({ type: 'disk-attached', description: JSON.stringify(await diskCells(page, DISK_B)) });

    // 5. detach: 행 선택 → Data Disk Detail 의 Detach → Confirm
    await diskRow(page, DISK_B).first().click();
    const det = page.locator('#detail-detach-btn');
    await expect(det, 'Detach 버튼').toBeVisible({ timeout: 15_000 });
    await det.click();
    const m2 = page.locator('.modal.show').last();
    await expect(m2).toBeVisible();
    test.info().annotations.push({ type: 'detach-confirm', description: (await m2.innerText()).replace(/\s+/g, ' ').slice(0, 160) });
    await m2.getByRole('button', { name: /Confirm|Detach|OK/ }).last().click();
    await waitDiskState(page, DISK_B, 'available');
    test.info().annotations.push({ type: 'disk-detached', description: JSON.stringify(await diskCells(page, DISK_B)) });
  });
}

// IV3_S06: Infra에서 Custom Image 생성 → MyImages 목록 표시 [정상, CSP별]
// 화면: Workloads > Infra Workloads > Infra 선택 > Default 탭 Node List 에서 node 선택 > 툴바 ⌄ 메뉴 'Create MyImage'(모달: MyImage Name #node-myimage-name / Description / Create #node-myimage-submit-btn) → Cloud Resources > MyImages
// 전제: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default. IV3_S02 mc1 Running
// 절차(AWS): 1.mc1 선택 → Running node 선택 2.툴바 ⌄ > Create MyImage: 이름 img1 → Create 3.생성 완료 대기 4.Cloud Resources > MyImages 목록에 img1 표시 확인 5.Provider(CSP) 열 확인
// 기대결과: img1 생성, MyImages 목록에 표시
// 생성 이미지는 이후 삭제 테스트(IV2 계열/CL)용으로 남긴다. 이미 img1 이 있으면 생성 생략(preexisting)
import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid } from '../../lib/data';
import { loginAsAdmin, toasts } from '../../lib/ui';
import { DISK_TARGET, openNodeInfo, pickRunningNode, rowCells } from '../../lib/infra';

// MyImage 이름은 CSP 번호 기준(img{n}): AWS img1, KT img9 — AWS 의 img1 이 이미 있어도 KT 는 별도로 만든다(2026-10-12)
const imgOf = (c: { n: number }) => `img${c.n}`;
async function openMyImages(page: import('@playwright/test').Page) {
  const link = page.locator('a#sidebar_cloudresources_myimages');
  if (!(await link.isVisible().catch(() => false))) await page.getByText('Cloud Resources', { exact: true }).first().click(); // 그룹 펼침
  await link.click();
  await page.waitForURL(/myimages/i);
  await page.getByText(/Showing \d+-\d+ of \d+ rows|No registered|No data/i).first().waitFor({ timeout: 30_000 }).catch(() => {});
  await page.waitForTimeout(1500);
}
const imgRowOf = (page: import('@playwright/test').Page, name: string) => page.getByRole('row').filter({ has: page.getByRole('gridcell', { name, exact: true }) });

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  test(`${tid("IV3_S06", c)} ` + "Infra에서 Custom Image 생성 → MyImages 목록 표시", async ({ page }) => {
    const IMG = imgOf(c);
    const imgRow = (page: import('@playwright/test').Page) => imgRowOf(page, IMG);
    const tg = DISK_TARGET[c.code];
    test.skip(!tg, `${c.name}: 대상 Infra/node 미지정(사전점검 필요)`);
    await loginAsAdmin(page);
    await openMyImages(page);
    if (await imgRow(page).count()) {
      test.info().annotations.push({ type: 'preexisting', description: `${IMG} 이미 존재 → 생성 건너뜀` });
    } else {
      const node = await pickRunningNode(page, tg!.infra, tg!.node); // 대상 node: DISK_TARGET.node (KT g9-1, 사용자 지시 2026-10-12)
      const ng = node.replace(/-\d+$/, '');
      await openNodeInfo(page, ng, node);
      test.info().annotations.push({ type: 'target', description: `${tg!.infra} / ${node}` });
      const item = page.locator('a[onclick*="openCreateNodeMyImageModal"]').first();
      await item.locator('xpath=ancestor::*[contains(@class,"dropdown-menu")][1]/preceding-sibling::*[1]').click(); // 툴바 ⌄
      await item.click();
      const m = page.locator('.modal.show').last();
      await expect(m).toBeVisible();
      await m.locator('#node-myimage-name').fill(IMG);
      await m.locator('#node-myimage-submit-btn').click();
      await expect(m).toBeHidden({ timeout: 180_000 });
      await page.waitForTimeout(3000);
      const t = (await toasts(page)).map((s) => s.replace(/\s+/g, ' ')).filter(Boolean);
      test.info().annotations.push({ type: 'myimage-create', description: t.join(' | ').slice(0, 300) || '(토스트 없음)' });
      await openMyImages(page);
    }
    // 생성 완료 대기(스냅샷 → 이미지 등록): 목록 재조회 최대 15분
    await expect.poll(async () => { await openMyImages(page); return await imgRow(page).count(); }, { timeout: 15 * 60_000, intervals: [30_000] }).toBeGreaterThan(0);
    const cells = await rowCells(imgRow(page).first());
    test.info().annotations.push({ type: 'myimage-row', description: JSON.stringify(cells) });
    // Provider 열은 driver 기준 소문자(nhn 등) — CSP 코드(NHNCloud)와 다를 수 있어 매핑(2026-10-16 NHN 오판 수정)
    const providerKey = ({ NHNCloud: 'nhn' } as Record<string, string>)[c.code] ?? c.code.toLowerCase();
    expect(JSON.stringify(cells).toLowerCase(), `Provider ${c.code}`).toContain(providerKey);
  });
}

// IV3_S07: NLB 생성 → 같은 Infra 의 NodeGroup node 할당 [정상, CSP별]
// 2026-10-12 사용자 결정: 기대결과를 '여러 Infra 할당' → '같은 Infra NodeGroup 할당'으로 변경(NLB 는 Infra+NodeGroup 단위, 다른 Infra node 는 할당 대상 아님)
// 화면: Cloud Resources > NLB (Create NLB 팝업) → NLB 목록 → NLB Detail(Assigned Nodes) → Edit(assign / unassign nodes)
// 전제: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default. mc1 의 g1 node(g1-1, g1-2) Running
// 화면 확인(2026-10-08 AWS 프로브): 사이드바 Cloud Resources > NLB(/cloudresources/nlbs). Create NLB 모달: #create-nlb-infra(Infra), #create-nlb-nodegroup(Target NodeGroup),
//   #create-nlb-listener-port(80), #create-nlb-target-port(80), #create-nlb-protocol(TCP/UDP), Type/Scope(PUBLIC / REGION), Health Checker(interval/timeout/threshold, 0=provider default), #create-nlb-execute-btn.
//   "NLB is created per target NodeGroup of the selected Infra. The NLB id follows the NodeGroup id."
// 절차(AWS): 1.NLB 진입 2.Create NLB: Infra=mc1, Target NodeGroup=g1, Listener Port=80, Target Port=80, Protocol=TCP, Health Checker 기본값 3.Create 4.목록에 NLB 표시
//   5.NLB Detail 의 Assigned Nodes 에 g1-1, g1-2 확인 6.Edit 에서 Assigned/Available Nodes 가 같은 Infra(mc1) node 로 구성되는지 확인(변경 없이 Cancel)
// 기대결과: NLB 생성·목록 표시, 같은 Infra 의 Target NodeGroup node(g1-1, g1-2)가 NLB 에 할당
import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, infraName, infraNodegroups } from '../../lib/data';
import { loginAsAdmin, selectWorkspaceProject, toasts } from '../../lib/ui';
import { infraInputBlocker, openInfraDetail } from '../../lib/infra';

const NLB_URL = '/webconsole/settings/environment/cloudresources/nlbs';
async function openNlb(page: import('@playwright/test').Page) {
  await page.goto(NLB_URL);
  await selectWorkspaceProject(page, 'ws01', 'default', true);
  await page.getByText(/Showing \d+(-\d+)? (of \d+ )?rows|No NLBs/i).first().waitFor({ timeout: 30_000 }).catch(() => {});
  await page.waitForTimeout(1500);
}

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  test(`${tid("IV3_S07", c)} ` + "NLB 생성 → 실행 중인 여러 Infra 할당", async ({ page }) => {
    test.setTimeout(20 * 60_000);
    const why = infraInputBlocker(c);
    test.skip(!!why, why);
    const infra = infraName(c);
    const ng = infraNodegroups(c)[0];
    await loginAsAdmin(page);
    await openNlb(page);
    const before = (await page.locator('.tabulator-row').allInnerTexts()).map((s) => s.replace(/\s+/g, ' '));
    test.info().annotations.push({ type: 'nlb-before', description: before.join(' || ') || '(NLB 없음)' });

    const exists = before.some((s) => s.includes(infra) && s.includes(ng));
    if (exists) test.info().annotations.push({ type: 'preexisting', description: `NLB(${infra}/${ng}) 이미 존재 → 생성 건너뜀` });
    if (!exists) {
    await page.getByRole('button', { name: 'Create NLB' }).click();
    const m = page.locator('.modal.show').last();
    await expect(m).toBeVisible();
    await m.locator('#create-nlb-infra').selectOption({ label: infra });
    await expect.poll(async () => (await m.locator('#create-nlb-nodegroup option').allInnerTexts()).length, { timeout: 30_000 }).toBeGreaterThan(1);
    await m.locator('#create-nlb-nodegroup').selectOption({ label: ng });
    await m.locator('#create-nlb-listener-port').fill('80');
    await m.locator('#create-nlb-target-port').fill('80');
    await m.locator('#create-nlb-protocol').selectOption('TCP');
    await m.locator('#create-nlb-execute-btn').click();
    await expect(m).toBeHidden({ timeout: 300_000 });
    await page.waitForTimeout(3000);
    const t = (await toasts(page)).map((s) => s.replace(/\s+/g, ' ')).filter(Boolean);
    test.info().annotations.push({ type: 'nlb-create', description: t.join(' | ').slice(0, 300) || '(토스트 없음)' });
    }

    await openNlb(page);
    const rows = (await page.locator('.tabulator-row').allInnerTexts()).map((s) => s.replace(/\s+/g, ' '));
    test.info().annotations.push({ type: 'nlb-after', description: rows.join(' || ') });
    expect(rows.join(' '), `NLB 목록에 ${infra} / ${ng}`).toMatch(new RegExp(`${infra}[^|]*${ng}|${ng}[^|]*${infra}`));

    // 4-1. 상세: 생성 직후 같은 NodeGroup 의 node 가 자동 할당되어 있어야 한다(Assigned Nodes)
    const row = page.locator('.tabulator-row').filter({ hasText: infra }).first();
    await row.click();
    await page.waitForTimeout(2000);
    const body = (await page.locator('body').innerText()).replace(/\s+/g, ' ');
    const detail = body.slice(body.indexOf('NLB Detail'), body.indexOf('NLB Detail') + 700);
    test.info().annotations.push({ type: 'nlb-detail', description: detail });
    // 2026-10-12 사용자 지시: AWS mc1 의 g1-1, g1-2 가 모두 할당되는지 확인(NLB_NODES 로 지정, 기본 {ng}-1)
    for (const n of (process.env.NLB_NODES ?? `${ng}-1`).split(',')) expect.soft(detail, `Assigned Nodes 에 ${n}`).toContain(n);

    // 5. Edit(assign / unassign nodes): 할당 대상은 같은 Infra 의 NodeGroup node 로 한정(2026-10-12 사용자 결정으로 기대결과 변경 —
    //    NLB 는 Infra+NodeGroup 단위라 다른 Infra(mw1) node 는 표시되지 않는 것이 사양)
    await openInfraDetail(page, infra);
    const sameNodes = (await page.locator('[id^="server_status_icon_"]').evaluateAll((es) => es.map((e) => e.id.replace('server_status_icon_', ''))));
    test.info().annotations.push({ type: 'same-infra-nodes', description: `${infra}: ${sameNodes.join(', ')}` });
    await openNlb(page);
    await page.locator('.tabulator-row').filter({ hasText: infra }).first().getByRole('checkbox').check();
    await page.locator('[title="Edit selected (assign / unassign nodes)"], [data-bs-original-title="Edit selected (assign / unassign nodes)"]').first().click();
    const em = page.locator('.modal.show').last();
    await expect(em).toBeVisible();
    await page.waitForTimeout(2000);
    const editText = (await em.innerText()).replace(/\s+/g, ' ');
    test.info().annotations.push({ type: 'nlb-edit-modal', description: editText.slice(0, 500) });
    await em.getByRole('button', { name: 'Cancel' }).click(); // 변경하지 않는다
    // Edit 의 Assigned + Available Nodes 가 모두 같은 Infra 의 node 인지 확인(Assigned 에 지정 node, Available 에 같은 Infra 의 나머지 node)
    const avail = editText.slice(editText.indexOf('Available Nodes'));
    const shown = sameNodes.filter((n) => editText.includes(n));
    test.info().annotations.push({ type: 'edit-nodes', description: `같은 Infra node 중 Edit 에 표시: ${shown.join(', ')} / Available 영역: ${avail.slice(0, 200)}` });
    for (const n of (process.env.NLB_NODES ?? `${ng}-1`).split(',')) expect(editText, `Edit Assigned Nodes 에 ${n}`).toContain(n);
    expect(shown.length, `Edit 에 같은 Infra(${infra}) 의 NodeGroup node 표시`).toBe(sameNodes.length);
  });
}

// IV3_S08: Workflow 필수 파라미터 누락 RUN [예상실패, 공통] — TC-WF-009
// 화면: Workflows(iframe) → multi-csp-vm-deploy RUN 팝업(Run Workflow) → Run → 토스트 / Infra Workloads
// 시작 상태: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default 선택된 상태에서 시작. TC-WF-001 완료(seed Workflow 존재)
// 절차: 1.Workflows 진입 → multi-csp-vm-deploy RUN 2.정상 입력값 설정: CSP_LIST=aws, Spec=t3.micro(상단 VM/K8s Spec), INFRA_ID=mcmp-e2e-v07-wf009,
//   INFRA_NODEGROUP_PREFIX=g1, INFRA_NODEGROUP_SIZE=1 3.AWS_IMAGE_ID 만 공란(상단 Image 미선택 + 파라미터 공란) 4.Run → 토스트 기록
//   5.약 2분 동안 Jenkins Build 목록(GET /workflow/log/{idx} — Workflows LOG 화면과 같은 출처)과 Infra 목록 관찰
// 입력값(Drive): CSP_LIST aws / 누락 항목 AWS_SPEC_ID 또는 AWS_IMAGE_ID 공란(이 spec 은 AWS_IMAGE_ID) / 나머지 유효한 값. INFRA_ID 공란은 기본 이름을 쓰므로 대상 아님
// 기대결과: 누락 값 검증 오류로 실행 요청 차단, 신규 Jenkins Build 와 자원(Infra mcmp-e2e-v07-wf009) 미생성
// 판정: 오류 안내가 있고 Build 수·Infra 변화가 없으면 PASS. Build 가 새로 생기거나 Infra 가 생기면 FAIL(검증 없이 실행)
// 비고: 2026-10-16 구현(stub 대체). 잘못 생성되면(결함) Infra mcmp-e2e-v07-wf009 는 정리 대상으로 결과 문서에 기록

import { test, expect } from '../../lib/fixtures';
import { tid } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { gotoInfraList, infraRow } from '../../lib/infra';
import { VM_DEPLOY_INPUT, pickSearchable, setParam, getParam, runAndCollectToasts } from '../../lib/workflow';
import { openRunRetry } from '../../lib/iv3-mc10';
import { workflowDetailByName, workflowBuilds } from '../../lib/iv3-wf';

const INFRA_ID = process.env.WF009_INFRA ?? 'mcmp-e2e-v07-wf009';

test(`${tid('IV3_S08')} Workflow 필수 파라미터 누락 RUN`, async ({ page }) => {
  test.setTimeout(15 * 60_000);
  const inp = VM_DEPLOY_INPUT.AWS!;
  await loginAsAdmin(page);
  await gotoInfraList(page);
  expect(await infraRow(page, INFRA_ID).count(), `${INFRA_ID} 미존재(시작 상태)`).toBe(0);

  const wf = await workflowDetailByName(page, 'multi-csp-vm-deploy');
  expect(wf, 'seed Workflow multi-csp-vm-deploy 존재(TC-WF-001)').toBeTruthy();
  const idx = Number(wf!.workflowInfo.workflowIdx);
  const before = await workflowBuilds(page, idx);
  const lastBefore = Math.max(0, ...before.map((b) => Number(b.buildIdx)));
  test.info().annotations.push({ type: 'builds-before', description: `workflowIdx ${idx} / Build ${before.length}건, 마지막 #${lastBefore}` });

  // 1~3. RUN 팝업: 정상값 + AWS_IMAGE_ID 공란
  const f = await openRunRetry(page, 'multi-csp-vm-deploy');
  await pickSearchable(f, 'VM/K8s Spec', inp.specQuery, inp.specOption);
  await setParam(f, 'CSP_LIST', inp.csp);
  await setParam(f, 'INFRA_ID', INFRA_ID);
  await setParam(f, 'INFRA_NODEGROUP_PREFIX', 'g1');
  await setParam(f, 'INFRA_NODEGROUP_SIZE', '1');
  await setParam(f, 'AWS_IMAGE_ID', '');
  const keys = ['NAMESPACE', 'INFRA_ID', 'INFRA_NODEGROUP_PREFIX', 'INFRA_NODEGROUP_SIZE', 'CSP_LIST', 'AWS_REGION', 'AWS_CONNECTION_NAME', 'AWS_ZONE', 'AWS_SPEC_ID', 'AWS_IMAGE_ID'];
  const vals: string[] = [];
  for (const k of keys) vals.push(`${k}=${await getParam(f, k).catch(() => '?')}`);
  test.info().annotations.push({ type: 'run-params', description: vals.join(', ') });
  test.info().annotations.push({ type: 'top-image', description: `상단 Image='${await f.getByPlaceholder('Image', { exact: true }).inputValue()}'` });
  expect(await getParam(f, 'AWS_IMAGE_ID'), 'AWS_IMAGE_ID 공란').toBe('');
  expect(await getParam(f, 'AWS_SPEC_ID'), 'AWS_SPEC_ID 정상값').toContain(inp.specQuery);

  // 4. Run
  const toasts = await runAndCollectToasts(page, f, 20_000);
  const modalOpen = await f.locator('.modal.show').isVisible().catch(() => false);
  const modalErr = modalOpen ? (await f.locator('.modal.show .invalid-feedback:visible, .modal.show .text-danger:visible, .modal.show .is-invalid').allInnerTexts().catch(() => [])).join(' | ') : '';
  test.info().annotations.push({ type: 'after-run', description: `팝업 ${modalOpen ? '열림(실행 안 됨)' : '닫힘'}${modalErr ? ` / 표시 오류: ${modalErr}` : ''}` });
  await page.waitForTimeout(3000); // 녹화용

  // 5. 관찰: 신규 Build·Infra
  let newBuild: { buildIdx: number; buildLog: string } | undefined;
  for (let i = 0; i < 4; i++) {
    await page.waitForTimeout(30_000);
    newBuild = (await workflowBuilds(page, idx)).find((b) => Number(b.buildIdx) > lastBefore);
    if (newBuild) break;
  }
  await gotoInfraList(page);
  const created = await infraRow(page, INFRA_ID).count();
  const tail = newBuild ? newBuild.buildLog.split(/\r?\n/).filter((l) => /ERROR|error|Finished|IMAGE/i.test(l)).slice(-5).join(' / ').slice(0, 600) : '';
  test.info().annotations.push({ type: 'result', description: `오류 토스트: ${toasts.join(' | ') || '(없음)'} / 신규 Build: ${newBuild ? `#${newBuild.buildIdx} ${tail}` : '없음'} / Infra ${INFRA_ID}: ${created ? '생성됨' : '없음'}` });

  expect(toasts.join(' '), '누락 값 검증 오류 안내').toMatch(/IMAGE|image|required|empty|missing|invalid|fail|error|select/i);
  expect(newBuild, '신규 Jenkins Build 미생성').toBeUndefined();
  expect(created, `Infra ${INFRA_ID} 미생성`).toBe(0);
});

// IV3_S09: Workflow Infra 이름 중복 RUN [예상실패, AWS]
// 화면: Workflows(iframe) → multi-csp-vm-deploy RUN 팝업 → Run
// 시작 상태: admin(mcmp) 로그인, ws01/default. IV3_S01 로 만든 mw1 이 Running
// 절차: 1.Infra Workloads 에서 mw1 의 노드 수·전체 Infra 수 기록 2.Workflows → multi-csp-vm-deploy RUN: INFRA_ID=mw1(기존과 동일), 나머지는 IV3_S01 과 같음
//   3.Run → 토스트 기록 4.일정 시간(최대 6분) Workflow 상태와 Infra 목록을 관찰
// 기대결과: 중복 에러 또는 실행 거부, 추가 자원 미생성(mw1 노드 수·Infra 수 변화 없음)
// 판정: 오류 토스트/Workflow 실패가 있고 자원이 늘지 않으면 PASS. 자원이 늘면 FAIL(중복 허용).

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, wfInfraName } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { gotoInfraList, infraRow, rowCells } from '../../lib/infra';
import { VM_DEPLOY_INPUT, runVmDeploy, workflowStatus } from '../../lib/workflow';

const nodesOf = (cells: Record<string, string>) => Number(cells['statusCount.countTotal'] ?? 'NaN');

for (const c of activeCsps(["AWS"])) {
  test(`${tid("IV3_S09", c)} ` + "Workflow Infra 이름 중복 RUN", async ({ page }) => {
    const inp = VM_DEPLOY_INPUT[c.code]!;
    const name = wfInfraName(c);
    await loginAsAdmin(page);
    await gotoInfraList(page);
    test.skip(!(await infraRow(page, name).count()), `선행 IV3_S01 의 ${name} 없음`);
    const before = await rowCells(infraRow(page, name).first());
    const infraCountBefore = await page.locator('.tabulator-row').filter({ has: page.locator('[tabulator-field="statusCount.countTotal"]') }).count();
    const wfBefore = await workflowStatus(page, 'multi-csp-vm-deploy');
    test.info().annotations.push({ type: 'before', description: `${name}: ${JSON.stringify(before)} / Infra 수 ${infraCountBefore} / workflow ${JSON.stringify(wfBefore)}` });

    const { toasts } = await runVmDeploy(page, inp, name, `g${c.n}`);
    const errToast = toasts.find((t) => /fail|error|exist|duplicat|invalid/i.test(t));

    // 관찰: Workflow 상태와 mw1 노드 수(최대 6분)
    let after = before; let wf = wfBefore; let infraCountAfter = infraCountBefore;
    for (let i = 0; i < 6; i++) {
      await page.waitForTimeout(45_000);
      wf = await workflowStatus(page, 'multi-csp-vm-deploy');
      await gotoInfraList(page);
      after = await rowCells(infraRow(page, name).first());
      infraCountAfter = await page.locator('.tabulator-row').filter({ has: page.locator('[tabulator-field="statusCount.countTotal"]') }).count();
      test.info().annotations.push({ type: `observe-${i}`, description: `workflow ${JSON.stringify(wf)} / ${name} ${after.status} nodes ${nodesOf(after)} / Infra 수 ${infraCountAfter}` });
      if (/fail|error|success|complete|done/i.test(wf.status) && i >= 1) break;
    }
    test.info().annotations.push({ type: 'result', description: `오류 토스트: ${errToast ?? '(없음)'} / workflow 최종 ${JSON.stringify(wf)} / 노드 ${nodesOf(before)} → ${nodesOf(after)} / Infra 수 ${infraCountBefore} → ${infraCountAfter}` });

    expect(nodesOf(after), `${name} 노드 수 변화 없음(추가 자원 미생성)`).toBe(nodesOf(before));
    expect(infraCountAfter, 'Infra 수 변화 없음').toBe(infraCountBefore);
    expect(errToast || /fail|error/i.test(wf.status) ? 'rejected' : 'accepted', '중복 에러 또는 실행 거부').toBe('rejected');
  });
}