hammerkit 1.6.0 → 1.7.0

package/dist/planner/utils/parse-work-port.spec.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const parse_work_port_1 = require("./parse-work-port");
-describe('parse-work-port', () => {
-    it('should parse 5432', () => {
-        expect((0, parse_work_port_1.parseWorkPort)('5432')).toEqual({
-            hostPort: 5432,
-            containerPort: 5432,
-        });
-    });
-    it('should parse 5432:5433', () => {
-        expect((0, parse_work_port_1.parseWorkPort)('5432:5433')).toEqual({
-            hostPort: 5432,
-            containerPort: 5433,
-        });
-    });
-    it('throws for a port with more than two parts', () => {
-        expect(() => (0, parse_work_port_1.parseWorkPort)('1:2:3')).toThrow('invalid port 1:2:3');
-    });
-    it('throws for a non-numeric port', () => {
-        expect(() => (0, parse_work_port_1.parseWorkPort)('http')).toThrow('invalid port http');
-    });
-});
-//# sourceMappingURL=parse-work-port.spec.js.map

package/dist/planner/utils/parse-work-ports.spec.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const parse_work_ports_1 = require("./parse-work-ports");
-const noEnvs = { variables: {}, replacements: [] };
-describe('parse-work-ports', () => {
-    it('returns an empty list when the service declares no ports', () => {
-        const schema = { image: 'postgres:12-alpine' };
-        expect((0, parse_work_ports_1.parseWorkPorts)(schema, noEnvs)).toEqual([]);
-    });
-    it('parses numeric and string ports', () => {
-        const schema = { image: 'node', ports: [5432, '8080:80'] };
-        expect((0, parse_work_ports_1.parseWorkPorts)(schema, noEnvs)).toEqual([
-            { hostPort: 5432, containerPort: 5432 },
-            { hostPort: 8080, containerPort: 80 },
-        ]);
-    });
-    it('templates env vars in port values', () => {
-        const schema = { image: 'node', ports: ['$PORT:80'] };
-        expect((0, parse_work_ports_1.parseWorkPorts)(schema, { variables: { PORT: '9090' }, replacements: [] })).toEqual([
-            { hostPort: 9090, containerPort: 80 },
-        ]);
-    });
-});
-//# sourceMappingURL=parse-work-ports.spec.js.map

