// IV7_S01: Monitoring: Infra Monitoring Agent 설치 [정상, CSP별]
// 대상: Infra node (K8s 아님)
// 화면: Monitorings > Config(Monitor Setting, /webconsole/_view/mc011yconfig, iframe) → 대상 node 의 Monitoring Agent 열 Install 버튼
//   (Monitoring 화면에서는 node 옆 'Go to Config to install agent' 버튼으로 같은 화면으로 이동. 2026-10-07 프로브 확인)
// 시작 상태: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default 선택된 상태에서 시작. IV3 Infra Running
// 절차 (예: AWS 기준): 1.Monitorings > Config 진입 2.Workload mc1 의 첫 node(g1-1) Monitoring Agent 가 Not installed 인지 확인
//   3.Monitoring Agent 'Install' 클릭 → 확인창 확인(Log Agent 는 누르지 않음) 4.요청 접수 및 Installing → Installed(SUCCESS) 확인
// 기대결과: 설치 요청 접수, Monitoring Agent 가 설치된다
// 2026-10-12: 화면의 '첫 Install 버튼' 이 아니라 대상 node({ng}-1, MON_NODE 로 변경 가능)의 Monitoring Agent 칸을 지정해 누른다 — 다른 Infra/CSP 의 node 를 잘못 누르지 않도록(KT mc9 추가).
//   이미 설치돼 있으면(preexisting) 설치 단계는 건너뛰고 상태만 기록한다.
// 선행 Infra 가 Config 화면에 없으면 BLOCKED 로 skip 한다.

import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, infraName, infraNodegroups, DEFAULT_PROJECT } from '../../lib/data';
import { openConfig, waitNodeRunning, agentAction, cellText, classify, settleAgent } from './monitoring';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) { // 엑셀에 있는 CSP: AWS, Azure, Alibaba, GCP, Tencent, NHN Cloud, NCP, IBM, KT
  test(`${tid("IV7_S01", c)} ` + "[Infra] Monitoring: Infra 에이전트 설치", async ({ page, dialogs }) => {
    test.setTimeout(30 * 60 * 1000);
    const infra = infraName(c);
    const node = process.env.MON_NODE || `${infraNodegroups(c)[0]}-1`;
    test.info().annotations.push({ type: 'target', description: `Infra node (K8s 아님): infra=${infra} node=${node}` });
    const first = await openConfig(page, DEFAULT_PROJECT);
    test.skip(!first.text.includes(infra), `BLOCKED: 선행 Infra ${infra} 가 Monitor Setting 화면에 없음 (IV3 Infra Running 필요)`);
    const fr = await waitNodeRunning(page, DEFAULT_PROJECT, node);
    const monBefore = await settleAgent(page, fr, node, 'Monitoring');
    const logBefore = await cellText(fr, node, 'Log');
    test.info().annotations.push({ type: 'before', description: `Monitoring: ${monBefore} / Log: ${logBefore}` });
    if (classify(monBefore) === 'installed' || classify(monBefore) === 'inactive') {
      test.info().annotations.push({ type: 'preexisting', description: `Monitoring Agent 이미 설치됨(${monBefore}) → 설치 단계 건너뜀` });
      return;
    }
    expect(classify(monBefore), `시작: Monitoring Agent Not installed(현재 ${monBefore})`).toMatch(/not-installed|failed/);
    if (classify(monBefore) === 'failed') { // 이전 시도 흔적(FAILED)은 Uninstall 로 정리한 뒤 다시 설치
      const u = await agentAction(page, fr, dialogs, node, 'Monitoring', 'Uninstall');
      test.info().annotations.push({ type: 'precondition', description: `Monitoring Agent(failed) Uninstall → ${u.state}` });
      expect(u.done, `Monitoring Agent Uninstall 후 Not installed — 마지막 상태: ${u.state}`).toBe(true);
    }
    const r = await agentAction(page, fr, dialogs, node, 'Monitoring', 'Install');
    test.info().annotations.push({ type: 'monitoring-result', description: `Monitoring Agent 설치 결과: ${r.cls} (${r.seen.join(' → ')})` });
    const logAfter = await cellText(fr, node, 'Log');
    test.info().annotations.push({ type: 'after', description: `Monitoring: ${r.state} / Log: ${logAfter}` });
    expect.soft(logAfter, 'Log Agent 상태 변화 없음').toBe(logBefore);
    expect(r.done, `Monitoring Agent 설치 완료(Installed) — 마지막 상태: ${r.state}`).toBe(true);
  });
}

// IV7_S02: Monitoring: K8s 모니터링 설치 [정상, CSP별]
// 대상: K8s cluster / K8s node (Infra 아님)
// 화면: Monitorings > Config(Monitor Setting, iframe, Namespace=Project) → K8s {cluster} 의 node → Monitoring Agent 'Install'
// 시작 상태: admin 로그인 상태, Workspace=ws01 / Project=p1 선택 상태에서 시작. IV3 K8s Ready
// 절차 (예: AWS 기준): 1.Monitoring(K8s 탭)에서 k1d 의 node 가 'agent not installed' 인지 확인 2.Config 화면 K8s k1d 의 node Monitoring Agent 'Install' 클릭
//   3.설치 요청 접수(알림 또는 상태 변화) 확인
// 기대결과: 설치 요청 접수
// 선행 K8s(k{n}) 가 Config 화면에 없으면 BLOCKED 로 skip 한다.
// 대상 K8s: 기본 k{n}(IV3_S13 Workflow 의 {prefix}-{csp} 이름은 k1-aws 라 다를 수 있음) — K8S_CLUSTER 로 변경(v07 AWS: k1d)

import { test } from '../../lib/fixtures';
import { activeCsps, tid, k8sName, k8sProject } from '../../lib/data';
import { openConfig, installFirstAgent } from './monitoring';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) { // 엑셀에 있는 CSP: AWS, Azure, Alibaba, GCP, Tencent, NHN Cloud, NCP, IBM, KT
  test(`${tid("IV7_S02", c)} ` + "[K8s] Monitoring: K8s 모니터링 설치", async ({ page, dialogs }) => {
    test.setTimeout(10 * 60 * 1000);
    const cluster = process.env.K8S_CLUSTER || k8sName(c);
    test.info().annotations.push({ type: 'target', description: `K8s cluster/node (Infra 아님): cluster=${cluster}, project=${k8sProject(c)}` });
    const { fr, text } = await openConfig(page, k8sProject(c));
    test.skip(!text.includes(cluster), `BLOCKED: 선행 K8s ${cluster} 가 Monitor Setting 화면에 없음 (IV3 K8s Ready, Project ${k8sProject(c)} 필요)`);
    // 클러스터가 여러 개면(k1-aws 는 node 0) 대상 클러스터 구역의 Install 을 눌러야 한다 — 'No nodes' 인 클러스터를 건너뛰고 첫 Install 을 사용
    await installFirstAgent(page, fr, dialogs);
  });
}

