@tenonhq/dovetail-core 0.0.121 → 0.0.123

package/dist/tests/createRecordUpdateSet.test.js

@@ -0,0 +1,276 @@
+"use strict";
+// Tests for `dove create sys_update_set` (TenonHQ/Dovetail#231).
+//
+// A generic record insert into sys_update_set lets ServiceNow default
+// `application` to the API session's current app, so `--scope` was silently
+// ignored. `dove create` must instead:
+//   1. route sys_update_set through snClient.createUpdateSet with the resolved
+//      scope's sys_id — and NOT call the generic createRecord;
+//   2. read the set back and exit non-zero, naming requested vs. actual scope
+//      and the set sys_id, when the application does not match;
+//   3. require --scope for sys_update_set in --ci mode;
+//   4. leave every other table on the generic createRecord path.
+//
+// Everything is mocked — no instance is contacted.
+Object.defineProperty(exports, "__esModule", { value: true });
+var logMessages = [];
+function pushLog(level) {
+    return jest.fn(function (msg) {
+        logMessages.push({ level: level, msg: String(msg) });
+    });
+}
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            setLogLevel: jest.fn(),
+            success: pushLog("success"),
+            info: pushLog("info"),
+            error: pushLog("error"),
+            warn: pushLog("warn"),
+            debug: jest.fn(),
+            getLogLevel: function () { return "info"; },
+        },
+    };
+});
+jest.mock("../FileLogger", function () {
+    return {
+        fileLogger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() },
+    };
+});
+jest.mock("../commands", function () {
+    return { setLogLevel: jest.fn() };
+});
+jest.mock("../config", function () {
+    return {
+        getManifest: jest.fn(function () { return undefined; }),
+        isMultiScopeManifest: jest.fn(function () { return false; }),
+        getConfig: jest.fn(function () { return {}; }),
+        getSourcePathForScope: jest.fn(function () { return "/virtual/src"; }),
+    };
+});
+var mockSyncManifest = jest.fn().mockResolvedValue(undefined);
+jest.mock("../appUtils", function () {
+    return { syncManifest: mockSyncManifest };
+});
+jest.mock("../projectFiles", function () {
+    return {
+        getUpdateSetsConfigPath: jest.fn(function () {
+            return "/nonexistent/dove-create-update-set-test/.dove-update-sets.json";
+        }),
+    };
+});
+jest.mock("inquirer", function () {
+    return { prompt: jest.fn() };
+});
+var mockClient = {
+    getScopeId: jest.fn(),
+    getScopeById: jest.fn(),
+    getUpdateSetById: jest.fn(),
+    createUpdateSet: jest.fn(),
+    createRecord: jest.fn(),
+};
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: jest.fn(function () { return mockClient; }),
+        // Mirror the real unwrapSNResponse: await the axios promise, return .data.result
+        unwrapSNResponse: jest.fn(async function (p) {
+            var resp = await p;
+            return resp.data.result;
+        }),
+    };
+});
+const createRecordCommand_1 = require("../createRecordCommand");
+function axiosResult(result) {
+    return Promise.resolve({ status: 200, data: { result: result } });
+}
+var REQUESTED_SCOPE = "x_cadso_journey";
+var REQUESTED_SCOPE_SYS_ID = "journeyScopeSysId0000000000000001";
+var SESSION_SCOPE = "x_cadso_core";
+var SESSION_SCOPE_SYS_ID = "coreScopeSysId00000000000000000002";
+var SET_SYS_ID = "updateSetSysId000000000000000000ab";
+class ExitSignal extends Error {
+    code;
+    constructor(code) {
+        super("process.exit(" + code + ")");
+        this.code = code;
+    }
+}
+describe("dove create sys_update_set (#231)", function () {
+    var exitSpy;
+    beforeEach(function () {
+        logMessages = [];
+        jest.clearAllMocks();
+        exitSpy = jest
+            .spyOn(process, "exit")
+            .mockImplementation(function (code) {
+            throw new ExitSignal(typeof code === "number" ? code : undefined);
+        });
+        mockClient.getScopeId.mockImplementation(function (scopeName) {
+            if (scopeName === REQUESTED_SCOPE) {
+                return axiosResult([{ sys_id: REQUESTED_SCOPE_SYS_ID }]);
+            }
+            return axiosResult([]);
+        });
+        mockClient.getScopeById.mockImplementation(function (sysId) {
+            if (sysId === SESSION_SCOPE_SYS_ID) {
+                return axiosResult([{ sys_id: SESSION_SCOPE_SYS_ID, scope: SESSION_SCOPE }]);
+            }
+            if (sysId === REQUESTED_SCOPE_SYS_ID) {
+                return axiosResult([{ sys_id: REQUESTED_SCOPE_SYS_ID, scope: REQUESTED_SCOPE }]);
+            }
+            return axiosResult([]);
+        });
+        mockClient.createUpdateSet.mockImplementation(function (name, scopeSysId) {
+            return axiosResult({ sys_id: SET_SYS_ID, name: name, application: scopeSysId });
+        });
+        mockClient.createRecord.mockResolvedValue({
+            status: 200,
+            data: { result: { sys_id: "genericSysId", table: "sys_script_include", name: "Generic" } },
+        });
+    });
+    afterEach(function () {
+        exitSpy.mockRestore();
+    });
+    function errorText() {
+        return logMessages
+            .filter(function (m) { return m.level === "error"; })
+            .map(function (m) { return m.msg; })
+            .join("\n");
+    }
+    it("routes through createUpdateSet with the requested scope and never calls the generic insert", async function () {
+        // Table API shape for a reference field without display values: { value, link }
+        mockClient.getUpdateSetById.mockReturnValue(axiosResult([{ sys_id: SET_SYS_ID, application: { value: REQUESTED_SCOPE_SYS_ID, link: "ref-link" } }]));
+        await (0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_update_set",
+            name: "Journey - Fix 231",
+            scope: REQUESTED_SCOPE,
+            field: ["description=Issue 231 regression set"],
+            ci: true,
+            logLevel: "info",
+        });
+        expect(mockClient.createUpdateSet).toHaveBeenCalledTimes(1);
+        expect(mockClient.createUpdateSet).toHaveBeenCalledWith("Journey - Fix 231", REQUESTED_SCOPE_SYS_ID, "Issue 231 regression set");
+        expect(mockClient.createRecord).not.toHaveBeenCalled();
+        expect(mockClient.getUpdateSetById).toHaveBeenCalledWith(SET_SYS_ID);
+        expect(mockSyncManifest).not.toHaveBeenCalled();
+        expect(exitSpy).not.toHaveBeenCalled();
+        var success = logMessages.filter(function (m) { return m.level === "success"; });
+        expect(success.length).toBe(1);
+        expect(success[0].msg).toContain(SET_SYS_ID);
+        expect(success[0].msg).toContain(REQUESTED_SCOPE);
+    });
+    it("fails loudly (exit 1, no success) when the created set's application is not the requested scope", async function () {
+        // The op "succeeded" but the set landed in the session's current app.
+        mockClient.createUpdateSet.mockImplementation(function (name) {
+            return axiosResult({ sys_id: SET_SYS_ID, name: name, application: SESSION_SCOPE_SYS_ID });
+        });
+        mockClient.getUpdateSetById.mockReturnValue(axiosResult([{ sys_id: SET_SYS_ID, application: { value: SESSION_SCOPE_SYS_ID } }]));
+        await expect((0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_update_set",
+            name: "Journey - Fix 231",
+            scope: REQUESTED_SCOPE,
+            ci: true,
+            logLevel: "info",
+        })).rejects.toBeInstanceOf(ExitSignal);
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(mockClient.createRecord).not.toHaveBeenCalled();
+        expect(logMessages.filter(function (m) { return m.level === "success"; })).toHaveLength(0);
+        var errors = errorText();
+        expect(errors).toContain(SET_SYS_ID);
+        expect(errors).toContain(REQUESTED_SCOPE);
+        expect(errors).toContain(SESSION_SCOPE);
+        expect(errors).toContain(REQUESTED_SCOPE_SYS_ID);
+        expect(errors).toContain(SESSION_SCOPE_SYS_ID);
+    });
+    it("falls back to the op response when read-back is unavailable, and still catches a mismatch", async function () {
+        mockClient.createUpdateSet.mockImplementation(function (name) {
+            return axiosResult({ sys_id: SET_SYS_ID, name: name, application: SESSION_SCOPE_SYS_ID });
+        });
+        mockClient.getUpdateSetById.mockReturnValue(Promise.reject(new Error("read denied")));
+        await expect((0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_update_set",
+            name: "Journey - Fix 231",
+            scope: REQUESTED_SCOPE,
+            ci: true,
+            logLevel: "info",
+        })).rejects.toBeInstanceOf(ExitSignal);
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorText()).toContain(SESSION_SCOPE);
+        expect(errorText()).toContain(SET_SYS_ID);
+    });
+    it("refuses to verify-by-assumption: no application from any source is a failure, not a success", async function () {
+        mockClient.createUpdateSet.mockImplementation(function (name) {
+            return axiosResult({ sys_id: SET_SYS_ID, name: name });
+        });
+        mockClient.getUpdateSetById.mockReturnValue(axiosResult([{ sys_id: SET_SYS_ID }]));
+        await expect((0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_update_set",
+            name: "Journey - Fix 231",
+            scope: REQUESTED_SCOPE,
+            ci: true,
+            logLevel: "info",
+        })).rejects.toBeInstanceOf(ExitSignal);
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorText()).toContain("could not be verified");
+        expect(logMessages.filter(function (m) { return m.level === "success"; })).toHaveLength(0);
+    });
+    it("requires --scope for sys_update_set in --ci mode before touching the instance", async function () {
+        await expect((0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_update_set",
+            name: "No Scope Set",
+            ci: true,
+            logLevel: "info",
+        })).rejects.toBeInstanceOf(ExitSignal);
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(mockClient.createUpdateSet).not.toHaveBeenCalled();
+        expect(mockClient.createRecord).not.toHaveBeenCalled();
+        expect(mockClient.getScopeId).not.toHaveBeenCalled();
+        expect(errorText()).toContain("--scope");
+    });
+    it("errors when the requested scope does not exist on the instance", async function () {
+        await expect((0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_update_set",
+            name: "Ghost Scope Set",
+            scope: "x_cadso_nope",
+            ci: true,
+            logLevel: "info",
+        })).rejects.toBeInstanceOf(ExitSignal);
+        expect(mockClient.createUpdateSet).not.toHaveBeenCalled();
+        expect(errorText()).toContain("x_cadso_nope");
+    });
+    it("keeps every other table on the generic createRecord path", async function () {
+        await (0, createRecordCommand_1.createRecordCommand)({
+            table: "sys_script_include",
+            name: "Generic",
+            scope: REQUESTED_SCOPE,
+            ci: true,
+            refresh: false,
+            logLevel: "info",
+        });
+        expect(mockClient.createRecord).toHaveBeenCalledTimes(1);
+        expect(mockClient.createRecord).toHaveBeenCalledWith({
+            table: "sys_script_include",
+            fields: { name: "Generic" },
+            scope: REQUESTED_SCOPE,
+            update_set_sys_id: undefined,
+        });
+        expect(mockClient.createUpdateSet).not.toHaveBeenCalled();
+        expect(mockClient.getScopeId).not.toHaveBeenCalled();
+        expect(exitSpy).not.toHaveBeenCalled();
+    });
+    it("exposes a typed mismatch error carrying both scopes", function () {
+        var err = new createRecordCommand_1.UpdateSetScopeMismatchError({
+            updateSetName: "n",
+            updateSetSysId: "s",
+            requestedScope: REQUESTED_SCOPE,
+            requestedScopeSysId: REQUESTED_SCOPE_SYS_ID,
+            actualScope: SESSION_SCOPE,
+            actualScopeSysId: SESSION_SCOPE_SYS_ID,
+        });
+        expect(err).toBeInstanceOf(Error);
+        expect(err.name).toBe("UpdateSetScopeMismatchError");
+        expect(err.requestedScope).toBe(REQUESTED_SCOPE);
+        expect(err.actualScope).toBe(SESSION_SCOPE);
+        expect(err.message).toContain("MIS-SCOPED");
+    });
+});

