hammerkit 1.5.1 → 1.6.0-alpha.2

package/dist/testing/ensure-local-registry.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureLocalRegistry = void 0;
+const dockerode_1 = __importDefault(require("dockerode"));
+const REGISTRY_NAME = 'hammerkit-test-registry';
+const REGISTRY_IMAGE = 'registry:2';
+// Small image with busybox wget, used to talk to the registry from the daemon's
+// network (see why below). alpine is already pulled by the package suites.
+const PROBE_IMAGE = 'alpine:3.19';
+const MANAGED_PORT = Number(process.env.HAMMERKIT_TEST_REGISTRY_PORT) || 5000;
+function registryAddressFromEnv() {
+    const fromEnv = process.env.REGISTRY;
+    if (!fromEnv) {
+        return null;
+    }
+    const match = /^([^:]+):(\d+)$/.exec(fromEnv);
+    if (!match) {
+        throw new Error(`REGISTRY must be of the form host:port (got "${fromEnv}")`);
+    }
+    return { host: match[1], hostPort: parseInt(match[2], 10) };
+}
+async function ensureImage(docker, image) {
+    try {
+        await docker.getImage(image).inspect();
+        return;
+    }
+    catch {
+        // not present locally — pull it below
+    }
+    await new Promise((resolve, reject) => {
+        docker.pull(image, (err, stream) => {
+            if (err || !stream) {
+                reject(err ?? new Error('no pull stream'));
+                return;
+            }
+            docker.modem.followProgress(stream, (e) => (e ? reject(e) : resolve()));
+        });
+    });
+}
+// Run a throwaway container on the *host* network and return its exit code.
+// The registry is reachable at 127.0.0.1:<port> from the daemon's network (see
+// ensureLocalRegistry), but not necessarily from this (host) process — on Docker
+// Desktop the daemon is in a VM — so registry HTTP is done from here instead.
+async function runOnHostNet(docker, shellCmd) {
+    await ensureImage(docker, PROBE_IMAGE);
+    const container = await docker.createContainer({
+        Image: PROBE_IMAGE,
+        Cmd: ['sh', '-c', shellCmd],
+        HostConfig: { NetworkMode: 'host', AutoRemove: false },
+    });
+    try {
+        await container.start();
+        const res = await container.wait();
+        return res.StatusCode ?? 1;
+    }
+    finally {
+        await container.remove({ force: true }).catch(() => undefined);
+    }
+}
+/**
+ * Returns a docker registry suitable for `cli.package({ registry, push: true, ... })`.
+ *
+ * Resolution order:
+ * 1. `REGISTRY=host:port` env var (used by CI; just probed for liveness, never managed).
+ * 2. A managed `registry:2` container on the daemon's own network (host networking).
+ *
+ * Host networking matters: the daemon performs the push, and an HTTP push needs a
+ * `127.0.0.1`/`localhost` address (the only registries docker treats as insecure
+ * without daemon config). On Docker Desktop the daemon runs in a VM, so a
+ * host-*published* port is not reachable from it via 127.0.0.1 (`docker push
+ * 127.0.0.1:<published>` → connection refused). Putting the registry on the
+ * daemon's network makes 127.0.0.1:<port> resolve to it. Because this process
+ * (on the host) then can't see the registry, liveness and tag lookups run inside
+ * a throwaway container on the same network — see `listsTag`.
+ *
+ * Callers must invoke `cleanup()`. For the env-var case it is a no-op.
+ */
+async function ensureLocalRegistry(docker) {
+    const d = docker ?? new dockerode_1.default();
+    const fromEnv = registryAddressFromEnv();
+    let host;
+    let hostPort;
+    let cleanup = async () => undefined;
+    if (fromEnv) {
+        host = fromEnv.host;
+        hostPort = fromEnv.hostPort;
+    }
+    else {
+        host = '127.0.0.1';
+        hostPort = MANAGED_PORT;
+        await ensureImage(d, REGISTRY_IMAGE);
+        const existing = await d.listContainers({ all: true, filters: { name: [REGISTRY_NAME] } });
+        if (existing.length === 0) {
+            const container = await d.createContainer({
+                Image: REGISTRY_IMAGE,
+                name: REGISTRY_NAME,
+                Env: [`REGISTRY_HTTP_ADDR=0.0.0.0:${MANAGED_PORT}`],
+                HostConfig: { AutoRemove: true, NetworkMode: 'host' },
+            });
+            await container.start();
+        }
+        else if (existing[0].State !== 'running') {
+            await d.getContainer(existing[0].Id).start();
+        }
+        cleanup = async () => {
+            const c = (await d.listContainers({ all: true, filters: { name: [REGISTRY_NAME] } }))[0];
+            if (c) {
+                await d
+                    .getContainer(c.Id)
+                    .remove({ force: true })
+                    .catch(() => undefined);
+            }
+        };
+    }
+    const base = `http://${host}:${hostPort}`;
+    const reachable = await runOnHostNet(d, `for i in $(seq 1 60); do wget -q -O /dev/null ${base}/v2/ && exit 0; sleep 1; done; exit 1`);
+    if (reachable !== 0) {
+        throw new Error(`docker registry at ${host}:${hostPort} did not become reachable in time`);
+    }
+    return {
+        host,
+        hostPort,
+        cleanup,
+        async listsTag(repository, tag) {
+            const code = await runOnHostNet(d, `wget -qO- ${base}/v2/${repository}/tags/list | grep -q '"${tag}"'`);
+            return code === 0;
+        },
+    };
+}
+exports.ensureLocalRegistry = ensureLocalRegistry;
+//# sourceMappingURL=ensure-local-registry.js.map

