@tenonhq/dovetail-core 0.0.85

package/dist/tests/retryOnHttpErr.test.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    getLogLevel: function () { return "debug"; },
+};
+jest.mock("../Logger", function () {
+    return { logger: mockLogger };
+});
+jest.mock("../FileLogger", function () {
+    return { fileLogger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() } };
+});
+// Minimal mock for genericUtils — just need wait()
+jest.mock("../genericUtils", function () {
+    return {
+        wait: jest.fn().mockResolvedValue(undefined),
+    };
+});
+const snClient_1 = require("../snClient");
+const genericUtils_1 = require("../genericUtils");
+function makeAxiosError(status, headers) {
+    var error = new Error("Request failed with status " + status);
+    error.isAxiosError = true;
+    error.response = {
+        status: status,
+        headers: headers || {},
+        data: {},
+    };
+    return error;
+}
+describe("retryOnHttpErr", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+    });
+    it("returns successfully on first try when no error", async function () {
+        var fn = jest.fn().mockResolvedValue({ status: 200, data: {} });
+        var result = await (0, snClient_1.retryOnHttpErr)(fn, "test > rec1");
+        expect(result).toEqual({ status: 200, data: {} });
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    // 401/403: Fail immediately
+    it("fails immediately on 401 with credential message", async function () {
+        var fn = jest.fn().mockRejectedValue(makeAxiosError(401));
+        await expect((0, snClient_1.retryOnHttpErr)(fn, "test > rec1")).rejects.toThrow();
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Unauthorized (401)"));
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("credentials"));
+    });
+    it("fails immediately on 403 with credential message", async function () {
+        var fn = jest.fn().mockRejectedValue(makeAxiosError(403));
+        await expect((0, snClient_1.retryOnHttpErr)(fn, "test > rec1")).rejects.toThrow();
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Forbidden (403)"));
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("credentials"));
+    });
+    // 404: Fail immediately
+    it("fails immediately on 404 with record not found message", async function () {
+        var fn = jest.fn().mockRejectedValue(makeAxiosError(404));
+        await expect((0, snClient_1.retryOnHttpErr)(fn, "test > rec1")).rejects.toThrow();
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Record not found (404)"));
+    });
+    // 429: Rate limited — honor Retry-After
+    it("retries on 429 and honors Retry-After header", async function () {
+        var fn = jest.fn()
+            .mockRejectedValueOnce(makeAxiosError(429, { "retry-after": "5" }))
+            .mockResolvedValue({ status: 200, data: {} });
+        var result = await (0, snClient_1.retryOnHttpErr)(fn, "test > rec1");
+        expect(result).toEqual({ status: 200, data: {} });
+        expect(fn).toHaveBeenCalledTimes(2);
+        expect(genericUtils_1.wait).toHaveBeenCalledWith(5000); // 5 seconds from Retry-After
+        expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining("Rate limited (429)"));
+    });
+    it("uses default 10s wait on 429 without Retry-After header", async function () {
+        var fn = jest.fn()
+            .mockRejectedValueOnce(makeAxiosError(429))
+            .mockResolvedValue({ status: 200, data: {} });
+        await (0, snClient_1.retryOnHttpErr)(fn, "test > rec1");
+        expect(genericUtils_1.wait).toHaveBeenCalledWith(10000);
+    });
+    // 500/502/503: Exponential backoff
+    it("retries 500 with exponential backoff (1s, 2s, 4s)", async function () {
+        var fn = jest.fn()
+            .mockRejectedValueOnce(makeAxiosError(500))
+            .mockRejectedValueOnce(makeAxiosError(500))
+            .mockRejectedValueOnce(makeAxiosError(500))
+            .mockResolvedValue({ status: 200, data: {} });
+        var result = await (0, snClient_1.retryOnHttpErr)(fn, "test > rec1");
+        expect(result).toEqual({ status: 200, data: {} });
+        expect(fn).toHaveBeenCalledTimes(4); // 3 failures + 1 success
+        expect(genericUtils_1.wait).toHaveBeenNthCalledWith(1, 1000); // 1s
+        expect(genericUtils_1.wait).toHaveBeenNthCalledWith(2, 2000); // 2s
+        expect(genericUtils_1.wait).toHaveBeenNthCalledWith(3, 4000); // 4s
+    });
+    it("gives up after 3 retries on 500", async function () {
+        var fn = jest.fn().mockRejectedValue(makeAxiosError(500));
+        await expect((0, snClient_1.retryOnHttpErr)(fn, "test > rec1")).rejects.toThrow();
+        expect(fn).toHaveBeenCalledTimes(4); // 1 initial + 3 retries
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("after 3 retries"));
+    });
+    it("retries 502 with exponential backoff", async function () {
+        var fn = jest.fn()
+            .mockRejectedValueOnce(makeAxiosError(502))
+            .mockResolvedValue({ status: 200, data: {} });
+        await (0, snClient_1.retryOnHttpErr)(fn, "test > rec1");
+        expect(fn).toHaveBeenCalledTimes(2);
+        expect(genericUtils_1.wait).toHaveBeenCalledWith(1000);
+    });
+    it("retries 503 with exponential backoff", async function () {
+        var fn = jest.fn()
+            .mockRejectedValueOnce(makeAxiosError(503))
+            .mockResolvedValue({ status: 200, data: {} });
+        await (0, snClient_1.retryOnHttpErr)(fn, "test > rec1");
+        expect(fn).toHaveBeenCalledTimes(2);
+        expect(genericUtils_1.wait).toHaveBeenCalledWith(1000);
+    });
+    it("caps backoff at 8s for server errors", async function () {
+        // After 3 retries with backoff doubling: 1s, 2s, 4s
+        // If we could do a 4th it would be 8s (capped), but we stop at 3
+        var fn = jest.fn()
+            .mockRejectedValueOnce(makeAxiosError(500))
+            .mockRejectedValueOnce(makeAxiosError(500))
+            .mockRejectedValueOnce(makeAxiosError(500))
+            .mockResolvedValue({ status: 200, data: {} });
+        await (0, snClient_1.retryOnHttpErr)(fn, "test > rec1");
+        // Verify the 3rd wait is 4s (next would be 8s = cap)
+        expect(genericUtils_1.wait).toHaveBeenNthCalledWith(3, 4000);
+    });
+    // Unknown errors: retry once
+    it("retries unknown status code once then fails", async function () {
+        var fn = jest.fn().mockRejectedValue(makeAxiosError(418));
+        await expect((0, snClient_1.retryOnHttpErr)(fn, "test > rec1")).rejects.toThrow();
+        expect(fn).toHaveBeenCalledTimes(2); // 1 initial + 1 retry
+        expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining("HTTP 418"));
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("after 1 retry"));
+    });
+    it("retries non-HTTP error once then fails", async function () {
+        var fn = jest.fn().mockRejectedValue(new Error("ECONNRESET"));
+        await expect((0, snClient_1.retryOnHttpErr)(fn, "test > rec1")).rejects.toThrow("ECONNRESET");
+        expect(fn).toHaveBeenCalledTimes(2); // 1 initial + 1 retry
+        expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining("unknown error"));
+    });
+    it("succeeds on retry for unknown error", async function () {
+        var fn = jest.fn()
+            .mockRejectedValueOnce(makeAxiosError(418))
+            .mockResolvedValue({ status: 200, data: {} });
+        var result = await (0, snClient_1.retryOnHttpErr)(fn, "test > rec1");
+        expect(result).toEqual({ status: 200, data: {} });
+        expect(fn).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/tests/scopeCaching.test.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+// Track API calls
+var apiCalls = [];
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () {
+            return {
+                getScopeId: function (scope) {
+                    apiCalls.push("getScopeId:" + scope);
+                    return Promise.resolve({ data: { result: [{ sys_id: "scope_" + scope }] } });
+                },
+                getUserSysId: function () {
+                    apiCalls.push("getUserSysId");
+                    return Promise.resolve({ data: { result: [{ sys_id: "user_abc123" }] } });
+                },
+                getCurrentAppUserPrefSysId: function (userSysId) {
+                    apiCalls.push("getCurrentAppUserPrefSysId");
+                    return Promise.resolve({ data: { result: [{ sys_id: "pref_123" }] } });
+                },
+                updateCurrentAppUserPref: function (scopeSysId, prefSysId) {
+                    apiCalls.push("updateCurrentAppUserPref");
+                    return Promise.resolve({});
+                },
+                createCurrentAppUserPref: function (scopeSysId, userSysId) {
+                    apiCalls.push("createCurrentAppUserPref");
+                    return Promise.resolve({});
+                },
+                changeScope: function (scope) {
+                    apiCalls.push("changeScope:" + scope);
+                    return Promise.resolve(undefined);
+                }
+            };
+        },
+        unwrapSNResponse: function (resp) {
+            return resp.then(function (r) { return r.data.result; });
+        }
+    };
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            debug: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            success: jest.fn()
+        }
+    };
+});
+jest.mock("../config", function () {
+    return {
+        loadConfigs: jest.fn().mockResolvedValue(undefined),
+        getConfig: jest.fn().mockReturnValue({ scopes: {} }),
+        getRootDir: jest.fn().mockReturnValue("/tmp"),
+        updateManifest: jest.fn()
+    };
+});
+describe("Scope Caching (US-013)", function () {
+    beforeEach(function () {
+        apiCalls = [];
+        // Reset cached state. switchToScope now uses the Claude REST API
+        // changeScope endpoint; the cache avoids redundant session switches.
+        MultiScopeWatcher_1.multiScopeWatcher.cachedScope = null;
+    });
+    it("should call changeScope on first switch to a scope", async function () {
+        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
+        expect(apiCalls).toContain("changeScope:x_cadso_core");
+    });
+    it("should skip API calls when switching to the same scope (cache hit)", async function () {
+        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
+        apiCalls = [];
+        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
+        expect(apiCalls).toEqual([]);
+    });
+    it("should call changeScope when switching to a different scope (cache miss)", async function () {
+        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
+        apiCalls = [];
+        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_automate");
+        expect(apiCalls).toContain("changeScope:x_cadso_automate");
+    });
+    it("should update cachedScope after a successful switch", async function () {
+        expect(MultiScopeWatcher_1.multiScopeWatcher.cachedScope).toBeNull();
+        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
+        expect(MultiScopeWatcher_1.multiScopeWatcher.cachedScope).toBe("x_cadso_core");
+        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_automate");
+        expect(MultiScopeWatcher_1.multiScopeWatcher.cachedScope).toBe("x_cadso_automate");
+    });
+    it("should invalidate cachedScope on failure", async function () {
+        // First successful switch
+        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
+        expect(MultiScopeWatcher_1.multiScopeWatcher.cachedScope).toBe("x_cadso_core");
+        // Swap in a client whose changeScope rejects
+        var snClient = require("../snClient");
+        var origDefault = snClient.defaultClient;
+        snClient.defaultClient = function () {
+            var client = origDefault();
+            client.changeScope = function (scope) {
+                apiCalls.push("changeScope:" + scope + ":failed");
+                return Promise.reject(new Error("changeScope failed"));
+            };
+            return client;
+        };
+        try {
+            await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("bad_scope");
+        }
+        catch (e) {
+            // Expected
+        }
+        expect(MultiScopeWatcher_1.multiScopeWatcher.cachedScope).toBeNull();
+        // Restore
+        snClient.defaultClient = origDefault;
+    });
+});

