hammerkit 1.6.0 → 1.8.0

package/dist/planner/validate.spec.js

@@ -1,251 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const validate_1 = require("./validate");
-function makeTask(name) {
-    const item = {
-        id: () => name,
-        name,
-        status: {},
-        data: { type: 'local-task', name },
-        needs: [],
-        deps: [],
-        requiredBy: [],
-        state: {},
-        runtime: {},
-    };
-    return item;
-}
-function makeService(name) {
-    const item = {
-        id: () => name,
-        name,
-        status: {},
-        data: { type: 'container-service', name },
-        needs: [],
-        deps: [],
-        requiredBy: [],
-        state: {},
-        runtime: {},
-    };
-    return item;
-}
-describe('validate', () => {
-    describe('hasDependencyCycle', () => {
-        it('returns null for an item with no deps', () => {
-            const t = makeTask('a');
-            expect((0, validate_1.hasDependencyCycle)(t, [])).toBeNull();
-        });
-        it('returns null for a linear chain', () => {
-            const a = makeTask('a');
-            const b = makeTask('b');
-            const c = makeTask('c');
-            a.deps.push(b);
-            b.deps.push(c);
-            expect((0, validate_1.hasDependencyCycle)(a, [])).toBeNull();
-        });
-        it('detects a direct self-cycle', () => {
-            const a = makeTask('a');
-            a.deps.push(a);
-            const cycle = (0, validate_1.hasDependencyCycle)(a, []);
-            expect(cycle).not.toBeNull();
-            expect(cycle.map((i) => i.name)).toEqual(['a', 'a']);
-        });
-        it('detects an indirect cycle', () => {
-            const a = makeTask('a');
-            const b = makeTask('b');
-            const c = makeTask('c');
-            a.deps.push(b);
-            b.deps.push(c);
-            c.deps.push(a);
-            const cycle = (0, validate_1.hasDependencyCycle)(a, []);
-            expect(cycle).not.toBeNull();
-            expect(cycle.map((i) => i.name)).toEqual(['a', 'b', 'c', 'a']);
-        });
-        it('does not flag a diamond as a cycle', () => {
-            const root = makeTask('root');
-            const left = makeTask('left');
-            const right = makeTask('right');
-            const leaf = makeTask('leaf');
-            root.deps.push(left, right);
-            left.deps.push(leaf);
-            right.deps.push(leaf);
-            expect((0, validate_1.hasDependencyCycle)(root, [])).toBeNull();
-        });
-    });
-    describe('hasNeedCycle', () => {
-        it('returns null when no needs', () => {
-            const s = makeService('db');
-            expect((0, validate_1.hasNeedCycle)(s, [])).toBeNull();
-        });
-        it('detects a need cycle across services', () => {
-            const a = makeService('a');
-            const b = makeService('b');
-            a.needs.push({ name: 'b', service: b });
-            b.needs.push({ name: 'a', service: a });
-            const cycle = (0, validate_1.hasNeedCycle)(a, []);
-            expect(cycle).not.toBeNull();
-            expect(cycle.map((i) => i.name)).toEqual(['a', 'b', 'a']);
-        });
-        it('detects a self-need cycle', () => {
-            const a = makeService('a');
-            a.needs.push({ name: 'a', service: a });
-            const cycle = (0, validate_1.hasNeedCycle)(a, []);
-            expect(cycle).not.toBeNull();
-            expect(cycle.map((i) => i.name)).toEqual(['a', 'a']);
-        });
-    });
-    describe('hasMixedCycle', () => {
-        it('returns null for an acyclic task → service → task chain', () => {
-            const t1 = makeTask('build');
-            const s = makeService('db');
-            const t2 = makeTask('migrate');
-            t1.needs.push({ name: 'db', service: s });
-            s.deps.push(t2);
-            expect((0, validate_1.hasMixedCycle)(t1, [])).toBeNull();
-        });
-        it('detects a cycle that alternates deps and needs', () => {
-            const t = makeTask('api-build');
-            const s = makeService('api');
-            t.needs.push({ name: 'api', service: s });
-            s.deps.push(t);
-            const cycle = (0, validate_1.hasMixedCycle)(t, []);
-            expect(cycle).not.toBeNull();
-            expect(cycle.map((i) => i.name)).toEqual(['api-build', 'api', 'api-build']);
-        });
-        it('detects a long mixed cycle', () => {
-            const a = makeTask('a');
-            const b = makeService('b');
-            const c = makeTask('c');
-            const d = makeService('d');
-            a.needs.push({ name: 'b', service: b });
-            b.deps.push(c);
-            c.needs.push({ name: 'd', service: d });
-            d.deps.push(a);
-            const cycle = (0, validate_1.hasMixedCycle)(a, []);
-            expect(cycle).not.toBeNull();
-            expect(cycle.map((i) => i.name)).toEqual(['a', 'b', 'c', 'd', 'a']);
-        });
-    });
-});
-function taskItem(name, data) {
-    const item = {
-        id: () => name,
-        name,
-        status: {},
-        data: { type: 'local-task', name, description: 'a task', cmds: [{}], src: [], ...data },
-        needs: [],
-        deps: [],
-        requiredBy: [],
-        state: {},
-        runtime: {},
-    };
-    return item;
-}
-function serviceItem(name, data) {
-    const item = {
-        id: () => name,
-        name,
-        status: {},
-        data: { type: 'container-service', name, description: 'a service', healthcheck: {}, mounts: [], ...data },
-        needs: [],
-        deps: [],
-        requiredBy: [],
-        state: {},
-        runtime: {},
-    };
-    return item;
-}
-function workTree(items) {
-    return {
-        tasks: Object.fromEntries((items.tasks ?? []).map((t) => [t.name, t])),
-        services: Object.fromEntries((items.services ?? []).map((s) => [s.name, s])),
-        environment: {},
-    };
-}
-// Environment whose file.exists only returns true for the listed paths.
-function fakeEnv(existing = []) {
-    return { file: { exists: vi.fn(async (p) => existing.includes(p)) } };
-}
-async function collect(gen) {
-    const out = [];
-    for await (const v of gen) {
-        out.push(v);
-    }
-    return out;
-}
-describe('validate (generator)', () => {
-    it('warns about a task without a description', async () => {
-        const tree = workTree({ tasks: [taskItem('build', { description: null })] });
-        const result = await collect((0, validate_1.validate)(tree, fakeEnv()));
-        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'missing description' }));
-    });
-    it('warns about an empty task (no cmds and no deps)', async () => {
-        const tree = workTree({ tasks: [taskItem('noop', { cmds: [] })] });
-        const result = await collect((0, validate_1.validate)(tree, fakeEnv()));
-        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'task is empty' }));
-    });
-    it('warns about a missing src path', async () => {
-        const tree = workTree({ tasks: [taskItem('build', { src: [{ absolutePath: '/nope' }] })] });
-        const result = await collect((0, validate_1.validate)(tree, fakeEnv([])));
-        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'src /nope does not exist' }));
-    });
-    it('does not warn when the src path exists', async () => {
-        const tree = workTree({ tasks: [taskItem('build', { src: [{ absolutePath: '/yes' }] })] });
-        const result = await collect((0, validate_1.validate)(tree, fakeEnv(['/yes'])));
-        expect(result.map((r) => r.message)).not.toContain('src /yes does not exist');
-    });
-    it('emits a cycle error through the generator', async () => {
-        const a = taskItem('a', {});
-        a.deps.push(a);
-        const tree = workTree({ tasks: [a] });
-        const result = await collect((0, validate_1.validate)(tree, fakeEnv()));
-        expect(result).toContainEqual(expect.objectContaining({ type: 'error', message: 'task cycle detected a -> a' }));
-    });
-    it('warns about a container service missing a healthcheck', async () => {
-        const tree = workTree({ services: [serviceItem('db', { healthcheck: null })] });
-        const result = await collect((0, validate_1.validate)(tree, fakeEnv()));
-        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'missing healthcheck' }));
-    });
-    it('warns about a container service mount that does not exist', async () => {
-        const tree = workTree({
-            services: [serviceItem('db', { mounts: [{ localPath: '/data' }] })],
-        });
-        const result = await collect((0, validate_1.validate)(tree, fakeEnv([])));
-        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'mount /data does not exist' }));
-    });
-    it('warns when a kubernetes service kubeconfig is missing', async () => {
-        const tree = workTree({
-            services: [
-                serviceItem('cluster', {
-                    type: 'kubernetes-service',
-                    kubeconfig: '/missing/kubeconfig',
-                    context: 'prod',
-                }),
-            ],
-        });
-        const result = await collect((0, validate_1.validate)(tree, fakeEnv([])));
-        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'kubeconfig /missing/kubeconfig does not exist' }));
-    });
-});
-describe('checkIfContextExists', () => {
-    function kubeconfigEnv(yaml) {
-        return {
-            file: { read: vi.fn(async () => yaml) },
-            status: { context: () => ({ write: vi.fn() }) },
-        };
-    }
-    const service = { kubeconfig: '/kube/config', context: 'prod' };
-    it('is true when the context is present', async () => {
-        const env = kubeconfigEnv('contexts:\n  - name: prod\n  - name: dev\n');
-        expect(await (0, validate_1.checkIfContextExists)(service, env)).toBe(true);
-    });
-    it('is false when the context is absent', async () => {
-        const env = kubeconfigEnv('contexts:\n  - name: dev\n');
-        expect(await (0, validate_1.checkIfContextExists)(service, env)).toBe(false);
-    });
-    it('is false when there are no contexts', async () => {
-        const env = kubeconfigEnv('clusters:\n  - name: c1\n');
-        expect(await (0, validate_1.checkIfContextExists)(service, env)).toBe(false);
-    });
-});
-//# sourceMappingURL=validate.spec.js.map

