@tenonhq/sincronia-core 0.0.78 → 0.0.80

package/dist/tests/rateLimitCoordination.test.js

@@ -0,0 +1,271 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function createMockWatcher() {
+    var handlers = {};
+    var mock = {
+        _handlers: handlers,
+        on: jest.fn(function (event, handler) {
+            if (!handlers[event])
+                handlers[event] = [];
+            handlers[event].push(handler);
+            return mock;
+        }),
+        close: jest.fn(),
+        _emit: function (event) {
+            var args = Array.prototype.slice.call(arguments, 1);
+            (handlers[event] || []).forEach(function (h) { h.apply(null, args); });
+        },
+    };
+    return mock;
+}
+var mockWatchers = [];
+jest.mock("chokidar", function () {
+    return {
+        watch: jest.fn(function () {
+            var w = createMockWatcher();
+            mockWatchers.push(w);
+            return w;
+        }),
+    };
+});
+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;
+        }),
+    };
+});
+var mockSNClient = {
+    getScopeId: jest.fn(),
+    getUserSysId: jest.fn(),
+    getCurrentAppUserPrefSysId: jest.fn(),
+    updateCurrentAppUserPref: jest.fn(),
+    createCurrentAppUserPref: jest.fn(),
+    getCurrentUpdateSetUserPref: jest.fn(),
+};
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: jest.fn(function () { return mockSNClient; }),
+        unwrapSNResponse: jest.fn(function (val) { return val; }),
+    };
+});
+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(),
+        getRootDir: jest.fn().mockReturnValue("/project"),
+        updateManifest: jest.fn(),
+        getManifest: jest.fn(),
+        getSourcePath: jest.fn().mockReturnValue("/project/src"),
+        getScopeManifestPath: jest.fn(function (scope) { return "/project/sinc.manifest." + scope + ".json"; }),
+        getManifestPath: jest.fn().mockReturnValue("/project/sinc.manifest.json"),
+    };
+});
+jest.mock("fs", function () {
+    return {
+        existsSync: jest.fn(),
+        readFileSync: jest.fn(),
+        writeFileSync: jest.fn(),
+        promises: {
+            readFile: jest.fn(),
+            writeFile: jest.fn(),
+            readdir: jest.fn(),
+            mkdir: jest.fn(),
+            access: jest.fn(),
+            stat: jest.fn(),
+        },
+    };
+});
+jest.mock("axios", function () {
+    return {
+        default: {
+            create: jest.fn(function () {
+                return { get: jest.fn().mockResolvedValue({ data: { result: null } }) };
+            }),
+        },
+    };
+});
+// --- Imports ---
+const ConfigManager = __importStar(require("../config"));
+const Logger_1 = require("../Logger");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+const fs_1 = __importDefault(require("fs"));
+var MOCK_CONFIG = {
+    sourceDirectory: "src",
+    buildDirectory: "build",
+    rules: [],
+    includes: {},
+    excludes: {},
+    tableOptions: {},
+    refreshInterval: 30,
+    scopes: {
+        x_test_core: { sourceDirectory: "src/x_test_core" },
+        x_test_work: {},
+    },
+};
+describe("US-009: Rate limit coordination", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        mockWatchers.length = 0;
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+        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.getCurrentUpdateSetUserPref.mockResolvedValue([]);
+    });
+    afterEach(function () {
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+    });
+    describe("configurable monitoring interval", function () {
+        it("uses the provided monitorIntervalMs", async function () {
+            var setIntervalSpy = jest.spyOn(global, "setInterval");
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_test: {} },
+            });
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 60000 });
+            await new Promise(function (r) { setTimeout(r, 50); });
+            expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 60000);
+            setIntervalSpy.mockRestore();
+        });
+        it("defaults to 120s when no options provided", async function () {
+            var setIntervalSpy = jest.spyOn(global, "setInterval");
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_test: {} },
+            });
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            await new Promise(function (r) { setTimeout(r, 50); });
+            expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 120000);
+            setIntervalSpy.mockRestore();
+        });
+        it("disables monitoring when monitorIntervalMs is 0", async function () {
+            var setIntervalSpy = jest.spyOn(global, "setInterval");
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_test: {} },
+            });
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+            await new Promise(function (r) { setTimeout(r, 50); });
+            expect(setIntervalSpy).not.toHaveBeenCalled();
+            expect(Logger_1.logger.info).toHaveBeenCalledWith(expect.stringContaining("monitoring disabled"));
+            setIntervalSpy.mockRestore();
+        });
+    });
+    describe("monitoring uses local config (no API calls)", function () {
+        it("reads update set config from local file instead of making API calls", async function () {
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_scope_a: {}, x_scope_b: {} },
+            });
+            // Simulate update set config on disk
+            fs_1.default.existsSync.mockReturnValue(true);
+            fs_1.default.readFileSync.mockReturnValue(JSON.stringify({
+                x_scope_a: { sys_id: "us_a", name: "Task A Update Set" },
+                x_scope_b: { sys_id: "us_b", name: "Task B Update Set" },
+            }));
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 60000 });
+            await new Promise(function (r) { setTimeout(r, 50); });
+            // Monitoring should NOT call any SN API (getScopeId is only from startWatching scope switching)
+            // The checkAllUpdateSets method uses local config file — no getUserSysId, no getCurrentUpdateSetUserPref
+            expect(Logger_1.logger.info).toHaveBeenCalledWith(expect.stringContaining("Task A Update Set"));
+            expect(Logger_1.logger.info).toHaveBeenCalledWith(expect.stringContaining("Task B Update Set"));
+        });
+        it("warns when scope has no update set configured", async function () {
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_scope_a: {} },
+            });
+            fs_1.default.existsSync.mockReturnValue(true);
+            fs_1.default.readFileSync.mockReturnValue(JSON.stringify({}));
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 60000 });
+            await new Promise(function (r) { setTimeout(r, 50); });
+            expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("No update set configured"));
+        });
+        it("warns when scope is on Default update set", async function () {
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_scope_a: {} },
+            });
+            fs_1.default.existsSync.mockReturnValue(true);
+            fs_1.default.readFileSync.mockReturnValue(JSON.stringify({
+                x_scope_a: { sys_id: "us_default", name: "Default" },
+            }));
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 60000 });
+            await new Promise(function (r) { setTimeout(r, 50); });
+            expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("DEFAULT update set"));
+        });
+    });
+});

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,124 @@
+"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({});
+                }
+            };
+        },
+        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
+        MultiScopeWatcher_1.multiScopeWatcher.cachedScope = null;
+        MultiScopeWatcher_1.multiScopeWatcher.cachedUserSysId = null;
+    });
+    it("should make API calls on first switch to a scope", async function () {
+        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
+        expect(apiCalls).toContain("getScopeId:x_cadso_core");
+        expect(apiCalls).toContain("getUserSysId");
+        expect(apiCalls).toContain("getCurrentAppUserPrefSysId");
+        expect(apiCalls).toContain("updateCurrentAppUserPref");
+    });
+    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 make API calls 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("getScopeId:x_cadso_automate");
+        expect(apiCalls).toContain("getCurrentAppUserPrefSysId");
+        expect(apiCalls).toContain("updateCurrentAppUserPref");
+    });
+    it("should cache getUserSysId and call it at most once across multiple scope switches", async function () {
+        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
+        apiCalls = [];
+        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_automate");
+        var userCalls = apiCalls.filter(function (c) { return c === "getUserSysId"; });
+        expect(userCalls).toHaveLength(0);
+        expect(MultiScopeWatcher_1.multiScopeWatcher.cachedUserSysId).toBe("user_abc123");
+    });
+    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");
+        // Mock getScopeId to fail for a bad scope
+        var snClient = require("../snClient");
+        var origDefault = snClient.defaultClient;
+        snClient.defaultClient = function () {
+            var client = origDefault();
+            client.getScopeId = function () {
+                apiCalls.push("getScopeId:bad_scope");
+                return Promise.resolve({ data: { result: [] } });
+            };
+            return client;
+        };
+        try {
+            await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("bad_scope");
+        }
+        catch (e) {
+            // Expected
+        }
+        expect(MultiScopeWatcher_1.multiScopeWatcher.cachedScope).toBeNull();
+        // Restore
+        snClient.defaultClient = origDefault;
+    });
+});