package/dist/tests/serializeUpdateSetConfig.test.js

@@ -0,0 +1,325 @@
+"use strict";
+/**
+ * US-005: Serialize update set config writes under scope lock
+ *
+ * Tests that:
+ * - ensureUpdateSetForScope() calls are serialized via scopeLock
+ * - 3 concurrent scope writes all persist correctly
+ * - After writing, config is verified by re-reading
+ * - No mapping is lost due to concurrent writes
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// --- Mock setup ---
+var mockFsStore = {};
+jest.mock("fs", function () {
+    return {
+        existsSync: jest.fn(function (p) {
+            return p in mockFsStore;
+        }),
+        readFileSync: jest.fn(function (p) {
+            if (p in mockFsStore)
+                return mockFsStore[p];
+            throw new Error("ENOENT: " + p);
+        }),
+        writeFileSync: jest.fn(function (p, data) {
+            mockFsStore[p] = data;
+        }),
+        statSync: jest.fn(function () { return { mtimeMs: Date.now() }; }),
+        promises: {
+            readFile: jest.fn(function (p) {
+                if (p in mockFsStore)
+                    return Promise.resolve(mockFsStore[p]);
+                return Promise.reject(new Error("ENOENT: " + p));
+            }),
+            writeFile: jest.fn(),
+            readdir: jest.fn(),
+            mkdir: jest.fn(),
+            access: jest.fn(),
+            stat: jest.fn(),
+        },
+    };
+});
+var mockSNClient = {
+    getScopeId: jest.fn(),
+    getUserSysId: jest.fn(),
+    getCurrentAppUserPrefSysId: jest.fn(),
+    updateCurrentAppUserPref: jest.fn(),
+    createCurrentAppUserPref: jest.fn(),
+    getCurrentUpdateSetUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
+    client: {
+        get: jest.fn(),
+    },
+    changeUpdateSet: jest.fn().mockResolvedValue(undefined),
+    createUpdateSet: jest.fn(),
+};
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: jest.fn(function () { return mockSNClient; }),
+        unwrapSNResponse: jest.fn(function (val) { return val; }),
+    };
+});
+jest.mock("chokidar", function () {
+    return {
+        watch: jest.fn(function () {
+            return {
+                on: jest.fn().mockReturnThis(),
+                close: jest.fn(),
+            };
+        }),
+    };
+});
+jest.mock("lodash", function () {
+    var actual = jest.requireActual("lodash");
+    return {
+        ...actual,
+        debounce: jest.fn(function (fn) {
+            var wrapper = jest.fn();
+            wrapper.cancel = jest.fn();
+            wrapper.flush = jest.fn(function () { return fn(); });
+            return wrapper;
+        }),
+    };
+});
+jest.mock("../FileUtils", function () {
+    return {
+        getFileContextFromPath: jest.fn(),
+        getFileContextWithSkipReason: jest.fn(),
+    };
+});
+jest.mock("../appUtils", function () {
+    return {
+        groupAppFiles: jest.fn(),
+        pushFiles: jest.fn(),
+    };
+});
+jest.mock("../logMessages", function () {
+    return { logFilePush: jest.fn() };
+});
+jest.mock("../recentEdits", function () {
+    return { writeRecentEdit: jest.fn() };
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+            success: jest.fn(),
+            getLogLevel: jest.fn().mockReturnValue("info"),
+        },
+    };
+});
+jest.mock("../config", function () {
+    return {
+        loadConfigs: jest.fn().mockResolvedValue(undefined),
+        getConfig: jest.fn().mockReturnValue({
+            sourceDirectory: "src",
+            buildDirectory: "build",
+            rules: [],
+            includes: {},
+            excludes: {},
+            tableOptions: {},
+            refreshInterval: 30,
+            scopes: {
+                x_scope_a: { sourceDirectory: "src/x_scope_a" },
+                x_scope_b: { sourceDirectory: "src/x_scope_b" },
+                x_scope_c: { sourceDirectory: "src/x_scope_c" },
+            },
+        }),
+        getRootDir: jest.fn().mockReturnValue("/project"),
+        updateManifest: jest.fn(),
+        getManifest: jest.fn(),
+        getSourcePath: jest.fn().mockReturnValue("/project/src"),
+        getScopeManifestPath: jest.fn(function (scope) { return "/project/dove.manifest." + scope + ".json"; }),
+        getManifestPath: jest.fn().mockReturnValue("/project/dove.manifest.json"),
+    };
+});
+jest.mock("axios", function () {
+    return {
+        default: {
+            create: jest.fn(function () {
+                return {
+                    get: jest.fn().mockResolvedValue({ data: { result: null } }),
+                };
+            }),
+        },
+    };
+});
+// --- Imports ---
+const fs_1 = __importDefault(require("fs"));
+const Logger_1 = require("../Logger");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+// --- Helpers ---
+var CONFIG_PATH = "/fake/.dove-update-sets.json";
+var TASK_PATH = "/fake/.dove-active-task.json";
+function setActiveTask(task) {
+    var taskPath = require("path").resolve(process.cwd(), ".dove-active-task.json");
+    mockFsStore[taskPath] = JSON.stringify(task);
+}
+function getConfigPath() {
+    return require("path").resolve(process.cwd(), ".dove-update-sets.json");
+}
+function readPersistedConfig() {
+    var configPath = getConfigPath();
+    if (configPath in mockFsStore) {
+        return JSON.parse(mockFsStore[configPath]);
+    }
+    return {};
+}
+function clearFsStore() {
+    Object.keys(mockFsStore).forEach(function (k) { delete mockFsStore[k]; });
+}
+// --- Tests ---
+describe("US-005: Serialize update set config writes under scope lock", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        clearFsStore();
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+        // 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({});
+        mockSNClient.changeScope.mockResolvedValue(undefined);
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        // Mock: existing update set found for each scope
+        mockSNClient.client.get.mockResolvedValue({
+            data: {
+                result: [{ sys_id: "us_found_123", name: "CU-TASK123 Update Set", state: "in progress" }],
+            },
+        });
+    });
+    afterEach(function () {
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+    });
+    it("3 concurrent ensureUpdateSetForScope calls all persist correctly", async function () {
+        // Set up active task so ensureUpdateSetForScope will create update sets
+        setActiveTask({
+            taskId: "TASK123",
+            taskName: "Test Task",
+            taskDescription: "desc",
+            updateSetName: "CU-TASK123 Update Set",
+            description: "desc",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        // Return different sys_ids for each scope's search
+        var callCount = 0;
+        mockSNClient.client.get.mockImplementation(function () {
+            callCount++;
+            return Promise.resolve({
+                data: {
+                    result: [{ sys_id: "us_" + callCount, name: "CU-TASK123 Scope " + callCount, state: "in progress" }],
+                },
+            });
+        });
+        // Call all 3 concurrently — they should serialize under scopeLock
+        var watcher = MultiScopeWatcher_1.multiScopeWatcher;
+        var p1 = watcher.withScopeLock(function () { return watcher.ensureUpdateSetForScope("x_scope_a"); });
+        var p2 = watcher.withScopeLock(function () { return watcher.ensureUpdateSetForScope("x_scope_b"); });
+        var p3 = watcher.withScopeLock(function () { return watcher.ensureUpdateSetForScope("x_scope_c"); });
+        await Promise.all([p1, p2, p3]);
+        // All 3 scopes should be in the persisted config
+        var config = readPersistedConfig();
+        expect(config.x_scope_a).toBeDefined();
+        expect(config.x_scope_a.sys_id).toBe("us_1");
+        expect(config.x_scope_b).toBeDefined();
+        expect(config.x_scope_b.sys_id).toBe("us_2");
+        expect(config.x_scope_c).toBeDefined();
+        expect(config.x_scope_c.sys_id).toBe("us_3");
+    });
+    it("re-reads config before writing to preserve other scopes' mappings", async function () {
+        // Pre-populate config with scope_a already mapped
+        var configPath = getConfigPath();
+        mockFsStore[configPath] = JSON.stringify({
+            x_scope_a: { sys_id: "existing_a", name: "Existing A" },
+        });
+        setActiveTask({
+            taskId: "TASK456",
+            taskName: "Test",
+            taskDescription: "",
+            updateSetName: "CU-TASK456",
+            description: "",
+            taskUrl: "",
+            scopes: {},
+        });
+        mockSNClient.client.get.mockResolvedValue({
+            data: {
+                result: [{ sys_id: "us_new_b", name: "CU-TASK456 B", state: "in progress" }],
+            },
+        });
+        var watcher = MultiScopeWatcher_1.multiScopeWatcher;
+        await watcher.withScopeLock(function () { return watcher.ensureUpdateSetForScope("x_scope_b"); });
+        // Both scope_a (pre-existing) and scope_b (new) should be present
+        var config = readPersistedConfig();
+        expect(config.x_scope_a).toBeDefined();
+        expect(config.x_scope_a.sys_id).toBe("existing_a");
+        expect(config.x_scope_b).toBeDefined();
+        expect(config.x_scope_b.sys_id).toBe("us_new_b");
+    });
+    it("verifies write after saving config and logs debug confirmation", async function () {
+        setActiveTask({
+            taskId: "TASK789",
+            taskName: "Test",
+            taskDescription: "",
+            updateSetName: "CU-TASK789",
+            description: "",
+            taskUrl: "",
+            scopes: {},
+        });
+        mockSNClient.client.get.mockResolvedValue({
+            data: {
+                result: [{ sys_id: "us_verified", name: "CU-TASK789", state: "in progress" }],
+            },
+        });
+        var watcher = MultiScopeWatcher_1.multiScopeWatcher;
+        await watcher.withScopeLock(function () { return watcher.ensureUpdateSetForScope("x_scope_a"); });
+        // Should log a debug message confirming verification
+        expect(Logger_1.logger.debug).toHaveBeenCalledWith(expect.stringContaining("Update set config verified"));
+    });
+    it("throws and logs error when write verification fails", async function () {
+        setActiveTask({
+            taskId: "TASKFAIL",
+            taskName: "Test",
+            taskDescription: "",
+            updateSetName: "CU-TASKFAIL",
+            description: "",
+            taskUrl: "",
+            scopes: {},
+        });
+        mockSNClient.client.get.mockResolvedValue({
+            data: {
+                result: [{ sys_id: "us_fail", name: "CU-TASKFAIL", state: "in progress" }],
+            },
+        });
+        // Make writeFileSync succeed but readFileSync return empty on verification re-read
+        var writeCount = 0;
+        fs_1.default.writeFileSync.mockImplementation(function (p, data) {
+            // Write succeeds but data is "corrupted" — store empty config
+            mockFsStore[p] = JSON.stringify({});
+        });
+        var watcher = MultiScopeWatcher_1.multiScopeWatcher;
+        // The error is caught by ensureUpdateSetForScope's try/catch, which logs error + warn
+        await watcher.withScopeLock(function () { return watcher.ensureUpdateSetForScope("x_scope_a"); });
+        // Should log error about verification failure
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("write verification failed"));
+    });
+    it("skips API calls when scope already has a mapping", async function () {
+        // Pre-populate config with scope_a already mapped
+        var configPath = getConfigPath();
+        mockFsStore[configPath] = JSON.stringify({
+            x_scope_a: { sys_id: "existing_a", name: "Existing A" },
+        });
+        var watcher = MultiScopeWatcher_1.multiScopeWatcher;
+        await watcher.withScopeLock(function () { return watcher.ensureUpdateSetForScope("x_scope_a"); });
+        // Should not have called any ServiceNow APIs
+        expect(mockSNClient.changeScope).not.toHaveBeenCalled();
+        expect(mockSNClient.client.get).not.toHaveBeenCalled();
+    });
+});