package/dist/planner/work-cache-id.spec.js

@@ -1,173 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const test_case_1 = require("../testing/test-case");
-const program_1 = require("../program");
-const path_1 = require("path");
-async function compareTasks(first, second, taskName, expectEqual) {
-    const testCase = (0, test_case_1.createTestCase)('work-task-id', {
-        'first.yaml': first,
-        'second.yaml': second,
-    });
-    await testCase.setup(async (cwd, environment) => {
-        const firstCli = await (0, program_1.createCli)((0, path_1.join)(cwd, 'first.yaml'), environment, { taskName });
-        const secondCli = await (0, program_1.createCli)((0, path_1.join)(cwd, 'second.yaml'), environment, { taskName });
-        const firstTask = firstCli.task(taskName);
-        const secondTask = secondCli.task(taskName);
-        if (expectEqual) {
-            expect(firstTask.id()).toEqual(secondTask.id());
-        }
-        else {
-            expect(firstTask.id()).not.toEqual(secondTask.id());
-        }
-    });
-}
-describe('work-cache-id', () => {
-    it('should be the same for different mount order', async () => {
-        await compareTasks({
-            tasks: {
-                example: {
-                    image: 'node',
-                    mounts: ['$PWD/.npm:/.npm', '$PWD/.config:/.config'],
-                },
-            },
-        }, {
-            tasks: {
-                example: {
-                    image: 'node',
-                    mounts: ['$PWD/.config:/.config', '$PWD/.npm:/.npm'],
-                },
-            },
-        }, 'example', true);
-    });
-    it('should be the same for different object key order', async () => {
-        await compareTasks({
-            tasks: {
-                example: {
-                    image: 'node:alpine',
-                    cmds: ['npm ci'],
-                },
-            },
-        }, {
-            tasks: {
-                example: {
-                    cmds: ['npm ci'],
-                    image: 'node:alpine',
-                },
-            },
-        }, 'example', true);
-    });
-    it('should be the same with additional description', async () => {
-        await compareTasks({
-            tasks: {
-                example: {
-                    image: 'node:alpine',
-                    cmds: ['npm ci'],
-                },
-            },
-        }, {
-            tasks: {
-                example: {
-                    image: 'node:alpine',
-                    cmds: ['npm ci'],
-                    description: 'should not matter',
-                },
-            },
-        }, 'example', true);
-    });
-    it('should be not be the same for different images', async () => {
-        await compareTasks({
-            tasks: {
-                example: {
-                    image: 'node:alpine',
-                },
-            },
-        }, {
-            tasks: {
-                example: {
-                    image: 'node',
-                },
-            },
-        }, 'example', false);
-    });
-    it('should be not be the same for different cmd order', async () => {
-        await compareTasks({
-            tasks: {
-                example: {
-                    cmds: ['npm ci', 'npm run build'],
-                },
-            },
-        }, {
-            tasks: {
-                example: {
-                    cmds: ['npm run build', 'npm ci'],
-                },
-            },
-        }, 'example', false);
-    });
-    it('should be be the same for different env key order', async () => {
-        await compareTasks({
-            tasks: {
-                example: {
-                    envs: {
-                        NODE_VERSION: '16.6.0',
-                        NPM_VERSION: '6.0.0',
-                    },
-                    cmds: ['npm ci', 'npm run build'],
-                },
-            },
-        }, {
-            tasks: {
-                example: {
-                    envs: {
-                        NPM_VERSION: '6.0.0',
-                        NODE_VERSION: '16.6.0',
-                    },
-                    cmds: ['npm ci', 'npm run build'],
-                },
-            },
-        }, 'example', true);
-    });
-    it('should be be the same for deps in different order', async () => {
-        await compareTasks({
-            tasks: {
-                install: {
-                    cmds: ['npm install'],
-                },
-                build: {
-                    cmds: ['tsc'],
-                },
-                example: {
-                    deps: ['install', 'build'],
-                },
-            },
-        }, {
-            tasks: {
-                install: {
-                    cmds: ['npm install'],
-                },
-                build: {
-                    cmds: ['tsc'],
-                },
-                example: {
-                    deps: ['build', 'install'],
-                },
-            },
-        }, 'example', true);
-    });
-    it('should be be the same for sources in different order', async () => {
-        await compareTasks({
-            tasks: {
-                example: {
-                    src: ['package.json', 'package-lock.json'],
-                },
-            },
-        }, {
-            tasks: {
-                example: {
-                    src: ['package-lock.json', 'package.json'],
-                },
-            },
-        }, 'example', true);
-    });
-});
-//# sourceMappingURL=work-cache-id.spec.js.map