// IV7_S03: [Infra] Monitoring: Log Agent 설치 [정상, CSP별]
// 대상: Infra node (K8s 아님)
// 화면: Monitorings > Config(Monitor Setting, /webconsole/_view/mc011yconfig, iframe) → 대상 node 의 Log Agent 열 Install 버튼
// 전제: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default. IV3 Infra mc{n} Running
// 절차(AWS): 1.Monitorings > Config 진입 2.Workload mc1 의 node g1-1 Log Agent 가 Not installed 인지 확인(FAILED 등 이전 시도 흔적이 있으면 Uninstall 로 정리)
//   3.Log Agent 'Install' 클릭(Monitoring Agent 는 누르지 않음) → 확인창 확인 4.요청 접수 및 Installing → Installed(SUCCESS) 확인 5.Monitoring Agent 상태는 시작 때와 같은지 확인
// 기대결과: Log Agent 설치 요청이 접수되고 Log Agent 만 설치된다(Monitoring Agent 상태 변화 없음)
// 상태 문구: Not installed / INSTALLING Installing… / SUCCESS(또는 Installed) / FAILED / SERVICE_INACTIVE (+ Uninstall 버튼). FAILED 는 설치 실패이며 Uninstall 로 정리 가능
// 선행 Infra 가 Config 화면에 없으면 BLOCKED 로 skip. 대상 node 는 첫 node({ng}-1), MON_NODE 환경변수로 변경 가능(NODE 는 node 실행 경로 환경변수라 쓰지 않는다)
import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, infraName, infraNodegroups, DEFAULT_PROJECT } from '../../lib/data';
import { openConfig, waitNodeRunning, agentAction, cellText, classify, settleAgent } from './monitoring';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  test(`${tid("IV7_S03", c)} ` + "[Infra] Monitoring: Log Agent 설치", async ({ page, dialogs }) => {
    test.setTimeout(30 * 60 * 1000);
    const infra = infraName(c);
    const node = process.env.MON_NODE ||`${infraNodegroups(c)[0]}-1`;
    test.info().annotations.push({ type: 'target', description: `Infra node (K8s 아님): infra=${infra} node=${node}` });
    const first = await openConfig(page, DEFAULT_PROJECT);
    test.skip(!first.text.includes(infra), `BLOCKED: 선행 Infra ${infra} 가 Monitor Setting 화면에 없음 (IV3 Infra Running 필요)`);
    const fr = await waitNodeRunning(page, DEFAULT_PROJECT, node);
    const monBefore = await cellText(fr, node, 'Monitoring');
    let logBefore = await settleAgent(page, fr, node, 'Log');
    test.info().annotations.push({ type: 'before', description: `Monitoring: ${monBefore} / Log: ${logBefore}` });
    // 전제 준비: 설치돼 있거나 실패 흔적이 있으면 Uninstall 로 Not installed 로 맞춘다
    if (!/not-installed/.test(classify(logBefore))) {
      const u = await agentAction(page, fr, dialogs, node, 'Log', 'Uninstall');
      test.info().annotations.push({ type: 'precondition', description: `Log Agent(${classify(logBefore)}) Uninstall → ${u.state}` });
      expect(u.done, `Log Agent Uninstall 후 Not installed — 마지막 상태: ${u.state}`).toBe(true);
    }
    const r = await agentAction(page, fr, dialogs, node, 'Log', 'Install');
    test.info().annotations.push({ type: 'log-result', description: `Log Agent 설치 결과: ${r.cls} (${r.seen.join(' → ')})` });
    const monAfter = await cellText(fr, node, 'Monitoring');
    test.info().annotations.push({ type: 'after', description: `Monitoring: ${monAfter} / Log: ${r.state}` });
    expect.soft(monAfter, 'Monitoring Agent 상태 변화 없음').toBe(monBefore);
    expect(r.done, `Log Agent 설치 완료(Installed) — 마지막 상태: ${r.state}`).toBe(true);
  });
}

// IV7_S04: [K8s] Monitoring: Log Agent 설치 [정상, CSP별]
// 대상: K8s cluster / K8s node (Infra 아님)
// 화면: Monitorings > Config(Monitor Setting, iframe, Namespace=Project) → K8s {cluster} 의 node → Log Agent 열 Install 버튼
// 전제: admin 로그인 상태, Workspace=ws01 / Project=p{n}. IV3 K8s Active. AWS: Project p1 / k1d / NodeGroup g1s
// 절차(AWS): 1.K8s Workloads 에서 k1d NodeGroup g1s 의 node 확인 2.Monitorings > Config(p1) 의 K8s k1d 에서 그 node 행의 Log Agent 확인
//   3.Log Agent 가 Not installed 가 아니면(이전 시도/설치) Uninstall 로 정리(전제 준비) 4.Log Agent 'Install' 클릭(Monitoring Agent 는 누르지 않음) → 확인
//   5.Log Agent Installing → Installed 확인 6.Monitoring Agent 상태는 시작 때와 같은지 확인
// 기대결과: Log Agent 설치 요청이 접수되고 Log Agent 만 설치된다(Monitoring Agent 상태 변화 없음)
// 대상 클러스터/NodeGroup: K8S_CLUSTER(기본 k{n}), K8S_NG(기본 g{n}s) — v07 AWS: k1d / g1s
import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, k8sName, k8sProject } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { gotoK8s, selectNodeGroup } from '../../lib/iv3-k8s';
import { openConfig, waitNodeRunning, agentAction, cellText, classify, settleAgent } from './monitoring';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  test(`${tid("IV7_S04", c)} ` + "[K8s] Monitoring: Log Agent 설치", async ({ page, dialogs }) => {
    test.setTimeout(40 * 60 * 1000);
    const prj = k8sProject(c);
    const cluster = process.env.K8S_CLUSTER || k8sName(c);
    const ngName = process.env.K8S_NG || `g${c.n}s`;
    await loginAsAdmin(page);
    await gotoK8s(page, prj);
    const st = await selectNodeGroup(page, cluster, ngName);
    const node = st.nodes[0];
    test.info().annotations.push({ type: 'target', description: `K8s cluster/node (Infra 아님): ${prj} / ${cluster} / NodeGroup ${ngName} / node ${node ?? '(없음)'}` });
    test.skip(!node, `BLOCKED: NodeGroup ${ngName} 에 node 없음`);
    // K8s 목록은 화면 제목보다 늦게 채워진다 → 최대 3회 다시 열어 확인
    let seen = false;
    for (let i = 0; i < 3 && !seen; i++) {
      const o = await openConfig(page, prj);
      seen = o.text.includes(cluster) && o.text.includes(node);
      if (!seen) await page.waitForTimeout(15_000);
    }
    test.skip(!seen, `BLOCKED: ${cluster} / ${node} 가 Monitor Setting 화면에 없음`);
    const fr = await waitNodeRunning(page, prj, node);
    const monBefore = await settleAgent(page, fr, node, 'Monitoring');
    const logBefore = await settleAgent(page, fr, node, 'Log');
    test.info().annotations.push({ type: 'before', description: `Monitoring: ${monBefore} / Log: ${logBefore}` });
    if (classify(logBefore) !== 'not-installed') {
      const u = await agentAction(page, fr, dialogs, node, 'Log', 'Uninstall');
      test.info().annotations.push({ type: 'precondition', description: `Log Agent(${classify(logBefore)}) Uninstall → ${u.state}` });
      expect(u.done, `Log Agent Uninstall 후 Not installed — 마지막 상태: ${u.state}`).toBe(true);
    }
    const r = await agentAction(page, fr, dialogs, node, 'Log', 'Install');
    test.info().annotations.push({ type: 'log-result', description: `Log Agent 설치 결과: ${r.cls} (${r.seen.join(' → ')})` });
    const monAfter = await cellText(fr, node, 'Monitoring');
    test.info().annotations.push({ type: 'after', description: `Monitoring: ${monAfter} / Log: ${r.state}` });
    expect.soft(monAfter, 'Monitoring Agent 상태 변화 없음').toBe(monBefore);
    expect(r.done, `Log Agent 설치 완료(Installed) — 마지막 상태: ${r.state}`).toBe(true);
  });
}

