@tenonhq/sincronia-core 0.0.78 → 0.0.80

package/dist/tests/taskStaleness.test.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * Tests for US-012: Add staleness warning for active task
+ *
+ * Validates:
+ * - On startup, if .sinc-active-task.json is older than 7 days, a warning is logged
+ * - Fresh task files produce no warning
+ * - Warning includes task name and age in days
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// --- Mock setup ---
+const mockSNClient = {
+    getScopeId: jest.fn(),
+    getUserSysId: jest.fn(),
+    getCurrentAppUserPrefSysId: jest.fn(),
+    updateCurrentAppUserPref: jest.fn(),
+    createCurrentAppUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
+    createUpdateSet: jest.fn(),
+    changeUpdateSet: jest.fn(),
+    getCurrentUpdateSet: jest.fn(),
+    client: {
+        get: jest.fn(),
+    },
+};
+jest.mock("../snClient", () => ({
+    defaultClient: jest.fn(() => mockSNClient),
+    unwrapSNResponse: jest.fn((val) => val),
+}));
+jest.mock("../FileUtils", () => ({
+    getFileContextFromPath: jest.fn(),
+    getFileContextWithSkipReason: jest.fn(),
+}));
+jest.mock("../appUtils", () => ({
+    groupAppFiles: jest.fn(),
+    pushFiles: jest.fn(),
+}));
+jest.mock("../logMessages", () => ({
+    logFilePush: jest.fn(),
+}));
+jest.mock("../recentEdits", () => ({
+    writeRecentEdit: jest.fn(),
+}));
+jest.mock("../Logger", () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        success: jest.fn(),
+        getLogLevel: jest.fn().mockReturnValue("info"),
+    },
+}));
+jest.mock("../config", () => ({
+    loadConfigs: jest.fn().mockResolvedValue(undefined),
+    getConfig: jest.fn(),
+    getRootDir: jest.fn().mockReturnValue("/project"),
+    updateManifest: jest.fn(),
+    getManifest: jest.fn(),
+    getSourcePath: jest.fn().mockReturnValue("/project/src"),
+    getScopeManifestPath: jest.fn((scope) => `/project/sinc.manifest.${scope}.json`),
+    getManifestPath: jest.fn().mockReturnValue("/project/sinc.manifest.json"),
+}));
+// Filesystem mock store
+var mockFsStore = {};
+var mockFsStatStore = {};
+jest.mock("fs", () => ({
+    existsSync: jest.fn((p) => {
+        return p in mockFsStore;
+    }),
+    readFileSync: jest.fn((p) => {
+        if (p in mockFsStore)
+            return mockFsStore[p];
+        throw new Error("ENOENT: " + p);
+    }),
+    writeFileSync: jest.fn((p, data) => {
+        mockFsStore[p] = data;
+    }),
+    statSync: jest.fn((p) => {
+        if (p in mockFsStatStore)
+            return mockFsStatStore[p];
+        return { mtimeMs: Date.now() };
+    }),
+    promises: {
+        readFile: jest.fn(),
+        writeFile: jest.fn(),
+        readdir: jest.fn(),
+        mkdir: jest.fn(),
+        access: jest.fn(),
+        stat: jest.fn(),
+    },
+}));
+jest.mock("chokidar", () => ({
+    watch: jest.fn(() => ({
+        on: jest.fn().mockReturnThis(),
+        close: jest.fn(),
+    })),
+}));
+jest.mock("lodash", () => {
+    var actual = jest.requireActual("lodash");
+    return {
+        ...actual,
+        debounce: jest.fn((fn) => {
+            var wrapper = jest.fn();
+            wrapper.cancel = jest.fn();
+            wrapper.flush = jest.fn(() => fn());
+            return wrapper;
+        }),
+    };
+});
+jest.mock("axios", () => ({
+    default: {
+        create: jest.fn(() => ({
+            get: jest.fn().mockResolvedValue({ data: { result: null } }),
+        })),
+    },
+}));
+// --- Imports ---
+const Logger_1 = require("../Logger");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+const path = __importStar(require("path"));
+// --- Tests ---
+describe("US-012: Add staleness warning for active task", () => {
+    var taskPath;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFsStore = {};
+        mockFsStatStore = {};
+        taskPath = path.resolve(process.cwd(), ".sinc-active-task.json");
+    });
+    it("should warn when active task file is older than 7 days", () => {
+        var validTask = {
+            taskId: "TASK-123",
+            taskName: "Old Feature",
+            updateSetName: "CU-TASK-123",
+        };
+        mockFsStore[taskPath] = JSON.stringify(validTask);
+        // 10 days ago
+        mockFsStatStore[taskPath] = { mtimeMs: Date.now() - (10 * 24 * 60 * 60 * 1000) };
+        var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+        expect(result).not.toBeNull();
+        expect(result.taskId).toBe("TASK-123");
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("Old Feature"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("10 days ago"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("sinc task clear"));
+    });
+    it("should not warn when active task file is fresh (under 7 days)", () => {
+        var validTask = {
+            taskId: "TASK-456",
+            taskName: "Recent Feature",
+            updateSetName: "CU-TASK-456",
+        };
+        mockFsStore[taskPath] = JSON.stringify(validTask);
+        // 2 days ago
+        mockFsStatStore[taskPath] = { mtimeMs: Date.now() - (2 * 24 * 60 * 60 * 1000) };
+        var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+        expect(result).not.toBeNull();
+        expect(result.taskId).toBe("TASK-456");
+        expect(Logger_1.logger.warn).not.toHaveBeenCalled();
+    });
+    it("should use taskId as fallback when taskName is missing", () => {
+        var taskNoName = {
+            taskId: "TASK-789",
+            updateSetName: "CU-TASK-789",
+        };
+        mockFsStore[taskPath] = JSON.stringify(taskNoName);
+        // 14 days ago
+        mockFsStatStore[taskPath] = { mtimeMs: Date.now() - (14 * 24 * 60 * 60 * 1000) };
+        var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+        expect(result).not.toBeNull();
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("TASK-789"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("14 days ago"));
+    });
+    it("should not warn when task file is exactly 6 days old", () => {
+        var validTask = {
+            taskId: "TASK-EDGE",
+            taskName: "Edge Case",
+            updateSetName: "CU-TASK-EDGE",
+        };
+        mockFsStore[taskPath] = JSON.stringify(validTask);
+        // 6 days ago
+        mockFsStatStore[taskPath] = { mtimeMs: Date.now() - (6 * 24 * 60 * 60 * 1000) };
+        var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+        expect(result).not.toBeNull();
+        expect(Logger_1.logger.warn).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/validateTaskId.test.js

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