package/dist/planner/work-runtime-local.spec.js

@@ -1,193 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const os_1 = require("os");
-const fs_1 = require("fs");
-const work_runtime_local_1 = require("./work-runtime-local");
-const environment_mock_1 = require("../executer/environment-mock");
-const state_1 = require("../executer/state");
-const mockFindProcess = vi.hoisted(() => vi.fn());
-vi.mock('find-process', () => ({
-    __esModule: true,
-    default: (...args) => mockFindProcess(...args),
-}));
-vi.mock('../executer/local-task', () => ({
-    localTask: vi.fn().mockResolvedValue(undefined),
-}));
-function makeTask(cwd) {
-    return {
-        id: () => 'task-1',
-        name: 'task-1',
-        status: { write: vi.fn() },
-        data: {
-            type: 'local-task',
-            name: 'task-1',
-            cwd,
-            cmds: [],
-            generates: [],
-            src: [],
-            envs: { variables: {}, processEnvs: {} },
-            labels: {},
-            shell: '/bin/sh',
-            continuous: false,
-            caching: {
-                name: 'none',
-                method: 'none',
-                backend: {
-                    type: 'local',
-                    has: async () => false,
-                    pull: async () => false,
-                    push: async () => { },
-                    clear: async () => { },
-                },
-                implicit: true,
-            },
-            description: null,
-            scope: {},
-        },
-        needs: [],
-        deps: [],
-        requiredBy: [],
-    };
-}
-describe('local task pidfile', () => {
-    let cwd;
-    beforeEach(() => {
-        cwd = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-pidfile-'));
-        mockFindProcess.mockReset();
-    });
-    afterEach(() => {
-        (0, fs_1.rmSync)(cwd, { recursive: true, force: true });
-    });
-    it('writes pidfile during execute and cleans up after', async () => {
-        const task = makeTask(cwd);
-        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
-        const env = (0, environment_mock_1.environmentMock)(cwd);
-        const state = new state_1.State({ type: 'pending', stateKey: null });
-        await runtime.execute(env, {
-            stateKey: 'state-1',
-            abort: new AbortController().signal,
-            state,
-            cache: {
-                cached: false,
-                stateKey: 'state-x',
-                resolved: {
-                    name: 'none',
-                    method: 'none',
-                    backend: {
-                        type: 'local',
-                        has: async () => false,
-                        pull: async () => false,
-                        push: async () => { },
-                        clear: async () => { },
-                    },
-                    implicit: true,
-                },
-            },
-            daemon: false,
-        });
-        expect(await env.file.exists((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'))).toBe(false);
-        expect(await env.file.exists((0, path_1.join)(cwd, '.hammerkit', 'task-1'))).toBe(true);
-    });
-    it('removes a stale pidfile when the process is not alive', async () => {
-        const task = makeTask(cwd);
-        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
-        const env = (0, environment_mock_1.environmentMock)(cwd);
-        const state = new state_1.State({ type: 'pending', stateKey: null });
-        await env.file.createDirectory((0, path_1.join)(cwd, '.hammerkit'));
-        (0, fs_1.writeFileSync)((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'), '999999');
-        mockFindProcess.mockResolvedValueOnce([]);
-        await runtime.execute(env, {
-            stateKey: 'state-2',
-            abort: new AbortController().signal,
-            state,
-            cache: {
-                cached: false,
-                stateKey: 'state-x',
-                resolved: {
-                    name: 'none',
-                    method: 'none',
-                    backend: {
-                        type: 'local',
-                        has: async () => false,
-                        pull: async () => false,
-                        push: async () => { },
-                        clear: async () => { },
-                    },
-                    implicit: true,
-                },
-            },
-            daemon: false,
-        });
-        expect(state.current.type).not.toBe('error');
-        expect(mockFindProcess).toHaveBeenCalledWith('pid', 999999);
-    });
-    it('refuses to run when the pidfile points at a live process', async () => {
-        const task = makeTask(cwd);
-        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
-        const env = (0, environment_mock_1.environmentMock)(cwd);
-        const state = new state_1.State({ type: 'pending', stateKey: null });
-        await env.file.createDirectory((0, path_1.join)(cwd, '.hammerkit'));
-        (0, fs_1.writeFileSync)((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'), '12345');
-        mockFindProcess.mockResolvedValueOnce([{ pid: 12345, name: 'node' }]);
-        await runtime.execute(env, {
-            stateKey: 'state-3',
-            abort: new AbortController().signal,
-            state,
-            cache: {
-                cached: false,
-                stateKey: 'state-x',
-                resolved: {
-                    name: 'none',
-                    method: 'none',
-                    backend: {
-                        type: 'local',
-                        has: async () => false,
-                        pull: async () => false,
-                        push: async () => { },
-                        clear: async () => { },
-                    },
-                    implicit: true,
-                },
-            },
-            daemon: false,
-        });
-        expect(state.current.type).toBe('error');
-        if (state.current.type === 'error') {
-            expect(state.current.errorMessage).toMatch(/already running.*12345/);
-        }
-    });
-    it('does not block when the pidfile contains our own pid', async () => {
-        const task = makeTask(cwd);
-        const runtime = (0, work_runtime_local_1.getLocalWorkRuntime)(task);
-        const env = (0, environment_mock_1.environmentMock)(cwd);
-        const state = new state_1.State({ type: 'pending', stateKey: null });
-        await env.file.createDirectory((0, path_1.join)(cwd, '.hammerkit'));
-        (0, fs_1.writeFileSync)((0, path_1.join)(cwd, '.hammerkit', 'task-1.pid'), `${process.pid}`);
-        await runtime.execute(env, {
-            stateKey: 'state-4',
-            abort: new AbortController().signal,
-            state,
-            cache: {
-                cached: false,
-                stateKey: 'state-x',
-                resolved: {
-                    name: 'none',
-                    method: 'none',
-                    backend: {
-                        type: 'local',
-                        has: async () => false,
-                        pull: async () => false,
-                        push: async () => { },
-                        clear: async () => { },
-                    },
-                    implicit: true,
-                },
-            },
-            daemon: false,
-        });
-        expect(state.current.type).not.toBe('error');
-        expect(mockFindProcess).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=work-runtime-local.spec.js.map