// IV7_S05: [Infra] Monitoring: Monitoring Agent + Log Agent 둘 다 설치 [정상, CSP별]
// 대상: Infra node (K8s 아님)
// 화면: Monitorings > Config(Monitor Setting, iframe) → 대상 node 의 Monitoring Agent 열 Install, Log Agent 열 Install
// 전제: admin(mcmp) 로그인 상태, Workspace=ws01 / Project=default. IV3 Infra mc{n} Running, 두 에이전트가 모두 Not installed 인 node 필요(AWS: g1-2)
// 절차(AWS): 1.Monitorings > Config 진입 2.Workload mc1 의 두 에이전트가 모두 Not installed 인 node(g1-2) 확인 3.Monitoring Agent 'Install' → 확인 4.Log Agent 'Install' → 확인
//   5.두 에이전트 모두 Installing → Installed(Uninstall 버튼) 확인(약 3분)
// 기대결과: 두 에이전트 설치 요청이 각각 접수되고 모두 Installed 가 된다
// 대상 node 는 MON_NODE 환경변수로 지정(기본 {ng}-2). 두 에이전트가 이미 설치/일부 설치된 node 면 BLOCKED 로 skip
import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, infraName, infraNodegroups, DEFAULT_PROJECT } from '../../lib/data';
import { openConfig, waitNodeRunning, agentAction, cellText, classify, settleAgent } from './monitoring';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  test(`${tid("IV7_S05", c)} ` + "[Infra] Monitoring: Monitoring Agent + Log Agent 둘 다 설치", async ({ page, dialogs }) => {
    test.setTimeout(30 * 60 * 1000);
    const infra = infraName(c);
    const node = process.env.MON_NODE ||`${infraNodegroups(c)[0]}-2`;
    test.info().annotations.push({ type: 'target', description: `Infra node (K8s 아님): infra=${infra} node=${node}` });
    const first = await openConfig(page, DEFAULT_PROJECT);
    test.skip(!first.text.includes(infra), `BLOCKED: 선행 Infra ${infra} 가 Monitor Setting 화면에 없음 (IV3 Infra Running 필요)`);
    const fr = await waitNodeRunning(page, DEFAULT_PROJECT, node);
    const mon0 = await settleAgent(page, fr, node, 'Monitoring');
    const log0 = await settleAgent(page, fr, node, 'Log');
    test.info().annotations.push({ type: 'before', description: `Monitoring: ${mon0} / Log: ${log0}` });
    test.skip(!(classify(mon0) === 'not-installed' && classify(log0) === 'not-installed'), `BLOCKED: ${node} 의 두 에이전트가 모두 Not installed 가 아님`);
    const m = await agentAction(page, fr, dialogs, node, 'Monitoring', 'Install');
    const l = await agentAction(page, fr, dialogs, node, 'Log', 'Install');
    test.info().annotations.push({ type: 'after', description: `Monitoring: ${await cellText(fr, node, 'Monitoring')} / Log: ${await cellText(fr, node, 'Log')}` });
    expect.soft(m.done, `Monitoring Agent 설치 완료 — 마지막 상태: ${m.state}`).toBe(true);
    expect.soft(l.done, `Log Agent 설치 완료 — 마지막 상태: ${l.state}`).toBe(true);
  });
}

// IV7_S06: [K8s] Monitoring: Monitoring Agent + Log Agent 둘 다 설치 [정상, CSP별]
// 대상: K8s cluster / K8s node (Infra 아님)
// 화면: Monitorings > Config(Monitor Setting, iframe, Namespace=Project) → K8s {cluster} 의 node → Monitoring Agent 열 Install, Log Agent 열 Install
// 전제: admin 로그인 상태, Workspace=ws01 / Project=p{n}. IV3 K8s Active. AWS: Project p1 / k1d / NodeGroup g1s(사용자 지시 2026-10-08)
// 절차(AWS): 1.K8s Workloads 에서 k1d NodeGroup g1s 의 node 확인 2.Monitorings > Config(p1) 의 K8s k1d 에서 그 node 행 확인
//   3.Monitoring Agent 가 이미 설치돼 있으면(IV7_S02) 먼저 Uninstall 로 Not installed 상태를 만든다(전제 준비) 4.Monitoring Agent 'Install' → 확인 5.Log Agent 'Install' → 확인
//   6.두 에이전트 모두 Installing → Installed 확인
// 기대결과: 두 에이전트 설치 요청이 각각 접수되고 모두 Installed 가 된다
// 대상 클러스터/NodeGroup: K8S_CLUSTER(기본 k{n}), K8S_NG(기본 g{n}s) — v07 AWS: k1d / g1s
import { test, expect } from '../../lib/fixtures';
import { activeCsps, tid, k8sName, k8sProject } from '../../lib/data';
import { loginAsAdmin } from '../../lib/ui';
import { gotoK8s, selectNodeGroup } from '../../lib/iv3-k8s';
import { openConfig, waitNodeRunning, agentAction, cellText, classify, settleAgent } from './monitoring';

