gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

package/src/resources/extensions/gsd/tests/uat-stuck-loop-orphaned-worktree.test.ts

@@ -1,289 +0,0 @@
-/**
- * uat-stuck-loop-orphaned-worktree.test.ts — Regression tests for #2821.
- *
- * Reproduces two cascading bugs:
- *
- * Bug 1 — UAT stuck-loop: syncProjectRootToWorktree uses force:false for
- *   milestone files. When the project root has an ASSESSMENT with a verdict
- *   but the worktree has a stale/empty ASSESSMENT (or none at all after DB
- *   rebuild), the verdict is NOT synced into the worktree. checkNeedsRunUat
- *   finds no verdict → re-dispatches run-uat indefinitely.
- *
- * Bug 2 — Orphaned worktree: removeWorktree silently swallows failures when
- *   git worktree remove fails (untracked files, CWD inside worktree, etc.).
- *   The worktree directory and branch persist on disk after teardown.
- *   teardownAutoWorktree has a fallback rmSync but it also fails when the
- *   git internal .git/worktrees/<name> directory holds a lock.
- */
-
-import { describe, test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import {
-  mkdtempSync,
-  mkdirSync,
-  writeFileSync,
-  rmSync,
-  existsSync,
-  readFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execFileSync } from "node:child_process";
-
-import { syncProjectRootToWorktree } from "../auto-worktree.ts";
-import {
-  createWorktree,
-  removeWorktree,
-  worktreePath,
-} from "../worktree-manager.ts";
-
-function git(args: string[], cwd: string): string {
-  return execFileSync("git", args, {
-    cwd,
-    stdio: ["ignore", "pipe", "pipe"],
-    encoding: "utf-8",
-  }).trim();
-}
-
-function makeBaseRepo(): string {
-  const base = mkdtempSync(join(tmpdir(), "gsd-2821-"));
-  git(["init", "-b", "main"], base);
-  git(["config", "user.name", "Test"], base);
-  git(["config", "user.email", "test@test.com"], base);
-  writeFileSync(join(base, "README.md"), "# test\n");
-  mkdirSync(join(base, ".gsd", "milestones", "M011"), { recursive: true });
-  git(["add", "."], base);
-  git(["commit", "-m", "init"], base);
-  return base;
-}
-
-// ─── Bug 1: ASSESSMENT force-sync ─────────────────────────────────────────
-
-describe("#2821 Bug 1 — ASSESSMENT file force-synced on resume", () => {
-  let mainBase: string;
-  let wtBase: string;
-
-  beforeEach(() => {
-    mainBase = mkdtempSync(join(tmpdir(), "gsd-2821-main-"));
-    wtBase = mkdtempSync(join(tmpdir(), "gsd-2821-wt-"));
-    mkdirSync(join(mainBase, ".gsd", "milestones", "M011", "slices", "S01"), {
-      recursive: true,
-    });
-    mkdirSync(join(wtBase, ".gsd", "milestones", "M011", "slices", "S01"), {
-      recursive: true,
-    });
-  });
-
-  afterEach(() => {
-    rmSync(mainBase, { recursive: true, force: true });
-    rmSync(wtBase, { recursive: true, force: true });
-  });
-
-  test("force-syncs ASSESSMENT with verdict from project root into worktree when worktree copy has no verdict", () => {
-    // Project root has ASSESSMENT with a PASS verdict (written by run-uat, synced by post-unit)
-    const prAssessment = join(
-      mainBase,
-      ".gsd",
-      "milestones",
-      "M011",
-      "slices",
-      "S01",
-      "S01-ASSESSMENT.md",
-    );
-    writeFileSync(
-      prAssessment,
-      "---\nverdict: pass\n---\n# S01 Assessment\nAll tests pass.\n",
-    );
-
-    // Worktree has a stale ASSESSMENT with FAIL verdict (from the initial run-uat execution)
-    const wtAssessment = join(
-      wtBase,
-      ".gsd",
-      "milestones",
-      "M011",
-      "slices",
-      "S01",
-      "S01-ASSESSMENT.md",
-    );
-    writeFileSync(
-      wtAssessment,
-      "---\nverdict: fail\n---\n# S01 Assessment\nSome tests fail.\n",
-    );
-
-    syncProjectRootToWorktree(mainBase, wtBase, "M011");
-
-    // The worktree ASSESSMENT must now have the project root's PASS verdict
-    const content = readFileSync(wtAssessment, "utf-8");
-    assert.ok(
-      content.includes("verdict: pass"),
-      `Expected worktree ASSESSMENT to have verdict:pass after sync, got: ${content.slice(0, 100)}`,
-    );
-  });
-
-  test("force-syncs ASSESSMENT from project root when worktree has no ASSESSMENT at all", () => {
-    // Project root has ASSESSMENT with verdict
-    const prAssessment = join(
-      mainBase,
-      ".gsd",
-      "milestones",
-      "M011",
-      "slices",
-      "S01",
-      "S01-ASSESSMENT.md",
-    );
-    writeFileSync(
-      prAssessment,
-      "---\nverdict: pass\n---\n# S01 Assessment\n",
-    );
-
-    // Worktree has NO ASSESSMENT (deleted during DB rebuild)
-    // — file simply doesn't exist
-
-    syncProjectRootToWorktree(mainBase, wtBase, "M011");
-
-    const wtAssessment = join(
-      wtBase,
-      ".gsd",
-      "milestones",
-      "M011",
-      "slices",
-      "S01",
-      "S01-ASSESSMENT.md",
-    );
-    assert.ok(
-      existsSync(wtAssessment),
-      "ASSESSMENT should be copied to worktree when missing",
-    );
-    const content = readFileSync(wtAssessment, "utf-8");
-    assert.ok(
-      content.includes("verdict: pass"),
-      `Synced ASSESSMENT should contain verdict:pass, got: ${content.slice(0, 100)}`,
-    );
-  });
-
-  test("does NOT overwrite worktree ASSESSMENT when project root has no verdict", () => {
-    // Project root has ASSESSMENT without verdict (incomplete)
-    const prAssessment = join(
-      mainBase,
-      ".gsd",
-      "milestones",
-      "M011",
-      "slices",
-      "S01",
-      "S01-ASSESSMENT.md",
-    );
-    writeFileSync(prAssessment, "# S01 Assessment\nIn progress...\n");
-
-    // Worktree has ASSESSMENT with verdict:fail
-    const wtAssessment = join(
-      wtBase,
-      ".gsd",
-      "milestones",
-      "M011",
-      "slices",
-      "S01",
-      "S01-ASSESSMENT.md",
-    );
-    writeFileSync(
-      wtAssessment,
-      "---\nverdict: fail\n---\n# S01 Assessment\nSome tests fail.\n",
-    );
-
-    syncProjectRootToWorktree(mainBase, wtBase, "M011");
-
-    // Worktree copy should NOT be overwritten by the verdictless project root copy
-    const content = readFileSync(wtAssessment, "utf-8");
-    assert.ok(
-      content.includes("verdict: fail"),
-      `Worktree ASSESSMENT should keep verdict:fail when project root has no verdict, got: ${content.slice(0, 100)}`,
-    );
-  });
-});
-
-// ─── Bug 2: Orphaned worktree cleanup ─────────────────────────────────────
-
-describe("#2821 Bug 2 — removeWorktree cleans up despite untracked files", () => {
-  let base: string;
-
-  beforeEach(() => {
-    base = makeBaseRepo();
-  });
-
-  afterEach(() => {
-    rmSync(base, { recursive: true, force: true });
-  });
-
-  test("removes worktree directory even when it contains untracked files", () => {
-    const info = createWorktree(base, "M011", {
-      branch: "milestone/M011",
-    });
-
-    // Simulate run-uat writing untracked files (S01-UAT-RESULT.md, ASSESSMENT)
-    mkdirSync(
-      join(info.path, ".gsd", "milestones", "M011", "slices", "S01"),
-      { recursive: true },
-    );
-    writeFileSync(
-      join(
-        info.path,
-        ".gsd",
-        "milestones",
-        "M011",
-        "slices",
-        "S01",
-        "S01-UAT-RESULT.md",
-      ),
-      "# UAT Result\nverdict: fail\n",
-    );
-    writeFileSync(
-      join(
-        info.path,
-        ".gsd",
-        "milestones",
-        "M011",
-        "slices",
-        "S01",
-        "S01-ASSESSMENT.md",
-      ),
-      "---\nverdict: fail\n---\n# Assessment\n",
-    );
-
-    removeWorktree(base, "M011", {
-      branch: "milestone/M011",
-      deleteBranch: true,
-      force: true,
-    });
-
-    const wtDir = worktreePath(base, "M011");
-    assert.ok(
-      !existsSync(wtDir),
-      `Worktree directory should be removed after teardown, but still exists at ${wtDir}`,
-    );
-  });
-
-  test("removes git internal worktree metadata after filesystem removal", () => {
-    createWorktree(base, "M011", {
-      branch: "milestone/M011",
-    });
-
-    removeWorktree(base, "M011", {
-      branch: "milestone/M011",
-      deleteBranch: true,
-      force: true,
-    });
-
-    // The git internal worktree directory should be cleaned up
-    const gitInternalWorktreeDir = join(base, ".git", "worktrees", "M011");
-    assert.ok(
-      !existsSync(gitInternalWorktreeDir),
-      `Git internal worktree dir should be removed: ${gitInternalWorktreeDir}`,
-    );
-
-    // The branch should be deleted
-    const branches = git(["branch"], base);
-    assert.ok(
-      !branches.includes("milestone/M011"),
-      "milestone/M011 branch should be deleted after removeWorktree",
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/vacuum-recovery.test.ts

@@ -1,154 +0,0 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { createRequire } from 'node:module';
-import {
-  openDatabase,
-  closeDatabase,
-  isDbAvailable,
-  _getAdapter,
-} from '../gsd-db.ts';
-
-const _require = createRequire(import.meta.url);
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Helpers
-// ═══════════════════════════════════════════════════════════════════════════
-
-function tempDbPath(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-vacuum-test-'));
-  return path.join(dir, 'test.db');
-}
-
-function cleanup(dbPath: string): void {
-  closeDatabase();
-  try {
-    const dir = path.dirname(dbPath);
-    for (const f of fs.readdirSync(dir)) {
-      fs.unlinkSync(path.join(dir, f));
-    }
-    fs.rmdirSync(dir);
-  } catch { /* best effort */ }
-}
-
-/**
- * Create a SQLite DB with a corrupt freelist that causes DDL to fail
- * with "database disk image is malformed" but is recoverable via VACUUM.
- *
- * Strategy:
- * 1. Create a DB with schema_version at v0 (so initSchema needs to run DDL)
- * 2. Add padding rows to create many pages, then delete + drop to free them
- * 3. Corrupt the freelist trunk pointer to point at a B-tree page
- *
- * This simulates the real-world scenario described in #2519: an interrupted
- * WAL checkpoint leaves the freelist in an inconsistent state.
- */
-function createCorruptFreelistDb(dbPath: string): void {
-  // Use node:sqlite directly to build the minimal corrupt DB
-  const sqlite = _require('node:sqlite');
-  const db = new sqlite.DatabaseSync(dbPath);
-  db.exec('PRAGMA journal_mode=WAL');
-  db.exec('CREATE TABLE schema_version (version INTEGER NOT NULL, applied_at TEXT NOT NULL)');
-  db.exec("INSERT INTO schema_version VALUES (0, '2024-01-01')");
-  // Pad with data to create many pages, then free them
-  db.exec('CREATE TABLE _padding (id INTEGER PRIMARY KEY, data TEXT)');
-  for (let i = 0; i < 30; i++) {
-    db.exec(`INSERT INTO _padding (data) VALUES ('${'x'.repeat(4000)}')`);
-  }
-  db.exec('DELETE FROM _padding');
-  db.exec('DROP TABLE _padding');
-  db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-  db.close();
-
-  // Remove WAL/SHM files to ensure clean file-only state
-  try { fs.unlinkSync(dbPath + '-wal'); } catch { /* may not exist */ }
-  try { fs.unlinkSync(dbPath + '-shm'); } catch { /* may not exist */ }
-
-  // Corrupt: point freelist trunk (offset 32-35) to page 2 (a B-tree page),
-  // and claim 10 free pages (offset 36-39)
-  const fd = fs.openSync(dbPath, 'r+');
-  try {
-    const buf = Buffer.alloc(8);
-    buf.writeUInt32BE(2, 0);   // trunk page = page 2 (actually a B-tree page)
-    buf.writeUInt32BE(10, 4);  // freelist count = 10
-    fs.writeSync(fd, buf, 0, 8, 32);
-  } finally {
-    fs.closeSync(fd);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe('openDatabase VACUUM recovery on corrupt freelist', () => {
-
-  test('recovers a file-backed DB with corrupt freelist via VACUUM', () => {
-    const dbPath = tempDbPath();
-
-    // Create a DB with corrupt freelist (schema at v0 so initSchema runs DDL)
-    createCorruptFreelistDb(dbPath);
-
-    // Without the fix, this throws "database disk image is malformed".
-    // With the fix, openDatabase detects "malformed", runs VACUUM, retries.
-    const ok = openDatabase(dbPath);
-    assert.ok(ok, 'openDatabase should succeed after VACUUM recovery');
-    assert.ok(isDbAvailable(), 'DB should be available after recovery');
-
-    // Verify full schema was applied
-    const adapter = _getAdapter()!;
-    const row = adapter.prepare(
-      'SELECT MAX(version) as version FROM schema_version',
-    ).get();
-    assert.ok(
-      typeof row?.['version'] === 'number' && (row['version'] as number) > 0,
-      'schema_version should have a positive version after recovery',
-    );
-
-    cleanup(dbPath);
-  });
-
-  test('does not attempt VACUUM for non-malformed errors', () => {
-    // openDatabase with :memory: never hits the fileBacked VACUUM path,
-    // so non-malformed errors propagate directly. We verify by checking
-    // that a non-file error from an in-memory DB propagates unchanged.
-    // (In-memory DBs always succeed for initSchema, so this is a design
-    // check — the VACUUM path is only for fileBacked = true.)
-    const ok = openDatabase(':memory:');
-    assert.ok(ok, 'in-memory DB should open fine');
-    closeDatabase();
-  });
-
-  test('throws if VACUUM itself fails on unrecoverable corruption', () => {
-    const dbPath = tempDbPath();
-
-    // Create a file with valid SQLite header but thoroughly corrupt content
-    const page = Buffer.alloc(4096);
-    // SQLite magic: "SQLite format 3\0"
-    page.write('SQLite format 3\0', 0, 'utf8');
-    // Page size: 4096 (big-endian at offset 16)
-    page.writeUInt16BE(4096, 16);
-    page[18] = 1;  // write version
-    page[19] = 1;  // read version
-    page[20] = 0;  // reserved space
-    page[21] = 64; // max embedded payload fraction
-    page[22] = 32; // min embedded payload fraction
-    page[23] = 32; // leaf payload fraction
-    page.writeUInt32BE(1, 28);   // page_count = 1
-    page.writeUInt32BE(999, 32); // corrupt freelist trunk
-    page.writeUInt32BE(5, 36);   // freelist count = 5
-
-    fs.writeFileSync(dbPath, page);
-
-    // Should throw — VACUUM cannot save a thoroughly corrupt file
-    assert.throws(
-      () => openDatabase(dbPath),
-      /./,
-      'should throw for unrecoverable corruption',
-    );
-
-    cleanup(dbPath);
-  });
-});

package/src/resources/extensions/gsd/tests/verdict-parser.test.ts

@@ -1,156 +0,0 @@
-/**
- * Tests for verdict-parser.ts — extraction, normalization, and schema validation.
- *
- * Regression tests for #2960: extractVerdict() must detect verdicts in both
- * YAML frontmatter and common markdown body patterns (LLM manual writes).
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import {
-  extractVerdict,
-  hasVerdict,
-  isAcceptableUatVerdict,
-  isValidMilestoneVerdict,
-} from "../verdict-parser.ts";
-
-// ── extractVerdict ──────────────────────────────────────────────────────────
-
-describe("extractVerdict", () => {
-  it("extracts verdict from YAML frontmatter", () => {
-    const content = "---\nverdict: pass\n---\n\n# Validation";
-    assert.equal(extractVerdict(content), "pass");
-  });
-
-  it("normalizes 'passed' to 'pass' in frontmatter", () => {
-    const content = "---\nverdict: passed\n---\n";
-    assert.equal(extractVerdict(content), "pass");
-  });
-
-  it("extracts case-insensitive verdict from frontmatter", () => {
-    const content = "---\nVerdict: PASS\n---\n";
-    assert.equal(extractVerdict(content), "pass");
-  });
-
-  it("extracts needs-remediation from frontmatter", () => {
-    const content = "---\nverdict: needs-remediation\n---\n";
-    assert.equal(extractVerdict(content), "needs-remediation");
-  });
-
-  it("returns undefined when content has no frontmatter and no markdown verdict", () => {
-    const content = "# Just a heading\n\nSome text without any verdict.";
-    assert.equal(extractVerdict(content), undefined);
-  });
-
-  // ── Regression: #2960 — markdown body verdicts ─────────────────────────
-
-  it("detects **Verdict:** PASS in markdown body (#2960)", () => {
-    const content = [
-      "# M013 — Milestone Validation",
-      "",
-      "**Verdict:** PASS",
-      "",
-      "All slices completed successfully.",
-    ].join("\n");
-    assert.equal(extractVerdict(content), "pass");
-  });
-
-  it("detects **Verdict:** with emoji prefix in markdown body (#2960)", () => {
-    const content = [
-      "# Milestone Validation",
-      "",
-      "**Verdict:** ✅ PASS",
-      "",
-      "Everything looks good.",
-    ].join("\n");
-    assert.equal(extractVerdict(content), "pass");
-  });
-
-  it("detects **Verdict:** needs-remediation in markdown body (#2960)", () => {
-    const content = [
-      "# Milestone Validation",
-      "",
-      "**Verdict:** needs-remediation",
-      "",
-      "Several issues found.",
-    ].join("\n");
-    assert.equal(extractVerdict(content), "needs-remediation");
-  });
-
-  it("normalizes 'passed' to 'pass' in markdown body (#2960)", () => {
-    const content = "# Validation\n\n**Verdict:** Passed\n";
-    assert.equal(extractVerdict(content), "pass");
-  });
-
-  it("detects verdict without colon in bold pattern (#2960)", () => {
-    const content = "# Validation\n\n**Verdict** PASS\n";
-    assert.equal(extractVerdict(content), "pass");
-  });
-
-  it("prefers frontmatter verdict over markdown body", () => {
-    const content = [
-      "---",
-      "verdict: needs-remediation",
-      "---",
-      "",
-      "**Verdict:** PASS",
-    ].join("\n");
-    assert.equal(extractVerdict(content), "needs-remediation");
-  });
-});
-
-// ── hasVerdict ────────────────────────────────────────────────────────────
-
-describe("hasVerdict", () => {
-  it("returns true when verdict field exists", () => {
-    assert.equal(hasVerdict("verdict: pass"), true);
-  });
-
-  it("returns false when no verdict field exists", () => {
-    assert.equal(hasVerdict("# Just a heading"), false);
-  });
-});
-
-// ── isAcceptableUatVerdict ───────────────────────────────────────────────
-
-describe("isAcceptableUatVerdict", () => {
-  it("accepts pass verdict", () => {
-    assert.equal(isAcceptableUatVerdict("pass", undefined), true);
-  });
-
-  it("accepts passed verdict", () => {
-    assert.equal(isAcceptableUatVerdict("passed", undefined), true);
-  });
-
-  it("rejects fail verdict", () => {
-    assert.equal(isAcceptableUatVerdict("fail", undefined), false);
-  });
-
-  it("accepts partial for mixed UAT type", () => {
-    assert.equal(isAcceptableUatVerdict("partial", "mixed"), true);
-  });
-
-  it("rejects partial for artifact-driven UAT type", () => {
-    assert.equal(isAcceptableUatVerdict("partial", "artifact-driven"), false);
-  });
-});
-
-// ── isValidMilestoneVerdict ──────────────────────────────────────────────
-
-describe("isValidMilestoneVerdict", () => {
-  it("accepts pass", () => {
-    assert.equal(isValidMilestoneVerdict("pass"), true);
-  });
-
-  it("accepts needs-attention", () => {
-    assert.equal(isValidMilestoneVerdict("needs-attention"), true);
-  });
-
-  it("accepts needs-remediation", () => {
-    assert.equal(isValidMilestoneVerdict("needs-remediation"), true);
-  });
-
-  it("rejects unknown verdict", () => {
-    assert.equal(isValidMilestoneVerdict("fail"), false);
-  });
-});

package/src/resources/extensions/gsd/tests/verification-operational-gate.test.ts

@@ -1,82 +0,0 @@
-/**
- * Regression test for #2931: completing-milestone gate should treat
- * "None required", "N/A", "Not applicable", etc. as equivalent to "none"
- * and skip the operational verification content check entirely.
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import { isVerificationNotApplicable } from "../auto-dispatch.ts";
-
-test("isVerificationNotApplicable: bare 'none' is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("none"), true);
-});
-
-test("isVerificationNotApplicable: 'None' (capitalized) is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("None"), true);
-});
-
-test("isVerificationNotApplicable: 'NONE' (uppercase) is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("NONE"), true);
-});
-
-test("isVerificationNotApplicable: 'None required' is not applicable (#2931)", () => {
-  assert.equal(isVerificationNotApplicable("None required"), true);
-});
-
-test("isVerificationNotApplicable: 'None needed' is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("None needed"), true);
-});
-
-test("isVerificationNotApplicable: 'None planned' is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("None planned"), true);
-});
-
-test("isVerificationNotApplicable: 'N/A' is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("N/A"), true);
-});
-
-test("isVerificationNotApplicable: 'n/a' is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("n/a"), true);
-});
-
-test("isVerificationNotApplicable: 'Not applicable' is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("Not applicable"), true);
-});
-
-test("isVerificationNotApplicable: 'Not required' is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("Not required"), true);
-});
-
-test("isVerificationNotApplicable: 'Not needed' is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("Not needed"), true);
-});
-
-test("isVerificationNotApplicable: 'No operational verification needed' is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("No operational verification needed"), true);
-});
-
-test("isVerificationNotApplicable: 'No operational' is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("No operational"), true);
-});
-
-test("isVerificationNotApplicable: empty string is not applicable", () => {
-  assert.equal(isVerificationNotApplicable(""), true);
-});
-
-test("isVerificationNotApplicable: whitespace-only is not applicable", () => {
-  assert.equal(isVerificationNotApplicable("   "), true);
-});
-
-// Positive cases: these SHOULD require verification
-test("isVerificationNotApplicable: 'Run load tests' requires verification", () => {
-  assert.equal(isVerificationNotApplicable("Run load tests"), false);
-});
-
-test("isVerificationNotApplicable: 'Verify API response times under load' requires verification", () => {
-  assert.equal(isVerificationNotApplicable("Verify API response times under load"), false);
-});
-
-test("isVerificationNotApplicable: 'Monitor error rates for 24h' requires verification", () => {
-  assert.equal(isVerificationNotApplicable("Monitor error rates for 24h"), false);
-});