hammerkit 1.4.0 → 1.5.0-alpha.0

package/dist/testing/cli.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCli = exports.isCliService = exports.isCliTask = void 0;
+const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
+const create_scheduler_state_1 = require("../executer/create-scheduler-state");
+const ci_1 = require("../utils/ci");
+const get_logger_1 = require("./get-logger");
+const hierarchy_scheduler_1 = require("../executer/hierarchy-scheduler");
+const event_cache_1 = require("../executer/event-cache");
+const validate_1 = require("../planner/validate");
+const start_watch_processes_1 = require("./start-watch-processes");
+const process_manager_1 = require("../executer/process-manager");
+const isCliTask = (val) => val.type === 'task';
+exports.isCliTask = isCliTask;
+const isCliService = (val) => val.type === 'service';
+exports.isCliService = isCliService;
+function getCli(workTree, environment) {
+    return {
+        execWatch(options) {
+            const processManager = new process_manager_1.ProcessManager(environment, options?.workers ?? 0);
+            const state = (0, create_scheduler_state_1.createSchedulerState)({
+                services: workTree.services,
+                nodes: workTree.nodes,
+                watch: options?.watch ?? false,
+                logMode: options?.logMode ?? ci_1.isCI ? 'live' : 'interactive',
+                cacheMethod: options?.cacheDefault ?? 'checksum',
+            });
+            const logMode = options?.logMode ?? (ci_1.isCI ? 'live' : 'interactive');
+            const logger = (0, get_logger_1.getLogger)(logMode, state, environment);
+            if (options?.watch) {
+                (0, start_watch_processes_1.startWatchProcesses)(state, processManager, environment);
+            }
+            return {
+                state,
+                start: async () => {
+                    const result = await (0, hierarchy_scheduler_1.schedule)(processManager, state, environment);
+                    await logger.complete(result, environment);
+                    return result;
+                },
+            };
+        },
+        async exec(options) {
+            return this.execWatch(options).start();
+        },
+        async clean() {
+            await (0, event_cache_1.cleanCache)(workTree, environment);
+        },
+        async restore(path) {
+            await (0, event_cache_1.restoreCache)(path, workTree, environment);
+        },
+        async store(path) {
+            await (0, event_cache_1.storeCache)(path, workTree, environment);
+        },
+        ls() {
+            return [
+                ...Array.from((0, plan_work_nodes_1.iterateWorkServices)(workTree.services)).map((item) => ({ item, type: 'service' })),
+                ...Array.from((0, plan_work_nodes_1.iterateWorkNodes)(workTree.nodes)).map((item) => ({ item, type: 'task' })),
+            ];
+        },
+        validate() {
+            return (0, validate_1.validate)(workTree, environment);
+        },
+        node(name) {
+            const node = Object.values(workTree.nodes).find((n) => n.name == name);
+            if (!node) {
+                throw new Error(`unable to find node ${name}`);
+            }
+            return node;
+        },
+    };
+}
+exports.getCli = getCli;
+//# sourceMappingURL=cli.js.map

package/dist/testing/create-build-file.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuildFile = void 0;
 const parse_build_file_1 = require("../parser/parse-build-file");
 function createBuildFile(env, buildFile) {
-    return parse_build_file_1.parseBuildFile(`${env.cwd}/build.yaml`, {}, buildFile, env);
+    return (0, parse_build_file_1.parseBuildFile)(`${env.cwd}/build.yaml`, {}, buildFile, env);
 }
 exports.createBuildFile = createBuildFile;
 //# sourceMappingURL=create-build-file.js.map

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

@@ -0,0 +1,54 @@
+"use strict";
+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 console_context_mock_1 = require("../console/console-context-mock");
+const work_node_status_1 = require("../planner/work-node-status");
+const program_1 = require("../program");
+const execute_docker_1 = require("../executer/execute-docker");
+class ExampleTestSuite {
+    constructor(exampleName, files) {
+        this.files = files;
+        this.tests = [];
+        this.exampleDirectory = (0, path_1.join)(__dirname, '../../examples/', exampleName);
+        this.path = (0, path_1.join)(process.cwd(), 'temp', exampleName);
+        this.file = (0, get_file_context_1.getFileContext)(this.path);
+    }
+    async close() {
+        for (const test of this.tests) {
+            await this.file.remove(test.cwd);
+        }
+    }
+    async setup(scope) {
+        await this.file.remove(this.path);
+        await this.file.createDirectory(this.path);
+        const environment = {
+            processEnvs: { ...process.env, ...(scope.envs ?? {}) },
+            abortCtrl: new AbortController(),
+            cwd: this.path,
+            file: this.file,
+            console: (0, console_context_mock_1.consoleContextMock)(),
+            status: (0, work_node_status_1.statusConsole)(),
+            docker: (0, execute_docker_1.getContainerCli)(),
+        };
+        for (const file of this.files) {
+            await this.file.copy((0, path_1.join)(this.exampleDirectory, file), (0, path_1.join)(this.path, file));
+        }
+        const fileName = (0, path_1.join)(this.path, 'build.yaml');
+        this.tests.push({
+            cwd: this.path,
+        });
+        const cli = await (0, program_1.createCli)(fileName, environment, scope);
+        await cli.clean({ service: true });
+        // reset cli clean stats
+        environment.console = (0, console_context_mock_1.consoleContextMock)();
+        environment.status = (0, work_node_status_1.statusConsole)();
+        return {
+            cli,
+            environment,
+        };
+    }
+}
+exports.ExampleTestSuite = ExampleTestSuite;
+//# sourceMappingURL=example-test-suite.js.map

