hammerkit 1.4.0 → 1.5.0-alpha.0

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

@@ -1,54 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const expect_1 = require("../expect");
-const plan_work_tree_1 = require("../../planner/utils/plan-work-tree");
 const get_test_suite_1 = require("../get-test-suite");
-const execute_1 = require("../../executer/execute");
 describe('env', () => {
-    const suite = get_test_suite_1.getTestSuite('env', ['build.yaml', '.env']);
+    const suite = (0, get_test_suite_1.getTestSuite)('env', ['build.yaml', '.env']);
     afterAll(() => suite.close());
     it('should use env from build file', async () => {
-        const { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        await expect_1.expectLog(result, `example`, '16.6.0');
+        const { cli, environment } = await suite.setup({ taskName: 'example' });
+        const result = await cli.exec();
+        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 () => {
-        const { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example_docker');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        await expect_1.expectLog(result, `example_docker`, '16.6.0');
+        const { cli, environment } = await suite.setup({ taskName: 'example_docker' });
+        const result = await cli.exec();
+        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 { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example_override');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        await expect_1.expectLog(result, `example_override`, '15.0.0');
+        const { cli, environment } = await suite.setup({ taskName: 'example_override' });
+        const result = await cli.exec();
+        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 { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example_with_dotenv');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        await expect_1.expectLog(result, `example_with_dotenv`, '123456');
+        const { cli, environment } = await suite.setup({ taskName: 'example_with_dotenv' });
+        const result = await cli.exec();
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
+        await (0, expect_1.expectLog)(result, environment, `example_with_dotenv`, '123456');
     });
     it('should use process env', async () => {
-        const { buildFile, executionContext } = await suite.setup();
-        executionContext.environment.processEnvs['VERSION'] = '1.0.0';
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example_with_shell_env');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        await expect_1.expectLog(result, `example_with_shell_env`, '1.0.0');
+        const { cli, environment } = await suite.setup({
+            taskName: 'example_with_shell_env',
+            envs: {
+                VERSION: '1.0.0',
+            },
+        });
+        const result = await cli.exec();
+        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 () => {
-        const { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example_with_shell_env');
-        const result = await execute_1.execute(workTree, executionContext);
-        expect(result.success).toBeFalsy();
-        //expect(result.nodes[`${buildFile.path}:example_with_shell_env`].type).toEqual('failed')
+        await expect(suite.setup({ taskName: 'example_with_shell_env' })).rejects.toThrow('missing env $VERSION');
     });
 });
 //# sourceMappingURL=env.spec.js.map

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

@@ -1,21 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const plan_work_tree_1 = require("../../planner/utils/plan-work-tree");
 const get_test_suite_1 = require("../get-test-suite");
-const execute_1 = require("../../executer/execute");
 describe('error', () => {
-    const suite = get_test_suite_1.getTestSuite('error', ['build.yaml']);
+    const suite = (0, get_test_suite_1.getTestSuite)('error', ['build.yaml']);
     afterAll(() => suite.close());
     it('should return error when local task failed', async () => {
-        const { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'local_error');
-        const result = await execute_1.execute(workTree, executionContext);
+        const { cli } = await suite.setup({ taskName: 'local_error' });
+        const result = await cli.exec();
         expect(result.success).toBeFalsy();
     });
     it('should return error when docker task failed', async () => {
-        const { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'docker_error');
-        const result = await execute_1.execute(workTree, executionContext);
+        const { cli } = await suite.setup({ taskName: 'docker_error' });
+        const result = await cli.exec();
         expect(result.success).toBeFalsy();
     });
 });

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_test_suite_1 = require("../get-test-suite");
+describe('extend', () => {
+    const suite = (0, get_test_suite_1.getTestSuite)('extend', ['build.yaml']);
+    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'],
+        ]);
+    });
+    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({
+            NAME: 'override',
+        });
+        expect(node.type).toBe('container');
+        if (node.type === 'container') {
+            expect(node.image).toBe('alpine');
+        }
+    });
+    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']);
+    });
+});
+//# sourceMappingURL=extend.spec.js.map

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

