@tenonhq/dovetail-core 0.0.85

package/dist/tests/validateTaskId.test.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * Tests for US-010: Validate task ID before ServiceNow queries
+ *
+ * Validates:
+ * - taskId is validated as non-empty string before constructing nameLIKECU-{taskId} query
+ * - Empty/undefined taskId logs an error and skips update set lookup
+ * - readActiveTask() validates required fields (taskId, updateSetName) and returns null if missing
+ * - Missing required fields produce a clear error, not a crash
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// --- Mock setup ---
+const mockSNClient = {
+    getScopeId: jest.fn(),
+    getUserSysId: jest.fn(),
+    getCurrentAppUserPrefSysId: jest.fn(),
+    updateCurrentAppUserPref: jest.fn(),
+    createCurrentAppUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
+    createUpdateSet: jest.fn(),
+    changeUpdateSet: jest.fn(),
+    getCurrentUpdateSet: jest.fn(),
+    client: {
+        get: jest.fn(),
+    },
+};
+jest.mock("../snClient", () => ({
+    defaultClient: jest.fn(() => mockSNClient),
+    unwrapSNResponse: jest.fn((val) => val),
+}));
+jest.mock("../FileUtils", () => ({
+    getFileContextFromPath: jest.fn(),
+    getFileContextWithSkipReason: jest.fn(),
+}));
+jest.mock("../appUtils", () => ({
+    groupAppFiles: jest.fn(),
+    pushFiles: jest.fn(),
+}));
+jest.mock("../logMessages", () => ({
+    logFilePush: jest.fn(),
+}));
+jest.mock("../recentEdits", () => ({
+    writeRecentEdit: jest.fn(),
+}));
+jest.mock("../Logger", () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        success: jest.fn(),
+        getLogLevel: jest.fn().mockReturnValue("info"),
+    },
+}));
+jest.mock("../config", () => ({
+    loadConfigs: jest.fn().mockResolvedValue(undefined),
+    getConfig: jest.fn(),
+    getRootDir: jest.fn().mockReturnValue("/project"),
+    updateManifest: jest.fn(),
+    getManifest: jest.fn(),
+    getSourcePath: jest.fn().mockReturnValue("/project/src"),
+    getScopeManifestPath: jest.fn((scope) => `/project/dove.manifest.${scope}.json`),
+    getManifestPath: jest.fn().mockReturnValue("/project/dove.manifest.json"),
+}));
+// Filesystem mock store
+var mockFsStore = {};
+jest.mock("fs", () => ({
+    existsSync: jest.fn((p) => {
+        return p in mockFsStore;
+    }),
+    readFileSync: jest.fn((p) => {
+        if (p in mockFsStore)
+            return mockFsStore[p];
+        throw new Error("ENOENT: " + p);
+    }),
+    writeFileSync: jest.fn((p, data) => {
+        mockFsStore[p] = data;
+    }),
+    statSync: jest.fn(() => ({ mtimeMs: Date.now() })),
+    promises: {
+        readFile: jest.fn(),
+        writeFile: jest.fn(),
+        readdir: jest.fn(),
+        mkdir: jest.fn(),
+        access: jest.fn(),
+        stat: jest.fn(),
+    },
+}));
+jest.mock("chokidar", () => ({
+    watch: jest.fn(() => ({
+        on: jest.fn().mockReturnThis(),
+        close: jest.fn(),
+    })),
+}));
+jest.mock("lodash", () => {
+    var actual = jest.requireActual("lodash");
+    return {
+        ...actual,
+        debounce: jest.fn((fn) => {
+            var wrapper = jest.fn();
+            wrapper.cancel = jest.fn();
+            wrapper.flush = jest.fn(() => fn());
+            return wrapper;
+        }),
+    };
+});
+jest.mock("axios", () => ({
+    default: {
+        create: jest.fn(() => ({
+            get: jest.fn().mockResolvedValue({ data: { result: null } }),
+        })),
+    },
+}));
+// --- Imports ---
+const Logger_1 = require("../Logger");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+const path = __importStar(require("path"));
+// --- Tests ---
+describe("US-010: Validate task ID before ServiceNow queries", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFsStore = {};
+        // Default: scope switching succeeds
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.getUserSysId.mockResolvedValue([{ sys_id: "user_sys_id" }]);
+        mockSNClient.getCurrentAppUserPrefSysId.mockResolvedValue([{ sys_id: "pref_sys_id" }]);
+        mockSNClient.updateCurrentAppUserPref.mockResolvedValue({});
+        mockSNClient.createCurrentAppUserPref.mockResolvedValue({});
+    });
+    afterEach(() => {
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+    });
+    describe("readActiveTask() validation", () => {
+        it("returns null and logs error when taskId is empty string", () => {
+            var taskPath = path.resolve(process.cwd(), ".dove-active-task.json");
+            mockFsStore[taskPath] = JSON.stringify({
+                taskId: "",
+                taskName: "Test Task",
+                updateSetName: "CU- Test Task",
+                description: "Test",
+                taskUrl: "",
+                scopes: {},
+            });
+            var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+            expect(result).toBeNull();
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("missing a valid taskId"));
+        });
+        it("returns null and logs error when taskId is undefined", () => {
+            var taskPath = path.resolve(process.cwd(), ".dove-active-task.json");
+            mockFsStore[taskPath] = JSON.stringify({
+                taskName: "Test Task",
+                updateSetName: "CU-abc Test Task",
+                description: "Test",
+                taskUrl: "",
+                scopes: {},
+            });
+            var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+            expect(result).toBeNull();
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("missing a valid taskId"));
+        });
+        it("returns null and logs error when updateSetName is empty string", () => {
+            var taskPath = path.resolve(process.cwd(), ".dove-active-task.json");
+            mockFsStore[taskPath] = JSON.stringify({
+                taskId: "abc123",
+                taskName: "Test Task",
+                updateSetName: "",
+                description: "Test",
+                taskUrl: "",
+                scopes: {},
+            });
+            var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+            expect(result).toBeNull();
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("missing a valid updateSetName"));
+        });
+        it("returns null and logs error when updateSetName is missing", () => {
+            var taskPath = path.resolve(process.cwd(), ".dove-active-task.json");
+            mockFsStore[taskPath] = JSON.stringify({
+                taskId: "abc123",
+                taskName: "Test Task",
+                description: "Test",
+                taskUrl: "",
+                scopes: {},
+            });
+            var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+            expect(result).toBeNull();
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("missing a valid updateSetName"));
+        });
+        it("returns valid task when both taskId and updateSetName are present", () => {
+            var taskPath = path.resolve(process.cwd(), ".dove-active-task.json");
+            mockFsStore[taskPath] = JSON.stringify({
+                taskId: "abc123",
+                taskName: "Test Task",
+                updateSetName: "CU-abc123 Test Task",
+                description: "Test",
+                taskUrl: "",
+                scopes: {},
+            });
+            var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+            expect(result).not.toBeNull();
+            expect(result.taskId).toBe("abc123");
+            expect(result.updateSetName).toBe("CU-abc123 Test Task");
+            expect(Logger_1.logger.error).not.toHaveBeenCalled();
+        });
+    });
+    describe("ensureUpdateSetForScope() taskId validation", () => {
+        it("skips update set lookup when taskId is whitespace-only", async () => {
+            var taskPath = path.resolve(process.cwd(), ".dove-active-task.json");
+            mockFsStore[taskPath] = JSON.stringify({
+                taskId: "   ",
+                taskName: "Test Task",
+                updateSetName: "CU- Test Task",
+                description: "Test",
+                taskUrl: "",
+                scopes: {},
+            });
+            await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+            // readActiveTask should have returned null due to whitespace-only taskId
+            // which triggers the no-active-task warning instead
+            expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("No update set configured for scope"));
+            // Should NOT have made any ServiceNow API calls
+            expect(mockSNClient.changeScope).not.toHaveBeenCalled();
+            expect(mockSNClient.client.get).not.toHaveBeenCalled();
+            expect(mockSNClient.createUpdateSet).not.toHaveBeenCalled();
+        });
+        it("does not crash with missing required fields in task file", async () => {
+            var taskPath = path.resolve(process.cwd(), ".dove-active-task.json");
+            mockFsStore[taskPath] = JSON.stringify({
+                taskName: "Partial Task",
+            });
+            // Should not throw
+            await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+            // readActiveTask returns null → falls through to no-active-task warning
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("missing a valid taskId"));
+            expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("No update set configured for scope"));
+            // No ServiceNow API calls
+            expect(mockSNClient.changeScope).not.toHaveBeenCalled();
+        });
+        it("proceeds with valid taskId and makes ServiceNow query", async () => {
+            var taskPath = path.resolve(process.cwd(), ".dove-active-task.json");
+            mockFsStore[taskPath] = JSON.stringify({
+                taskId: "abc123",
+                taskName: "Test Task",
+                updateSetName: "CU-abc123 Test Task",
+                description: "Test",
+                taskUrl: "",
+                scopes: {},
+            });
+            // Mock: scope found, existing update set found
+            mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+            mockSNClient.client.get.mockResolvedValue({
+                data: { result: [{ sys_id: "us_123", name: "CU-abc123 Test Task", state: "in progress" }] },
+            });
+            mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+            mockSNClient.getCurrentUpdateSet.mockResolvedValue({
+                data: { result: { sysId: "us_123", name: "CU-abc123 Test Task" } },
+            });
+            await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_valid_scope");
+            // Should have proceeded to search ServiceNow
+            expect(mockSNClient.client.get).toHaveBeenCalled();
+            // The query should contain the taskId
+            var getCall = mockSNClient.client.get.mock.calls[0];
+            expect(getCall[1].params.sysparm_query).toContain("CU-abc123");
+            // No "empty taskId" error
+            var errorCalls = Logger_1.logger.error.mock.calls.map(function (c) { return c[0]; });
+            var hasEmptyTaskIdError = errorCalls.some(function (msg) {
+                return msg.indexOf("empty taskId") !== -1;
+            });
+            expect(hasEmptyTaskIdError).toBe(false);
+        });
+    });
+});