for (const c of activeCsps(["AWS","Azure","Alibaba","GCP","Tencent","NHN Cloud","NCP","IBM","KT"])) {
  test(`${tid("IV7_S06", c)} ` + "[K8s] Monitoring: Monitoring Agent + Log Agent 둘 다 설치", async ({ page, dialogs }) => {
    test.setTimeout(40 * 60 * 1000);
    const prj = k8sProject(c);
    const cluster = process.env.K8S_CLUSTER || k8sName(c);
    const ngName = process.env.K8S_NG || `g${c.n}s`;
    await loginAsAdmin(page);
    await gotoK8s(page, prj);
    const st = await selectNodeGroup(page, cluster, ngName);
    const node = st.nodes[0];
    test.info().annotations.push({ type: 'target', description: `K8s cluster/node (Infra 아님): ${prj} / ${cluster} / NodeGroup ${ngName} / node ${node ?? '(없음)'}` });
    test.skip(!node, `BLOCKED: NodeGroup ${ngName} 에 node 없음`);
    // K8s 목록은 화면 제목보다 늦게 채워진다(2026-10-08: 첫 로드에서 'Monitor Setting Namespace: p1 Refresh' 만 보임) → 최대 3회 다시 열어 확인
    let seen = false;
    for (let i = 0; i < 3 && !seen; i++) {
      const o = await openConfig(page, prj);
      seen = o.text.includes(cluster) && o.text.includes(node);
      if (!seen) await page.waitForTimeout(15_000);
    }
    test.skip(!seen, `BLOCKED: ${cluster} / ${node} 가 Monitor Setting 화면에 없음`);
    const fr = await waitNodeRunning(page, prj, node);
    const mon = await settleAgent(page, fr, node, 'Monitoring');
    const log = await settleAgent(page, fr, node, 'Log');
    test.info().annotations.push({ type: 'before', description: `Monitoring: ${mon} / Log: ${log}` });
    // 전제 준비: 이미 설치된 에이전트는 Uninstall 해서 둘 다 Not installed 로 맞춘다
    for (const kind of ['Monitoring', 'Log'] as const) {
      const t = kind === 'Monitoring' ? mon : log;
      // 'Failed Install'(K8s 설치 실패, 2026-10-15 GKE)처럼 Install 버튼만 있으면 Uninstall 없이 바로 Install 단계로
      if (classify(t) !== 'not-installed' && /Uninstall/.test(t)) {
        const u = await agentAction(page, fr, dialogs, node, kind, 'Uninstall');
        test.info().annotations.push({ type: 'precondition', description: `${kind} Agent Uninstall → ${u.state}` });
        expect(u.done, `${kind} Agent Uninstall 후 Not installed — 마지막 상태: ${u.state}`).toBe(true);
      }
    }
    const m = await agentAction(page, fr, dialogs, node, 'Monitoring', 'Install');
    const l = await agentAction(page, fr, dialogs, node, 'Log', 'Install');
    test.info().annotations.push({ type: 'after', description: `Monitoring: ${await cellText(fr, node, 'Monitoring')} / Log: ${await cellText(fr, node, 'Log')}` });
    expect.soft(m.done, `Monitoring Agent 설치 완료 — 마지막 상태: ${m.state}`).toBe(true);
    expect.soft(l.done, `Log Agent 설치 완료 — 마지막 상태: ${l.state}`).toBe(true);
  });
}

// IV7_S07: TC-OBS-007 모니터링 플러그인(item) 등록 (Monitoring Agent) [정상, 공통]
// v0.6 TC-ID: TC-OBS-AGENT-04
// 화면: Monitorings > Config → Agent 설치 완료 node → 메트릭(플러그인) 토글 표
// 시작 상태: admin(mcmp) 로그인, ws01/default. 대상 node Monitoring Agent SUCCESS(TC-OBS-AGENT-03), node Running
// 절차: 1.설치 완료 node 선택 2.등록 item(GET …/node/{nodeId}/item)·사용 가능 플러그인(GET /api/o11y/monitoring/plugins) 3.비활성 플러그인 ON 4.등록(POST …/node/{nodeId}/item) 5.item 목록 갱신 6.(원복) 켠 플러그인 OFF(DELETE …/item/{itemSeq})
// 기대결과: 플러그인 등록 2xx, item 목록(seq, pluginName, state)
// 실행 보류(사용자 결정 2026-10-14: 상태를 바꾸는 OBS TC 는 spec 만 작성). OBS_WRITE=1 일 때만 실행.
// 2026-10-16 수정(rf-obs2 탐색, 실행 전): 화면 확인 결과 node 행(<td>) 클릭 → 표 아래 'Monitoring Metrics — {node}' 패널(플러그인 11개 체크박스 cpu…system + 'Apply',
//   안내 'Enables the selected metrics and disables the rest.'). 행별 토글이 아니라 Apply 한 번에 선택 집합을 반영 → 이전 선택 상태를 기록하고 하나만 추가해 Apply, 원복은 이전 집합으로 다시 Apply.
// 2026-10-16 보완(사용자 지시): 비활성 플러그인이 없으면 하나를 끄고 Apply → 다시 켜서 Apply → item 목록에 등록 확인(끝 상태 = 원래대로 모두 켜짐)
//   node 가 Suspended 이면 item 조회가 없고 체크가 모두 비어 보여(Apply 시 전부 끄게 됨) 실행하지 않는다 — Running node(OBS_WRITE_NODE) 필요. Apply 이후 API(POST/DELETE item) 는 미검증
import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { openObs, collectResponses, clean, OBS_NS, OBS_INFRA } from '../../lib/iv7-obs';

