hammerkit 1.5.0 → 1.6.0-alpha.1

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

@@ -2,30 +2,31 @@
 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('env', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('env', ['.hammerkit.yaml', '.env']);
     afterAll(() => suite.close());
     it('should use env from build file', 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`, '16.6.0');
     });
-    it('should pass env to docker', async () => {
+    it('should pass env to docker', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         const { cli, environment } = await suite.setup({ taskName: 'example_docker' });
-        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_docker`, '16.6.0');
-    });
+    }));
     it('should use env from task', async () => {
         const { cli, environment } = await suite.setup({ taskName: 'example_override' });
-        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_override`, '15.0.0');
     });
     it('should use env from .env', async () => {
         const { cli, environment } = await suite.setup({ taskName: 'example_with_dotenv' });
-        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_with_dotenv`, '123456');
     });
@@ -36,12 +37,12 @@ describe('env', () => {
                 VERSION: '1.0.0',
             },
         });
-        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_with_shell_env`, '1.0.0');
     });
     it('should throw if process env is missing', async () => {
-        await expect(suite.setup({ taskName: 'example_with_shell_env' })).rejects.toThrow('missing env $VERSION');
+        await expect(suite.setup({ taskName: 'example_with_shell_env' })).rejects.toThrow('missing environment variable VERSION');
     });
 });
 //# sourceMappingURL=env.spec.js.map

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_test_suite_1 = require("../get-test-suite");
+const test_case_1 = require("../test-case");
+const requires_kubernetes_1 = require("../requires-kubernetes");
+const testing_timeout_1 = require("../testing-timeout");
+describe('environment', () => {
+    const suite = (0, get_test_suite_1.getTestSuite)('error', ['.hammerkit.yaml']);
+    afterAll(() => suite.close());
+    it('should run on environment (kubernetes)', (0, requires_kubernetes_1.requiresKubernetes)(async () => {
+        const testCase = (0, test_case_1.createTestCase)('environment', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    install: {
+                        image: 'node:18-alpine',
+                        cmds: ['npm install'],
+                        src: ['package.json'],
+                        generates: ['node_modules'],
+                    },
+                },
+                services: {
+                    postgres: {
+                        image: 'postgres:16-alpine',
+                        envs: {
+                            POSTGRES_USER: 'postgres',
+                            POSTGRES_DB: 'demo',
+                            POSTGRES_PASSWORD: '123456',
+                        },
+                        ports: [':5432'],
+                        volumes: ['postgres-db:/var/lib/postgresql/data'],
+                    },
+                    api: {
+                        deps: ['install'],
+                        needs: ['postgres'],
+                        image: 'node:16.6.0-alpine',
+                        envs: {
+                            DATABASE_URL: 'postgres://postgres:123456@postgres/demo',
+                        },
+                        cmd: 'node index.js',
+                        src: ['index.js'],
+                        ports: [':3000'],
+                    },
+                },
+                environments: {
+                    staging: {
+                        kubernetes: {
+                            namespace: `hammerkit-env-${(process.env.HAMMERKIT_TEST_RUN_ID ?? 'local').slice(0, 40)}`,
+                            context: process.env.CLUSTER_NAME || 'docker-desktop',
+                            ingresses: [
+                                {
+                                    host: 'demo.bertschi.io',
+                                    service: 'api',
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+            'package.json': '{ "dependencies": { "pg": "^8.7.1" } }',
+            'index.js': `const { Client } = require('pg')
+const { createServer } = require('http')
+
+const client = new Client(process.env.DATABASE_URL)
+
+const server = createServer(async (req, res) => {
+  const result = await client.query('SELECT $1::text as message', ['Hello world!'])
+  res.writeHead(200)
+  res.end(result.rows[0].message)
+})
+
+async function main() {
+  await client.connect()
+  server.listen(3000)
+}
+
+process.on('SIGINT', async function () {
+  server.close()
+  await client.end()
+})
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})
+`,
+        });
+        await testCase.cli({ environmentName: 'staging' }, async (cli) => {
+            try {
+                await (0, testing_timeout_1.testingTimeout)(cli.up({ daemon: true }));
+            }
+            finally {
+                await cli.runDown();
+            }
+        });
+    }));
+});
+//# sourceMappingURL=environment.spec.js.map

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

@@ -1,18 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const get_test_suite_1 = require("../get-test-suite");
+const requires_linux_containers_1 = require("../requires-linux-containers");
 describe('error', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('error', ['.hammerkit.yaml']);
     afterAll(() => suite.close());
     it('should return error when local task failed', async () => {
         const { cli } = await suite.setup({ taskName: 'local_error' });
-        const result = await cli.exec();
+        const result = await cli.runExec();
         expect(result.success).toBeFalsy();
     });
-    it('should return error when docker task failed', async () => {
+    it('should return error when docker task failed', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         const { cli } = await suite.setup({ taskName: 'docker_error' });
-        const result = await cli.exec();
+        const result = await cli.runExec();
         expect(result.success).toBeFalsy();
-    });
+    }));
 });
 //# sourceMappingURL=error.spec.js.map

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

@@ -0,0 +1,22 @@
+"use strict";
+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('export', () => {
+    const suite = (0, get_test_suite_1.getTestSuite)('export', ['.hammerkit.yaml']);
+    afterAll(() => suite.close());
+    it('should export created file', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
+        const { cli, environment } = await suite.setup({ taskName: 'example_file' });
+        const result = await cli.runExec();
+        expect(result.success).toBeTruthy();
+        expect(await environment.file.read((0, path_1.join)(environment.cwd, 'test.txt'))).toEqual('hello\n');
+    }));
+    it('should export created directory', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
+        const { cli, environment } = await suite.setup({ taskName: 'example_dir' });
+        const result = await cli.runExec();
+        expect(result.success).toBeTruthy();
+        expect(await environment.file.read((0, path_1.join)(environment.cwd, 'dist/test.txt'))).toEqual('hello\n');
+    }));
+});
+//# sourceMappingURL=export.spec.js.map

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

@@ -6,27 +6,24 @@ describe('extend', () => {
     afterAll(() => suite.close());
     it('should merge env variables', async () => {
         const { cli } = await suite.setup({ taskName: 'extend_env' });
-        const node = await cli.node('extend_env');
-        expect(node.envs).toContainEntries([
-            ['NAME', 'base'],
-            ['KEEP', 'value'],
-        ]);
+        const task = await cli.task('extend_env');
+        expect(task.data.envs.variables).toMatchObject({ NAME: 'base', KEEP: 'value' });
     });
     it('should extend and override', async () => {
         const { cli } = await suite.setup({ taskName: 'extend_container_task' });
-        const node = await cli.node('extend_container_task');
-        expect(node.envs).toEqual({
+        const task = await cli.task('extend_container_task');
+        expect(task.data.envs.variables).toEqual({
             NAME: 'override',
         });
-        expect(node.type).toBe('container');
-        if (node.type === 'container') {
-            expect(node.image).toBe('alpine:latest');
+        expect(task.data.type).toBe('container-task');
+        if (task.data.type === 'container-task') {
+            expect(task.data.image).toBe('alpine:latest');
         }
     });
     it('should merge deps', async () => {
         const { cli } = await suite.setup({ taskName: 'extend_dep' });
-        const node = await cli.node('extend_dep');
-        expect(node.deps.map((d) => d.name)).toIncludeSameMembers(['base_env', 'extend_env']);
+        const task = await cli.task('extend_dep');
+        expect(task.deps.map((d) => d.name).sort()).toEqual(['base_env', 'extend_env'].sort());
     });
 });
 //# sourceMappingURL=extend.spec.js.map

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

@@ -1,34 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const get_test_suite_1 = require("../get-test-suite");
-const expect_1 = require("../expect");
+const enqueue_next_1 = require("../../executer/scheduler/enqueue-next");
 describe('glob', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('glob', ['.hammerkit.yaml', 'test.md', 'test.txt']);
     afterAll(() => suite.close());
     async function testCache(expectInvalidate, action) {
         const { cli, environment } = await suite.setup({ taskName: 'example' });
-        const result1 = await cli.exec();
-        await (0, expect_1.expectSuccessfulResult)(result1, environment);
-        const node = cli.node('example');
-        const nodeState1 = result1.state.node[node.id];
-        expect(nodeState1.type).toEqual('completed');
-        if (nodeState1.type === 'completed') {
-            expect(nodeState1.duration).toBeGreaterThanOrEqual(100);
-        }
+        const task = cli.task('example');
+        const cacheBefore = await (0, enqueue_next_1.checkCacheState)(task, 'checksum', environment);
+        expect(cacheBefore.stateKey).not.toBeNull();
         if (action) {
             await action(environment);
         }
-        const result2 = await cli.exec();
-        await (0, expect_1.expectSuccessfulResult)(result2, environment);
-        const nodeState2 = result2.state.node[node.id];
-        expect(nodeState2.type).toEqual('completed');
-        if (nodeState2.type === 'completed') {
-            if (expectInvalidate) {
-                expect(nodeState2.cached).toBeFalsy();
-            }
-            else {
-                expect(nodeState2.cached).toBeTruthy();
-            }
+        const exampleAfter = cli.task('example');
+        const cacheAfter = await (0, enqueue_next_1.checkCacheState)(exampleAfter, 'checksum', environment);
+        expect(cacheAfter.stateKey).not.toBeNull();
+        if (expectInvalidate) {
+            expect(cacheAfter.stateKey).not.toEqual(cacheBefore.stateKey);
+        }
+        else {
+            expect(cacheAfter.stateKey).toEqual(cacheBefore.stateKey);
         }
     }
     it('should remove task after written cache', async () => {

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

@@ -7,13 +7,13 @@ describe('include', () => {
     afterAll(() => suite.close());
     it('should run included task', 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, `foo:bar`, 'foobar');
     });
     it('should get name:example', async () => {
         const { cli, environment } = await suite.setup({ taskName: 'name:example' });
-        const result = await cli.exec();
+        const result = await cli.runExec();
         await (0, expect_1.expectSuccessfulResult)(result, environment);
     });
     it('should get included task', async () => {
@@ -21,7 +21,7 @@ describe('include', () => {
         expect(cli.ls().map((n) => n.item.name)).toEqual(['foo:bar']);
         const item = cli.ls()[0];
         if (item.type === 'task') {
-            expect(item.item.cwd).toBe(suite.path);
+            expect(item.item.data.cwd).toBe(suite.path);
         }
         else {
             expect(item.type).toBe('task');

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

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const get_test_suite_1 = require("../get-test-suite");
-const work_scope_1 = require("../../executer/work-scope");
 describe('invalid', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('invalid', ['.hammerkit.yaml']);
     afterAll(() => suite.close());
     it('should throw on invalid yaml', async () => {
         try {
-            await suite.setup((0, work_scope_1.emptyWorkLabelScope)());
+            await suite.setup({});
             expect.fail('should not be called');
         }
         catch (e) {
-            expect(e.message).toStartWith('unable to parse');
+            expect(e.message.startsWith('unable to parse')).toBe(true);
         }
     });
 });

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

@@ -1,13 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const get_test_suite_1 = require("../get-test-suite");
+const test_case_1 = require("../test-case");
 describe('invalid', () => {
-    const suite = (0, get_test_suite_1.getTestSuite)('invalid_loop', ['.hammerkit.yaml']);
-    afterAll(() => suite.close());
     it('should detect loop in execution', async () => {
-        const { cli } = await suite.setup({ taskName: 'foo' });
-        const result = await cli.exec();
-        expect(result.success).toBeFalsy();
+        const testCase = (0, test_case_1.createTestCase)('invalid_loop', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    bar: {
+                        deps: ['foo'],
+                        cmds: ['echo bar'],
+                    },
+                    foo: {
+                        deps: ['bar'],
+                        cmds: ['echo foo'],
+                    },
+                },
+            },
+        });
+        await testCase.cli({ taskName: 'foo' }, async (cli) => {
+            const result = await cli.runExec();
+            expect(result.success).toBeFalsy();
+        });
+    });
+    it('should detect loop in services', async () => {
+        const testCase = (0, test_case_1.createTestCase)('invalid_loop', {
+            '.hammerkit.yaml': {
+                services: {
+                    foodb: {
+                        image: 'postgres:12-alpine',
+                        volumes: ['foo:/var/lib/postgresql/data'],
+                        needs: ['bardb'],
+                        ports: [':5432'],
+                    },
+                    bardb: {
+                        image: 'postgres:12-alpine',
+                        volumes: ['bar:/var/lib/postgresql/data'],
+                        needs: ['foodb'],
+                        ports: [':5432'],
+                    },
+                },
+                tasks: {
+                    example: {
+                        needs: ['foodb'],
+                        cmds: ['echo bar'],
+                    },
+                },
+            },
+        });
+        await testCase.cli({ taskName: 'example' }, async (cli) => {
+            const result = await cli.runExec();
+            expect(result.success).toBeFalsy();
+        });
     });
 });
 //# sourceMappingURL=invalid_loop.spec.js.map

package/dist/testing/integration/k8s-state-cache.spec.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_case_1 = require("../test-case");
+const requires_kubernetes_1 = require("../requires-kubernetes");
+/**
+ * Regression test for the k8s currentStateKey caching wired up in
+ * feature/shared-services. Running `up` twice with no input change should
+ * produce a cached second run, not redeploy.
+ */
+describe('k8s deployment caches via hammerkit.dev/state label', () => {
+    const namespace = `hammerkit-cache-${(process.env.HAMMERKIT_TEST_RUN_ID ?? 'local').slice(0, 30)}`;
+    const suite = (0, test_case_1.createTestCase)('k8s-state-cache', {
+        '.hammerkit.yaml': {
+            services: {
+                redis: {
+                    image: 'redis:7-alpine',
+                    ports: [':6379'],
+                },
+            },
+            environments: {
+                default: {
+                    kubernetes: {
+                        namespace,
+                        context: process.env.CLUSTER_NAME || 'docker-desktop',
+                    },
+                },
+            },
+        },
+    });
+    it('second up() is a cache hit on the same state key', (0, requires_kubernetes_1.requiresKubernetes)(async () => {
+        await suite.cli({}, async (cli, env) => {
+            await cli.runUp({ daemon: true });
+            const firstKey = await cli.service('redis').runtime.currentStateKey(env);
+            expect(firstKey).not.toBeNull();
+            await cli.runUp({ daemon: true });
+            const secondKey = await cli.service('redis').runtime.currentStateKey(env);
+            expect(secondKey).toBe(firstKey);
+        });
+    }), 240000);
+});
+//# sourceMappingURL=k8s-state-cache.spec.js.map

package/dist/testing/integration/kubernetes-service.spec.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const requires_kubernetes_1 = require("../requires-kubernetes");
+const test_case_1 = require("../test-case");
+const client_node_1 = require("@kubernetes/client-node");
+const http_1 = require("http");
+// Exercises src/executer/kubernetes-service.ts end-to-end: hammerkit's
+// `kubernetes-service` type opens a local TCP server (one per published port)
+// that tunnels via the k8s API to a pod. We deploy nginx directly with the k8s
+// client, then point a hammerkit kubernetes-service at it, drive the lifecycle
+// (load kubeconfig -> resolve pod -> listen -> state `running`) and actually
+// HTTP-GET the forwarded port to prove data flows through to the pod.
+const RUN_ID = (process.env.HAMMERKIT_TEST_RUN_ID ?? 'local').slice(0, 30);
+const NS = `hammerkit-k8s-svc-${RUN_ID}`;
+const CTX = process.env.CLUSTER_NAME || 'docker-desktop';
+const HOST_PORT = 28080;
+const DEPLOY_NAME = 'nginx';
+function makeClients() {
+    const kc = new client_node_1.KubeConfig();
+    kc.loadFromDefault();
+    kc.setCurrentContext(CTX);
+    return {
+        coreApi: kc.makeApiClient(client_node_1.CoreV1Api),
+        appsApi: kc.makeApiClient(client_node_1.AppsV1Api),
+    };
+}
+async function ensureNamespace(coreApi) {
+    try {
+        await coreApi.readNamespace(NS);
+        return;
+    }
+    catch {
+        /* missing */
+    }
+    try {
+        await coreApi.createNamespace({ metadata: { name: NS } });
+    }
+    catch {
+        /* racing creator */
+    }
+}
+async function applyNginx(coreApi, appsApi) {
+    await appsApi.deleteNamespacedDeployment(DEPLOY_NAME, NS).catch(() => undefined);
+    await appsApi.createNamespacedDeployment(NS, {
+        metadata: { name: DEPLOY_NAME, labels: { app: DEPLOY_NAME } },
+        spec: {
+            replicas: 1,
+            selector: { matchLabels: { app: DEPLOY_NAME } },
+            template: {
+                metadata: { labels: { app: DEPLOY_NAME } },
+                spec: {
+                    containers: [{ name: DEPLOY_NAME, image: 'nginx:1.25-alpine', ports: [{ containerPort: 80 }] }],
+                },
+            },
+        },
+    });
+    const deadline = Date.now() + 90000;
+    while (Date.now() < deadline) {
+        const pods = await coreApi.listNamespacedPod(NS, undefined, undefined, undefined, undefined, `app=${DEPLOY_NAME}`);
+        const ready = pods.body.items.some((p) => p.status?.conditions?.some((c) => c.type === 'Ready' && c.status === 'True'));
+        if (ready)
+            return;
+        await new Promise((r) => setTimeout(r, 1000));
+    }
+    throw new Error(`nginx pod in ${NS} did not become ready in time`);
+}
+async function waitFor(predicate, timeoutMs, intervalMs = 200) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate())
+            return;
+        await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    throw new Error('waitFor: predicate never became true');
+}
+function httpGet(host, port, path) {
+    return new Promise((resolve, reject) => {
+        const req = (0, http_1.request)({ host, port, path, method: 'GET', timeout: 5000 }, (res) => {
+            let body = '';
+            res.on('data', (c) => (body += c));
+            res.on('end', () => resolve({ status: res.statusCode ?? 0, body }));
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('http timeout'));
+        });
+        req.end();
+    });
+}
+describe('kubernetes-service (port-forward)', () => {
+    const suite = (0, test_case_1.createTestCase)('k8s-service-forward', {
+        '.hammerkit.yaml': {
+            services: {
+                nginx: {
+                    context: CTX,
+                    namespace: NS,
+                    selector: { type: 'deployment', name: DEPLOY_NAME },
+                    ports: [`${HOST_PORT}:80`],
+                },
+            },
+            environments: {
+                default: {
+                    kubernetes: { context: CTX, namespace: NS },
+                },
+            },
+        },
+    });
+    beforeAll((0, requires_kubernetes_1.requiresKubernetes)(async () => {
+        const { coreApi, appsApi } = makeClients();
+        await ensureNamespace(coreApi);
+        await applyNginx(coreApi, appsApi);
+    }), 120000);
+    afterAll(async () => {
+        try {
+            const { coreApi } = makeClients();
+            await coreApi.deleteNamespace(NS).catch(() => undefined);
+        }
+        catch {
+            /* no cluster available */
+        }
+    });
+    it('forwards a kubernetes-service to a pod and tears down on abort', (0, requires_kubernetes_1.requiresKubernetes)(async () => {
+        await suite.cli({}, async (cli, env) => {
+            const exec = cli.up({ logMode: 'live' });
+            const done = exec.start();
+            try {
+                // state transitions to `running` only after the forward server's
+                // listen() resolves — proves loadKubeConfig + resolvePodName + the
+                // TCP listener setup all completed against a live cluster.
+                await waitFor(() => exec.state.current.services['nginx']?.state.current.type === 'running', 30000);
+                // and an actual byte round-trip through the forward confirms the
+                // per-connection portForward path (createServer callback) works too.
+                const res = await httpGet('127.0.0.1', HOST_PORT, '/');
+                expect(res.status).toBe(200);
+                expect(res.body).toMatch(/nginx/i);
+            }
+            finally {
+                env.abortCtrl.abort();
+                await done;
+            }
+            // abort triggers the finally block in kubernetesService: forwards close,
+            // state advances to `end`.
+            expect(exec.state.current.services['nginx']?.state.current.type).toBe('end');
+        });
+    }), 120000);
+});
+//# sourceMappingURL=kubernetes-service.spec.js.map