package/dist/planner/utils/parse-work-source.spec.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const parse_work_source_1 = require("./parse-work-source");
-const noEnvs = { variables: {}, replacements: [] };
-// parseWorkSource builds absolutePath via path.join and the no-wildcard matcher
-// compares with String.startsWith, so both are native-separated. Author the
-// expectations in posix and convert to the host separator. No-op on posix.
-const toNative = (value) => value.split(path_1.posix.sep).join(path_1.sep);
-describe('parse-work-source', () => {
-    it('returns an empty list for null/undefined sources', () => {
-        expect((0, parse_work_source_1.parseWorkSource)('/proj', null, noEnvs)).toEqual([]);
-        expect((0, parse_work_source_1.parseWorkSource)('/proj', undefined, noEnvs)).toEqual([]);
-    });
-    describe('without a wildcard', () => {
-        it('treats a path with an extension as a file', () => {
-            const [src] = (0, parse_work_source_1.parseWorkSource)('/proj', ['dist/app.js'], noEnvs);
-            expect(src.absolutePath).toBe(toNative('/proj/dist/app.js'));
-            expect(src.isFile).toBe(true);
-            expect(src.matcher(toNative('/proj/dist/app.js'), '/proj')).toBe(true);
-            expect(src.matcher(toNative('/proj/dist/other.js'), '/proj')).toBe(false);
-        });
-        it('treats a path without an extension as a directory', () => {
-            const [src] = (0, parse_work_source_1.parseWorkSource)('/proj', ['src'], noEnvs);
-            expect(src.absolutePath).toBe(toNative('/proj/src'));
-            expect(src.isFile).toBe(false);
-            expect(src.matcher(toNative('/proj/src/index.ts'), '/proj')).toBe(true);
-        });
-    });
-    describe('with a leading wildcard', () => {
-        it('anchors the absolute path to cwd and matches relative paths', () => {
-            const [src] = (0, parse_work_source_1.parseWorkSource)('/proj', ['*.spec.ts'], noEnvs);
-            expect(src.absolutePath).toBe('/proj');
-            expect(src.isFile).toBe(false);
-            expect(src.matcher('/proj/a.spec.ts', '/proj')).toBe(true);
-            expect(src.matcher('/proj/a.ts', '/proj')).toBe(false);
-        });
-    });
-    describe('with a mid-string wildcard', () => {
-        it('uses the prefix for the absolute path and globs against the full path', () => {
-            const [src] = (0, parse_work_source_1.parseWorkSource)('/proj', ['src/*.ts'], noEnvs);
-            expect(src.absolutePath).toBe(toNative('/proj/src/'));
-            expect(src.isFile).toBe(false);
-            expect(src.matcher('/proj/src/a.ts', '/proj')).toBe(true);
-            expect(src.matcher('/proj/src/sub/a.ts', '/proj')).toBe(false);
-        });
-    });
-    describe('createSource', () => {
-        it('builds a prefix matcher from an absolute path', () => {
-            const src = (0, parse_work_source_1.createSource)('/proj/dist');
-            expect(src.absolutePath).toBe('/proj/dist');
-            expect(src.source).toBe('/proj/dist');
-            expect(src.matcher('/proj/dist/app.js', '/proj')).toBe(true);
-            expect(src.matcher('/proj/other', '/proj')).toBe(false);
-        });
-    });
-});
-//# sourceMappingURL=parse-work-source.spec.js.map

package/dist/planner/utils/parse-work-volume.spec.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const parse_work_volume_1 = require("./parse-work-volume");
-describe('parse-work-volume', () => {
-    it('should parse projdata:/usr/data', () => {
-        expect((0, parse_work_volume_1.parseWorkVolume)('/home/user/proj', 'projdata:/usr/data', { replacements: [], variables: {} })).toEqual({
-            name: 'projdata',
-            containerPath: '/usr/data',
-            resetOnChange: false,
-            export: false,
-            inherited: null,
-        });
-    });
-    it('throws for a volume string that is not name:path', () => {
-        expect(() => (0, parse_work_volume_1.parseWorkVolume)('/home/user/proj', 'a:b:c', { replacements: [], variables: {} })).toThrow('invalid volume a:b:c');
-    });
-});
-//# sourceMappingURL=parse-work-volume.spec.js.map

package/dist/planner/utils/plan-work-tasks.spec.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const plan_work_tasks_1 = require("./plan-work-tasks");
-const ok = { state: { current: { type: 'completed' } } };
-const err = { state: { current: { type: 'error' } } };
-const tree = (services, tasks) => ({ services, tasks });
-describe('plan-work-tasks iterators and error helpers', () => {
-    it('iterateWorkServices yields every service value', () => {
-        const t = tree({ a: { id: 'A' }, b: { id: 'B' } }, {});
-        expect([...(0, plan_work_tasks_1.iterateWorkServices)(t)].map((s) => s.id)).toEqual(['A', 'B']);
-    });
-    it('iterateWorkTasks yields every task value', () => {
-        const t = tree({}, { a: { id: 'A' } });
-        expect([...(0, plan_work_tasks_1.iterateWorkTasks)(t)].map((s) => s.id)).toEqual(['A']);
-    });
-    it('hasErrorTask is true iff a task is in error', () => {
-        expect((0, plan_work_tasks_1.hasErrorTask)(tree({}, { a: ok }))).toBe(false);
-        expect((0, plan_work_tasks_1.hasErrorTask)(tree({}, { a: ok, b: err }))).toBe(true);
-    });
-    it('hasErrorService is true iff a service is in error', () => {
-        expect((0, plan_work_tasks_1.hasErrorService)(tree({ a: ok }, {}))).toBe(false);
-        expect((0, plan_work_tasks_1.hasErrorService)(tree({ a: err }, {}))).toBe(true);
-    });
-    it('hasError covers both services and tasks', () => {
-        expect((0, plan_work_tasks_1.hasError)(tree({}, {}))).toBe(false);
-        expect((0, plan_work_tasks_1.hasError)(tree({ a: err }, {}))).toBe(true);
-        expect((0, plan_work_tasks_1.hasError)(tree({}, { a: err }))).toBe(true);
-    });
-});
-//# sourceMappingURL=plan-work-tasks.spec.js.map