test('IV7_S07 TC-OBS-007 모니터링 플러그인(item) 등록', async ({ page }) => {
  test.skip(process.env.OBS_WRITE !== '1', '상태 변경 TC — OBS_WRITE=1 일 때만 실행(사용자 결정 2026-10-14)');
  const node = process.env.OBS_WRITE_NODE ?? '';
  test.skip(!node, 'OBS_WRITE_NODE 미지정(공용 node 보호)');
  const items = collectResponses(page, new RegExp(`/api/o11y/monitoring/${OBS_NS}/${OBS_INFRA}/node/${node}/item`));
  await loginAsAdmin(page);
  const f = await openObs(page, 'config');
  const row = f.locator('tr').filter({ has: f.locator('td', { hasText: new RegExp(`^${node}$`) }) }).first();
  const rowText = clean(await row.innerText());
  test.info().annotations.push({ type: 'row', description: rowText });
  test.skip(!/Running/.test(rowText), `BLOCKED: ${node} 가 Running 아님(${rowText}) — 플러그인 반영에 VM 접속 필요`);
  await row.locator('td').first().click();
  await expect(f.getByRole('button', { name: 'Apply', exact: true })).toBeVisible({ timeout: 30_000 });
  await expect.poll(() => items.filter((i) => i.method === 'GET').length, { message: 'item 목록 GET', timeout: 30_000 }).toBeGreaterThan(0);
  const before: any[] = items.filter((i) => i.method === 'GET').at(-1)!.json?.data ?? [];
  test.info().annotations.push({ type: 'items-before', description: JSON.stringify(before).slice(0, 600) });
  const boxes = f.locator('label').filter({ has: f.locator('input[type="checkbox"]') });
  const names = (await boxes.allInnerTexts()).map((s) => s.trim());
  const checked = await boxes.locator('input[type="checkbox"]').evaluateAll((els) => els.map((e) => (e as HTMLInputElement).checked));
  const apply = async (label: string) => {
    const n0 = items.length;
    await f.getByRole('button', { name: 'Apply', exact: true }).click();
    await expect.poll(() => items.slice(n0).some((i) => i.method !== 'GET' && i.status < 300), { message: `${label} 2xx`, timeout: 60_000 }).toBe(true);
    test.info().annotations.push({ type: label, description: items.slice(n0).filter((i) => i.method !== 'GET').map((i) => `${i.status} ${i.method} ${i.url.split('/api/')[1]}`).join(' | ').slice(0, 600) });
  };
  let offIdx = checked.findIndex((c, i) => !c && !/nvidia/.test(names[i]));
  // 2026-10-16 보완(사용자 지시): 모든 플러그인이 켜져 있으면(비활성 없음) 하나를 먼저 끄고 Apply → 그 플러그인을 다시 켜서 등록되는지 확인한다.
  //   끈 플러그인은 마지막에 켠 상태로 끝나므로 원래 상태(모두 켜짐)로 돌아간다.
  let restoreOff = true; // 원래 꺼져 있던 것을 켰으면 마지막에 다시 끈다
  if (offIdx < 0) {
    offIdx = names.findIndex((n) => !/nvidia/.test(n) && !/^cpu$/i.test(n)); // cpu 는 기본 수집이라 피함
    expect(offIdx, '끄고 다시 켤 플러그인').toBeGreaterThanOrEqual(0);
    await boxes.nth(offIdx).locator('input').uncheck();
    await apply('pre-off');
    restoreOff = false;
  }
  const name = names[offIdx];
  await boxes.nth(offIdx).locator('input').check();
  await apply('register');
  // 등록 확인: item 목록을 다시 읽어 그 플러그인이 있는지
  await f.locator('tr').filter({ has: f.locator('td', { hasText: new RegExp(`^${node}$`) }) }).first().locator('td').first().click();
  await expect.poll(() => (items.filter((i) => i.method === 'GET').at(-1)?.json?.data ?? []).some((x: any) => new RegExp(name, 'i').test(x.pluginName ?? x.name ?? JSON.stringify(x))),
    { message: `item 목록에 ${name}`, timeout: 60_000 }).toBe(true);
  test.info().annotations.push({ type: 'items-after', description: JSON.stringify(items.filter((i) => i.method === 'GET').at(-1)?.json?.data ?? []).slice(0, 600) });
  if (restoreOff) { // (원복) 원래 꺼져 있던 플러그인은 다시 끔
    await boxes.nth(offIdx).locator('input').uncheck();
    await apply('restore-off');
  }
});

// IV7_S08: TC-OBS-008 Monitoring Agent 제거 (Uninstall) [정상, 공통]
// v0.6 TC-ID: TC-OBS-AGENT-05
// 화면: Monitorings > Config → node 행 Monitoring Agent 의 Uninstall → 확인
// 시작 상태: admin(mcmp) 로그인, ws01/default. 설치된 node(OBS_WRITE_NODE — 다른 세션이 쓰는 node 는 지정 금지)
// 절차: 1.node 행 Monitoring Agent Uninstall → 확인 2.제거 호출(DELETE /api/o11y/monitoring/{ns}/{infra}/node/{node}) 3.미등록 상태 전환 4.(원복) 재설치는 IV7_S01 절차
// 기대결과: 제거 응답 2xx, node 미등록 상태
// 실행 보류(사용자 결정 2026-10-14: 상태를 바꾸는 OBS TC 는 spec 만 작성). OBS_WRITE=1 일 때만 실행. 셀렉터는 IV7_S03 과 같은 monitoring.ts agentAction(검증됨)
// 2026-10-16 수정(rf-obs2): node 가 Running 이 아니면 BLOCKED skip 추가 — Suspended node 에서 Uninstall 하면 VM 접속 실패로 FAILED 가 남는다(mc9 g9-1 사례).
//   2026-10-16 시점 대상 후보 mc1/g1-2(두 에이전트 SERVICE_INACTIVE=설치됨, Suspended)는 Resume 이 필요해 미실행
import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { openObs, collectResponses, OBS_NS, OBS_INFRA } from '../../lib/iv7-obs';
import { agentAction, cellText, rowStatus } from './monitoring';

test('IV7_S08 TC-OBS-008 Monitoring Agent 제거 (Uninstall)', async ({ page, dialogs }) => {
  test.skip(process.env.OBS_WRITE !== '1', '상태 변경 TC — OBS_WRITE=1 일 때만 실행(사용자 결정 2026-10-14)');
  const node = process.env.OBS_WRITE_NODE ?? '';
  test.skip(!node, 'OBS_WRITE_NODE 미지정(공용 node 보호)');
  const del = collectResponses(page, new RegExp(`/api/o11y/monitoring/${OBS_NS}/${OBS_INFRA}/node/${node}`));
  await loginAsAdmin(page);
  const f = page.frameLocator('iframe').first();
  await openObs(page, 'config');
  const st = await rowStatus(f, node);
  test.info().annotations.push({ type: 'node-status', description: `${node}:${st || '행 없음'} / Monitoring: ${await cellText(f, node, 'Monitoring')} / Log: ${await cellText(f, node, 'Log')}` });
  test.skip(st !== 'Running', `BLOCKED: ${node} 가 Running 아님(${st || '행 없음'}) — 에이전트 제거는 VM 접속 필요('Cannot connect to the VM — it must be running')`);
  await agentAction(page, f, dialogs, node, 'Monitoring', 'Uninstall');
  test.info().annotations.push({ type: 'api', description: del.map((d) => `${d.status} ${d.method} ${d.url}`).join(' | ') });
  expect(await cellText(f, node, 'Monitoring')).toMatch(/NOT[_ ]INSTALLED|Install/i);
});

// IV7_S09: TC-OBS-009 Log Agent 제거 (Uninstall) [정상, 공통]
// v0.6 TC-ID: TC-OBS-AGENT-05(Log)
// 화면: Monitorings > Config → node 행 Log Agent 의 Uninstall → 확인
// 시작 상태: admin(mcmp) 로그인, ws01/default. Log Agent 설치 node(OBS_WRITE_NODE)
// 절차: 1.node 행 Log Agent Uninstall → 확인 2.제거 호출 3.미등록 상태 4.(원복) 재설치는 IV7_S03 절차
// 기대결과: 제거 응답 2xx, node 미등록 상태
// 실행 보류(사용자 결정 2026-10-14: 상태를 바꾸는 OBS TC 는 spec 만 작성). OBS_WRITE=1 일 때만 실행. 셀렉터는 IV7_S03 과 같은 monitoring.ts agentAction(검증됨)
// 2026-10-16 수정(rf-obs2): node 가 Running 이 아니면 BLOCKED skip 추가 — Suspended node 에서 Uninstall 하면 VM 접속 실패로 FAILED 가 남는다(mc9 g9-1 사례).
//   2026-10-16 시점 대상 후보 mc1/g1-2(두 에이전트 SERVICE_INACTIVE=설치됨, Suspended)는 Resume 이 필요해 미실행
import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { openObs } from '../../lib/iv7-obs';
import { agentAction, cellText, rowStatus } from './monitoring';

