hammerkit 1.5.0 → 1.6.0-alpha.1

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

@@ -1,15 +1,99 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const get_test_suite_1 = require("../get-test-suite");
-const expect_1 = require("../expect");
+const requires_kubernetes_1 = require("../requires-kubernetes");
+const test_case_1 = require("../test-case");
 describe('kubernetes', () => {
-    const suite = (0, get_test_suite_1.getTestSuite)('kubernetes', ['index.js', 'package.json', 'package-lock.json', '.hammerkit.yaml']);
-    afterAll(() => suite.close());
-    // CI setup missing
-    xit('should forward deployment', async () => {
-        const { cli, environment } = await suite.setup({ taskName: 'api' });
-        const result = await cli.exec();
-        (0, expect_1.expectSuccessfulResult)(result, environment);
+    const suite = (0, test_case_1.createTestCase)('kubernetes', {
+        '.hammerkit.yaml': {
+            services: {
+                postgres: {
+                    image: 'postgres:12-alpine',
+                    envs: {
+                        POSTGRES_USER: 'postgres',
+                        POSTGRES_DB: 'demo',
+                        POSTGRES_PASSWORD: '123456',
+                    },
+                    volumes: ['data:/var/lib/postgresql/data'],
+                    ports: [':5432'],
+                },
+                api: {
+                    image: 'node:16.6.0-alpine',
+                    deps: ['install'],
+                    needs: ['postgres'],
+                    ports: [':3000'],
+                    labels: {
+                        app: 'example',
+                    },
+                    src: ['index.js'],
+                    cmd: 'node index.js',
+                },
+            },
+            tasks: {
+                install: {
+                    image: 'node:16.6.0-alpine',
+                    src: ['package.json'],
+                    generates: ['node_modules'],
+                    cmds: ['npm install'],
+                },
+            },
+            environments: {
+                default: {
+                    kubernetes: {
+                        namespace: `hammerkit-k8s-${(process.env.HAMMERKIT_TEST_RUN_ID ?? 'local').slice(0, 40)}`,
+                        context: process.env.CLUSTER_NAME || 'docker-desktop',
+                    },
+                },
+            },
+        },
+        'index.js': `const { Pool } = require('pg')
+const { createServer } = require('http')
+
+const pool = new Pool({
+  connectionString: 'postgres://api:123456@postgres:5432/api',
+})
+
+pool.on('error', () => {
+  console.error('pool has connection error')
+})
+
+const server = createServer(async function (req, res) {
+  let client
+  try {
+    client = await pool.connect()
+    const queryResult = await client.query('SELECT $1::text as message', ['Hello world from PG!'])
+
+    res.writeHead(200)
+    res.end(queryResult.rows[0].message)
+  } catch (e) {
+    res.writeHead(500)
+    res.end(e.message)
+  } finally {
+    client?.release()
+  }
+})
+
+process.on('SIGINT', async function () {
+  server.close()
+  await pool.end()
+})
+
+server.listen(3000, () => {
+  console.log(\`Server is running on http://0.0.0.0:3000\`)
+})
+`,
+        'package.json': `{
+  "name": "example-with-service",
+  "version": "1.0.0",
+  "dependencies": {
+    "pg": "^8.7.1"
+  }
+}
+`,
     });
+    it('should create deployment', (0, requires_kubernetes_1.requiresKubernetes)(async () => {
+        await suite.cli({}, async (cli) => {
+            await cli.runUp({ daemon: true });
+        });
+    }));
 });
 //# sourceMappingURL=kubernetes.spec.js.map

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

@@ -7,41 +7,36 @@ describe('local', () => {
     it('should run only run labeled task with app=bar and dependencies', async () => {
         const { cli } = await suite.setup({
             filterLabels: { app: ['bar'] },
-            excludeLabels: {},
         });
         expectNodes(cli.ls(), ['bar', 'base']);
     });
     it('should not run labeled task with app=foo and dependencies', async () => {
         const { cli } = await suite.setup({
             filterLabels: { app: ['foo'] },
-            excludeLabels: {},
         });
         expectNodes(cli.ls(), ['foo', 'base']);
     });
-    it('should exclude foo labeled nodes', async () => {
+    it('should exclude foo labeled tasks', async () => {
         const { cli } = await suite.setup({
-            filterLabels: {},
             excludeLabels: { app: ['foo'] },
         });
         expectNodes(cli.ls(), ['bar', 'base']);
     });
-    it('should exclude base labeled nodes', async () => {
+    it('should exclude base labeled tasks', async () => {
         const { cli } = await suite.setup({
-            filterLabels: {},
             excludeLabels: { app: ['base'] },
         });
         expectNodes(cli.ls(), []);
     });
-    it('should run nodes with label app=bar or app=foo', async () => {
+    it('should run tasks with label app=bar or app=foo', async () => {
         const { cli } = await suite.setup({
             filterLabels: { app: ['foo', 'bar'] },
-            excludeLabels: {},
         });
         expectNodes(cli.ls(), ['foo', 'bar', 'base']);
     });
 });
-function expectNodes(nodes, expectedNodes) {
-    const nodeNames = Object.values(nodes).map((n) => n.item.name);
-    expect(nodeNames).toIncludeSameMembers(expectedNodes);
+function expectNodes(items, expectedNames) {
+    const itemNames = items.map((n) => n.item.name);
+    expect([...itemNames].sort()).toEqual([...expectedNames].sort());
 }
 //# sourceMappingURL=labels.spec.js.map

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

@@ -7,7 +7,7 @@ describe('local', () => {
     afterAll(() => suite.close());
     it('should run local 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);
     });
 });

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

@@ -2,14 +2,14 @@
 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('monorepo', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('monorepo', ['.hammerkit.yaml', 'projects', 'build.npm.yaml', 'build.tsc.yaml']);
     afterAll(() => suite.close());
-    it('should build and clean monorepo', async () => {
+    it('should build and clean monorepo', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         const { cli, environment } = await suite.setup({ taskName: 'build' });
-        const result = await cli.exec();
-        await (0, expect_1.expectSuccessfulResult)(result, environment);
+        await (0, expect_1.expectSuccessfulExecution)(cli.exec(), environment);
         await cli.clean();
-    }, 120000);
+    }), 900000);
 });
 //# sourceMappingURL=monorepo.spec.js.map

package/dist/testing/integration/multi-line.spec.js

@@ -6,12 +6,12 @@ describe('multi-line', () => {
     afterAll(() => suite.close());
     it('should get multi lines', async () => {
         const { cli } = await suite.setup({ taskName: 'example' });
-        const task = cli.node('example');
-        expect((task.cmds || []).map((c) => c.cmd)).toEqual([
+        const task = cli.task('example');
+        expect((task.data.cmds || []).map((c) => c.cmd)).toEqual([
             'some very long cmd continues on line 2',
             'some other very long cmd continues on line 2',
         ]);
-        expect(task.description).toEqual('Test multiline description');
+        expect(task.data.description).toEqual('Test multiline description');
     });
 });
 //# sourceMappingURL=multi-line.spec.js.map

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

@@ -2,21 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const expect_1 = require("../expect");
 const get_test_suite_1 = require("../get-test-suite");
-const work_scope_1 = require("../../executer/work-scope");
 describe('reference', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('reference', ['.hammerkit.yaml', 'foo']);
     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');
         await (0, expect_1.expectLog)(result, environment, `example`, 'hammertime');
     });
     it('should list task with references tasks nested', async () => {
-        const { cli } = await suite.setup((0, work_scope_1.emptyWorkLabelScope)());
-        const workNodes = cli.ls();
-        expect(workNodes.map((t) => t.item.name)).toEqual(['example', 'foo:bar', 'foo:sub:sub']);
+        const { cli } = await suite.setup({});
+        const workItems = cli.ls();
+        expect(workItems.map((t) => t.item.name)).toEqual(['foo:bardb', 'example', 'foo:bar', 'foo:sub:sub']);
     });
 });
 //# sourceMappingURL=reference.spec.js.map

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

@@ -2,19 +2,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const get_test_suite_1 = require("../get-test-suite");
 const expect_1 = require("../expect");
+const testing_timeout_1 = require("../testing-timeout");
+const requires_linux_containers_1 = require("../requires-linux-containers");
 describe('services', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('services', [
         'index.js',
+        'server.js',
         'config.json',
         'package.json',
         'package-lock.json',
         '.hammerkit.yaml',
     ]);
     afterAll(() => suite.close());
-    it('should run service', async () => {
-        const { cli, environment } = await suite.setup({ taskName: 'api' });
-        const result = await cli.exec();
+    it('should run with needed service', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
+        const { cli, environment } = await suite.setup({});
+        const result = await (0, testing_timeout_1.testingTimeout)(cli.up({ daemon: true }), 120000);
         await (0, expect_1.expectSuccessfulResult)(result, environment);
-    }, 120000);
+    }), 900000);
+    it('should start needs of service', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
+        const { cli, environment } = await suite.setup({ taskName: 'test' });
+        const result = await (0, testing_timeout_1.testingTimeout)(cli.exec(), 120000);
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
+    }), 900000);
+    it('should start services up', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
+        const { cli } = await suite.setup({
+            filterLabels: { task: ['dev'] },
+            excludeLabels: {},
+        });
+        const upResult = await (0, testing_timeout_1.testingTimeout)(cli.up({ daemon: true }));
+        expect(upResult.success).toBe(true);
+        const downResult = await cli.runDown();
+        expect(downResult.success).toBe(true);
+    }), 900000);
 });
 //# sourceMappingURL=services.spec.js.map

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

