hammerkit 1.6.0 → 1.7.0

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

package/dist/logging/loggers.spec.js

@@ -1,154 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const stream_1 = require("stream");
-const state_1 = require("../executer/state");
-const work_item_status_1 = require("../planner/work-item-status");
-const live_logger_1 = require("./live-logger");
-const grouped_logger_1 = require("./grouped-logger");
-const interactive_logger_1 = require("./interactive-logger");
-function memStream() {
-    const chunks = [];
-    const stream = new stream_1.Writable({
-        write(c, _e, cb) {
-            chunks.push(c.toString());
-            cb();
-        },
-    });
-    return Object.assign(stream, { read: () => chunks.join('') });
-}
-function noopStream() {
-    return new stream_1.Writable({ write: (_c, _e, cb) => cb() });
-}
-function makeEnv(stdout = noopStream()) {
-    return {
-        cwd: '/tmp',
-        file: {},
-        processEnvs: {},
-        abortCtrl: new AbortController(),
-        console: { info: vi.fn(), error: vi.fn(), warn: vi.fn(), debug: vi.fn(), log: vi.fn() },
-        status: (0, work_item_status_1.statusConsole)(noopStream()),
-        stdout,
-        stderr: noopStream(),
-        stdoutColumns: 80,
-    };
-}
-function taskItem(env, name, state) {
-    const data = { type: 'local-task', name, description: null, scope: { fileName: 'x' } };
-    return {
-        id: () => name,
-        name,
-        data,
-        status: env.status.from(data),
-        state: new state_1.State(state),
-        needs: [],
-        deps: [],
-        requiredBy: [],
-        runtime: {},
-    };
-}
-function serviceItem(env, name, state) {
-    const data = { type: 'container-service', name, ports: [] };
-    return {
-        id: () => name,
-        name,
-        data,
-        status: env.status.from(data),
-        state: new state_1.State(state),
-        needs: [],
-        deps: [],
-        requiredBy: [],
-        runtime: {},
-    };
-}
-function workTree(items) {
-    return {
-        tasks: Object.fromEntries((items.tasks ?? []).map((t) => [t.name, t])),
-        services: Object.fromEntries((items.services ?? []).map((s) => [s.name, s])),
-        environment: { type: 'docker' },
-    };
-}
-describe('loggers', () => {
-    describe('liveLogger', () => {
-        it('writes each status message and renders results on complete', async () => {
-            const out = memStream();
-            const env = makeEnv(out);
-            const task = taskItem(env, 'build', { type: 'pending', stateKey: null });
-            const tree = workTree({ tasks: [task] });
-            const state = new state_1.State(tree);
-            const logger = (0, live_logger_1.liveLogger)(state, env);
-            // a write on the scoped console emits a message on env.status, which the
-            // logger's listener formats into env.stdout
-            task.status.write('info', 'compiling');
-            const result = { state: tree, success: true };
-            await logger.complete(result, env);
-            expect(out.read()).toContain('compiling');
-        });
-    });
-    describe('groupedLogger', () => {
-        it("writes a completed task's logs on the next status update", async () => {
-            const out = memStream();
-            const env = makeEnv(out);
-            const task = taskItem(env, 'build', { type: 'pending', stateKey: null });
-            const tree = workTree({ tasks: [task] });
-            const state = new state_1.State(tree);
-            const logger = (0, grouped_logger_1.groupedLogger)(state, env);
-            // buffer one info log, mark the task completed, then notify the parent state
-            task.status.write('info', 'compiling');
-            task.state.set({ type: 'completed', stateKey: 'k', duration: 5, cached: false });
-            state.set(tree);
-            await logger.complete({ state: tree, success: true }, env);
-            expect(out.read()).toContain('compiling');
-        });
-        it("writes an ended service's logs on the next status update", async () => {
-            const out = memStream();
-            const env = makeEnv(out);
-            const svc = serviceItem(env, 'db', { type: 'pending', stateKey: null });
-            const tree = workTree({ services: [svc] });
-            const state = new state_1.State(tree);
-            const logger = (0, grouped_logger_1.groupedLogger)(state, env);
-            svc.status.write('info', 'ready');
-            svc.state.set({ type: 'end', reason: 'terminated', stateKey: 'k' });
-            state.set(tree);
-            await logger.complete({ state: tree, success: true }, env);
-            expect(out.read()).toContain('ready');
-        });
-        it('does not duplicate a task that is already in the completed set', async () => {
-            const out = memStream();
-            const env = makeEnv(out);
-            const task = taskItem(env, 'build', { type: 'pending', stateKey: null });
-            const tree = workTree({ tasks: [task] });
-            const state = new state_1.State(tree);
-            const logger = (0, grouped_logger_1.groupedLogger)(state, env);
-            task.status.write('info', 'once');
-            task.state.set({ type: 'completed', stateKey: 'k', duration: 1, cached: false });
-            state.set(tree);
-            const after = out.read();
-            // a second notification with no further log message should not append another copy
-            state.set(tree);
-            expect(out.read()).toEqual(after);
-            await logger.complete({ state: tree, success: true }, env);
-        });
-    });
-    describe('interactiveLogger', () => {
-        beforeEach(() => vi.useFakeTimers());
-        afterEach(() => vi.useRealTimers());
-        it('hides the cursor, ticks, redraws on log-status, then cleans up on complete', async () => {
-            const out = memStream();
-            const env = makeEnv(out);
-            const task = taskItem(env, 'build', { type: 'pending', stateKey: null });
-            const tree = workTree({ tasks: [task] });
-            const state = new state_1.State(tree);
-            const logger = (0, interactive_logger_1.interactiveLogger)(state, env); // hideCursor + first tick + setTimeout
-            // drive a state change to re-render
-            task.state.set({ type: 'running', stateKey: 'k' });
-            state.set(tree);
-            // let one fake tick fire while running===true (covers the recursive branch)
-            vi.advanceTimersByTime(150);
-            await logger.complete({ state: tree, success: true }, env);
-            // and one more after complete — covers the `if (!running) return` early exit
-            vi.advanceTimersByTime(150);
-            expect(out.read().length).toBeGreaterThan(0);
-        });
-    });
-});
-//# sourceMappingURL=loggers.spec.js.map

