hammerkit 1.5.1 → 1.6.0-alpha.2

package/dist/testing/integration/watch.spec.js

@@ -2,30 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const get_test_suite_1 = require("../get-test-suite");
 const path_1 = require("path");
+const requires_linux_containers_1 = require("../requires-linux-containers");
 describe('watch', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('watch', ['.hammerkit.yaml', 'src', 'package.json', 'package-lock.json', 'tsconfig.json']);
     afterAll(() => suite.close());
-    it('should run watch task and cancel', async () => {
-        const { cli, environment } = await suite.setup({ taskName: 'api' });
-        const apiNode = cli.node('api');
-        const exec = cli.execWatch({ watch: true });
-        exec.processManager.on((evt) => {
-            if (evt.context.id === apiNode.id && evt.type === 'started') {
+    it('should run watch task and cancel', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
+        const { cli, environment } = await suite.setup({ filterLabels: { task: ['dev'] } });
+        const exec = await cli.up({ watch: true });
+        exec.state.on('test-status', (evt) => {
+            if (evt.services['api'].state.current.type === 'running') {
                 environment.abortCtrl.abort();
             }
         });
         const result = await exec.start();
         expect(result.success).toBeFalsy();
-        expect(result.state.node[apiNode.id].type).toEqual('canceled');
-    });
-    it('should restart task if dependency updates', async () => {
-        const { cli, environment } = await suite.setup({ taskName: 'api' });
-        const apiNode = cli.node('api');
-        const exec = cli.execWatch({ watch: true });
+        expect(result.state.services['api'].state.current.type).toEqual('canceled');
+    }), 900000);
+    it('should restart task if dependency updates', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
+        const { cli, environment } = await suite.setup({ filterLabels: { task: ['dev'] } });
+        const exec = await cli.up({ watch: true });
         let appendedFile = false;
         let restarted = false;
-        exec.processManager.on((evt) => {
-            if (evt.type === 'started' && evt.context.id === apiNode.id) {
+        exec.state.on('test-status', (evt) => {
+            if (evt.services['api'].state.current.type === 'running') {
                 if (!appendedFile) {
                     appendedFile = true;
                     environment.file.appendFile((0, path_1.join)(environment.cwd, 'package.json'), '\n');
@@ -40,7 +39,7 @@ describe('watch', () => {
         expect(appendedFile).toBeTruthy();
         expect(restarted).toBeTruthy();
         expect(result.success).toBeFalsy();
-        expect(result.state.node[apiNode.id].type).toEqual('canceled');
-    });
+        expect(result.state.services['api'].state.current.type).toEqual('canceled');
+    }), 900000);
 });
 //# sourceMappingURL=watch.spec.js.map

package/dist/testing/requires-kubernetes.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiresKubernetes = void 0;
+const ci_1 = require("../utils/ci");
+function requiresKubernetes(fn) {
+    if (process.env.CLUSTER_NAME) {
+        return fn;
+    }
+    if (process.env.HAMMERKIT_FULL_INTEGRATION) {
+        return () => Promise.reject(new Error('CLUSTER_NAME not set but HAMMERKIT_FULL_INTEGRATION is on'));
+    }
+    if (ci_1.isCI) {
+        return () => Promise.resolve();
+    }
+    return fn;
+}
+exports.requiresKubernetes = requiresKubernetes;
+//# sourceMappingURL=requires-kubernetes.js.map

package/dist/testing/requires-linux-containers.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiresLinuxContainers = void 0;
+const ci_1 = require("../utils/ci");
+function requiresLinuxContainers(fn) {
+    if (process.env.LINUX_CONTAINERS) {
+        return fn;
+    }
+    if (process.env.HAMMERKIT_FULL_INTEGRATION) {
+        return () => Promise.reject(new Error('LINUX_CONTAINERS not set but HAMMERKIT_FULL_INTEGRATION is on'));
+    }
+    if (ci_1.isCI) {
+        return () => Promise.resolve();
+    }
+    return fn;
+}
+exports.requiresLinuxContainers = requiresLinuxContainers;
+//# sourceMappingURL=requires-linux-containers.js.map

package/dist/testing/requires-windows-containers.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiresWindowsContainers = void 0;
+const ci_1 = require("../utils/ci");
+function requiresWindowsContainers(fn) {
+    if (process.env.WINDOWS_CONTAINERS) {
+        return fn;
+    }
+    if (process.env.HAMMERKIT_FULL_INTEGRATION) {
+        return () => Promise.reject(new Error('WINDOWS_CONTAINERS not set but HAMMERKIT_FULL_INTEGRATION is on'));
+    }
+    if (ci_1.isCI) {
+        return () => Promise.resolve();
+    }
+    return fn;
+}
+exports.requiresWindowsContainers = requiresWindowsContainers;
+//# sourceMappingURL=requires-windows-containers.js.map

package/dist/testing/test-case.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestCase = exports.getTestRunId = void 0;
+const path_1 = require("path");
+const get_file_context_1 = require("../file/get-file-context");
+const log_1 = require("../log");
+const work_item_status_1 = require("../planner/work-item-status");
+const program_1 = require("../program");
+const yaml_1 = require("yaml");
+const run_program_1 = require("../run-program");
+const test_streams_1 = require("./test-streams");
+function getTestRunId(name) {
+    const base = process.env.HAMMERKIT_TEST_RUN_ID ?? `local-${process.pid}`;
+    return `${base}-${name}`
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 63);
+}
+exports.getTestRunId = getTestRunId;
+function createTestCase(name, files) {
+    const runId = getTestRunId(name);
+    return {
+        runId,
+        async shell(args) {
+            await this.setup(async (cwd, env) => {
+                await (0, run_program_1.runProgram)(env, args, true);
+            });
+        },
+        async setup(fn) {
+            const path = (0, path_1.join)(process.cwd(), 'temp', name);
+            const file = (0, get_file_context_1.getFileContext)(path);
+            const statusStream = (0, test_streams_1.memoryStream)();
+            try {
+                await file.remove(path);
+                await file.createDirectory(path);
+                const environment = {
+                    processEnvs: { ...process.env, HAMMERKIT_TEST_RUN_ID: runId },
+                    abortCtrl: new AbortController(),
+                    cwd: path,
+                    file,
+                    console: (0, log_1.consoleContext)((0, test_streams_1.emptyStream)()),
+                    status: (0, work_item_status_1.statusConsole)(statusStream.stream),
+                    stdout: (0, test_streams_1.emptyStream)(),
+                    stderr: (0, test_streams_1.emptyStream)(),
+                    stdoutColumns: 80,
+                };
+                for (const [fileName, fileContent] of Object.entries(files)) {
+                    await file.createDirectory((0, path_1.dirname)((0, path_1.join)(path, fileName)));
+                    await file.writeFile((0, path_1.join)(path, fileName), typeof fileContent === 'string' ? fileContent : (0, yaml_1.stringify)(fileContent));
+                }
+                await fn(path, environment);
+            }
+            catch (e) {
+                process.stdout.write(statusStream.read());
+                throw e;
+            }
+        },
+        async cli(scope, fn) {
+            return this.setup(async (cwd, environment) => {
+                const fileName = (0, path_1.join)(cwd, '.hammerkit.yaml');
+                environment.processEnvs = { ...environment.processEnvs, ...(scope.envs ?? {}) };
+                const cli = await (0, program_1.createCli)(fileName, environment, scope);
+                // also clear the persistent backend cache (~/.hammerkit/remote-cache)
+                // so results don't leak between test runs on the same machine.
+                await cli.clean({ cache: true });
+                if (fn) {
+                    await fn(cli, environment);
+                }
+            });
+        },
+    };
+}
+exports.createTestCase = createTestCase;
+//# sourceMappingURL=test-case.js.map

package/dist/testing/test-streams.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryStream = exports.emptyStream = void 0;
+const stream_1 = require("stream");
+function emptyStream() {
+    const stream = new stream_1.Writable();
+    stream._write = function (_chunk, _encoding, done) {
+        done();
+    };
+    return stream;
+}
+exports.emptyStream = emptyStream;
+function memoryStream() {
+    const stream = new stream_1.Writable();
+    const chunks = [];
+    stream._write = function (chunk, encoding, done) {
+        chunks.push(chunk.toString());
+        done();
+    };
+    return {
+        stream,
+        read() {
+            return chunks.join('');
+        },
+    };
+}
+exports.memoryStream = memoryStream;
+//# sourceMappingURL=test-streams.js.map

package/dist/testing/testing-timeout.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testingTimeout = void 0;
+const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
+async function testingTimeout(exec, timeout) {
+    const timer = setTimeout(() => {
+        for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(exec.state.current)) {
+            printWorkItem(task);
+        }
+        for (const service of (0, plan_work_tasks_1.iterateWorkServices)(exec.state.current)) {
+            printWorkItem(service);
+        }
+    }, (timeout || 45 * 1000) - 2000);
+    try {
+        return await exec.start();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+exports.testingTimeout = testingTimeout;
+function printWorkItem(task) {
+    const messages = [` - ${task.name}: ${task.state.current.type}`];
+    for (const log of task.status.logs()) {
+        messages.push(` console ${log.console}: ${log.message}`);
+    }
+    for (const log of task.status.read()) {
+        messages.push(` status ${log.level}: ${log.message}`);
+    }
+    process.stdout.write(messages.join('\n'));
+}
+//# sourceMappingURL=testing-timeout.js.map

package/dist/utils/abort-event.js

@@ -4,12 +4,18 @@ exports.waitOnAbort = exports.listenOnAbort = void 0;
 function listenOnAbort(abort, callback) {
     if (abort.aborted) {
         callback();
-        return;
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        return { close() { } };
     }
-    const listener = abort;
-    listener.addEventListener('abort', () => {
+    const eventListener = () => {
         callback();
-    }, { once: true });
+    };
+    abort.addEventListener('abort', eventListener, { once: true });
+    return {
+        close: () => {
+            abort.removeEventListener('abort', eventListener);
+        },
+    };
 }
 exports.listenOnAbort = listenOnAbort;
 function waitOnAbort(abort) {

package/dist/utils/abort-event.spec.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const abort_event_1 = require("./abort-event");
+describe('abort-event', () => {
+    describe('listenOnAbort', () => {
+        it('fires immediately when the signal is already aborted', () => {
+            const ctrl = new AbortController();
+            ctrl.abort();
+            const cb = vi.fn();
+            const handle = (0, abort_event_1.listenOnAbort)(ctrl.signal, cb);
+            expect(cb).toHaveBeenCalledTimes(1);
+            // close on a pre-aborted listener is a no-op; calling it must not throw.
+            expect(() => handle.close()).not.toThrow();
+        });
+        it('fires when the signal is aborted later', () => {
+            const ctrl = new AbortController();
+            const cb = vi.fn();
+            (0, abort_event_1.listenOnAbort)(ctrl.signal, cb);
+            expect(cb).not.toHaveBeenCalled();
+            ctrl.abort();
+            expect(cb).toHaveBeenCalledTimes(1);
+        });
+        it('does not fire after close()', () => {
+            const ctrl = new AbortController();
+            const cb = vi.fn();
+            const handle = (0, abort_event_1.listenOnAbort)(ctrl.signal, cb);
+            handle.close();
+            ctrl.abort();
+            expect(cb).not.toHaveBeenCalled();
+        });
+    });
+    describe('waitOnAbort', () => {
+        it('resolves immediately when already aborted', async () => {
+            const ctrl = new AbortController();
+            ctrl.abort();
+            await expect((0, abort_event_1.waitOnAbort)(ctrl.signal)).resolves.toBeUndefined();
+        });
+        it('resolves when the signal is aborted later', async () => {
+            const ctrl = new AbortController();
+            const pending = (0, abort_event_1.waitOnAbort)(ctrl.signal);
+            ctrl.abort();
+            await expect(pending).resolves.toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=abort-event.spec.js.map

package/dist/utils/buffer-context.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferContext = void 0;
+class BufferContext {
+    constructor(limit) {
+        this.limit = limit;
+        this.scopedBuffer = {};
+        this.buffer = [];
+    }
+    add(id, data) {
+        this.buffer.push(data);
+        if (id in this.scopedBuffer) {
+            const scopedBuffer = this.scopedBuffer[id];
+            scopedBuffer.push(data);
+            if (scopedBuffer.length > this.limit) {
+                const removedBuffer = this.buffer.splice(0, 1)[0];
+                const bufferIndex = this.buffer.indexOf(removedBuffer);
+                if (bufferIndex >= 0) {
+                    this.buffer.splice(bufferIndex, 1);
+                }
+            }
+        }
+        else {
+            this.scopedBuffer[id] = [data];
+        }
+    }
+    current(id) {
+        if (!(id in this.scopedBuffer)) {
+            return null;
+        }
+        const value = this.scopedBuffer[id];
+        return value[value.length - 1];
+    }
+    get(id) {
+        if (id) {
+            return this.scopedBuffer[id] ?? [];
+        }
+        else {
+            return this.buffer;
+        }
+    }
+}
+exports.BufferContext = BufferContext;
+//# sourceMappingURL=buffer-context.js.map

package/dist/utils/buffer-context.spec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const buffer_context_1 = require("./buffer-context");
+describe('BufferContext', () => {
+    it('returns null for current of an unknown id', () => {
+        const ctx = new buffer_context_1.BufferContext(10);
+        expect(ctx.current('missing')).toBeNull();
+    });
+    it('returns an empty array for get of an unknown id', () => {
+        const ctx = new buffer_context_1.BufferContext(10);
+        expect(ctx.get('missing')).toEqual([]);
+    });
+    it('tracks the latest value per id', () => {
+        const ctx = new buffer_context_1.BufferContext(10);
+        ctx.add('a', 1);
+        ctx.add('a', 2);
+        ctx.add('b', 9);
+        expect(ctx.current('a')).toBe(2);
+        expect(ctx.current('b')).toBe(9);
+    });
+    it('keeps per-id and global buffers', () => {
+        const ctx = new buffer_context_1.BufferContext(10);
+        ctx.add('a', 1);
+        ctx.add('b', 2);
+        expect(ctx.get('a')).toEqual([1]);
+        expect(ctx.get('b')).toEqual([2]);
+        expect(ctx.get()).toEqual([1, 2]);
+    });
+    it('evicts the oldest global entry once an id exceeds the limit', () => {
+        const ctx = new buffer_context_1.BufferContext(2);
+        ctx.add('a', 1);
+        ctx.add('a', 2);
+        ctx.add('a', 3);
+        expect(ctx.get()).toEqual([2, 3]);
+        expect(ctx.current('a')).toBe(3);
+    });
+});
+//# sourceMappingURL=buffer-context.spec.js.map

package/dist/utils/ci.spec.js

@@ -0,0 +1,53 @@
+"use strict";
+// Each `isCI` arm is evaluated once at module load, so the only way to cover
+// every branch of the OR chain is to load the module repeatedly under different
+// process.env. vi.resetModules + a fresh dynamic import gives us that.
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+const KEYS = ['CI', 'CONTINUOUS_INTEGRATION', 'BUILD_NUMBER', 'RUN_ID'];
+async function loadIsCI(set) {
+    for (const k of KEYS)
+        delete process.env[k];
+    if (set)
+        Object.assign(process.env, set);
+    vi.resetModules();
+    return (await Promise.resolve().then(() => __importStar(require('./ci')))).isCI;
+}
+describe('isCI', () => {
+    const original = { ...process.env };
+    afterEach(() => {
+        for (const k of KEYS)
+            delete process.env[k];
+        for (const k of KEYS)
+            if (k in original)
+                process.env[k] = original[k];
+    });
+    it('is false when no CI env var is set', async () => {
+        expect(await loadIsCI()).toBe(false);
+    });
+    it.each(KEYS)('is true when %s is set', async (key) => {
+        expect(await loadIsCI({ [key]: '1' })).toBe(true);
+    });
+});
+//# sourceMappingURL=ci.spec.js.map

package/dist/utils/emitter.spec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const emitter_1 = require("./emitter");
+describe('emitter', () => {
+    it('invokes every registered listener on emit', () => {
+        const e = (0, emitter_1.emitter)();
+        const a = vi.fn();
+        const b = vi.fn();
+        e.on(a);
+        e.on(b);
+        e.emit(42);
+        expect(a).toHaveBeenCalledWith(42);
+        expect(b).toHaveBeenCalledWith(42);
+    });
+    it('emit with no listeners is a no-op', () => {
+        const e = (0, emitter_1.emitter)();
+        expect(() => e.emit('noop')).not.toThrow();
+    });
+    it('close() removes the listener from future emits', () => {
+        const e = (0, emitter_1.emitter)();
+        const cb = vi.fn();
+        const handle = e.on(cb);
+        handle.close();
+        e.emit(1);
+        expect(cb).not.toHaveBeenCalled();
+    });
+    it('close() called twice is safe (no listener to remove)', () => {
+        const e = (0, emitter_1.emitter)();
+        const handle = e.on(vi.fn());
+        handle.close();
+        expect(() => handle.close()).not.toThrow();
+    });
+});
+//# sourceMappingURL=emitter.spec.js.map

package/dist/utils/empty-writable.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const empty_writable_1 = require("./empty-writable");
+describe('emptyWritable', () => {
+    it('accepts writes and invokes the callback', async () => {
+        const stream = (0, empty_writable_1.emptyWritable)();
+        await new Promise((resolve, reject) => {
+            stream.write('hello', (err) => (err ? reject(err) : resolve()));
+        });
+    });
+    it('ends cleanly after writes', async () => {
+        const stream = (0, empty_writable_1.emptyWritable)();
+        stream.write('a');
+        stream.write('b');
+        await new Promise((resolve) => stream.end(resolve));
+    });
+});
+//# sourceMappingURL=empty-writable.spec.js.map

package/dist/utils/environment-config.js

@@ -3,7 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEnvironmentConfig = void 0;
 function getEnvironmentConfig(name, defaultValue) {
     if (name in process.env) {
-        return parseInt(`${process.env[name]}`, 0) ?? defaultValue;
+        // parseInt returns NaN (not nullish) when the value isn't a number, so use
+        // an explicit NaN check; otherwise an invalid env value leaked NaN downstream.
+        const parsed = parseInt(`${process.env[name]}`, 10);
+        return Number.isNaN(parsed) ? defaultValue : parsed;
     }
     else {
         return defaultValue;

package/dist/utils/environment-config.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const environment_config_1 = require("./environment-config");
+const VAR = 'HAMMERKIT_TEST_ENV_CONFIG';
+describe('getEnvironmentConfig', () => {
+    afterEach(() => {
+        delete process.env[VAR];
+    });
+    it('returns the default when the variable is unset', () => {
+        delete process.env[VAR];
+        expect((0, environment_config_1.getEnvironmentConfig)(VAR, 7)).toBe(7);
+    });
+    it('parses an integer env value', () => {
+        process.env[VAR] = '42';
+        expect((0, environment_config_1.getEnvironmentConfig)(VAR, 7)).toBe(42);
+    });
+    it('falls back to the default when the env value is not a number', () => {
+        process.env[VAR] = 'not-a-number';
+        expect((0, environment_config_1.getEnvironmentConfig)(VAR, 7)).toBe(7);
+    });
+    it('treats an empty string env value as not-a-number and uses the default', () => {
+        process.env[VAR] = '';
+        expect((0, environment_config_1.getEnvironmentConfig)(VAR, 5)).toBe(5);
+    });
+});
+//# sourceMappingURL=environment-config.spec.js.map

package/dist/utils/fail-never.spec.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fail_never_1 = require("./fail-never");
+describe('failNever', () => {
+    it('throws an error with the given message', () => {
+        expect(() => (0, fail_never_1.failNever)('value', 'unexpected')).toThrow('unexpected');
+    });
+});
+//# sourceMappingURL=fail-never.spec.js.map

package/dist/version.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersion = void 0;
+function getVersion() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require('../package.json').version;
+}
+exports.getVersion = getVersion;
+//# sourceMappingURL=version.js.map

package/dist/version.spec.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const version_1 = require("./version");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require('../package.json');
+describe('getVersion', () => {
+    it('returns the version from package.json', () => {
+        expect((0, version_1.getVersion)()).toBe(pkg.version);
+        expect((0, version_1.getVersion)()).toMatch(/^\d+\.\d+\.\d+/);
+    });
+});
+//# sourceMappingURL=version.spec.js.map