@@ -4,6 +4,7 @@ const path_1 = require("path");
 const get_test_suite_1 = require("../get-test-suite");
 const fs_1 = require("fs");
 const expect_1 = require("../expect");
+const requires_linux_containers_1 = require("../requires-linux-containers");
 describe('store/restore', () => {
     const suite = (0, get_test_suite_1.getTestSuite)('store-restore', ['.hammerkit.yaml', 'package.json']);
     afterAll(() => suite.close());
@@ -13,7 +14,7 @@ describe('store/restore', () => {
         const cacheStoragePath = (0, path_1.join)(environment.cwd, 'storage');
         expect((0, fs_1.existsSync)(generatedPath)).toBeFalsy();
         expect((0, fs_1.existsSync)(cacheStoragePath)).toBeFalsy();
-        const result = await cli.exec({});
+        const result = await cli.runExec({});
         await (0, expect_1.expectSuccessfulResult)(result, environment);
         expect((0, fs_1.existsSync)(generatedPath)).toBeTruthy();
         expect((0, fs_1.existsSync)(cacheStoragePath)).toBeFalsy();
@@ -23,31 +24,29 @@ describe('store/restore', () => {
         expect((0, fs_1.existsSync)(generatedPath)).toBeFalsy();
         await cli.restore(cacheStoragePath);
         expect((0, fs_1.existsSync)(generatedPath)).toBeTruthy();
-        const execAfterRestore = await cli.exec();
+        const execAfterRestore = await cli.runExec();
         await (0, expect_1.expectSuccessfulResult)(execAfterRestore, environment);
-        const node = cli.node('example');
-        const nodeState = execAfterRestore.state.node[node.id];
-        expect(nodeState.type).toBe('completed');
-        if (nodeState.type === 'completed') {
-            expect(nodeState.cached).toBeTruthy();
+        const taskState = execAfterRestore.state.tasks['example'];
+        expect(taskState.state.current.type).toBe('completed');
+        if (taskState.state.current.type === 'completed') {
+            expect(taskState.state.current.cached).toBeTruthy();
         }
     });
-    it('should clean and restore created outputs in container', async () => {
+    it('should clean and restore created outputs in container', (0, requires_linux_containers_1.requiresLinuxContainers)(async () => {
         const { cli, environment } = await suite.setup({ taskName: 'example:docker' });
         const cacheStoragePath = (0, path_1.join)(environment.cwd, 'storage');
-        const firstExecResult = await cli.exec();
+        const firstExecResult = await cli.runExec();
         await (0, expect_1.expectSuccessfulResult)(firstExecResult, environment);
         await cli.store(cacheStoragePath);
         await cli.clean();
         await cli.restore(cacheStoragePath);
-        const execAfterRestore = await cli.exec();
+        const execAfterRestore = await cli.runExec();
         await (0, expect_1.expectSuccessfulResult)(execAfterRestore, environment);
-        const node = cli.node('example:docker');
-        const nodeState = execAfterRestore.state.node[node.id];
-        expect(nodeState.type).toBe('completed');
-        if (nodeState.type === 'completed') {
-            expect(nodeState.cached).toBeTruthy();
+        const taskState = execAfterRestore.state.tasks['example:docker'];
+        expect(taskState.state.current.type).toBe('completed');
+        if (taskState.state.current.type === 'completed') {
+            expect(taskState.state.current.cached).toBeTruthy();
         }
-    }, 90000);
+    }), 900000);
 });
 //# sourceMappingURL=store.spec.js.map

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

@@ -1,26 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("jest-extended");
-const get_test_suite_1 = require("../get-test-suite");
+const test_case_1 = require("../test-case");
+const parse_error_1 = require("../../schema/parse-error");
 describe('unknown', () => {
-    const suite = (0, get_test_suite_1.getTestSuite)('unknown', ['.hammerkit.yaml']);
-    afterAll(() => suite.close());
-    async function validateTask(name, expectedErrors) {
-        const { cli } = await suite.setup({ taskName: name });
-        let i = 0;
-        for await (const message of cli.validate()) {
-            expect(expectedErrors[i++]).toEqual(message.message);
-        }
-        expect(i).toEqual(expectedErrors.length);
-    }
     it('should validate unknown props', async () => {
-        await validateTask('example', ['cmd is an unknown configuration']);
+        const testCase = (0, test_case_1.createTestCase)('wrong-cmd', {
+            '.hammerkit.yaml': {
+                example: {
+                    cmd: ['echo wrong cmd'],
+                },
+            },
+        });
+        await expect(testCase.cli({ taskName: 'example' })).rejects.toThrow(parse_error_1.ParseError);
     });
-    it('should validate unknown props for local tasks with docker keys', async () => {
-        await validateTask('invalid:local:example', ['mounts is an unknown configuration']);
-    });
-    it('should validate unknown props for docker tasks', async () => {
-        await validateTask('docker:example', ['mount is an unknown configuration']);
+    it('should validate unknown container props for local tasks', async () => {
+        const testCase = (0, test_case_1.createTestCase)('wrong-cmd', {
+            '.hammerkit.yaml': {
+                example: {
+                    cmds: ['echo hello'],
+                    mounts: ['/.npm:/.npm'],
+                },
+            },
+        });
+        await expect(testCase.cli({ taskName: 'example' })).rejects.toThrow(parse_error_1.ParseError);
     });
 });
 //# sourceMappingURL=unknown.spec.js.map

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

@@ -1,43 +1,160 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("jest-extended");
-const get_test_suite_1 = require("../get-test-suite");
+const test_case_1 = require("../test-case");
 describe('validate', () => {
-    const suite = (0, get_test_suite_1.getTestSuite)('validate', ['.hammerkit.yaml', 'build-loop.yaml']);
-    async function validateTask(name, expectedErrors) {
-        const { cli } = await suite.setup({ taskName: name });
-        let i = 0;
-        for await (const message of cli.validate()) {
-            expect(expectedErrors[i++]).toEqual(message.message);
-        }
-        expect(i).toEqual(expectedErrors.length);
+    async function validateTask(testCase, name, expectedErrors) {
+        await testCase.cli({ taskName: name }, async (cli) => {
+            let i = 0;
+            for await (const message of cli.validate()) {
+                expect(message.message).toEqual(expectedErrors[i++]);
+            }
+            expect(i).toEqual(expectedErrors.length);
+        });
     }
-    afterAll(() => suite.close());
-    it('should validate regular task', async () => {
-        await validateTask('regular_task', []);
+    it('should validate local task', async () => {
+        const testCase = (0, test_case_1.createTestCase)('valid_local_task', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    valid_local_task: {
+                        description: 'build code',
+                        cmds: ['make'],
+                    },
+                },
+            },
+        });
+        await validateTask(testCase, 'valid_local_task', []);
     });
-    it('should validate regular docker task', async () => {
-        await validateTask('regular_docker_task', []);
+    it('should validate container task', async () => {
+        const testCase = (0, test_case_1.createTestCase)('valid_container_task', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    valid_container_task: {
+                        image: 'alpine',
+                        description: 'build code',
+                        cmds: ['make'],
+                        mounts: ['/.kube:/.kube'],
+                    },
+                },
+            },
+        });
+        await validateTask(testCase, 'valid_container_task', []);
     });
-    it('should validate task without description', async () => {
-        await validateTask('missing_desc', ['missing description']);
+    it('should warn about tasks without description', async () => {
+        const testCase = (0, test_case_1.createTestCase)('missing_doc', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    missing_doc: {
+                        image: 'alpine',
+                        cmds: ['make'],
+                        mounts: ['/.kube:/.kube'],
+                    },
+                },
+            },
+        });
+        await validateTask(testCase, 'missing_doc', ['missing description']);
     });
-    it('should detect empty tasks', async () => {
-        await validateTask('empty', ['task is empty']);
+    it('should detect empty tasks without cmds', async () => {
+        const testCase = (0, test_case_1.createTestCase)('missing_cmd', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    missing_cmd: {
+                        image: 'alpine',
+                        description: 'build code',
+                        mounts: ['/.kube:/.kube'],
+                    },
+                },
+            },
+        });
+        await validateTask(testCase, 'missing_cmd', ['task is empty']);
     });
-    it('should allow only deps', async () => {
-        await validateTask('only_deps', []);
+    it('should allow only deps without cmds', async () => {
+        const testCase = (0, test_case_1.createTestCase)('dep_only', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    build: {
+                        cmds: ['make'],
+                        description: 'build code',
+                    },
+                    dep_only: {
+                        image: 'alpine',
+                        description: 'deps',
+                        deps: ['build'],
+                    },
+                },
+            },
+        });
+        await validateTask(testCase, 'dep_only', []);
     });
     it('should detect loop in dep', async () => {
-        await validateTask('loop_with_dep', ['task cycle detected loop_with_dep -> loop_with_dep']);
+        const testCase = (0, test_case_1.createTestCase)('loop_with_dep', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    loop_with_dep: {
+                        image: 'alpine',
+                        description: 'build code',
+                        cmds: ['make'],
+                        deps: ['loop_with_dep'],
+                    },
+                },
+            },
+        });
+        await validateTask(testCase, 'loop_with_dep', ['task cycle detected loop_with_dep -> loop_with_dep']);
     });
     it('should detect loop in refs', async () => {
-        await validateTask('loop_with_refs', ['task cycle detected loop_with_refs -> loop_with_refs']);
+        const testCase = (0, test_case_1.createTestCase)('loop_with_refs', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    loop_with_refs: {
+                        image: 'alpine',
+                        description: 'build code',
+                        cmds: ['make'],
+                        deps: ['ref:loop_with_refs'],
+                    },
+                },
+                references: { ref: '.hammerkit2.yaml' },
+            },
+            '.hammerkit2.yaml': {
+                tasks: {
+                    loop_with_refs: {
+                        deps: ['ref:loop_with_refs'],
+                        image: 'alpine',
+                        description: 'build code',
+                        cmds: ['make 2'],
+                    },
+                },
+                references: { ref: '.hammerkit.yaml' },
+            },
+        });
+        await validateTask(testCase, 'loop_with_refs', [
+            'task cycle detected loop_with_refs -> ref:loop_with_refs -> loop_with_refs',
+        ]);
     });
     it('should detect loop over multiple tasks', async () => {
-        await validateTask('loop_with_multiple_tasks', [
-            'task cycle detected loop_with_multiple_tasks -> loop_with_multiple_tasks_2 -> loop_with_multiple_tasks',
-        ]);
+        const testCase = (0, test_case_1.createTestCase)('loop_with_multiple_tasks', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    first: {
+                        image: 'alpine',
+                        description: 'build code',
+                        cmds: ['make 1'],
+                        deps: ['second'],
+                    },
+                    second: {
+                        image: 'alpine',
+                        description: 'build code',
+                        cmds: ['make 2'],
+                        deps: ['third'],
+                    },
+                    third: {
+                        image: 'alpine',
+                        description: 'build code',
+                        cmds: ['make 3'],
+                        deps: ['first'],
+                    },
+                },
+            },
+        });
+        await validateTask(testCase, 'first', ['task cycle detected first -> second -> third -> first']);
     });
 });
 //# sourceMappingURL=validate.spec.js.map

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

@@ -6,19 +6,22 @@ describe('watch-dependency', () => {
     afterAll(() => suite.close());
     it('should run watch task', async () => {
         const { cli, environment } = await suite.setup({ taskName: 'third' });
-        const thirdNode = cli.node('third');
-        const exec = cli.execWatch({ watch: true });
+        const thirdNode = cli.task('third');
+        const exec = await cli.exec({ watch: true });
         let content = '';
-        let changed = false;
-        exec.processManager.on(async (evt) => {
-            if (evt.type === 'ended' && evt.context.id === thirdNode.id) {
-                if (changed) {
+        let changedStateKey = '';
+        exec.state.on('test-status', async (evt) => {
+            const currentState = evt.tasks[thirdNode.name].state.current;
+            if (currentState.type === 'completed') {
+                if (changedStateKey != '' &&
+                    currentState.stateKey !== changedStateKey &&
+                    !environment.abortCtrl.signal.aborted) {
                     content = await environment.file.read('third.txt');
                     environment.abortCtrl.abort();
                 }
-                else {
+                else if (changedStateKey === '') {
                     await environment.file.appendFile('source.txt', 'world\n');
-                    changed = true;
+                    changedStateKey = currentState.stateKey;
                 }
             }
         });