package/dist/optimizer/calculate-checksum.spec.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const os_1 = require("os");
-const fs_1 = require("fs");
-const crypto_1 = require("crypto");
-const environment_mock_1 = require("../executer/environment-mock");
-const calculate_checksum_1 = require("./calculate-checksum");
-describe('calculateChecksum', () => {
-    let scratch;
-    beforeEach(() => {
-        scratch = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-checksum-'));
-    });
-    afterEach(() => {
-        (0, fs_1.rmSync)(scratch, { recursive: true, force: true });
-    });
-    it('returns the sha1 of the file contents', async () => {
-        const env = (0, environment_mock_1.environmentMock)(scratch);
-        const file = (0, path_1.join)(scratch, 'a.txt');
-        (0, fs_1.writeFileSync)(file, 'hello world');
-        const expected = (0, crypto_1.createHash)('sha1').update('hello world').digest('hex');
-        expect(await (0, calculate_checksum_1.calculateChecksum)(env, file)).toBe(expected);
-    });
-    it('is deterministic and content-sensitive', async () => {
-        const env = (0, environment_mock_1.environmentMock)(scratch);
-        const file = (0, path_1.join)(scratch, 'a.txt');
-        (0, fs_1.writeFileSync)(file, 'one');
-        const first = await (0, calculate_checksum_1.calculateChecksum)(env, file);
-        expect(await (0, calculate_checksum_1.calculateChecksum)(env, file)).toBe(first);
-        (0, fs_1.writeFileSync)(file, 'two');
-        expect(await (0, calculate_checksum_1.calculateChecksum)(env, file)).not.toBe(first);
-    });
-});
-//# sourceMappingURL=calculate-checksum.spec.js.map

package/dist/optimizer/get-cache-directory.spec.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const get_cache_directory_1 = require("./get-cache-directory");
-function withPlatform(value, env, fn) {
-    const originalPlatform = process.platform;
-    const originalEnv = {};
-    for (const k of Object.keys(env))
-        originalEnv[k] = process.env[k];
-    Object.defineProperty(process, 'platform', { value, configurable: true });
-    for (const [k, v] of Object.entries(env)) {
-        if (v === undefined)
-            delete process.env[k];
-        else
-            process.env[k] = v;
-    }
-    try {
-        return fn();
-    }
-    finally {
-        Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
-        for (const [k, v] of Object.entries(originalEnv)) {
-            if (v === undefined)
-                delete process.env[k];
-            else
-                process.env[k] = v;
-        }
-    }
-}
-describe('cache directory helpers', () => {
-    it('builds the per-cache directory under the hammerkit directory', () => {
-        const dir = (0, get_cache_directory_1.getCacheDirectory)('abc123');
-        expect(dir.endsWith((0, path_1.join)('cache', 'abc123'))).toBe(true);
-    });
-    it('builds the description file path under the cache directory', () => {
-        expect((0, get_cache_directory_1.getCacheDescriptionFile)('id').endsWith((0, path_1.join)('cache', 'id', 'description.json'))).toBe(true);
-    });
-    it('builds the stats file path under the cache directory', () => {
-        expect((0, get_cache_directory_1.getCacheStatsFile)('id').endsWith((0, path_1.join)('cache', 'id', 'stats.json'))).toBe(true);
-    });
-    describe('getHammerkitDirectory', () => {
-        it('uses %APPDATA% on Windows', () => {
-            withPlatform('win32', { APPDATA: 'C:\\Users\\X\\AppData\\Roaming' }, () => {
-                expect((0, get_cache_directory_1.getHammerkitDirectory)()).toBe((0, path_1.join)('C:\\Users\\X\\AppData\\Roaming', 'hammerkit'));
-            });
-        });
-        it('uses ~/Library/Application Support on macOS', () => {
-            withPlatform('darwin', { HOME: '/Users/x' }, () => {
-                expect((0, get_cache_directory_1.getHammerkitDirectory)()).toBe((0, path_1.join)('/Users/x', 'Library', 'Application Support', 'hammerkit'));
-            });
-        });
-        it('uses ~/.hammerkit on Linux', () => {
-            withPlatform('linux', { HOME: '/home/x' }, () => {
-                expect((0, get_cache_directory_1.getHammerkitDirectory)()).toBe((0, path_1.join)('/home/x', '.hammerkit'));
-            });
-        });
-    });
-});
-//# sourceMappingURL=get-cache-directory.spec.js.map