test('IV7_S09 TC-OBS-009 Log Agent 제거 (Uninstall)', async ({ page, dialogs }) => {
  test.skip(process.env.OBS_WRITE !== '1', '상태 변경 TC — OBS_WRITE=1 일 때만 실행(사용자 결정 2026-10-14)');
  const node = process.env.OBS_WRITE_NODE ?? '';
  test.skip(!node, 'OBS_WRITE_NODE 미지정(공용 node 보호)');
  await loginAsAdmin(page);
  const f = page.frameLocator('iframe').first();
  await openObs(page, 'config');
  const st = await rowStatus(f, node);
  test.info().annotations.push({ type: 'node-status', description: `${node}:${st || '행 없음'} / Monitoring: ${await cellText(f, node, 'Monitoring')} / Log: ${await cellText(f, node, 'Log')}` });
  test.skip(st !== 'Running', `BLOCKED: ${node} 가 Running 아님(${st || '행 없음'}) — 에이전트 제거는 VM 접속 필요('Cannot connect to the VM — it must be running')`);
  await agentAction(page, f, dialogs, node, 'Log', 'Uninstall');
  expect(await cellText(f, node, 'Log')).toMatch(/NOT[_ ]INSTALLED|Install/i);
});

// IV7_S10: TC-OBS-010 Trigger Policy 생성/목록/삭제 [정상, 공통]
// v0.6 TC-ID: TC-OBS-TRIG-01
// 화면: Monitorings > Alert → Policies → + New Policy
// 시작 상태: admin(mcmp) 로그인, ws01/default. mc-o11y-manager / Grafana(알림) 기동
// 절차: 1.Policies 탭 2.목록(GET /api/o11y/trigger/policy) 3.+ New Policy: title/description/resourceType CPU/aggregation AVG/holdDuration 5m/repeatInterval 1h/threshold info·warning·critical → 생성(POST) 4.목록 반영 5.삭제(202) → 목록에서 제거
// 기대결과: 생성 201(id), 목록(content[], totalElements), 삭제 202
// 실행 보류(사용자 결정 2026-10-14: 상태를 바꾸는 OBS TC 는 spec 만 작성). OBS_WRITE=1 일 때만 실행.
// 2026-10-16 수정(첫 실행, rf-obs2): 2026-10-14 추정 셀렉터(getByLabel)가 화면과 달라 교체 — 폼 라벨이 <label> 이 아닌 <div> 라서
//   lib/iv7-obs.ts policyField/createPolicy/deletePolicy 사용. 삭제 확인은 JS confirm('Delete this policy?')이라 fixtures dialogs 가 수락. 실패해도 finally 에서 정책 삭제(정리)
import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { openObs, collectResponses, createPolicy, deletePolicy, policyRow, clean } from '../../lib/iv7-obs';

export const POLICY = 'iv7-s10-cpu-policy';
test('IV7_S10 TC-OBS-010 Trigger Policy 생성/목록/삭제', async ({ page }) => {
  test.skip(process.env.OBS_WRITE !== '1', '상태 변경 TC — OBS_WRITE=1 일 때만 실행(사용자 결정 2026-10-14)');
  const list = collectResponses(page, /\/api\/o11y\/trigger\/policy\?/);
  await loginAsAdmin(page);
  const f = await openObs(page, 'alerts');
  try {
    await test.step('1~2. Policies 목록', async () => {
      await expect.poll(() => list.length, { timeout: 30_000 }).toBeGreaterThan(0);
      const d = list.at(-1)!.json?.data;
      test.info().annotations.push({ type: 'list-before', description: `${list.at(-1)!.status} totalElements=${d?.totalElements} content=${(d?.content ?? []).map((p: any) => p.title).join(',')}` });
      expect(Array.isArray(d?.content)).toBe(true);
    });
    const c = await test.step('3. + New Policy → Create', async () =>
      createPolicy(page, f, { title: POLICY, description: 'IV7_S10 test policy', resource: 'CPU', aggregation: 'AVG', hold: '5m', repeat: '1h', info: '50', warning: '70', critical: '90' }));
    expect(c.status, '생성 201').toBe(201);
    expect(c.id, '생성 id').toBeTruthy();
    await test.step('4. 목록 반영', async () => {
      const row = clean(await policyRow(f, POLICY).innerText());
      test.info().annotations.push({ type: 'row', description: row });
      expect(row).toMatch(/cpu/i);
      expect(row).toContain('I:50 W:70 C:90');
      const d = list.at(-1)!.json?.data;
      expect((d?.content ?? []).some((p: any) => p.title === POLICY && p.holdDuration === '5m' && p.repeatInterval === '1h' && /avg/i.test(p.aggregationType))).toBe(true);
    });
    await test.step('5. 삭제 202 → 목록에서 제거', async () => {
      expect(await deletePolicy(page, f, POLICY)).toBe(202);
    });
  } finally {
    await deletePolicy(page, f, POLICY).catch(() => 0); // 정리(이미 지웠으면 아무것도 안 함)
  }
});

// IV7_S11: TC-OBS-011 정책 ↔ Node/Infra 연결 [정상, 공통]
// v0.6 TC-ID: TC-OBS-TRIG-02
// 화면: Monitorings > Alert → 정책 행 Manage → Alarm targets
// 시작 상태: admin(mcmp) 로그인, ws01/default. 정책 존재(IV7_S10 절차로 생성), 대상 node 존재
// 절차: 1.Manage → Alarm targets 2.Infra 선택 → 레벨 Node(단일 VM) 3.Add targets(POST /api/o11y/trigger/policy/{id}/node) 4.정책 vms 목록 갱신 5.(정리) 대상 제거 · 정책 삭제
// 기대결과: 202 ACCEPTED, 정책 vms 목록 갱신
// 실행 보류(사용자 결정 2026-10-14: 상태를 바꾸는 OBS TC 는 spec 만 작성). OBS_WRITE=1 일 때만 실행.
// 2026-10-16 수정(첫 실행, rf-obs2): 추정 셀렉터 교체 — 정책이 없으면 Manage 가 없으므로 이 spec 이 정책을 만들고(IV7_S10 절차) 끝에 지운다.
//   Alarm targets 패널은 'Infra / Cluster' select + node 체크박스(label 'g1-2 (g1-2)') + 'Add targets'. 레벨(Infra/Node) 선택 UI 는 없고 node 체크가 단일 VM 연결.
//   대상 node 는 OBS_TARGET_NODE(기본 OBS_NODE) — 연결만 하고 node 상태는 바꾸지 않음. 알림 채널은 비워 두어 발송 없음
import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { openObs, collectResponses, createPolicy, deletePolicy, policyRow, clean, OBS_INFRA, OBS_NODE } from '../../lib/iv7-obs';