package/dist/testing/expect.js

@@ -1,17 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectContainsLog = exports.expectLog = exports.expectSuccessfulResult = void 0;
-async function expectSuccessfulResult(result) {
+const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
+async function expectSuccessfulResult(result, env) {
     if (!result.success) {
-        for (const nodeId of Object.keys(result.nodes)) {
-            const node = result.nodes[nodeId];
-            if (node.state.type === 'failed') {
+        for (const state of (0, plan_work_nodes_1.iterateWorkNodes)(result.state.node)) {
+            if (state.type !== 'completed') {
                 expect({
-                    nodeId,
-                    status: node.state.type,
-                    logs: await node.console.read(),
+                    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) => ({
+                        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}`),
+                    })),
                 }).toEqual({
-                    nodeId,
+                    nodeId: state.node.id,
                     status: 'completed',
                 });
             }
@@ -19,23 +26,28 @@ async function expectSuccessfulResult(result) {
     }
 }
 exports.expectSuccessfulResult = expectSuccessfulResult;
-function getNode(result, name) {
-    const node = Object.values(result.nodes).find((n) => n.name === name);
+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}`);
     }
     return node;
 }
-async function expectLog(result, name, message) {
-    const node = getNode(result, name);
-    const logs = await node.console.read();
-    expect(logs.map((l) => l.message)).toContain(message);
+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);
+    expect(logs).toContain(message);
 }
 exports.expectLog = expectLog;
-async function expectContainsLog(result, name, message) {
-    const node = getNode(result, name);
-    const logs = await node.console.read();
-    expect(logs.some((l) => l.message.indexOf(message))).toBeTruthy();
+async function expectContainsLog(result, env, name, message) {
+    const state = getNodeState(result.state, name);
+    const logs = env.status.task(state.node).logs();
+    for (const log of logs) {
+        if (log.message.indexOf(message) >= 0) {
+            return;
+        }
+    }
+    expect(Array.from(logs)).toContain(message);
 }
 exports.expectContainsLog = expectContainsLog;
 //# sourceMappingURL=expect.js.map

package/dist/testing/get-logger.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = void 0;
+const grouped_logger_1 = require("../logging/grouped-logger");
+const live_logger_1 = require("../logging/live-logger");
+const interactive_logger_1 = require("../logging/interactive-logger");
+const fail_never_1 = require("../utils/fail-never");
+function getLogger(mode, state, env) {
+    if (mode === 'grouped') {
+        return (0, grouped_logger_1.groupedLogger)(state, env);
+    }
+    else if (mode === 'live') {
+        return (0, live_logger_1.liveLogger)(state, env);
+    }
+    else if (mode === 'interactive') {
+        return (0, interactive_logger_1.interactiveLogger)(state, env);
+    }
+    else {
+        (0, fail_never_1.failNever)(mode, 'unknown log mode');
+    }
+}
+exports.getLogger = getLogger;
+//# sourceMappingURL=get-logger.js.map

package/dist/testing/get-node.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNode = void 0;
-function getNode(buildFile, workTree, taskName) {
-    const node = Object.values(workTree.nodes).find((n) => n.name === taskName);
+function getNode(buildFile, nodes, taskName) {
+    const node = Object.values(nodes).find((n) => n.name === taskName);
     if (!node) {
         throw new Error(`could not find node ${taskName}`);
     }

package/dist/testing/get-test-context.js

@@ -2,14 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTestContext = void 0;
 const get_file_context_1 = require("../file/get-file-context");
-const get_console_context_mock_1 = require("../console/get-console-context-mock");
+const work_node_status_1 = require("../planner/work-node-status");
+const log_1 = require("../log");
 function getTestContext(cwd) {
     const context = {
         processEnvs: { ...process.env },
         abortCtrl: new AbortController(),
         cwd,
-        file: get_file_context_1.getFileContext(),
-        console: get_console_context_mock_1.getConsoleContextMock(),
+        file: (0, get_file_context_1.getFileContext)(cwd),
+        console: (0, log_1.consoleContext)(),
+        status: (0, work_node_status_1.statusConsole)(),
     };
     return context;
 }

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

@@ -1,57 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTestSuite = void 0;
-const path_1 = require("path");
-const get_build_file_1 = require("../parser/get-build-file");
-const get_docker_executor_1 = require("../executer/get-docker-executor");
-const get_console_context_mock_1 = require("../console/get-console-context-mock");
-const get_file_context_1 = require("../file/get-file-context");
-const emitter_1 = require("../utils/emitter");
-const clean_1 = require("../executer/clean");
-const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
+const example_test_suite_1 = require("./example-test-suite");
 function getTestSuite(exampleName, files) {
-    const exampleDirectory = path_1.join(__dirname, '../../examples/', exampleName);
-    const testDirectory = path_1.join(process.cwd(), 'temp', exampleName);
-    const file = get_file_context_1.getFileContext();
-    const tests = [];
-    return {
-        async close() {
-            for (const test of tests) {
-                await file.remove(test.cwd);
-            }
-        },
-        async setup(executionOptions) {
-            const context = {
-                processEnvs: { ...process.env },
-                abortCtrl: new AbortController(),
-                cwd: testDirectory,
-                file,
-                console: get_console_context_mock_1.getConsoleContextMock(),
-            };
-            await file.remove(testDirectory);
-            await file.createDirectory(testDirectory);
-            for (const file of files) {
-                await context.file.copy(path_1.join(exampleDirectory, file), path_1.join(testDirectory, file));
-            }
-            const fileName = path_1.join(testDirectory, 'build.yaml');
-            const buildFile = await get_build_file_1.getBuildFile(fileName, context);
-            const workNodes = plan_work_nodes_1.planWorkNodes(buildFile);
-            const executor = get_docker_executor_1.getDockerExecutor();
-            await clean_1.clean(workNodes, context, executor);
-            const executionContext = {
-                environment: context,
-                watch: executionOptions?.watch ?? false,
-                cacheMethod: executionOptions?.cacheMethod ?? 'checksum',
-                workers: executionOptions?.workers ?? 0,
-                events: emitter_1.emitter(),
-                executor,
-            };
-            tests.push({
-                cwd: testDirectory,
-            });
-            return { buildFile, context, executionContext };
-        },
-    };
+    return new example_test_suite_1.ExampleTestSuite(exampleName, files);
 }
 exports.getTestSuite = getTestSuite;
 //# sourceMappingURL=get-test-suite.js.map

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

@@ -3,50 +3,47 @@ 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 plan_work_tree_1 = require("../../planner/utils/plan-work-tree");
-const execute_1 = require("../../executer/execute");
-const optimize_1 = require("../../optimizer/optimize");
 const get_test_suite_1 = require("../get-test-suite");
 const path_1 = require("path");
-const get_node_1 = require("../get-node");
-const work_node_id_1 = require("../../planner/work-node-id");
+const enqueue_next_1 = require("../../executer/scheduler/enqueue-next");
+const read_build_file_1 = require("../../parser/read-build-file");
 describe('cache', () => {
-    const suite = get_test_suite_1.getTestSuite('cache', ['build.yaml', 'package.json', 'package-lock.json']);
+    const suite = (0, get_test_suite_1.getTestSuite)('cache', ['build.yaml', 'package.json', 'package-lock.json']);
     afterAll(() => suite.close());
     async function testCache(action, expectInvalidate) {
-        const { buildFile, context, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        expect(workTree.nodes).toContainKey(workTree.rootNode.id);
-        await write_work_node_cache_1.writeWorkNodeCache(workTree.nodes[workTree.rootNode.id], context);
-        await action(buildFile, workTree, executionContext);
-        await optimize_1.optimize(workTree, executionContext);
+        const setupBefore = await suite.setup({ taskName: 'example' });
+        const nodeBefore = setupBefore.cli.node('example');
+        await (0, write_work_node_cache_1.writeWorkNodeCache)(nodeBefore, 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);
         if (expectInvalidate) {
-            expect(workTree.nodes[workTree.rootNode.id].status.state.type).toEqual('pending');
+            expect(checksumUpToDate.cached).toBeFalsy();
+            expect(modifyDateUpToDate.cached).toBeFalsy();
         }
         else {
-            expect(workTree.nodes[workTree.rootNode.id].status.state.type).toEqual('completed');
+            expect(checksumUpToDate.cached).toBeTruthy();
+            expect(modifyDateUpToDate.cached).toBeTruthy();
         }
     }
     it('should run invalid cache on src file change', async () => {
-        await testCache(async (buildFile, workTree, context) => {
-            await context.environment.file.appendFile(path_1.join(context.environment.cwd, 'package.json'), '\n');
+        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 () => {
-        const { buildFile, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'dependant');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        await expect_1.expectLog(result, `dependant`, 'node_modules');
+        const { cli, environment } = await suite.setup({ taskName: 'dependant' });
+        const result = await cli.exec();
+        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 () => {
-        await testCache(async (buildFile, workTree) => {
-            const node = get_node_1.getNode(buildFile, workTree, 'example');
-            node.image = '15.0.0';
-            node.mergedTask.image = '15.0.0';
-            delete workTree.nodes[node.id];
-            node.id = work_node_id_1.getWorkNodeId(node.cwd, node.mergedTask, node.mergedDeps);
-            workTree.nodes[node.id] = node;
+        await testCache(async (environment) => {
+            const buildFile = await (0, read_build_file_1.read)('build.yaml', environment);
+            buildFile.tasks['example'].image = '15.0.0';
+            await (0, read_build_file_1.write)('build.yaml', buildFile, environment);
         }, true);
     });
 });

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

@@ -1,42 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
-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('cancellation', () => {
-    const suite = get_test_suite_1.getTestSuite('cancellation', ['build.yaml']);
+    const suite = (0, get_test_suite_1.getTestSuite)('cancellation', ['build.yaml']);
     afterAll(() => suite.close());
     async function testAbort(taskName, expectedState) {
-        const { buildFile, context, executionContext } = await suite.setup();
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, taskName);
-        executionContext.events.on((evt) => {
-            if (evt.newState.type === 'running' && !executionContext.environment.abortCtrl.signal.aborted) {
-                evt.workTree.nodes[evt.nodeId].status.console.on((log) => {
-                    if (log.message.startsWith('execute cmd ')) {
-                        setTimeout(() => {
-                            executionContext.environment.abortCtrl.abort();
-                        }, 2000);
-                    }
-                });
+        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) {
+                environment.abortCtrl.abort();
             }
         });
-        const result = await execute_1.execute(workTree, executionContext);
+        const result = await exec.start();
         expect(result.success).toBeFalsy();
-        expect(result.nodes[workTree.rootNode.id].state.type).toEqual(expectedState);
-        expect(await context.file.exists(path_1.join(buildFile.path, 'test'))).toBeFalsy();
+        if (abortNode) {
+            expect(result.state.node[abortNode.node.id].type).toEqual(expectedState);
+        }
+        else {
+            expect(abortNode).toBeDefined();
+        }
+        expect(await environment.file.exists((0, path_1.join)(suite.path, 'test'))).toBeFalsy();
     }
     it('should cancel local task with dependencies', async () => {
-        await testAbort('local_cancel', 'aborted');
+        await testAbort('local_cancel', 'canceled');
     });
     it('should cancel local task', async () => {
-        await testAbort('long_running_local', 'aborted');
+        await testAbort('long_running_local', 'canceled');
     });
     it('should cancel docker task', async () => {
-        await testAbort('long_running_docker', 'aborted');
+        await testAbort('long_running_docker', 'canceled');
     });
     it('should cancel docker task with dependencies', async () => {
-        await testAbort('local_cancel', 'aborted');
+        await testAbort('docker_cancel', 'canceled');
     });
 });
 //# sourceMappingURL=cancellation.spec.js.map

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

@@ -3,41 +3,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const fs_1 = require("fs");
 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");
-const get_local_executor_1 = require("../../executer/get-local-executor");
-const execute_docker_1 = require("../../executer/execute-docker");
 const get_docker_executor_1 = require("../../executer/get-docker-executor");
+const plan_work_volume_1 = require("../../planner/utils/plan-work-volume");
 describe('clean', () => {
-    const suite = get_test_suite_1.getTestSuite('clean', ['build.yaml', 'package.json']);
+    const suite = (0, get_test_suite_1.getTestSuite)('clean', ['build.yaml', 'package.json']);
     afterAll(() => suite.close());
     it('should clean generated outputs locally', async () => {
-        const { buildFile, context, executionContext } = await suite.setup();
-        executionContext.executor = get_local_executor_1.getLocalExecutor();
-        executionContext.cacheMethod = 'none';
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        const outputPath = path_1.join(buildFile.path, 'node_modules');
-        expect(fs_1.existsSync(outputPath)).toBeTruthy();
-        await clean_1.clean(workTree.nodes, context, executionContext.executor);
-        expect(fs_1.existsSync(outputPath)).toBeFalsy();
+        const { cli, environment } = await suite.setup({ taskName: 'example' });
+        const result = await cli.exec({ 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 () => {
-        const { buildFile, context, executionContext } = await suite.setup();
-        executionContext.executor = get_docker_executor_1.getDockerExecutor();
-        executionContext.cacheMethod = 'none';
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
-        const outputPath = path_1.join(buildFile.path, 'node_modules');
-        const volumeName = execute_docker_1.getVolumeName(outputPath);
-        const docker = execute_docker_1.getDocker();
-        expect(await get_docker_executor_1.existsVolume(docker, volumeName)).toBeTruthy();
-        await clean_1.clean(workTree.nodes, context, executionContext.executor);
-        expect(await get_docker_executor_1.existsVolume(docker, volumeName)).toBeFalsy();
+        const { cli, environment } = await suite.setup({ taskName: 'docker:example' });
+        const result = await cli.exec({ cacheDefault: 'none' });
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
+        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();
+        await cli.clean();
+        expect(await (0, get_docker_executor_1.existsVolume)(environment, volumeName)).toBeFalsy();
+    });
+    it('should clean and restore created data in volumes', async () => {
+        const { cli, environment } = await suite.setup({ taskName: 'example:service' });
+        const result = await cli.exec();
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
+        await cli.clean({ service: true });
+        const resultAfterClean = await cli.exec();
+        await (0, expect_1.expectSuccessfulResult)(resultAfterClean, environment);
     });
 });
 //# sourceMappingURL=clean.spec.js.map

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

@@ -1,18 +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 get_test_suite_1 = require("../get-test-suite");
-const execute_1 = require("../../executer/execute");
 describe('cmd', () => {
-    const suite = get_test_suite_1.getTestSuite('cmd', ['build.yaml', 'sub/README.md']);
+    const suite = (0, get_test_suite_1.getTestSuite)('cmd', ['build.yaml', 'sub/README.md']);
     afterAll(() => suite.close());
     it('should run with path arg', 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.expectContainsLog(result, `example`, 'README.md');
+        const { cli, environment } = await suite.setup({ taskName: 'example' });
+        const result = await cli.exec();
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
+        await (0, expect_1.expectContainsLog)(result, environment, `example`, 'README.md');
     });
 });
 //# sourceMappingURL=cmd.spec.js.map

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

@@ -1,28 +1,19 @@
 "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('concurrency', () => {
-    const suite = get_test_suite_1.getTestSuite('concurrency', ['build.yaml']);
+    const suite = (0, get_test_suite_1.getTestSuite)('concurrency', ['build.yaml']);
     afterAll(() => suite.close());
     it('should run with concurrency lower than total tasks', async () => {
-        const { buildFile, executionContext } = await suite.setup();
-        executionContext.workers = 1;
-        let concurrentRunners = 0;
-        executionContext.events.on((evt) => {
-            if (evt.newState.type === 'running') {
-                concurrentRunners++;
-            }
-            else if (evt.newState.type === 'failed' || evt.newState.type === 'completed') {
-                concurrentRunners--;
-            }
-            expect(concurrentRunners).toBeLessThanOrEqual(1);
+        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');
+            expect(runningNodes.length).toBeLessThanOrEqual(1);
         });
-        const workTree = plan_work_tree_1.planWorkTree(buildFile, 'example');
-        const result = await execute_1.execute(workTree, executionContext);
-        await expect_1.expectSuccessfulResult(result);
+        const result = await exec.start();
+        await (0, expect_1.expectSuccessfulResult)(result, environment);
     });
 });
 //# sourceMappingURL=concurrency.spec.js.map

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

@@ -1,19 +1,16 @@
 "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('docker', () => {
-    const suite = get_test_suite_1.getTestSuite('docker', ['build.yaml']);
+    const suite = (0, get_test_suite_1.getTestSuite)('docker', ['build.yaml']);
     afterAll(() => suite.close());
     it('should pull docker image', 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`, '7.19.1');
-        await expect_1.expectLog(result, `example`, 'v16.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`, '7.19.1');
+        await (0, expect_1.expectLog)(result, environment, `example`, 'v16.6.0');
     });
 });
 //# sourceMappingURL=docker.spec.js.map