package/dist/tests/verifyUpdateSetSwitch.test.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * Tests for US-007: Verify update set is active after creation
+ *
+ * Validates:
+ * - After switchToUpdateSet(), getCurrentUpdateSet() is called to verify the sys_id matches
+ * - Verification failure triggers a retry
+ * - Retry failure produces explicit error with actual update set name
+ * - MultiScopeWatcher's ensureUpdateSetForScope() includes the same verification
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// --- Mock setup (MultiScopeWatcher tests) ---
+var mockSNClient = {
+    getScopeId: jest.fn(),
+    getUserSysId: jest.fn(),
+    getCurrentAppUserPrefSysId: jest.fn(),
+    updateCurrentAppUserPref: jest.fn(),
+    createCurrentAppUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
+    createUpdateSet: jest.fn(),
+    changeUpdateSet: jest.fn(),
+    getCurrentUpdateSet: jest.fn(),
+    client: {
+        get: jest.fn(),
+    },
+};
+jest.mock("../snClient", () => ({
+    defaultClient: jest.fn(() => mockSNClient),
+    unwrapSNResponse: jest.fn((val) => val),
+}));
+jest.mock("../FileUtils", () => ({
+    getFileContextFromPath: jest.fn(),
+    getFileContextWithSkipReason: jest.fn(),
+}));
+jest.mock("../appUtils", () => ({
+    groupAppFiles: jest.fn(),
+    pushFiles: jest.fn(),
+}));
+jest.mock("../logMessages", () => ({
+    logFilePush: jest.fn(),
+}));
+jest.mock("../recentEdits", () => ({
+    writeRecentEdit: jest.fn(),
+}));
+jest.mock("../Logger", () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        success: jest.fn(),
+        getLogLevel: jest.fn().mockReturnValue("info"),
+    },
+}));
+jest.mock("../config", () => ({
+    loadConfigs: jest.fn().mockResolvedValue(undefined),
+    getConfig: jest.fn(),
+    getRootDir: jest.fn().mockReturnValue("/project"),
+    updateManifest: jest.fn(),
+    getManifest: jest.fn(),
+    getSourcePath: jest.fn().mockReturnValue("/project/src"),
+    getScopeManifestPath: jest.fn((scope) => `/project/dove.manifest.${scope}.json`),
+    getManifestPath: jest.fn().mockReturnValue("/project/dove.manifest.json"),
+}));
+var mockFsStore = {};
+jest.mock("fs", () => ({
+    existsSync: jest.fn((p) => {
+        return p in mockFsStore;
+    }),
+    readFileSync: jest.fn((p) => {
+        if (p in mockFsStore)
+            return mockFsStore[p];
+        throw new Error("ENOENT: " + p);
+    }),
+    writeFileSync: jest.fn((p, data) => {
+        mockFsStore[p] = data;
+    }),
+    statSync: jest.fn(() => ({ mtimeMs: Date.now() })),
+    promises: {
+        readFile: jest.fn(),
+        writeFile: jest.fn(),
+        readdir: jest.fn(),
+        mkdir: jest.fn(),
+        access: jest.fn(),
+        stat: jest.fn(),
+    },
+}));
+jest.mock("chokidar", () => ({
+    watch: jest.fn(() => ({
+        on: jest.fn().mockReturnThis(),
+        close: jest.fn(),
+    })),
+}));
+jest.mock("lodash", () => {
+    var actual = jest.requireActual("lodash");
+    return {
+        ...actual,
+        debounce: jest.fn((fn) => {
+            var wrapper = jest.fn();
+            wrapper.cancel = jest.fn();
+            wrapper.flush = jest.fn(() => fn());
+            return wrapper;
+        }),
+    };
+});
+jest.mock("axios", () => ({
+    default: {
+        create: jest.fn(() => ({
+            get: jest.fn().mockResolvedValue({ data: { result: null } }),
+        })),
+    },
+}));
+// --- Imports ---
+const Logger_1 = require("../Logger");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+// --- Tests ---
+describe("US-007: Verify update set is active after creation", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFsStore = {};
+        // Default: scope switching succeeds
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.getUserSysId.mockResolvedValue([{ sys_id: "user_sys_id" }]);
+        mockSNClient.getCurrentAppUserPrefSysId.mockResolvedValue([{ sys_id: "pref_sys_id" }]);
+        mockSNClient.updateCurrentAppUserPref.mockResolvedValue({});
+        mockSNClient.createCurrentAppUserPref.mockResolvedValue({});
+    });
+    afterEach(() => {
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+    });
+    it("verifies update set switch by calling getCurrentUpdateSet after changeUpdateSet", async () => {
+        // Setup: active task + no existing config
+        var taskPath = require("path").resolve(process.cwd(), ".dove-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        // Scope exists
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        // Search returns existing update set
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_123", name: "CU-abc123 Test Task" }] }
+        });
+        // changeUpdateSet succeeds
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        // getCurrentUpdateSet confirms the correct sys_id
+        mockSNClient.getCurrentUpdateSet.mockResolvedValue({
+            data: { result: { sysId: "us_123", name: "CU-abc123 Test Task" } }
+        });
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+        // changeUpdateSet was called
+        expect(mockSNClient.changeUpdateSet).toHaveBeenCalledWith({ sysId: "us_123" });
+        // getCurrentUpdateSet was called for verification
+        expect(mockSNClient.getCurrentUpdateSet).toHaveBeenCalledWith("x_test_scope");
+        // Verify debug confirmation logged
+        expect(Logger_1.logger.debug).toHaveBeenCalledWith(expect.stringContaining("Update set switch verified"));
+    });
+    it("retries switch when verification shows wrong update set, succeeds on retry", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".dove-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_123", name: "CU-abc123 Test Task" }] }
+        });
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        // First verification fails (wrong sys_id), second succeeds
+        mockSNClient.getCurrentUpdateSet
+            .mockResolvedValueOnce({
+            data: { result: { sysId: "wrong_us_id", name: "Default" } }
+        })
+            .mockResolvedValueOnce({
+            data: { result: { sysId: "us_123", name: "CU-abc123 Test Task" } }
+        });
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+        // changeUpdateSet called twice (initial + retry)
+        expect(mockSNClient.changeUpdateSet).toHaveBeenCalledTimes(2);
+        // Warning logged about retry
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("verification failed, retrying"));
+        // Should succeed — no error about "could not be activated"
+        var errorCalls = Logger_1.logger.error.mock.calls.map(function (c) { return c[0]; });
+        var hasActivationError = errorCalls.some(function (msg) {
+            return typeof msg === "string" && msg.indexOf("could not be activated") !== -1;
+        });
+        expect(hasActivationError).toBe(false);
+    });
+    it("logs explicit error when both switch attempts fail verification", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".dove-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_123", name: "CU-abc123 Test Task" }] }
+        });
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        // Both verifications fail — always returns wrong sys_id
+        mockSNClient.getCurrentUpdateSet.mockResolvedValue({
+            data: { result: { sysId: "wrong_us_id", name: "Default" } }
+        });
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+        // changeUpdateSet called twice (initial + retry)
+        expect(mockSNClient.changeUpdateSet).toHaveBeenCalledTimes(2);
+        // Error message should include both the update set name and the actual active one
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("could not be activated"));
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("Default"));
+    });
+    it("does not retry when verification passes on first attempt", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".dove-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_123", name: "CU-abc123 Test Task" }] }
+        });
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        // Verification passes on first attempt
+        mockSNClient.getCurrentUpdateSet.mockResolvedValue({
+            data: { result: { sysId: "us_123", name: "CU-abc123 Test Task" } }
+        });
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+        // changeUpdateSet called only once
+        expect(mockSNClient.changeUpdateSet).toHaveBeenCalledTimes(1);
+        // getCurrentUpdateSet called once for verification
+        expect(mockSNClient.getCurrentUpdateSet).toHaveBeenCalledTimes(1);
+        // No retry warning
+        expect(Logger_1.logger.warn).not.toHaveBeenCalledWith(expect.stringContaining("verification failed, retrying"));
+    });
+    it("handles getCurrentUpdateSet throwing during verification gracefully", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".dove-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_123", name: "CU-abc123 Test Task" }] }
+        });
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        // getCurrentUpdateSet throws (network error etc.)
+        mockSNClient.getCurrentUpdateSet.mockRejectedValue(new Error("Network error"));
+        // Should not crash — the outer try/catch in ensureUpdateSetForScope handles it
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_scope");
+        // Should have attempted verification
+        expect(mockSNClient.getCurrentUpdateSet).toHaveBeenCalled();
+    });
+});