@tenonhq/sincronia-core 0.0.78 → 0.0.80

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/sinc.manifest." + scope + ".json"; }),
+        getManifestPath: jest.fn().mockReturnValue("/project/sinc.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/.sinc-update-sets.json";
+var TASK_PATH = "/fake/.sinc-active-task.json";
+function setActiveTask(task) {
+    var taskPath = require("path").resolve(process.cwd(), ".sinc-active-task.json");
+    mockFsStore[taskPath] = JSON.stringify(task);
+}
+function getConfigPath() {
+    return require("path").resolve(process.cwd(), ".sinc-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();
+    });
+});

package/dist/tests/taskClear.test.js

@@ -0,0 +1,170 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = require("../commands");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Mock logger
+var logMessages = [];
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            setLogLevel: jest.fn(),
+            success: jest.fn(function (msg) {
+                logMessages.push({ level: "success", msg: msg });
+            }),
+            info: jest.fn(function (msg) {
+                logMessages.push({ level: "info", msg: msg });
+            }),
+            error: jest.fn(function (msg) {
+                logMessages.push({ level: "error", msg: msg });
+            }),
+            warn: jest.fn(function (msg) {
+                logMessages.push({ level: "warn", msg: msg });
+            }),
+            debug: jest.fn(),
+            getInternalLogger: jest.fn(function () {
+                return { error: jest.fn() };
+            }),
+        },
+    };
+});
+// Mock fs
+jest.mock("fs");
+var mockFs = fs;
+// Mock other imports to prevent side effects
+jest.mock("../config", function () {
+    return {
+        getConfig: jest.fn(function () { return {}; }),
+        loadConfigs: jest.fn(),
+    };
+});
+jest.mock("../appUtils", function () { return {}; });
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: jest.fn(),
+        unwrapSNResponse: jest.fn(),
+    };
+});
+jest.mock("../FileLogger", function () {
+    return { fileLogger: { debug: jest.fn() } };
+});
+jest.mock("../logMessages", function () {
+    return {
+        logPushResults: jest.fn(),
+        logBuildResults: jest.fn(),
+    };
+});
+jest.mock("../gitUtils", function () {
+    return { gitDiffToEncodedPaths: jest.fn() };
+});
+jest.mock("../FileUtils", function () {
+    return { encodedPathsToFilePaths: jest.fn() };
+});
+jest.mock("inquirer", function () {
+    return { prompt: jest.fn() };
+});
+describe("taskClearCommand", function () {
+    var taskPath;
+    var defaultArgs = { logLevel: "info" };
+    beforeEach(function () {
+        logMessages = [];
+        taskPath = path.resolve(process.cwd(), ".sinc-active-task.json");
+        jest.clearAllMocks();
+    });
+    it("should remove .sinc-active-task.json when it exists", async function () {
+        var taskData = JSON.stringify({
+            taskId: "abc123",
+            taskName: "My Test Task",
+            updateSetName: "CU-abc123",
+        });
+        mockFs.existsSync.mockImplementation(function (p) {
+            return p === taskPath;
+        });
+        mockFs.readFileSync.mockImplementation(function (p) {
+            if (p === taskPath)
+                return taskData;
+            throw new Error("file not found");
+        });
+        mockFs.unlinkSync.mockImplementation(function () { });
+        await (0, commands_1.taskClearCommand)(defaultArgs);
+        expect(mockFs.unlinkSync).toHaveBeenCalledWith(taskPath);
+        expect(logMessages.some(function (m) {
+            return m.level === "success" && m.msg.indexOf("My Test Task") !== -1;
+        })).toBe(true);
+    });
+    it("should show informational message when no active task exists", async function () {
+        mockFs.existsSync.mockReturnValue(false);
+        await (0, commands_1.taskClearCommand)(defaultArgs);
+        expect(mockFs.unlinkSync).not.toHaveBeenCalled();
+        expect(logMessages.some(function (m) {
+            return m.level === "info" && m.msg.indexOf("No active task") !== -1;
+        })).toBe(true);
+    });
+    it("should still remove file even if JSON is invalid", async function () {
+        mockFs.existsSync.mockImplementation(function (p) {
+            return p === taskPath;
+        });
+        mockFs.readFileSync.mockImplementation(function () {
+            return "not valid json";
+        });
+        mockFs.unlinkSync.mockImplementation(function () { });
+        await (0, commands_1.taskClearCommand)(defaultArgs);
+        expect(mockFs.unlinkSync).toHaveBeenCalledWith(taskPath);
+        expect(logMessages.some(function (m) {
+            return m.level === "success" && m.msg.indexOf("removed") !== -1;
+        })).toBe(true);
+    });
+    it("should use taskId as fallback when taskName is missing", async function () {
+        var taskData = JSON.stringify({
+            taskId: "def456",
+            updateSetName: "CU-def456",
+        });
+        mockFs.existsSync.mockImplementation(function (p) {
+            return p === taskPath;
+        });
+        mockFs.readFileSync.mockImplementation(function (p) {
+            if (p === taskPath)
+                return taskData;
+            throw new Error("file not found");
+        });
+        mockFs.unlinkSync.mockImplementation(function () { });
+        await (0, commands_1.taskClearCommand)(defaultArgs);
+        expect(mockFs.unlinkSync).toHaveBeenCalledWith(taskPath);
+        expect(logMessages.some(function (m) {
+            return m.level === "success" && m.msg.indexOf("def456") !== -1;
+        })).toBe(true);
+    });
+});