hammerkit 1.6.0 → 1.8.0

package/dist/kubernetes/ensure-http-route.spec.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ensure_http_route_1 = require("./ensure-http-route");
-function httpError(statusCode) {
-    return Object.assign(new Error(`http ${statusCode}`), { statusCode });
-}
-function makeInstance(objectApi) {
-    return { objectApi };
-}
-const env = { type: 'kubernetes', namespace: 'demo', context: 'ctx', ingresses: [] };
-const service = {
-    name: 'api',
-    id: () => 'abc123',
-    data: { ports: [{ containerPort: 3000, hostPort: null }] },
-};
-function ingress(overrides = {}) {
-    return {
-        kind: 'httproute',
-        host: 'api.example.com',
-        service: 'api',
-        gateway: 'web',
-        ...overrides,
-    };
-}
-describe('ensureHttpRoute', () => {
-    it('creates an HTTPRoute with the expected shape', async () => {
-        const read = vi.fn().mockRejectedValue(httpError(404));
-        const create = vi.fn().mockResolvedValue({ body: {} });
-        await (0, ensure_http_route_1.ensureHttpRoute)(makeInstance({ read, create }), env, ingress(), service);
-        expect(create).toHaveBeenCalledTimes(1);
-        expect(create.mock.calls[0][0]).toMatchObject({
-            apiVersion: 'gateway.networking.k8s.io/v1',
-            kind: 'HTTPRoute',
-            metadata: { name: 'api.example.com', namespace: 'demo', labels: { 'hammerkit.dev/id': 'abc123' } },
-            spec: {
-                parentRefs: [{ name: 'web' }],
-                hostnames: ['api.example.com'],
-                rules: [
-                    {
-                        matches: [{ path: { type: 'PathPrefix', value: '/' } }],
-                        backendRefs: [{ name: 'api-abc123', port: 3000 }],
-                    },
-                ],
-            },
-        });
-    });
-    it('uses servicePort, path and gatewayNamespace when provided', async () => {
-        const read = vi.fn().mockRejectedValue(httpError(404));
-        const create = vi.fn().mockResolvedValue({ body: {} });
-        await (0, ensure_http_route_1.ensureHttpRoute)(makeInstance({ read, create }), env, ingress({ servicePort: 8080, path: '/api', gatewayNamespace: 'gateways' }), service);
-        expect(create.mock.calls[0][0]).toMatchObject({
-            spec: {
-                parentRefs: [{ name: 'web', namespace: 'gateways' }],
-                rules: [
-                    {
-                        matches: [{ path: { type: 'PathPrefix', value: '/api' } }],
-                        backendRefs: [{ name: 'api-abc123', port: 8080 }],
-                    },
-                ],
-            },
-        });
-    });
-    it('throws when no gateway is set', async () => {
-        const read = vi.fn();
-        const create = vi.fn();
-        await expect((0, ensure_http_route_1.ensureHttpRoute)(makeInstance({ read, create }), env, ingress({ gateway: undefined }), service)).rejects.toThrow(/requires a "gateway"/);
-        expect(create).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=ensure-http-route.spec.js.map

package/dist/kubernetes/ensure-ingress.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureIngress = void 0;
-const apply_1 = require("./apply");
-const resources_1 = require("./resources");
-async function ensureIngress(instance, env, ingress, service) {
-    const resource = {
-        kind: 'Ingress',
-        apiVersion: 'networking.k8s.io/v1',
-        metadata: {
-            name: ingress.host,
-            namespace: env.namespace,
-            annotations: {
-                'cert-manager.io/cluster-issuer': 'hammerkit-issuer',
-            },
-            labels: {
-                'hammerkit.dev/id': service.id(),
-            },
-        },
-        spec: {
-            ingressClassName: 'nginx',
-            rules: [
-                {
-                    host: ingress.host,
-                    http: {
-                        paths: [
-                            {
-                                path: ingress.path ?? '/',
-                                pathType: 'Prefix',
-                                backend: {
-                                    service: {
-                                        name: (0, resources_1.getResourceName)(service),
-                                        port: {
-                                            number: ingress.servicePort ?? service.data.ports[0].containerPort,
-                                        },
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                },
-            ],
-            tls: [
-                {
-                    secretName: `${ingress.host}-tls`,
-                    hosts: [ingress.host],
-                },
-            ],
-        },
-    };
-    return await (0, apply_1.apply)(instance, resource);
-}
-exports.ensureIngress = ensureIngress;
-//# sourceMappingURL=ensure-ingress.js.map

package/dist/kubernetes/ensure-namespace.spec.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ensure_namespace_1 = require("./ensure-namespace");
-function httpError(statusCode) {
-    return Object.assign(new Error(`http ${statusCode}`), { statusCode });
-}
-function makeInstance(coreApi) {
-    return { coreApi };
-}
-describe('ensureNamespace', () => {
-    it('does nothing when the namespace already exists', async () => {
-        const readNamespace = vi.fn().mockResolvedValue({ body: {} });
-        const createNamespace = vi.fn();
-        await (0, ensure_namespace_1.ensureNamespace)(makeInstance({ readNamespace, createNamespace }), 'demo');
-        expect(readNamespace).toHaveBeenCalledWith('demo');
-        expect(createNamespace).not.toHaveBeenCalled();
-    });
-    it('creates the namespace (labeled managed) when missing', async () => {
-        const readNamespace = vi.fn().mockRejectedValue(httpError(404));
-        const createNamespace = vi.fn().mockResolvedValue({ body: {} });
-        await (0, ensure_namespace_1.ensureNamespace)(makeInstance({ readNamespace, createNamespace }), 'demo');
-        expect(createNamespace).toHaveBeenCalledTimes(1);
-        expect(createNamespace.mock.calls[0][0]).toMatchObject({
-            metadata: { name: 'demo', labels: { 'hammerkit.dev/managed': 'true' } },
-        });
-    });
-    it('swallows a 409 from a racing create', async () => {
-        const readNamespace = vi.fn().mockRejectedValue(httpError(404));
-        const createNamespace = vi.fn().mockRejectedValue(httpError(409));
-        await expect((0, ensure_namespace_1.ensureNamespace)(makeInstance({ readNamespace, createNamespace }), 'demo')).resolves.toBeUndefined();
-    });
-    it('rethrows unexpected read errors', async () => {
-        const readNamespace = vi.fn().mockRejectedValue(httpError(500));
-        const createNamespace = vi.fn();
-        await expect((0, ensure_namespace_1.ensureNamespace)(makeInstance({ readNamespace, createNamespace }), 'demo')).rejects.toThrow();
-        expect(createNamespace).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=ensure-namespace.spec.js.map

package/dist/kubernetes/resolve-pod-name.spec.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const resolve_pod_name_1 = require("./resolve-pod-name");
-function podBody(items) {
-    return {
-        body: {
-            items: items.map((p) => ({
-                metadata: { name: p.name },
-                status: {
-                    conditions: [{ type: 'Ready', status: p.ready ? 'True' : 'False' }],
-                },
-            })),
-        },
-    };
-}
-function makeCoreApi(opts = {}) {
-    return {
-        readNamespacedService: vi.fn().mockResolvedValue({ body: { spec: { selector: opts.service?.selector } } }),
-        listNamespacedPod: vi.fn().mockResolvedValue(podBody(opts.pods ?? [])),
-    };
-}
-function makeAppsApi(opts = {}) {
-    return {
-        readNamespacedDeployment: vi
-            .fn()
-            .mockResolvedValue({ body: { spec: { selector: { matchLabels: opts.deployment?.matchLabels } } } }),
-    };
-}
-describe('resolvePodName', () => {
-    it('returns the name directly for selector type "pod"', async () => {
-        const core = makeCoreApi();
-        const apps = makeAppsApi();
-        await expect((0, resolve_pod_name_1.resolvePodName)(core, apps, 'ns', { type: 'pod', name: 'my-pod' })).resolves.toBe('my-pod');
-        expect(core.listNamespacedPod).not.toHaveBeenCalled();
-    });
-    it('resolves a service to a ready pod', async () => {
-        const core = makeCoreApi({
-            service: { selector: { app: 'api' } },
-            pods: [
-                { name: 'api-old', ready: false },
-                { name: 'api-new', ready: true },
-            ],
-        });
-        const apps = makeAppsApi();
-        await expect((0, resolve_pod_name_1.resolvePodName)(core, apps, 'ns', { type: 'service', name: 'api' })).resolves.toBe('api-new');
-        expect(core.listNamespacedPod).toHaveBeenCalledWith('ns', undefined, undefined, undefined, undefined, 'app=api');
-    });
-    it('falls back to the first pod if none are ready', async () => {
-        const core = makeCoreApi({
-            service: { selector: { app: 'api' } },
-            pods: [
-                { name: 'api-1', ready: false },
-                { name: 'api-2', ready: false },
-            ],
-        });
-        const apps = makeAppsApi();
-        await expect((0, resolve_pod_name_1.resolvePodName)(core, apps, 'ns', { type: 'service', name: 'api' })).resolves.toBe('api-1');
-    });
-    it('resolves a deployment via matchLabels', async () => {
-        const core = makeCoreApi({ pods: [{ name: 'p', ready: true }] });
-        const apps = makeAppsApi({ deployment: { matchLabels: { 'hammerkit.dev/id': 'x' } } });
-        await expect((0, resolve_pod_name_1.resolvePodName)(core, apps, 'ns', { type: 'deployment', name: 'api' })).resolves.toBe('p');
-        expect(core.listNamespacedPod).toHaveBeenCalledWith('ns', undefined, undefined, undefined, undefined, 'hammerkit.dev/id=x');
-    });
-    it('throws when a service has no selector', async () => {
-        const core = makeCoreApi({ service: { selector: undefined } });
-        const apps = makeAppsApi();
-        await expect((0, resolve_pod_name_1.resolvePodName)(core, apps, 'ns', { type: 'service', name: 'api' })).rejects.toThrow(/no selector/);
-    });
-    it('throws when no pods match', async () => {
-        const core = makeCoreApi({ service: { selector: { app: 'api' } }, pods: [] });
-        const apps = makeAppsApi();
-        await expect((0, resolve_pod_name_1.resolvePodName)(core, apps, 'ns', { type: 'service', name: 'api' })).rejects.toThrow(/no pod found/);
-    });
-    it('rejects unsupported selector types', async () => {
-        const core = makeCoreApi();
-        const apps = makeAppsApi();
-        await expect((0, resolve_pod_name_1.resolvePodName)(core, apps, 'ns', { type: 'statefulset', name: 'x' })).rejects.toThrow(/unsupported selector type/);
-    });
-});
-//# sourceMappingURL=resolve-pod-name.spec.js.map

package/dist/log.spec.js

@@ -1,131 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const stream_1 = require("stream");
-const log_1 = require("./log");
-const environment_mock_1 = require("./executer/environment-mock");
-function capture() {
-    const chunks = [];
-    const stream = new stream_1.Writable({
-        write(chunk, _enc, cb) {
-            chunks.push(chunk.toString());
-            cb();
-        },
-    });
-    return { stream, read: () => chunks.join('') };
-}
-describe('log helpers', () => {
-    describe('getLogs', () => {
-        it('splits on \\r?\\n and drops empty lines', () => {
-            expect((0, log_1.getLogs)('a\r\nb\nc\n\n')).toEqual(['a', 'b', 'c']);
-        });
-        it('accepts a Buffer', () => {
-            expect((0, log_1.getLogs)(Buffer.from('x\ny'))).toEqual(['x', 'y']);
-        });
-    });
-    describe('getLogLevel', () => {
-        it.each(['debug', 'info', 'warn', 'error'])('returns a string containing %s', (level) => {
-            expect((0, log_1.getLogLevel)(level)).toContain(level);
-        });
-    });
-    describe('getErrorMessage', () => {
-        it('uses Error.message for Error instances', () => {
-            expect((0, log_1.getErrorMessage)(new Error('boom'))).toBe('boom');
-        });
-        it('returns a string value unchanged', () => {
-            expect((0, log_1.getErrorMessage)('plain')).toBe('plain');
-        });
-        it('falls back to "unknown error <value>" for other values', () => {
-            expect((0, log_1.getErrorMessage)({ x: 1 })).toMatch(/^unknown error/);
-        });
-    });
-    describe('consoleContext', () => {
-        it('writes formatted lines for each level', () => {
-            const cap = capture();
-            const ctx = (0, log_1.consoleContext)(cap.stream);
-            ctx.debug('d-msg');
-            ctx.info('i-msg');
-            ctx.warn('w-msg');
-            ctx.error('e-msg');
-            const out = cap.read();
-            expect(out).toContain('d-msg');
-            expect(out).toContain('i-msg');
-            expect(out).toContain('w-msg');
-            expect(out).toContain('e-msg');
-            // 4 newlines, one per call
-            expect(out.split('\n').filter((l) => l.length > 0)).toHaveLength(4);
-        });
-    });
-    describe('getType / getNodeName / getMaxNameLength', () => {
-        it('formats the type with the configured padding', () => {
-            expect((0, log_1.getType)('cli')).toContain('cli');
-        });
-        it('pads name to a given length', () => {
-            expect((0, log_1.getNodeName)('a', 4)).toContain('a');
-            // pads with spaces to reach the requested length, then color codes
-            // surround it — assert by inspecting the visible characters
-            // ANSI color wrappers can only add chars, so the rendered string is at
-            // least the requested width even when colors are enabled.
-            expect((0, log_1.getNodeName)('a', 4).length).toBeGreaterThanOrEqual(4);
-        });
-        it('getMaxNameLength returns the longest name yielded', () => {
-            const names = function* () {
-                yield 'aa';
-                yield 'aaaaa';
-                yield 'a';
-            };
-            expect((0, log_1.getMaxNameLength)(names)).toBe(5);
-        });
-        it('getMaxNameLength returns 0 for an empty source', () => {
-            expect((0, log_1.getMaxNameLength)(() => [])).toBe(0);
-        });
-    });
-    describe('print helpers', () => {
-        it('printItem with and without description', () => {
-            const env = (0, environment_mock_1.environmentMock)('/tmp');
-            const cap = capture();
-            env.stdout = cap.stream;
-            (0, log_1.printItem)(env, { name: 'a', description: null });
-            (0, log_1.printItem)(env, { name: 'b', description: 'desc' });
-            const out = cap.read();
-            expect(out).toContain('• a\n');
-            expect(out).toContain('• b');
-            expect(out).toContain('desc');
-        });
-        it('printProperty writes "<name>: <value>"', () => {
-            const env = (0, environment_mock_1.environmentMock)('/tmp');
-            const cap = capture();
-            env.stdout = cap.stream;
-            (0, log_1.printProperty)(env, 'image', 'alpine');
-            expect(cap.read()).toContain('image:');
-            expect(cap.read()).toContain('alpine');
-        });
-        it('printTitle writes the title with a colon', () => {
-            const env = (0, environment_mock_1.environmentMock)('/tmp');
-            const cap = capture();
-            env.stdout = cap.stream;
-            (0, log_1.printTitle)(env, 'Tasks');
-            expect(cap.read()).toContain('Tasks:');
-        });
-    });
-    describe('formatDate', () => {
-        it('produces a [yyyy-MM-DD HH:mm:ss.SSS] formatted timestamp', () => {
-            // Use a fixed Date in UTC; the function uses local-time getters, so only
-            // pattern-check the output rather than the literal value.
-            const out = (0, log_1.formatDate)(new Date(2024, 0, 2, 3, 4, 5, 6));
-            expect(out).toMatch(/\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}\]/);
-        });
-    });
-    describe('cursor', () => {
-        it('hideCursor / showCursor write escape sequences', () => {
-            const env = (0, environment_mock_1.environmentMock)('/tmp');
-            const cap = capture();
-            env.stdout = cap.stream;
-            (0, log_1.hideCursor)(env);
-            (0, log_1.showCursor)(env);
-            const out = cap.read();
-            expect(out).toContain('\x1B[?25l');
-            expect(out).toContain('\x1B[?25h');
-        });
-    });
-});
-//# sourceMappingURL=log.spec.js.map

package/dist/logging/grouped-logger.spec.js

@@ -1,84 +0,0 @@
-"use strict";
-// Verifies that the grouped logger only flushes a task/service once it reaches
-// a terminal state, by mocking the underlying log helpers and iterators.
-Object.defineProperty(exports, "__esModule", { value: true });
-vi.mock('../log', () => ({
-    writeWorkItemLogToConsole: vi.fn(),
-    printWorkTreeResult: vi.fn().mockResolvedValue(undefined),
-    getWorkItemMaxLength: vi.fn(() => 10),
-}));
-vi.mock('../planner/utils/plan-work-tasks', () => ({
-    iterateWorkTasks: vi.fn(),
-    iterateWorkServices: vi.fn(),
-}));
-const grouped_logger_1 = require("./grouped-logger");
-const state_1 = require("../executer/state");
-const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
-const log_1 = require("../log");
-const mockedIterTasks = plan_work_tasks_1.iterateWorkTasks;
-const mockedIterServices = plan_work_tasks_1.iterateWorkServices;
-const mockedWrite = log_1.writeWorkItemLogToConsole;
-const mockedPrint = log_1.printWorkTreeResult;
-function fakeTask(name, type, logs = []) {
-    return { name, state: { current: { type } }, status: { read: () => logs } };
-}
-describe('groupedLogger', () => {
-    beforeEach(() => {
-        mockedWrite.mockClear();
-        mockedPrint.mockClear();
-        mockedIterTasks.mockReset();
-        mockedIterServices.mockReset();
-    });
-    it('flushes a task only once it reaches a terminal state and not again on re-emit', () => {
-        const t = fakeTask('t1', 'pending', [{ id: 1 }]);
-        mockedIterTasks.mockImplementation(function* () {
-            yield t;
-        });
-        mockedIterServices.mockImplementation(function* () { });
-        const state = new state_1.State({ services: {}, tasks: { t1: t } });
-        (0, grouped_logger_1.groupedLogger)(state, {});
-        state.set(state.current); // pending — should NOT flush
-        expect(mockedWrite).not.toHaveBeenCalled();
-        t.state.current.type = 'completed';
-        state.set(state.current); // completed — flush once
-        expect(mockedWrite).toHaveBeenCalledTimes(1);
-        state.set(state.current); // already-flushed task — must not flush again
-        expect(mockedWrite).toHaveBeenCalledTimes(1);
-    });
-    it.each(['crash', 'error', 'completed'])('flushes on terminal state %s', (terminal) => {
-        const t = fakeTask('t1', terminal, [{ id: 1 }]);
-        mockedIterTasks.mockImplementation(function* () {
-            yield t;
-        });
-        mockedIterServices.mockImplementation(function* () { });
-        const state = new state_1.State({ services: {}, tasks: { t1: t } });
-        (0, grouped_logger_1.groupedLogger)(state, {});
-        state.set(state.current);
-        expect(mockedWrite).toHaveBeenCalledTimes(1);
-    });
-    it('flushes a service on type "end" and not again', () => {
-        const s = fakeTask('svc1', 'starting', [{ id: 1 }]);
-        mockedIterTasks.mockImplementation(function* () { });
-        mockedIterServices.mockImplementation(function* () {
-            yield s;
-        });
-        const state = new state_1.State({ services: { svc1: s }, tasks: {} });
-        (0, grouped_logger_1.groupedLogger)(state, {});
-        state.set(state.current); // not yet ended
-        expect(mockedWrite).not.toHaveBeenCalled();
-        s.state.current.type = 'end';
-        state.set(state.current); // ended — flush
-        expect(mockedWrite).toHaveBeenCalledTimes(1);
-        state.set(state.current); // already flushed — no second call
-        expect(mockedWrite).toHaveBeenCalledTimes(1);
-    });
-    it('complete() delegates to printWorkTreeResult', async () => {
-        mockedIterTasks.mockImplementation(function* () { });
-        mockedIterServices.mockImplementation(function* () { });
-        const state = new state_1.State({ services: {}, tasks: {} });
-        const logger = (0, grouped_logger_1.groupedLogger)(state, {});
-        await logger.complete({ state: state.current, success: true }, {});
-        expect(mockedPrint).toHaveBeenCalledTimes(1);
-    });
-});
-//# sourceMappingURL=grouped-logger.spec.js.map

package/dist/logging/interactive-logger.spec.js

@@ -1,57 +0,0 @@
-"use strict";
-// interactiveLogger hides the cursor, polls writeWorkTreeStatus on a 100ms
-// ticker, and writes on every state change until complete() stops it.
-Object.defineProperty(exports, "__esModule", { value: true });
-vi.mock('../log', () => ({
-    writeWorkTreeStatus: vi.fn(),
-    printWorkTreeResult: vi.fn().mockResolvedValue(undefined),
-    hideCursor: vi.fn(),
-    showCursor: vi.fn(),
-}));
-vi.mock('readline', () => ({ clearScreenDown: vi.fn() }));
-const interactive_logger_1 = require("./interactive-logger");
-const state_1 = require("../executer/state");
-const log_1 = require("../log");
-const readline_1 = require("readline");
-const mockedWriteStatus = log_1.writeWorkTreeStatus;
-const mockedHide = log_1.hideCursor;
-const mockedShow = log_1.showCursor;
-const mockedClear = readline_1.clearScreenDown;
-const mockedPrint = log_1.printWorkTreeResult;
-describe('interactiveLogger', () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-        mockedWriteStatus.mockClear();
-        mockedHide.mockClear();
-        mockedShow.mockClear();
-        mockedClear.mockClear();
-        mockedPrint.mockClear();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    it('hides the cursor, ticks every 100ms, and writes on state changes', async () => {
-        const state = new state_1.State({ services: {}, tasks: {} });
-        const env = { stdout: { write: vi.fn() } };
-        const logger = (0, interactive_logger_1.interactiveLogger)(state, env);
-        // hideCursor on construction; initial tick fired immediately
-        expect(mockedHide).toHaveBeenCalledTimes(1);
-        expect(mockedWriteStatus).toHaveBeenCalledTimes(1);
-        // advance one tick window → one additional writeWorkTreeStatus
-        vi.advanceTimersByTime(100);
-        expect(mockedWriteStatus).toHaveBeenCalledTimes(2);
-        // a state change writes status synchronously
-        state.set({ services: {}, tasks: {} });
-        expect(mockedWriteStatus).toHaveBeenCalledTimes(3);
-        // complete() stops the ticker and restores the cursor
-        await logger.complete({ state: state.current, success: true }, env);
-        expect(mockedClear).toHaveBeenCalledWith(env.stdout);
-        expect(mockedPrint).toHaveBeenCalledTimes(1);
-        expect(mockedShow).toHaveBeenCalledTimes(1);
-        // after complete, advancing time must NOT schedule further writes
-        const after = mockedWriteStatus.mock.calls.length;
-        vi.advanceTimersByTime(1000);
-        expect(mockedWriteStatus.mock.calls.length).toBe(after);
-    });
-});
-//# sourceMappingURL=interactive-logger.spec.js.map

package/dist/logging/live-logger.spec.js

@@ -1,37 +0,0 @@
-"use strict";
-// liveLogger forwards every status message verbatim to writeWorkItemLogToConsole.
-Object.defineProperty(exports, "__esModule", { value: true });
-vi.mock('../log', () => ({
-    writeWorkItemLogToConsole: vi.fn(),
-    printWorkTreeResult: vi.fn().mockResolvedValue(undefined),
-    getWorkItemMaxLength: vi.fn(() => 10),
-}));
-const live_logger_1 = require("./live-logger");
-const state_1 = require("../executer/state");
-const log_1 = require("../log");
-const emitter_1 = require("../utils/emitter");
-const mockedWrite = log_1.writeWorkItemLogToConsole;
-const mockedPrint = log_1.printWorkTreeResult;
-describe('liveLogger', () => {
-    beforeEach(() => {
-        mockedWrite.mockClear();
-        mockedPrint.mockClear();
-    });
-    it('forwards each status message to writeWorkItemLogToConsole', () => {
-        const status = (0, emitter_1.emitter)();
-        const env = { status };
-        const state = new state_1.State({ services: {}, tasks: {} });
-        (0, live_logger_1.liveLogger)(state, env);
-        const msg = { type: 'status', message: 'hi' };
-        status.emit(msg);
-        expect(mockedWrite).toHaveBeenCalledWith(env, msg, 10);
-    });
-    it('complete() delegates to printWorkTreeResult', async () => {
-        const status = (0, emitter_1.emitter)();
-        const state = new state_1.State({ services: {}, tasks: {} });
-        const logger = (0, live_logger_1.liveLogger)(state, { status });
-        await logger.complete({ state: state.current, success: true }, {});
-        expect(mockedPrint).toHaveBeenCalledTimes(1);
-    });
-});
-//# sourceMappingURL=live-logger.spec.js.map