@@ -1,41 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const fs_1 = require("fs");
-const write_work_node_cache_1 = require("../../optimizer/write-work-node-cache");
-const optimize_1 = require("../../optimizer/optimize");
-const plan_work_tree_1 = require("../../planner/utils/plan-work-tree");
 const get_test_suite_1 = require("../get-test-suite");
+const expect_1 = require("../expect");
 describe('glob', () => {
-    const suite = get_test_suite_1.getTestSuite('glob', ['build.yaml', 'test.md', 'test.txt']);
+    const suite = (0, get_test_suite_1.getTestSuite)('glob', ['build.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);
+        }
+        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();
+            }
+        }
+    }
     it('should remove task after written cache', async () => {
-        const { buildFile, context, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        expect(workTree.nodes[workTree.rootNode.id].status.state.type).toEqual('pending');
-        await optimize_1.optimize(workTree, executionContext);
-        expect(workTree.nodes[workTree.rootNode.id].status.state.type).toEqual('pending');
-        await write_work_node_cache_1.writeWorkNodeCache(workTree.rootNode, context);
-        await optimize_1.optimize(workTree, executionContext);
-        expect(workTree.nodes[workTree.rootNode.id].status.state.type).toEqual('completed');
+        await testCache(false);
     });
     it('should keep being cached after ignored file changed', async () => {
-        const { buildFile, context, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        expect(workTree.nodes[workTree.rootNode.id].status.state.type).toEqual('pending');
-        await write_work_node_cache_1.writeWorkNodeCache(workTree.rootNode, context);
-        fs_1.appendFileSync(path_1.join(buildFile.path, 'test.txt'), '\n');
-        await optimize_1.optimize(workTree, executionContext);
-        expect(workTree.nodes[workTree.rootNode.id].status.state.type).toEqual('completed');
+        await testCache(false, async (env) => {
+            await env.file.appendFile('test.txt', '\n');
+        });
     });
     it('should invalid cache after file has changed', async () => {
-        const { buildFile, context, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        expect(workTree.nodes[workTree.rootNode.id].status.state.type).toEqual('pending');
-        await write_work_node_cache_1.writeWorkNodeCache(workTree.rootNode, context);
-        fs_1.appendFileSync(path_1.join(buildFile.path, 'test.md'), '\n');
-        await optimize_1.optimize(workTree, executionContext);
-        expect(workTree.nodes[workTree.rootNode.id].status.state.type).toEqual('pending');
+        await testCache(true, async (env) => {
+            await env.file.appendFile('test.md', '\n');
+        });
     });
 });
 //# sourceMappingURL=glob.spec.js.map

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

@@ -1,30 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const expect_1 = require("../expect");
-const plan_work_tree_1 = require("../../planner/utils/plan-work-tree");
 const get_test_suite_1 = require("../get-test-suite");
-const execute_1 = require("../../executer/execute");
 describe('include', () => {
-    const suite = get_test_suite_1.getTestSuite('include', ['build.yaml', 'foo', 'foobar.txt']);
+    const suite = (0, get_test_suite_1.getTestSuite)('include', ['build.yaml', 'foo', 'foobar.txt']);
     afterAll(() => suite.close());
     it('should run included task', async () => {
-        const { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        await expect_1.expectLog(result, `foo:bar`, 'foobar');
+        const { cli, environment } = await suite.setup({ taskName: 'example' });
+        const result = await cli.exec();
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
+        await (0, expect_1.expectLog)(result, environment, `foo:bar`, 'foobar');
     });
     it('should get name:example', async () => {
-        const { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'name:example');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
+        const { cli, environment } = await suite.setup({ taskName: 'name:example' });
+        const result = await cli.exec();
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
     });
     it('should get included task', async () => {
-        const { buildFile } = await suite.setup();
-        const tree = plan_work_tree_1.planWorkTree(buildFile, 'foo:bar');
-        expect(tree.rootNode.name).toEqual('foo:bar');
-        expect(tree.rootNode.cwd).toEqual(buildFile.path);
+        const { cli } = await suite.setup({ taskName: 'foo:bar' });
+        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);
+        }
+        else {
+            expect(item.type).toBe('task');
+        }
     });
 });
 //# sourceMappingURL=include.spec.js.map

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

