@tenonhq/sincronia-core 0.0.80 → 0.0.82

package/dist/snClient.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unwrapSNResponse = exports.defaultClient = exports.snClient = exports.processPushResponse = exports.retryOnHttpErr = exports.retryOnErr = void 0;
+exports.setBenchmarkSink = setBenchmarkSink;
 exports.unwrapTableAPIFirstItem = unwrapTableAPIFirstItem;
 const axios_1 = __importDefault(require("axios"));
 const axios_cookiejar_support_1 = require("axios-cookiejar-support");
@@ -12,6 +13,11 @@ const tough_cookie_1 = require("tough-cookie");
 const genericUtils_1 = require("./genericUtils");
 const Logger_1 = require("./Logger");
 const FileLogger_1 = require("./FileLogger");
+// Benchmark sink. Null when --benchmark is off; zero overhead in that case.
+let _benchmarkSink = null;
+function setBenchmarkSink(sink) {
+    _benchmarkSink = sink;
+}
 // Local helper to strip _ directive keys before sending to ServiceNow API.
 // Defined here (not imported from config.ts) to avoid circular dependencies.
 function _stripUnderscoreKeys(obj) {
@@ -143,7 +149,7 @@ const processPushResponse = (response, recSummary) => {
 exports.processPushResponse = processPushResponse;
 const snClient = (baseURL, username, password) => {
     const jar = new tough_cookie_1.CookieJar();
-    const client = (0, axios_rate_limit_1.default)((0, axios_cookiejar_support_1.wrapper)(axios_1.default.create({
+    const rawAxios = (0, axios_cookiejar_support_1.wrapper)(axios_1.default.create({
         withCredentials: true,
         auth: {
             username,
@@ -154,7 +160,55 @@ const snClient = (baseURL, username, password) => {
         },
         baseURL,
         jar,
-    })), { maxRPS: 20 });
+    }));
+    // Request interceptor: stamp startedAt so the response interceptor can
+    // compute durationMs. Only when a benchmark sink is attached — when it
+    // isn't, this is a single property assignment and does not change shape.
+    rawAxios.interceptors.request.use(function (cfg) {
+        if (_benchmarkSink) {
+            cfg._benchStartedAt = Date.now();
+        }
+        return cfg;
+    });
+    rawAxios.interceptors.response.use(function (response) {
+        if (!_benchmarkSink)
+            return response;
+        var startedAt = response.config && response.config._benchStartedAt;
+        if (!startedAt)
+            return response;
+        var url = (response.config && response.config.url) || "";
+        var payload = response.data;
+        var responseBytes = 0;
+        try {
+            responseBytes = payload ? JSON.stringify(payload).length : 0;
+        }
+        catch (e) {
+            responseBytes = 0;
+        }
+        var tableCount = 0;
+        var result = payload && payload.result;
+        if (result && typeof result === "object") {
+            if (url.indexOf("bulkDownload") !== -1) {
+                tableCount = Object.keys(result).length;
+            }
+            else if (url.indexOf("getManifest") !== -1 && result.tables) {
+                tableCount = Object.keys(result.tables).length;
+            }
+        }
+        _benchmarkSink.recordHttp({
+            path: url,
+            tableCount: tableCount,
+            durationMs: Date.now() - startedAt,
+            statusCode: response.status,
+            responseBytes: responseBytes,
+        });
+        return response;
+    }, function (error) {
+        // Preserve original rejection; don't record errored requests (they skew
+        // latency tails without adding signal for the "scales the same" question).
+        return Promise.reject(error);
+    });
+    const client = (0, axios_rate_limit_1.default)(rawAxios, { maxRPS: 20 });
     const getAppList = () => {
         const endpoint = "api/sinc/sincronia/getAppList";
         return client.get(endpoint);
@@ -369,13 +423,56 @@ const unwrapSNResponse = async (clientPromise) => {
         return resp.data.result;
     }
     catch (e) {
-        let message;
-        if (e instanceof Error)
-            message = e.message;
-        else
-            message = String(e);
         const instance = process.env.SN_INSTANCE || "unknown";
-        Logger_1.logger.error("Error from " + instance + ": " + message);
+        if (axios_1.default.isAxiosError(e) && e.response) {
+            const status = e.response.status;
+            const statusText = e.response.statusText || "";
+            const method = ((e.config && e.config.method) || "").toUpperCase();
+            const url = (e.config && e.config.url) || "";
+            const data = e.response.data;
+            // Extract ServiceNow-shaped error message if present (`{error: {message, detail}, status}`)
+            let snMessage = "";
+            if (data && typeof data === "object") {
+                if (data.error && typeof data.error === "object" && data.error.message) {
+                    snMessage = " — " + String(data.error.message);
+                }
+                else if (typeof data.message === "string") {
+                    snMessage = " — " + data.message;
+                }
+            }
+            // Pull scope out of /getManifest/:scope URLs for easy grepping
+            let scope;
+            const manifestMatch = url.match(/\/getManifest\/([^/?]+)/);
+            if (manifestMatch)
+                scope = manifestMatch[1];
+            Logger_1.logger.error("Error from " + instance + ": HTTP " + status + " " +
+                method + " " + url + snMessage);
+            FileLogger_1.fileLogger.debug("REST error detail", {
+                instance: instance,
+                scope: scope,
+                method: method,
+                url: url,
+                status: status,
+                statusText: statusText,
+                responseData: data,
+                responseHeaders: e.response.headers,
+            });
+        }
+        else {
+            // Non-Axios error: preserve today's behaviour, add debug detail
+            let message;
+            if (e instanceof Error)
+                message = e.message;
+            else
+                message = String(e);
+            Logger_1.logger.error("Error from " + instance + ": " + message);
+            FileLogger_1.fileLogger.debug("Non-Axios error detail", {
+                instance: instance,
+                errorName: e instanceof Error ? e.name : undefined,
+                errorStack: e instanceof Error ? e.stack : undefined,
+                message: message,
+            });
+        }
         throw e;
     }
 };

package/dist/tests/benchmarkRefresh.test.js

@@ -0,0 +1,265 @@
+"use strict";
+/**
+ * Unit tests for the --benchmark flag on `sinc refresh`.
+ *
+ * Two layers:
+ *   1. BenchmarkCollector in isolation — covers p50/p95/max math and the
+ *      formatSummary string the CLI prints.
+ *   2. refreshAllFiles wired to a collector — asserts startScope/endScope
+ *      bookends the scope and that filesWritten/filesUnchanged match what
+ *      refresh actually did.
+ *
+ * The axios interceptor hook (snClient.setBenchmarkSink) is exercised by the
+ * real-run integration against workstudio — not here. This suite covers the
+ * collector contract and the appUtils lifecycle.
+ */
+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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const benchmark_1 = require("../benchmark");
+// ---------- mocks for refreshAllFiles test (must come before importing) ----
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+    getLogLevel: function () { return "warn"; },
+};
+var mockFileLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+};
+var mockClient = {
+    getManifest: jest.fn(),
+    getMissingFiles: jest.fn(),
+};
+jest.mock("../Logger", function () { return { logger: mockLogger }; });
+jest.mock("../FileLogger", function () { return { fileLogger: mockFileLogger }; });
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () { return mockClient; },
+        unwrapSNResponse: function (p) { return Promise.resolve(p).then(function (r) { return r; }); },
+        processPushResponse: jest.fn(),
+        retryOnErr: jest.fn(),
+        retryOnHttpErr: jest.fn(),
+        unwrapTableAPIFirstItem: jest.fn(),
+        setBenchmarkSink: jest.fn(),
+    };
+});
+var mockConfig = {
+    getConfig: jest.fn().mockReturnValue({ scopes: { x_cadso_core: {} }, tableOptions: {} }),
+    getManifest: jest.fn().mockResolvedValue({
+        x_cadso_core: { scope: "x_cadso_core", tables: {} },
+    }),
+    getSourcePathForScope: jest.fn(),
+    getSourcePath: jest.fn(),
+    getManifestPath: jest.fn().mockReturnValue("/tmp/sinc.manifest.json"),
+    resolveConfigForScope: jest.fn().mockImplementation(function () {
+        return { tables: ["sys_script_include"], fieldOverrides: {}, apiIncludes: {}, apiExcludes: {} };
+    }),
+    isMultiScopeManifest: jest.fn().mockReturnValue(true),
+    updateManifest: jest.fn(),
+};
+jest.mock("../config", function () { return mockConfig; });
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () { return { tick: jest.fn() }; });
+});
+jest.mock("../FileUtils", function () {
+    var actual = jest.requireActual("../FileUtils");
+    return Object.assign({}, actual, {
+        writeScopeManifest: jest.fn().mockResolvedValue(undefined),
+    });
+});
+const AppUtils = __importStar(require("../appUtils"));
+// ---------- collector unit tests ----------
+describe("BenchmarkCollector", function () {
+    test("formatSummary reports empty state when nothing recorded", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        var summary = collector.formatSummary();
+        expect(summary).toContain("Refresh Benchmark");
+        expect(summary).toContain("(no samples recorded)");
+    });
+    test("percentiles reflect the recorded latencies", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        // 10, 20, 30, ..., 100 — p50 at index 5 = 60, p95 at index 9 = 100.
+        for (var i = 1; i <= 10; i++) {
+            collector.recordHttp({
+                path: "/api/test",
+                tableCount: 1,
+                durationMs: i * 10,
+                statusCode: 200,
+                responseBytes: 100,
+            });
+        }
+        var summary = collector.formatSummary();
+        expect(summary).toContain("p50 60ms");
+        expect(summary).toContain("p95 100ms");
+        expect(summary).toContain("max 100ms");
+        expect(summary).toContain("10 HTTP requests");
+    });
+    test("scope samples record wall time, request counts, and file counts", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.startScope("x_cadso_core");
+        collector.recordHttp({
+            path: "/api/bulkDownload",
+            tableCount: 3,
+            durationMs: 50,
+            statusCode: 200,
+            responseBytes: 2048,
+        });
+        collector.recordHttp({
+            path: "/api/bulkDownload",
+            tableCount: 3,
+            durationMs: 80,
+            statusCode: 200,
+            responseBytes: 4096,
+        });
+        collector.endScope(7, 42);
+        var scopes = collector.getScopeSamples();
+        expect(scopes).toHaveLength(1);
+        expect(scopes[0].scopeName).toBe("x_cadso_core");
+        expect(scopes[0].httpRequests).toBe(2);
+        expect(scopes[0].totalResponseBytes).toBe(2048 + 4096);
+        expect(scopes[0].filesWritten).toBe(7);
+        expect(scopes[0].filesUnchanged).toBe(42);
+        expect(scopes[0].wallTimeMs).toBeGreaterThanOrEqual(0);
+        var summary = collector.formatSummary();
+        expect(summary).toContain("x_cadso_core:");
+        expect(summary).toContain("7 written / 42 unchanged");
+    });
+    test("formatBytes switches units at KB and MB thresholds", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.recordHttp({ path: "/a", tableCount: 1, durationMs: 1, statusCode: 200, responseBytes: 500 });
+        expect(collector.formatSummary()).toContain("500B received");
+        var collector2 = new benchmark_1.BenchmarkCollector();
+        collector2.recordHttp({ path: "/a", tableCount: 1, durationMs: 1, statusCode: 200, responseBytes: 2048 });
+        expect(collector2.formatSummary()).toContain("2.0KB received");
+        var collector3 = new benchmark_1.BenchmarkCollector();
+        collector3.recordHttp({ path: "/a", tableCount: 1, durationMs: 1, statusCode: 200, responseBytes: 2 * 1024 * 1024 });
+        expect(collector3.formatSummary()).toContain("2.00MB received");
+    });
+    test("endScope is a no-op when no scope is active", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.endScope(5, 5);
+        expect(collector.getScopeSamples()).toHaveLength(0);
+    });
+});
+// ---------- refreshAllFiles integration with collector ----------
+describe("refreshAllFiles — benchmarkCollector lifecycle", function () {
+    var tmpRoot;
+    beforeEach(function () {
+        jest.clearAllMocks();
+        tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sinc-bench-test-"));
+        mockConfig.getSourcePathForScope.mockReturnValue(tmpRoot);
+        mockConfig.getSourcePath.mockReturnValue(tmpRoot);
+    });
+    afterEach(function () {
+        try {
+            fs.rmSync(tmpRoot, { recursive: true, force: true });
+        }
+        catch (e) { }
+    });
+    test("endScope captures filesWritten and filesUnchanged for a refresh pass", async function () {
+        // "Stale" file — content diverges from what the mock returns → will be written.
+        fs.mkdirSync(path.join(tmpRoot, "sys_script_include", "StaleRec"), { recursive: true });
+        fs.writeFileSync(path.join(tmpRoot, "sys_script_include", "StaleRec", "script.js"), "var x = 1;");
+        // "Matching" file — content matches → counted as unchanged.
+        fs.mkdirSync(path.join(tmpRoot, "sys_script_include", "SameRec"), { recursive: true });
+        var matching = "var same = true;";
+        fs.writeFileSync(path.join(tmpRoot, "sys_script_include", "SameRec", "script.js"), matching);
+        var manifest = {
+            scope: "x_cadso_core",
+            tables: {
+                sys_script_include: {
+                    records: {
+                        StaleRec: { name: "StaleRec", sys_id: "sysid_Stale", files: [{ name: "script", type: "js" }] },
+                        SameRec: { name: "SameRec", sys_id: "sysid_Same", files: [{ name: "script", type: "js" }] },
+                    },
+                },
+            },
+        };
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    StaleRec: {
+                        name: "StaleRec", sys_id: "sysid_Stale",
+                        files: [{ name: "script", type: "js", content: "var x = 99; // new from instance" }],
+                    },
+                    SameRec: {
+                        name: "SameRec", sys_id: "sysid_Same",
+                        files: [{ name: "script", type: "js", content: matching }],
+                    },
+                },
+            },
+        });
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.startScope("x_cadso_core");
+        await AppUtils.refreshAllFiles(manifest, tmpRoot, {
+            benchmarkCollector: collector,
+        });
+        var scopes = collector.getScopeSamples();
+        expect(scopes).toHaveLength(1);
+        expect(scopes[0].scopeName).toBe("x_cadso_core");
+        // One file had divergent content → written. One matched → unchanged.
+        expect(scopes[0].filesWritten).toBe(1);
+        expect(scopes[0].filesUnchanged).toBe(1);
+    });
+    test("endScope(0, 0) on error path so the collector still closes cleanly", async function () {
+        mockClient.getMissingFiles.mockRejectedValue(new Error("boom"));
+        var manifest = {
+            scope: "x_cadso_core",
+            tables: {
+                sys_script_include: {
+                    records: {
+                        Rec: { name: "Rec", sys_id: "sysid_Rec", files: [{ name: "script", type: "js" }] },
+                    },
+                },
+            },
+        };
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.startScope("x_cadso_core");
+        await expect(AppUtils.refreshAllFiles(manifest, tmpRoot, { benchmarkCollector: collector })).rejects.toThrow("boom");
+        var scopes = collector.getScopeSamples();
+        expect(scopes).toHaveLength(1);
+        expect(scopes[0].filesWritten).toBe(0);
+        expect(scopes[0].filesUnchanged).toBe(0);
+    });
+});