const POLICY = 'iv7-s11-target-policy';
const NODE = process.env.OBS_TARGET_NODE ?? OBS_NODE;
test('IV7_S11 TC-OBS-011 정책 ↔ Node/Infra 연결', async ({ page }) => {
  test.skip(process.env.OBS_WRITE !== '1', '상태 변경 TC — OBS_WRITE=1 일 때만 실행(사용자 결정 2026-10-14)');
  const api = collectResponses(page, /\/api\/o11y\/trigger\/policy\/\d+\/node/);
  const list = collectResponses(page, /\/api\/o11y\/trigger\/policy\?/);
  await loginAsAdmin(page);
  const f = await openObs(page, 'alerts');
  try {
    await test.step('0. 사전: 정책 생성(IV7_S10 절차)', async () => { await createPolicy(page, f, { title: POLICY, description: 'IV7_S11 target test' }); });
    await test.step('1~3. Manage → Alarm targets → Infra·Node → Add targets', async () => {
      await policyRow(f, POLICY).getByRole('button', { name: 'Manage', exact: true }).click();
      await expect(f.getByRole('button', { name: 'Add targets' })).toBeVisible();
      const sel = f.locator('select').filter({ has: f.locator('option', { hasText: new RegExp(`^${OBS_INFRA}$`) }) }).first();
      await sel.selectOption({ label: OBS_INFRA });
      await page.waitForTimeout(2000);
      await f.locator('label').filter({ hasText: new RegExp(`^\\s*${NODE} \\(`) }).first().locator('input[type="checkbox"]').check()
        .catch(async () => f.getByLabel(new RegExp(`^${NODE} \\(`)).first().check());
      await f.getByRole('button', { name: 'Add targets' }).click();
      await expect.poll(() => api.find((a) => a.method === 'POST')?.status ?? 0, { message: 'Add targets POST', timeout: 30_000 }).toBeGreaterThan(0);
      const p = api.find((a) => a.method === 'POST')!;
      test.info().annotations.push({ type: 'add-targets', description: `${p.status} POST ${p.url} ${JSON.stringify(p.json ?? '').slice(0, 300)}` });
      expect(p.status, '202 ACCEPTED').toBe(202);
    });
    await test.step('4. 정책 vms 목록 갱신', async () => {
      await expect.poll(() => (list.at(-1)?.json?.data?.content ?? []).find((x: any) => x.title === POLICY)?.vms?.length ?? 0, { timeout: 30_000 }).toBeGreaterThan(0);
      const vms = (list.at(-1)!.json.data.content as any[]).find((x) => x.title === POLICY).vms;
      test.info().annotations.push({ type: 'vms', description: JSON.stringify(vms).slice(0, 500) });
      expect(JSON.stringify(vms)).toContain(NODE);
      const row = clean(await policyRow(f, POLICY).innerText());
      test.info().annotations.push({ type: 'row', description: row });
      test.info().annotations.push({ type: 'panel', description: clean(await f.locator('body').innerText()).slice(0, 1200) });
    });
  } finally {
    await test.step('5. (정리) 정책 삭제 — 연결된 대상도 함께 제거', async () => {
      await page.keyboard.press('Escape').catch(() => {});
      const st = await deletePolicy(page, f, POLICY).catch((e) => { test.info().annotations.push({ type: 'cleanup-error', description: String(e).slice(0, 200) }); return -1; });
      test.info().annotations.push({ type: 'cleanup', description: `정책 삭제 ${st}` });
    });
  }
});

// IV7_S12: TC-OBS-012 알림 채널 설정 [정상, 공통]
// v0.6 TC-ID: TC-OBS-TRIG-03
// 화면: Monitorings > Alert → 정책 Manage → Notification channels
// 시작 상태: admin(mcmp) 로그인, ws01/default. 정책 존재, Grafana contact point(SMTP 등)·채널별 자격 구성
// 절차: 1.Notification channels 2.지원 채널(GET /api/o11y/trigger/noti/channel) 3.Email 체크 · 수신자 입력 4.Test(POST /api/o11y/trigger/noti/test) 5.Save channels(PUT /api/o11y/trigger/policy/{id}/channel)
// 기대결과: 202, notiChannels 갱신, (테스트 시) 발송 결과
// 비고: 채널 자격(SMTP·Slack 토큰 등)이 없으면 SKIP(지침 4-0). 수신자는 OBS_NOTI_EMAIL
// 실행 보류(사용자 결정 2026-10-14: 상태를 바꾸는 OBS TC 는 spec 만 작성). OBS_WRITE=1 일 때만 실행.
// 2026-10-16 수정(첫 실행, rf-obs2): 추정 셀렉터 교체 — 이 spec 이 정책을 만들고(IV7_S10 절차, 대상 node 없음) Manage → Notification channels → Email 체크·수신자 → Save channels 후 정책 삭제.
//   수신자 기본값은 발송되지 않는 예약 도메인 [email protected](OBS_NOTI_EMAIL 로 변경). 'Test' 는 실제 메시지를 보내므로('Test delivers a real message through RabbitMQ')
//   수신자·발송 승인이 있을 때만(OBS_NOTI_TEST=1) 누른다. 정책에 대상 node 가 없어 저장만으로는 알림이 발송되지 않는다
import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { openObs, collectResponses, createPolicy, deletePolicy, policyRow, clean } from '../../lib/iv7-obs';