@@ -1,12 +1,13 @@
 "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 = get_test_suite_1.getTestSuite('invalid', ['build.yaml']);
+    const suite = (0, get_test_suite_1.getTestSuite)('invalid', ['build.yaml']);
     afterAll(() => suite.close());
     it('should throw on invalid yaml', async () => {
         try {
-            await suite.setup();
+            await suite.setup((0, work_scope_1.emptyWorkLabelScope)());
             expect.fail('should not be called');
         }
         catch (e) {

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_test_suite_1 = require("../get-test-suite");
+describe('invalid', () => {
+    const suite = (0, get_test_suite_1.getTestSuite)('invalid_loop', ['build.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();
+    });
+});
+//# sourceMappingURL=invalid_loop.spec.js.map

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_test_suite_1 = require("../get-test-suite");
+const expect_1 = require("../expect");
+describe('kubernetes', () => {
+    const suite = (0, get_test_suite_1.getTestSuite)('kubernetes', ['index.js', 'package.json', 'package-lock.json', 'build.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);
+    });
+});
+//# sourceMappingURL=kubernetes.spec.js.map

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_test_suite_1 = require("../get-test-suite");
+describe('local', () => {
+    const suite = (0, get_test_suite_1.getTestSuite)('labels', ['build.yaml']);
+    afterAll(() => suite.close());
+    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 () => {
+        const { cli } = await suite.setup({
+            filterLabels: {},
+            excludeLabels: { app: ['foo'] },
+        });
+        expectNodes(cli.ls(), ['bar', 'base']);
+    });
+    it('should exclude base labeled nodes', 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 () => {
+        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);
+}
+//# sourceMappingURL=labels.spec.js.map

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

@@ -1,17 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const expect_1 = require("../expect");
-const plan_work_tree_1 = require("../../planner/utils/plan-work-tree");
 const get_test_suite_1 = require("../get-test-suite");
-const execute_1 = require("../../executer/execute");
 describe('local', () => {
-    const suite = get_test_suite_1.getTestSuite('local', ['build.yaml']);
+    const suite = (0, get_test_suite_1.getTestSuite)('local', ['build.yaml']);
     afterAll(() => suite.close());
     it('should run local task', async () => {
-        const { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
+        const { cli, environment } = await suite.setup({ taskName: 'example' });
+        const result = await cli.exec();
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
     });
 });
 //# sourceMappingURL=local.spec.js.map

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

@@ -1,19 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const expect_1 = require("../expect");
-const plan_work_tree_1 = require("../../planner/utils/plan-work-tree");
-const clean_1 = require("../../executer/clean");
 const get_test_suite_1 = require("../get-test-suite");
-const execute_1 = require("../../executer/execute");
 describe('monorepo', () => {
-    const suite = get_test_suite_1.getTestSuite('monorepo', ['build.yaml', 'projects', 'build.npm.yaml', 'build.tsc.yaml']);
+    const suite = (0, get_test_suite_1.getTestSuite)('monorepo', ['build.yaml', 'projects', 'build.npm.yaml', 'build.tsc.yaml']);
     afterAll(() => suite.close());
     it('should build and clean monorepo', async () => {
-        const { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'build');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        await clean_1.clean(workTree.nodes, executionContext.environment, executionContext.executor);
+        const { cli, environment } = await suite.setup({ taskName: 'build' });
+        const result = await cli.exec();
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
+        await cli.clean();
     }, 120000);
 });
 //# sourceMappingURL=monorepo.spec.js.map

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

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const get_test_suite_1 = require("../get-test-suite");
 describe('multi-line', () => {
-    const suite = get_test_suite_1.getTestSuite('multi-line', ['build.yaml']);
+    const suite = (0, get_test_suite_1.getTestSuite)('multi-line', ['build.yaml']);
     afterAll(() => suite.close());
     it('should get multi lines', async () => {
-        const { buildFile } = await suite.setup();
-        const task = buildFile.tasks['example'];
-        expect(task.cmds || []).toEqual([
+        const { cli } = await suite.setup({ taskName: 'example' });
+        const task = cli.node('example');
+        expect((task.cmds || []).map((c) => c.cmd)).toEqual([
             'some very long cmd continues on line 2',
             'some other very long cmd continues on line 2',
         ]);

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

@@ -5,9 +5,9 @@ const get_test_context_1 = require("../get-test-context");
 const program_1 = require("../../program");
 describe('program', () => {
     async function testCommand(commandArgs) {
-        const fileName = path_1.join(__dirname, '../../../examples/program');
-        const context = get_test_context_1.getTestContext(fileName);
-        const { program, args } = await program_1.getProgram(context, [process.argv[0], fileName, ...commandArgs]);
+        const fileName = (0, path_1.join)(__dirname, '../../../examples/program');
+        const context = (0, get_test_context_1.getTestContext)(fileName);
+        const { program, args } = await (0, program_1.getProgram)(context, [process.argv[0], fileName, ...commandArgs]);
         return new Promise((resolve, reject) => {
             program
                 .exitOverride((err) => {
@@ -18,13 +18,6 @@ describe('program', () => {
                 .then(() => resolve());
         });
     }
-    it('should get help with description', async () => {
-        const fileName = path_1.join(__dirname, '../../../examples/program');
-        const context = get_test_context_1.getTestContext(fileName);
-        const { program } = await program_1.getProgram(context, process.argv);
-        const help = program.exitOverride().helpInformation({ error: false });
-        expect(help).toContain('example [options]  install npm packages');
-    });
     it('should run when cache is up to date and --no-cache arg is passed', async () => {
         await testCommand(['example', '--cache', 'none']);
     }, 120000);

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

@@ -1,25 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const expect_1 = require("../expect");
-const plan_work_tree_1 = require("../../planner/utils/plan-work-tree");
-const plan_work_nodes_1 = require("../../planner/utils/plan-work-nodes");
 const get_test_suite_1 = require("../get-test-suite");
-const execute_1 = require("../../executer/execute");
+const work_scope_1 = require("../../executer/work-scope");
 describe('reference', () => {
-    const suite = get_test_suite_1.getTestSuite('reference', ['build.yaml', 'foo']);
+    const suite = (0, get_test_suite_1.getTestSuite)('reference', ['build.yaml', 'foo']);
     afterAll(() => suite.close());
     it('should run included task', async () => {
-        const { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        await expect_1.expectLog(result, `foo:bar`, 'foobar');
-        await expect_1.expectLog(result, `example`, 'hammertime');
+        const { cli, environment } = await suite.setup({ taskName: 'example' });
+        const result = await cli.exec();
+        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 { buildFile } = await suite.setup();
-        const node = plan_work_nodes_1.planWorkNodes(buildFile);
-        expect(Object.values(node).map((t) => t.name)).toEqual(['example', 'foo:bar', 'foo:sub:sub']);
+        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']);
     });
 });
 //# sourceMappingURL=reference.spec.js.map

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_test_suite_1 = require("../get-test-suite");
+const expect_1 = require("../expect");
+describe('services', () => {
+    const suite = (0, get_test_suite_1.getTestSuite)('services', ['index.js', 'config.json', 'package.json', 'package-lock.json', 'build.yaml']);
+    afterAll(() => suite.close());
+    it('should run service', async () => {
+        const { cli, environment } = await suite.setup({ taskName: 'api' });
+        const result = await cli.exec();
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
+    }, 120000);
+});
+//# sourceMappingURL=services.spec.js.map

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

@@ -1,49 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
-const expect_1 = require("../expect");
-const restore_1 = require("../../executer/restore");
-const plan_work_tree_1 = require("../../planner/utils/plan-work-tree");
-const store_1 = require("../../executer/store");
-const clean_1 = require("../../executer/clean");
-const plan_work_nodes_1 = require("../../planner/utils/plan-work-nodes");
 const get_test_suite_1 = require("../get-test-suite");
-const execute_1 = require("../../executer/execute");
 const fs_1 = require("fs");
-const get_local_executor_1 = require("../../executer/get-local-executor");
+const expect_1 = require("../expect");
 describe('store/restore', () => {
-    const suite = get_test_suite_1.getTestSuite('store-restore', ['build.yaml', 'package.json']);
+    const suite = (0, get_test_suite_1.getTestSuite)('store-restore', ['build.yaml', 'package.json']);
     afterAll(() => suite.close());
-    it('should clean created outputs locally', async () => {
-        const { buildFile, context, executionContext } = await suite.setup();
-        executionContext.cacheMethod = 'none';
-        executionContext.executor = get_local_executor_1.getLocalExecutor();
-        const outputPath = path_1.join(buildFile.path, 'test-output');
-        const generatedPath = path_1.join(buildFile.path, 'node_modules');
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        expect(fs_1.existsSync(generatedPath)).toBeTruthy();
-        expect(fs_1.existsSync(outputPath)).toBeFalsy();
-        await store_1.store(workTree.nodes, outputPath, context, executionContext.executor);
-        await clean_1.clean(workTree.nodes, context, executionContext.executor);
-        expect(fs_1.existsSync(outputPath)).toBeTruthy();
-        expect(fs_1.existsSync(generatedPath)).toBeFalsy();
-        await restore_1.restore(workTree.nodes, outputPath, context, executionContext.executor);
-        expect(fs_1.existsSync(outputPath)).toBeTruthy();
-        expect(fs_1.existsSync(generatedPath)).toBeTruthy();
+    it('should clean and restore created outputs locally', async () => {
+        const { cli, environment } = await suite.setup({ taskName: 'example' });
+        const generatedPath = (0, path_1.join)(environment.cwd, 'node_modules');
+        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({});
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
+        expect((0, fs_1.existsSync)(generatedPath)).toBeTruthy();
+        expect((0, fs_1.existsSync)(cacheStoragePath)).toBeFalsy();
+        await cli.store(cacheStoragePath);
+        expect((0, fs_1.existsSync)(cacheStoragePath)).toBeTruthy();
+        await cli.clean();
+        expect((0, fs_1.existsSync)(generatedPath)).toBeFalsy();
+        await cli.restore(cacheStoragePath);
+        expect((0, fs_1.existsSync)(generatedPath)).toBeTruthy();
+        const execAfterRestore = await cli.exec();
+        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();
+        }
     });
-    it('should not store anything if nothing got generated', async () => {
-        const { buildFile, context, executionContext } = await suite.setup();
-        const workNodes = plan_work_nodes_1.planWorkNodes(buildFile);
-        const outputPath = path_1.join(buildFile.path, 'test-output');
-        const generatedPath = path_1.join(buildFile.path, 'node_modules');
-        expect(fs_1.existsSync(generatedPath)).toBeFalsy();
-        expect(fs_1.existsSync(outputPath)).toBeFalsy();
-        await store_1.store(workNodes, outputPath, context, executionContext.executor);
-        await restore_1.restore(workNodes, outputPath, context, executionContext.executor);
-        expect(fs_1.existsSync(generatedPath)).toBeFalsy();
-        expect(fs_1.existsSync(outputPath)).toBeFalsy();
+    it('should clean and restore created outputs in container', async () => {
+        const { cli, environment } = await suite.setup({ taskName: 'example:docker' });
+        const cacheStoragePath = (0, path_1.join)(environment.cwd, 'storage');
+        const firstExecResult = await cli.exec();
+        await (0, expect_1.expectSuccessfulResult)(firstExecResult, environment);
+        await cli.store(cacheStoragePath);
+        await cli.clean();
+        await cli.restore(cacheStoragePath);
+        const execAfterRestore = await cli.exec();
+        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();
+        }
     });
 });
 //# sourceMappingURL=store.spec.js.map