package/dist/planner/utils/plan-work-volume.spec.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const plan_work_volume_1 = require("./plan-work-volume");
-describe('plan-work-volume', () => {
-    describe('generateId / getVolumeName', () => {
-        it('hashes the input deterministically (sha1)', () => {
-            expect((0, plan_work_volume_1.generateId)('a')).toBe((0, plan_work_volume_1.generateId)('a'));
-            expect((0, plan_work_volume_1.generateId)('a')).not.toBe((0, plan_work_volume_1.generateId)('b'));
-            expect((0, plan_work_volume_1.getVolumeName)('x')).toMatch(/^hammerkit-[a-f0-9]{40}$/);
-        });
-    });
-    describe('getContainerVolumes', () => {
-        const task = {
-            generates: [
-                { path: '/out/a', volumeName: 'na', inherited: null, resetOnChange: true, export: false, isFile: false },
-                { path: '/out/b', volumeName: 'nb', inherited: null, resetOnChange: false, export: true, isFile: false },
-            ],
-        };
-        it('emits a named volume for every generate that has no matching mount', () => {
-            const volumes = (0, plan_work_volume_1.getContainerVolumes)(task, []);
-            expect(volumes.map((v) => v.containerPath)).toEqual(['/out/a', '/out/b']);
-            expect(volumes[0].resetOnChange).toBe(true);
-            expect(volumes[1].export).toBe(true);
-            expect(volumes[0].name).toMatch(/^hammerkit-/);
-        });
-        it('skips a generate whose path is already mounted (mount wins)', () => {
-            const mounts = [{ containerPath: '/out/a' }];
-            const volumes = (0, plan_work_volume_1.getContainerVolumes)(task, mounts);
-            expect(volumes.map((v) => v.containerPath)).toEqual(['/out/b']);
-        });
-    });
-});
-//# sourceMappingURL=plan-work-volume.spec.js.map

package/dist/planner/utils/split-name.spec.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const split_name_1 = require("./split-name");
-describe('split-name', () => {
-    it('should split test:bar', () => {
-        const result = (0, split_name_1.splitName)('test:bar');
-        expect(result.name).toEqual('bar');
-        expect(result.prefix).toEqual('test');
-    });
-    it('should not split test', () => {
-        const result = (0, split_name_1.splitName)('test');
-        expect(result.name).toEqual('test');
-        expect(result.prefix).toEqual(undefined);
-    });
-});
-//# sourceMappingURL=split-name.spec.js.map

package/dist/planner/utils/template-value.spec.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const template_value_1 = require("./template-value");
-describe('template-value', () => {
-    it('should template string value', () => {
-        const value = (0, template_value_1.templateValue)('echo $VAR', { variables: { VAR: 'hello' }, replacements: [] });
-        expect(value).toEqual('echo hello');
-    });
-    it('should leave missing envs', () => {
-        const value = (0, template_value_1.templateValue)('echo $VAR', { variables: {}, replacements: [] });
-        expect(value).toEqual('echo $VAR');
-    });
-});
-//# sourceMappingURL=template-value.spec.js.map

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