const POLICY = 'iv7-s12-channel-policy';
test('IV7_S12 TC-OBS-012 알림 채널 설정', async ({ page }) => {
  test.skip(process.env.OBS_WRITE !== '1', '상태 변경 TC — OBS_WRITE=1 일 때만 실행(사용자 결정 2026-10-14)');
  const to = process.env.OBS_NOTI_EMAIL || '[email protected]';
  const api = collectResponses(page, /\/api\/o11y\/trigger\/(noti|policy\/\d+\/channel)/);
  const list = collectResponses(page, /\/api\/o11y\/trigger\/policy\?/);
  await loginAsAdmin(page);
  const f = await openObs(page, 'alerts');
  try {
    await test.step('2. 지원 채널 목록', async () => {
      await expect.poll(() => api.filter((a) => /noti\/channel/.test(a.url)).length, { timeout: 30_000 }).toBeGreaterThan(0);
      const ch = api.filter((a) => /noti\/channel/.test(a.url)).at(-1)!.json?.data?.notiChannels ?? [];
      test.info().annotations.push({ type: 'channels', description: ch.map((c: any) => `${c.id}:${c.name}(${c.type}/${c.provider}, active=${c.isActive})`).join(', ') });
      expect(ch.some((c: any) => c.type === 'email' && c.isActive), 'email 채널 활성').toBe(true);
    });
    await test.step('0. 사전: 정책 생성(IV7_S10 절차, 대상 없음)', async () => { await createPolicy(page, f, { title: POLICY, description: 'IV7_S12 channel test' }); });
    await test.step('1·3. Manage → Notification channels → Email 체크 · 수신자', async () => {
      await policyRow(f, POLICY).getByRole('button', { name: 'Manage', exact: true }).click();
      await expect(f.getByRole('button', { name: 'Save channels' })).toBeVisible();
      const email = f.locator('label').filter({ hasText: /^\s*Email\s*$/ }).first();
      const cb = email.locator('input[type="checkbox"]');
      if (await cb.count()) await cb.check(); else await email.click();
      await f.getByPlaceholder(/Email addresses/).first().fill(to);
      test.info().annotations.push({ type: 'recipient', description: to });
    });
    await test.step('4. Test 발송(OBS_NOTI_TEST=1 일 때만)', async () => {
      if (process.env.OBS_NOTI_TEST !== '1') { test.info().annotations.push({ type: 'test-send', description: '미실행 — 실제 메시지 발송(수신자·발송 승인 필요)' }); return; }
      const row = f.locator('div').filter({ has: f.getByPlaceholder(/Email addresses/) }).filter({ has: f.getByRole('button', { name: 'Test', exact: true }) }).last();
      await row.getByRole('button', { name: 'Test', exact: true }).click();
      await expect.poll(() => api.some((a) => /noti\/test/.test(a.url)), { timeout: 60_000 }).toBe(true);
      const t = api.find((a) => /noti\/test/.test(a.url))!;
      test.info().annotations.push({ type: 'test-send', description: `${t.status} ${t.method} ${t.url} ${JSON.stringify(t.json ?? '').slice(0, 300)}` });
    });
    await test.step('5. Save channels → 202, notiChannels 갱신', async () => {
      await f.getByRole('button', { name: 'Save channels' }).click();
      await expect.poll(() => api.find((a) => a.method === 'PUT')?.status ?? 0, { message: 'Save channels PUT', timeout: 30_000 }).toBeGreaterThan(0);
      const p = api.find((a) => a.method === 'PUT')!;
      test.info().annotations.push({ type: 'save-channels', description: `${p.status} PUT ${p.url} ${JSON.stringify(p.json ?? '').slice(0, 300)}` });
      expect(p.status, 'Save channels 202').toBe(202);
      await expect.poll(() => JSON.stringify((list.at(-1)?.json?.data?.content ?? []).find((x: any) => x.title === POLICY)?.notiChannels ?? []), { timeout: 30_000 }).toMatch(/email/i);
      const nc = (list.at(-1)!.json.data.content as any[]).find((x) => x.title === POLICY).notiChannels;
      test.info().annotations.push({ type: 'notiChannels', description: JSON.stringify(nc).slice(0, 500) });
      test.info().annotations.push({ type: 'row', description: clean(await policyRow(f, POLICY).innerText()) });
    });
  } finally {
    await test.step('(정리) 정책 삭제', async () => {
      const st = await deletePolicy(page, f, POLICY).catch((e) => { test.info().annotations.push({ type: 'cleanup-error', description: String(e).slice(0, 200) }); return -1; });
      test.info().annotations.push({ type: 'cleanup', description: `정책 삭제 ${st}` });
    });
  }
});

// IV7_S13: TC-OBS-013 Trigger / Notification History [정상, 공통]
// v0.6 TC-ID: TC-OBS-TRIG-04 — 기존 spec(mcmp-e2e deploy/scenarios/shared/step-handlers/obs/trigger.ts runObsTrig04)은 절차만 참고(사용자 결정 2026-10-14)
// 화면: Monitorings > Alert (iframe /embed/alerts/{ns}) → Policies(트리거 이력) · Notification History 탭
// 시작 상태: admin(mcmp) 로그인, ws01/default. TC-OBS-011·012 완료, 임계치 초과 트리거 발생
// 절차: 1.트리거 발생 후 History 확인 2.트리거 이력(GET /api/o11y/trigger/history) severity/value/threshold 3.(옵션) 코멘트 수정 4.알림 발송 이력(GET /api/o11y/trigger/noti/history) 5.Notification History 탭 발송 로그
// 기대결과: 트리거 이력 content[](severity, value, threshold), 알림 이력 content[](channelName, isSucceeded)
// 비고: 읽기 TC 로 먼저 진행(사용자 결정 2026-10-14). 정책·트리거가 없으면 SKIP(선행 TC-OBS-010~012 미실행)
import { test, expect } from '../../lib/fixtures';
import { loginAsAdmin } from '../../lib/ui';
import { openObs, collectResponses, clean } from '../../lib/iv7-obs';

test('IV7_S13 TC-OBS-013 Trigger / Notification History', async ({ page }) => {
  const policy = collectResponses(page, /\/api\/o11y\/trigger\/policy(\?|$)/);
  const notiHist = collectResponses(page, /\/api\/o11y\/trigger\/noti\/history/);
  const trigHist = collectResponses(page, /\/api\/o11y\/trigger\/history/);
  await loginAsAdmin(page);
  const f = await openObs(page, 'alerts');
  await expect.poll(() => policy.length, { timeout: 30_000 }).toBeGreaterThan(0);
  const policies = policy.at(-1)!.json?.data?.totalElements ?? 0;
  await test.step('4~5. Notification History 탭', async () => {
    await f.getByRole('button', { name: 'Notification History', exact: true }).click();
    await page.waitForTimeout(4000);
    test.info().annotations.push({ type: 'noti-history', description: `${notiHist.map((n) => `${n.status} ${n.url.slice(0, 120)} total=${n.json?.data?.totalElements}`).join(' | ') || '(호출 없음)'} / ${clean(await f.locator('body').innerText()).slice(0, 300)}` });
  });
  const trig = trigHist.at(-1)?.json?.data?.totalElements ?? 0;
  const noti = notiHist.at(-1)?.json?.data?.totalElements ?? 0;
  test.info().annotations.push({ type: 'counts', description: `정책 ${policies} / 트리거 이력 ${trig} / 알림 이력 ${noti}` });
  test.skip(!policies || (!trig && !noti), '정책·트리거 이력 없음 — 선행 TC-OBS-010~012(정책 생성·대상 연결·채널) 미실행');
  expect(noti + trig).toBeGreaterThan(0);
});