package/dist/testing/example-test-suite.js

@@ -3,14 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExampleTestSuite = void 0;
 const path_1 = require("path");
 const get_file_context_1 = require("../file/get-file-context");
-const work_node_status_1 = require("../planner/work-node-status");
+const work_item_status_1 = require("../planner/work-item-status");
 const program_1 = require("../program");
-const execute_docker_1 = require("../executer/execute-docker");
-const fs_1 = require("fs");
 const log_1 = require("../log");
+const test_streams_1 = require("./test-streams");
 class ExampleTestSuite {
     constructor(exampleName, files) {
-        this.exampleName = exampleName;
         this.files = files;
         this.tests = [];
         this.exampleDirectory = (0, path_1.join)(__dirname, '../../examples/', exampleName);
@@ -19,29 +17,23 @@ class ExampleTestSuite {
     }
     async close() {
         for (const test of this.tests) {
+            test.close();
             await this.file.remove(test.cwd);
         }
     }
     async setup(scope) {
         await this.file.remove(this.path);
         await this.file.createDirectory(this.path);
-        const logPath = (0, path_1.join)(process.cwd(), 'logs');
-        const stdoutFile = (0, path_1.join)(logPath, this.exampleName + '-stout.log');
-        const statusFile = (0, path_1.join)(logPath, this.exampleName + '-status.log');
-        const consoleFile = (0, path_1.join)(logPath, this.exampleName + '-console.log');
-        await this.file.createDirectory(logPath);
-        await this.file.remove(stdoutFile);
-        await this.file.remove(statusFile);
-        await this.file.remove(consoleFile);
+        const statusStream = (0, test_streams_1.memoryStream)();
         const environment = {
             processEnvs: { ...process.env, ...(scope.envs ?? {}) },
             abortCtrl: new AbortController(),
             cwd: this.path,
             file: this.file,
-            console: (0, log_1.consoleContext)((0, fs_1.createWriteStream)(consoleFile)),
-            status: (0, work_node_status_1.statusConsole)((0, fs_1.createWriteStream)(statusFile)),
-            docker: (0, execute_docker_1.getContainerCli)(),
-            stdout: (0, fs_1.createWriteStream)(stdoutFile),
+            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 file of this.files) {
@@ -50,11 +42,17 @@ class ExampleTestSuite {
         const fileName = (0, path_1.join)(this.path, '.hammerkit.yaml');
         this.tests.push({
             cwd: this.path,
+            close() {
+                environment.abortCtrl.abort();
+            },
         });
         const cli = await (0, program_1.createCli)(fileName, environment, scope);
-        await cli.clean({ service: true });
+        // clear the backend cache too: the default `local` backend persists under
+        // ~/.hammerkit/remote-cache outside the test's temp dir, so without this a
+        // prior run's result would leak in and make cache assertions flaky.
+        await cli.clean({ cache: true });
         // reset cli clean stats
-        environment.status = (0, work_node_status_1.statusConsole)((0, fs_1.createWriteStream)(statusFile, { flags: 'a' }));
+        environment.status = (0, work_item_status_1.statusConsole)(statusStream.stream);
         return {
             cli,
             environment,

package/dist/testing/expect.js

@@ -1,24 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expectContainsLog = exports.expectLog = exports.expectSuccessfulResult = void 0;
-const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
+exports.expectContainsLog = exports.expectLog = exports.expectSuccessfulResult = exports.expectSuccessfulExecution = void 0;
+const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
+const get_scheduler_execute_result_1 = require("../executer/get-scheduler-execute-result");
+const testing_timeout_1 = require("./testing-timeout");
+async function expectSuccessfulExecution(exec, env) {
+    const badResult = new Promise((resolve) => {
+        exec.state.on('expected-status', (workTree) => {
+            if (env.abortCtrl.signal.aborted) {
+                return;
+            }
+            const hasErrorTask = Object.values(workTree.tasks).some((n) => n.state.current.type === 'error' || n.state.current.type === 'crash');
+            const hasErrorService = Object.values(workTree.services).some((n) => n.state.current.type === 'error' || n.state.current.type === 'end');
+            if (!hasErrorTask && !hasErrorService) {
+                return;
+            }
+            const stateResult = (0, get_scheduler_execute_result_1.getSchedulerExecuteResult)(workTree);
+            if (!stateResult.success) {
+                resolve(stateResult);
+                env.abortCtrl.abort();
+            }
+        });
+    });
+    const result = await Promise.race([badResult, (0, testing_timeout_1.testingTimeout)(exec)]);
+    await expectSuccessfulResult(result, env);
+}
+exports.expectSuccessfulExecution = expectSuccessfulExecution;
 async function expectSuccessfulResult(result, env) {
     if (!result.success) {
-        for (const state of (0, plan_work_nodes_1.iterateWorkNodes)(result.state.node)) {
-            if (state.type !== 'completed') {
+        for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(result.state)) {
+            if (task.state.current.type !== 'completed') {
                 expect({
-                    nodeId: state.node.id,
-                    status: state.type,
-                    updates: Array.from(env.status.task(state.node).read()).map((s) => `${s.level}: ${s.message}`),
-                    logs: Array.from(env.status.task(state.node).logs()).map((l) => `${l.console}: ${l.message}`),
-                    errorMessage: state.type === 'error' ? state.errorMessage : undefined,
-                    needs: state.node.needs.map((need) => ({
+                    cacheId: task.id(),
+                    status: task.state.current.type,
+                    updates: Array.from(task.status.read()).map((s) => `${s.level}: ${s.message}`),
+                    logs: Array.from(task.status.logs()).map((l) => `${l.console}: ${l.message}`),
+                    errorMessage: task.state.current.type === 'error' ? task.state.current.errorMessage : undefined,
+                    needs: task.needs.map((need) => ({
                         name: need.name,
-                        updates: Array.from(env.status.service(need).read()).map((s) => `${s.level}: ${s.message}`),
-                        logs: Array.from(env.status.service(need).logs()).map((l) => `${l.console}: ${l.message}`),
+                        updates: Array.from(need.service.status.read()).map((s) => `${s.level}: ${s.message}`),
+                        logs: Array.from(need.service.status.logs()).map((l) => `${l.console}: ${l.message}`),
                     })),
                 }).toEqual({
-                    nodeId: state.node.id,
+                    cacheId: task.id(),
                     status: 'completed',
                 });
             }
@@ -31,22 +55,22 @@ async function expectSuccessfulResult(result, env) {
     expect(errorStatus).toEqual([]);
 }
 exports.expectSuccessfulResult = expectSuccessfulResult;
-function getNodeState(state, name) {
-    const node = Object.values(state.node).find((n) => n.node.name === name);
-    if (!node) {
-        throw new Error(`could not find node ${name}`);
+function getTaskState(state, name) {
+    const tasks = Object.values(state.tasks).find((n) => n.name === name);
+    if (!tasks) {
+        throw new Error(`could not find task ${name}`);
     }
-    return node;
+    return tasks;
 }
 async function expectLog(result, env, name, message) {
-    const state = getNodeState(result.state, name);
-    const logs = Array.from(env.status.task(state.node).logs()).map((n) => n.message);
+    const state = getTaskState(result.state, name);
+    const logs = Array.from(state.status.logs()).map((n) => n.message);
     expect(logs).toContain(message);
 }
 exports.expectLog = expectLog;
 async function expectContainsLog(result, env, name, message) {
-    const state = getNodeState(result.state, name);
-    const logs = env.status.task(state.node).logs();
+    const state = getTaskState(result.state, name);
+    const logs = state.status.logs();
     for (const log of logs) {
         if (log.message.indexOf(message) >= 0) {
             return;

package/dist/testing/http-get.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpGet = void 0;
+const http_1 = require("http");
+function httpGet(host, port, path, timeoutMs = 10000) {
+    return new Promise((resolve, reject) => {
+        const req = (0, http_1.request)({ host, port, path, method: 'GET', timeout: timeoutMs }, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => resolve({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString('utf8') }));
+            res.on('error', reject);
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy(new Error(`timeout after ${timeoutMs}ms`));
+        });
+        req.end();
+    });
+}
+exports.httpGet = httpGet;
+//# sourceMappingURL=http-get.js.map

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

@@ -1,24 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("jest-extended");
-const write_work_node_cache_1 = require("../../optimizer/write-work-node-cache");
 const expect_1 = require("../expect");
 const get_test_suite_1 = require("../get-test-suite");
 const path_1 = require("path");
 const enqueue_next_1 = require("../../executer/scheduler/enqueue-next");
 const read_build_file_1 = require("../../parser/read-build-file");
+const requires_linux_containers_1 = require("../requires-linux-containers");
 describe('cache', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('cache', ['.hammerkit.yaml', 'package.json', 'package-lock.json']);
     afterAll(() => suite.close());
     async function testCache(action, expectInvalidate) {
         const setupBefore = await suite.setup({ taskName: 'example' });
-        const nodeBefore = setupBefore.cli.node('example');
-        await (0, write_work_node_cache_1.writeWorkNodeCache)(nodeBefore, setupBefore.environment);
+        const result = await setupBefore.cli.exec().start();
+        await (0, expect_1.expectSuccessfulResult)(result, setupBefore.environment);
         await action(setupBefore.environment);
         const setupAfter = await suite.setup({ taskName: 'example' });
-        const node = setupAfter.cli.node('example');
-        const checksumUpToDate = await (0, enqueue_next_1.checkCacheState)(node, 'checksum', setupAfter.environment);
-        const modifyDateUpToDate = await (0, enqueue_next_1.checkCacheState)(node, 'modify-date', setupAfter.environment);
+        const task = setupAfter.cli.task('example');
+        const checksumUpToDate = await (0, enqueue_next_1.checkCacheState)(task, 'checksum', setupAfter.environment);
+        const modifyDateUpToDate = await (0, enqueue_next_1.checkCacheState)(task, 'modify-date', setupAfter.environment);
         if (expectInvalidate) {
             expect(checksumUpToDate.cached).toBeFalsy();
             expect(modifyDateUpToDate.cached).toBeFalsy();
@@ -28,23 +27,23 @@ describe('cache', () => {
             expect(modifyDateUpToDate.cached).toBeTruthy();
         }
     }
-    it('should run invalid cache on src file change', async () => {
+    it('should run invalid cache on src file change', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         await testCache(async (environment) => {
             await environment.file.appendFile((0, path_1.join)(environment.cwd, 'package.json'), '\n');
         }, true);
-    });
-    it('should mount generations of dependant tasks', async () => {
+    }));
+    it('should mount generations of dependant tasks', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         const { cli, environment } = await suite.setup({ taskName: 'dependant' });
-        const result = await cli.exec();
+        const result = await cli.runExec();
         await (0, expect_1.expectSuccessfulResult)(result, environment);
         await (0, expect_1.expectLog)(result, environment, `dependant`, 'node_modules');
-    });
-    it('should invalid cache on image change', async () => {
+    }));
+    it('should invalid cache on image change', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         await testCache(async (environment) => {
             const buildFile = await (0, read_build_file_1.read)('.hammerkit.yaml', environment);
             buildFile.tasks['example'].image = '15.0.0';
             await (0, read_build_file_1.write)('.hammerkit.yaml', buildFile, environment);
         }, true);
-    });
+    }));
 });
 //# sourceMappingURL=cache.spec.js.map

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

@@ -2,22 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const get_test_suite_1 = require("../get-test-suite");
+const requires_linux_containers_1 = require("../requires-linux-containers");
 describe('cancellation', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('cancellation', ['.hammerkit.yaml']);
     afterAll(() => suite.close());
     async function testAbort(taskName, expectedState) {
         const { cli, environment } = await suite.setup({ taskName });
-        const exec = await cli.execWatch({ logMode: 'live' });
-        const abortNode = Object.values(exec.state.current.node).find((n) => n.node.name.startsWith('long_'));
-        exec.processManager.on((evt) => {
-            if (evt.type === 'started' && evt.context.id === abortNode?.node.id) {
+        const exec = await cli.exec({ logMode: 'live' });
+        const abortNode = Object.values(exec.state.current.tasks).find((n) => n.data.name.startsWith('long_'));
+        expect_toBeDefined(abortNode);
+        exec.state.on('check-status', (evt) => {
+            if (evt.tasks[abortNode.name].state.current.type === 'running') {
                 environment.abortCtrl.abort();
             }
         });
         const result = await exec.start();
         expect(result.success).toBeFalsy();
         if (abortNode) {
-            expect(result.state.node[abortNode.node.id].type).toEqual(expectedState);
+            expect(abortNode.state.current.type).toEqual(expectedState);
         }
         else {
             expect(abortNode).toBeDefined();
@@ -30,11 +32,14 @@ describe('cancellation', () => {
     it('should cancel local task', async () => {
         await testAbort('long_running_local', 'canceled');
     });
-    it('should cancel docker task', async () => {
+    it('should cancel docker task', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         await testAbort('long_running_docker', 'canceled');
-    });
-    it('should cancel docker task with dependencies', async () => {
+    }));
+    it('should cancel docker task with dependencies', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         await testAbort('docker_cancel', 'canceled');
-    });
+    }));
 });
+function expect_toBeDefined(arg) {
+    expect(arg).toBeDefined();
+}
 //# sourceMappingURL=cancellation.spec.js.map

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

@@ -6,35 +6,38 @@ const expect_1 = require("../expect");
 const get_test_suite_1 = require("../get-test-suite");
 const get_docker_executor_1 = require("../../executer/get-docker-executor");
 const plan_work_volume_1 = require("../../planner/utils/plan-work-volume");
+const execute_docker_1 = require("../../executer/execute-docker");
+const requires_linux_containers_1 = require("../requires-linux-containers");
 describe('clean', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('clean', ['.hammerkit.yaml', 'package.json']);
     afterAll(() => suite.close());
     it('should clean generated outputs locally', async () => {
         const { cli, environment } = await suite.setup({ taskName: 'example' });
-        const result = await cli.exec({ cacheDefault: 'none' });
+        const result = await cli.runExec({ cacheDefault: 'none' });
         await (0, expect_1.expectSuccessfulResult)(result, environment);
         const outputPath = (0, path_1.join)(suite.path, 'node_modules');
         expect((0, fs_1.existsSync)(outputPath)).toBeTruthy();
         await cli.clean();
         expect((0, fs_1.existsSync)(outputPath)).toBeFalsy();
     });
-    it('should clean generated outputs in containers', async () => {
+    it('should clean generated outputs in containers', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         const { cli, environment } = await suite.setup({ taskName: 'docker:example' });
-        const result = await cli.exec({ cacheDefault: 'none' });
+        const result = await cli.runExec({ cacheDefault: 'none' });
         await (0, expect_1.expectSuccessfulResult)(result, environment);
+        const docker = (0, execute_docker_1.getContainerCli)({ type: 'docker' });
         const outputPath = (0, path_1.join)(suite.path, 'node_modules');
         const volumeName = (0, plan_work_volume_1.getVolumeName)(outputPath);
-        expect(await (0, get_docker_executor_1.existsVolume)(environment, volumeName)).toBeTruthy();
+        expect(await (0, get_docker_executor_1.existsVolume)(docker, volumeName)).toBeTruthy();
         await cli.clean();
-        expect(await (0, get_docker_executor_1.existsVolume)(environment, volumeName)).toBeFalsy();
-    });
-    it('should clean and restore created data in volumes', async () => {
+        expect(await (0, get_docker_executor_1.existsVolume)(docker, volumeName)).toBeFalsy();
+    }));
+    it('should clean and restore created data in volumes', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         const { cli, environment } = await suite.setup({ taskName: 'example:service' });
-        const result = await cli.exec();
+        const result = await cli.runExec();
         await (0, expect_1.expectSuccessfulResult)(result, environment);
-        await cli.clean({ service: true });
-        const resultAfterClean = await cli.exec();
+        await cli.clean();
+        const resultAfterClean = await cli.runExec();
         await (0, expect_1.expectSuccessfulResult)(resultAfterClean, environment);
-    });
+    }));
 });
 //# sourceMappingURL=clean.spec.js.map

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

@@ -7,7 +7,7 @@ describe('cmd', () => {
     afterAll(() => suite.close());
     it('should run with path arg', async () => {
         const { cli, environment } = await suite.setup({ taskName: 'example' });
-        const result = await cli.exec();
+        const result = await cli.runExec();
         await (0, expect_1.expectSuccessfulResult)(result, environment);
         await (0, expect_1.expectContainsLog)(result, environment, `example`, 'README.md');
     });

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

@@ -7,9 +7,9 @@ describe('concurrency', () => {
     afterAll(() => suite.close());
     it('should run with concurrency lower than total tasks', async () => {
         const { cli, environment } = await suite.setup({ taskName: 'example' });
-        const exec = cli.execWatch({ workers: 1 });
-        exec.state.on((state) => {
-            const runningNodes = Object.values(state.node).filter((n) => n.type === 'running');
+        const exec = await cli.exec({ workers: 1 });
+        exec.state.on('check-status', (state) => {
+            const runningNodes = Object.values(state.tasks).filter((n) => n.state.current.type === 'running');
             expect(runningNodes.length).toBeLessThanOrEqual(1);
         });
         const result = await exec.start();

package/dist/testing/integration/docker-package-registry.spec.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_case_1 = require("../test-case");
+const ensure_local_registry_1 = require("../ensure-local-registry");
+const requires_linux_containers_1 = require("../requires-linux-containers");
+describe('docker/package against a local registry', () => {
+    let registry;
+    beforeAll((0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
+        registry = await (0, ensure_local_registry_1.ensureLocalRegistry)();
+    }));
+    afterAll(async () => {
+        if (registry && process.env.HAMMERKIT_KEEP_REGISTRY !== 'true') {
+            await registry.cleanup();
+        }
+    });
+    it('pushes a built service image and the registry lists its tag', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
+        const repository = `pkg-${Date.now()}`;
+        const testCase = (0, test_case_1.createTestCase)('docker-package-registry', {
+            '.hammerkit.yaml': {
+                services: {
+                    [repository]: {
+                        image: 'alpine:3.19',
+                        labels: { app: 'svc' },
+                        cmd: 'sh -c "echo hi && sleep 3600"',
+                        src: ['hello.txt'],
+                        ports: ['8080'],
+                    },
+                },
+            },
+            'hello.txt': 'hi from hammerkit',
+        });
+        await testCase.cli({ filterLabels: { app: ['svc'] } }, async (cli) => {
+            await cli.package({
+                registry: `${registry.host}:${registry.hostPort}`,
+                push: true,
+                overrideUser: false,
+                username: null,
+                password: null,
+            });
+        });
+        expect(await registry.listsTag(repository, 'latest')).toBe(true);
+    }), 180000);
+});
+//# sourceMappingURL=docker-package-registry.spec.js.map

package/dist/testing/integration/docker-service-crash.spec.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_case_1 = require("../test-case");
+const requires_linux_containers_1 = require("../requires-linux-containers");
+/**
+ * Regression for the crash detection in docker-service.ts: a container that
+ * exits while the runtime is waiting on abort must surface as
+ * `{ type: 'end', reason: 'crash' }` instead of being silently 'terminated'.
+ */
+describe('docker service crash detection', () => {
+    const testCase = (0, test_case_1.createTestCase)('docker-service-crash', {
+        '.hammerkit.yaml': {
+            services: {
+                flaky: {
+                    image: 'alpine:3.19',
+                    // command exits with non-zero after a short delay
+                    cmd: 'sh -c "sleep 1 && exit 17"',
+                    ports: [':9000'],
+                },
+            },
+        },
+    });
+    it('reports crash when the container exits while running', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
+        await testCase.cli({}, async (cli) => {
+            // daemon=false so docker-service.ts awaits container.wait() instead of
+            // returning as soon as the service is 'running'
+            await cli.runUp({ daemon: false });
+            const service = cli.service('flaky');
+            expect(service.state.current.type).toBe('end');
+            if (service.state.current.type === 'end') {
+                expect(service.state.current.reason).toBe('crash');
+            }
+        });
+    }), 90000);
+});
+//# sourceMappingURL=docker-service-crash.spec.js.map

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

@@ -2,15 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const expect_1 = require("../expect");
 const get_test_suite_1 = require("../get-test-suite");
+const requires_linux_containers_1 = require("../requires-linux-containers");
 describe('docker', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('docker', ['.hammerkit.yaml']);
     afterAll(() => suite.close());
-    it('should pull docker image', async () => {
+    it('should pull docker image', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         const { cli, environment } = await suite.setup({ taskName: 'example' });
-        const result = await cli.exec();
+        const result = await cli.runExec();
         await (0, expect_1.expectSuccessfulResult)(result, environment);
         await (0, expect_1.expectLog)(result, environment, `example`, '7.19.1');
         await (0, expect_1.expectLog)(result, environment, `example`, 'v16.6.0');
-    });
+    }));
 });
 //# sourceMappingURL=docker.spec.js.map