package/dist/tests/watchHidden.test.js

@@ -0,0 +1,146 @@
+"use strict";
+// `dove watch` is hidden from the `--help` command index but stays wired for
+// humans (TenonHQ/Dovetail#155). These tests pin both halves: the help text
+// never lists `watch` / `w` / `watchAllScopes`, and all three spellings still
+// route to the watch handler. Mocks mirror commanderStrict.test.ts — the parser
+// is under test, not the commands, which would hit ServiceNow.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock("../commands", () => ({
+    refreshCommand: jest.fn(),
+    pushCommand: jest.fn(),
+    downloadCommand: jest.fn(),
+    initCommand: jest.fn(),
+    buildCommand: jest.fn(),
+    deployCommand: jest.fn(),
+    statusCommand: jest.fn(),
+    taskClearCommand: jest.fn(),
+}));
+jest.mock("../allScopesCommands", () => ({
+    initScopesCommand: jest.fn(),
+    watchAllScopesCommand: jest.fn(),
+}));
+jest.mock("../updateSetCommands", () => ({
+    createUpdateSetCommand: jest.fn(),
+    switchUpdateSetCommand: jest.fn(),
+    listUpdateSetsCommand: jest.fn(),
+    showCurrentUpdateSetCommand: jest.fn(),
+    changeScopeCommand: jest.fn(),
+    showCurrentScopeCommand: jest.fn(),
+}));
+jest.mock("../dashboardCommand", () => ({ dashboardCommand: jest.fn() }));
+jest.mock("../schemaCommand", () => ({
+    schemaPullCommand: jest.fn(),
+    schemaDiffCommand: jest.fn(),
+    schemaSnapshotsCommand: jest.fn(),
+}));
+jest.mock("../claudeCommand", () => ({ initClaudeCommand: jest.fn() }));
+jest.mock("../createRecordCommand", () => ({ createRecordCommand: jest.fn() }));
+jest.mock("../deleteRecordCommand", () => ({ deleteRecordCommand: jest.fn() }));
+jest.mock("../reconcileCommand", () => ({ reconcileCommand: jest.fn() }));
+jest.mock("../migrateCommand", () => ({ migrateCommand: jest.fn() }));
+jest.mock("../loginCommand", () => ({ loginCommand: jest.fn() }));
+jest.mock("../knowledgeDiffCommand", () => ({ knowledgeDiffCommand: jest.fn() }));
+jest.mock("../clickupCommands", () => ({
+    clickupTasksCommand: jest.fn(),
+    clickupTaskCommand: jest.fn(),
+    clickupCreateCommand: jest.fn(),
+    clickupUpdateCommand: jest.fn(),
+    clickupCommentCommand: jest.fn(),
+    clickupSetupCommand: jest.fn(),
+    clickupTeamsCommand: jest.fn(),
+    clickupSpacesCommand: jest.fn(),
+    clickupListsCommand: jest.fn(),
+}));
+// --- Imports (after mocks) ---
+const yargs_1 = __importDefault(require("yargs/yargs"));
+const commander_1 = require("../commander");
+const allScopesCommands_1 = require("../allScopesCommands");
+/**
+ * @description Runs a fake `dove` invocation through a fresh, non-exiting parser.
+ * @param {string[]} args - Argv as the user would type it, minus the binary name.
+ * @returns {Promise<ParseResult>} The parse error (if any) and yargs' captured output.
+ */
+async function run(args) {
+    const cli = (0, commander_1.configureCli)((0, yargs_1.default)([])).exitProcess(false);
+    const result = await new Promise(function (resolve) {
+        cli.parse(args, {}, function (error, _argv, output) {
+            resolve({
+                error: error === null ? undefined : error,
+                output: output || "",
+            });
+        });
+    });
+    await new Promise(function (resolve) {
+        setImmediate(resolve);
+    });
+    return result;
+}
+/**
+ * @description Extracts the `dove <cmd>` command names listed in a yargs help
+ * body (the "Commands:" index), so assertions target the index rather than
+ * incidental prose in option descriptions.
+ * @param {string} help - Captured `--help` output.
+ * @returns {string[]} Command tokens exactly as the index prints them.
+ */
+function listedCommands(help) {
+    const names = [];
+    const lines = help.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const match = /^\s*dove\s+(\S+)/.exec(lines[i]);
+        if (match)
+            names.push(match[1]);
+    }
+    return names;
+}
+beforeEach(function () {
+    jest.clearAllMocks();
+});
+describe("dove --help hides watch", function () {
+    it("does not list watch, w, or watchAllScopes in the command index", async function () {
+        const { output } = await run(["--help"]);
+        const commands = listedCommands(output);
+        expect(commands.length).toBeGreaterThan(0);
+        expect(commands).not.toContain("watch");
+        expect(commands).not.toContain("w");
+        expect(commands).not.toContain("watchAllScopes");
+        expect(output).not.toMatch(/\bwatchAllScopes\b/);
+        expect(output).not.toMatch(/\bdove\s+w(atch)?\b/);
+    });
+    it("still lists the safe headless verbs", async function () {
+        const { output } = await run(["--help"]);
+        const commands = listedCommands(output);
+        expect(commands).toContain("refresh");
+        expect(commands).toContain("push");
+        expect(commands).toContain("status");
+    });
+    it("does not surface watch in the bare-invocation help either", async function () {
+        const { output, error } = await run([]);
+        expect(error).toBeDefined();
+        expect(output + String(error)).not.toMatch(/\bwatchAllScopes\b/);
+        expect(listedCommands(output)).not.toContain("watch");
+    });
+});
+describe("dove watch stays wired for humans", function () {
+    it("routes `watch` to the watch handler", async function () {
+        const { error } = await run(["watch"]);
+        expect(error).toBeUndefined();
+        expect(allScopesCommands_1.watchAllScopesCommand).toHaveBeenCalledTimes(1);
+    });
+    it("routes the `w` and `watchAllScopes` aliases too", async function () {
+        await run(["w"]);
+        expect(allScopesCommands_1.watchAllScopesCommand).toHaveBeenCalledTimes(1);
+        await run(["watchAllScopes"]);
+        expect(allScopesCommands_1.watchAllScopesCommand).toHaveBeenCalledTimes(2);
+    });
+    it("passes watch flags through", async function () {
+        await run(["watch", "--noDashboard", "--port", "4000"]);
+        expect(allScopesCommands_1.watchAllScopesCommand).toHaveBeenCalledTimes(1);
+        const mock = allScopesCommands_1.watchAllScopesCommand;
+        const args = mock.mock.calls[0][0];
+        expect(args.noDashboard).toBe(true);
+        expect(args.port).toBe(4000);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/dovetail-core",
-  "version": "0.0.121",
+  "version": "0.0.123",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",