package/dist/tests/globalDebounce.test.js

@@ -86,6 +86,7 @@ var mockSNClient = {
     updateCurrentAppUserPref: jest.fn(),
     createCurrentAppUserPref: jest.fn(),
     getCurrentUpdateSetUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
 };
 jest.mock("../snClient", function () {
     return {
@@ -267,9 +268,9 @@ describe("US-014: Global debounce for serialized scope processing", function ()
         watcherB.pushQueue.push(ctxB.filePath);
         // Track the order of scope switches
         var switchOrder = [];
-        mockSNClient.getScopeId.mockImplementation(function (scope) {
+        mockSNClient.changeScope.mockImplementation(function (scope) {
             switchOrder.push(scope);
-            return Promise.resolve([{ sys_id: "scope_sys_id_" + scope }]);
+            return Promise.resolve(undefined);
         });
         // Fire the global debounce
         await capturedDebounceFns[0]();

package/dist/tests/multi-scope-watcher.test.js

@@ -83,6 +83,7 @@ const mockSNClient = {
     updateCurrentAppUserPref: jest.fn(),
     createCurrentAppUserPref: jest.fn(),
     getCurrentUpdateSetUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
 };
 jest.mock("../snClient", () => ({
     defaultClient: jest.fn(() => mockSNClient),
@@ -415,28 +416,17 @@ describe("MultiScopeWatcherManager", () => {
         });
     });
     describe("switchToScope", () => {
-        it("updates existing preference when one exists", async () => {
-            mockSNClient.getCurrentAppUserPrefSysId.mockResolvedValue([{ sys_id: "existing_pref" }]);
-            // Access private method
+        // switchToScope now uses the Claude REST API changeScope endpoint
+        // (gs.setCurrentApplicationId) to switch the active REST session scope.
+        // The previous user-preference approach only wrote a DB record and did
+        // not affect the session, causing updateRecord() to operate in the wrong scope.
+        it("invokes client.changeScope with the target scope", async () => {
             await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_test_core");
-            expect(mockSNClient.getScopeId).toHaveBeenCalledWith("x_test_core");
-            expect(mockSNClient.getUserSysId).toHaveBeenCalled();
-            expect(mockSNClient.updateCurrentAppUserPref).toHaveBeenCalledWith("scope_sys_id", "existing_pref");
-            expect(mockSNClient.createCurrentAppUserPref).not.toHaveBeenCalled();
+            expect(mockSNClient.changeScope).toHaveBeenCalledWith("x_test_core");
         });
-        it("creates new preference when none exists", async () => {
-            mockSNClient.getCurrentAppUserPrefSysId.mockResolvedValue([]);
-            await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_test_core");
-            expect(mockSNClient.createCurrentAppUserPref).toHaveBeenCalledWith("scope_sys_id", "user_sys_id");
-            expect(mockSNClient.updateCurrentAppUserPref).not.toHaveBeenCalled();
-        });
-        it("throws when scope not found", async () => {
-            mockSNClient.getScopeId.mockResolvedValue([]);
-            await expect(MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_missing")).rejects.toThrow("Scope x_missing not found");
-        });
-        it("throws when user sys_id cannot be retrieved", async () => {
-            mockSNClient.getUserSysId.mockResolvedValue([]);
-            await expect(MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_test_core")).rejects.toThrow("Could not get user sys_id");
+        it("propagates errors from changeScope and invalidates cached scope", async () => {
+            mockSNClient.changeScope.mockRejectedValueOnce(new Error("changeScope failed"));
+            await expect(MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_test_core")).rejects.toThrow("changeScope failed");
         });
     });
     describe("loadScopeManifest", () => {

package/dist/tests/scopeCaching.test.js

@@ -26,6 +26,10 @@ jest.mock("../snClient", function () {
                 createCurrentAppUserPref: function (scopeSysId, userSysId) {
                     apiCalls.push("createCurrentAppUserPref");
                     return Promise.resolve({});
+                },
+                changeScope: function (scope) {
+                    apiCalls.push("changeScope:" + scope);
+                    return Promise.resolve(undefined);
                 }
             };
         },
@@ -56,16 +60,13 @@ jest.mock("../config", function () {
 describe("Scope Caching (US-013)", function () {
     beforeEach(function () {
         apiCalls = [];
-        // Reset cached state
+        // Reset cached state. switchToScope now uses the Claude REST API
+        // changeScope endpoint; the cache avoids redundant session switches.
         MultiScopeWatcher_1.multiScopeWatcher.cachedScope = null;
-        MultiScopeWatcher_1.multiScopeWatcher.cachedUserSysId = null;
     });
-    it("should make API calls on first switch to a scope", async function () {
+    it("should call changeScope 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");
+        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");
@@ -73,21 +74,11 @@ describe("Scope Caching (US-013)", function () {
         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 () {
+    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");
-        var userCalls = apiCalls.filter(function (c) { return c === "getUserSysId"; });
-        expect(userCalls).toHaveLength(0);
-        expect(MultiScopeWatcher_1.multiScopeWatcher.cachedUserSysId).toBe("user_abc123");
+        expect(apiCalls).toContain("changeScope:x_cadso_automate");
     });
     it("should update cachedScope after a successful switch", async function () {
         expect(MultiScopeWatcher_1.multiScopeWatcher.cachedScope).toBeNull();
@@ -100,14 +91,14 @@ describe("Scope Caching (US-013)", 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
+        // Swap in a client whose changeScope rejects
         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: [] } });
+            client.changeScope = function (scope) {
+                apiCalls.push("changeScope:" + scope + ":failed");
+                return Promise.reject(new Error("changeScope failed"));
             };
             return client;
         };