hammerkit 1.6.0 → 1.7.0

package/dist/executer/process-manager.spec.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const process_manager_1 = require("./process-manager");
-const work_item_status_1 = require("../planner/work-item-status");
-const empty_writable_1 = require("../utils/empty-writable");
-describe('process-manager', () => {
-    function fakeWorkItem(id) {
-        return {
-            id: () => '',
-            status: (0, work_item_status_1.statusConsole)((0, empty_writable_1.emptyWritable)()).context((0, work_item_status_1.logContext)('task', { name: id })),
-            deps: [],
-            aliases: [id],
-            needs: [],
-            requiredBy: [],
-            name: id,
-            data: null,
-            state: null,
-            runtime: null,
-        };
-    }
-    it('should complete on success', async () => {
-        const manager = new process_manager_1.ProcessManager(0);
-        let called = false;
-        await manager.task(fakeWorkItem('a'), () => new Promise((resolve) => setTimeout(() => {
-            called = true;
-            resolve();
-        }, 100)));
-        expect(called).toBeTruthy();
-    });
-    it('should throw error', async () => {
-        const manager = new process_manager_1.ProcessManager(0);
-        await expect(manager.task(fakeWorkItem('a'), () => new Promise((resolve, reject) => setTimeout(() => reject(new Error('3')), 100)))).rejects.toThrow('3');
-    });
-    it('should not start more than worker count', async () => {
-        const manager = new process_manager_1.ProcessManager(1);
-        let concurrencyCount = 0;
-        const fakeAction = () => new Promise((resolve) => {
-            expect(concurrencyCount).toBe(0);
-            concurrencyCount++;
-            setTimeout(() => {
-                expect(concurrencyCount).toBe(1);
-                concurrencyCount--;
-                resolve();
-            }, 100);
-        });
-        await Promise.all([
-            manager.task(fakeWorkItem('a'), fakeAction),
-            manager.task(fakeWorkItem('b'), fakeAction),
-            manager.task(fakeWorkItem('c'), fakeAction),
-        ]);
-        expect(concurrencyCount).toBe(0);
-    });
-});
-//# sourceMappingURL=process-manager.spec.js.map

package/dist/executer/scheduler/enqueue-next.spec.js

@@ -1,136 +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 environment_mock_1 = require("../environment-mock");
-const enqueue_next_1 = require("./enqueue-next");
-const local_cache_backend_1 = require("../../cache/backends/local-cache-backend");
-const state_1 = require("../state");
-describe('checkCacheState', () => {
-    let scratch;
-    let remoteDir;
-    let machineHome;
-    let originalHome;
-    beforeEach(() => {
-        scratch = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-enqueue-'));
-        remoteDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-remote-'));
-        machineHome = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-home-'));
-        originalHome = process.env.HOME;
-        if (process.platform === 'win32') {
-            process.env.APPDATA = machineHome;
-        }
-        else {
-            process.env.HOME = machineHome;
-        }
-    });
-    afterEach(() => {
-        (0, fs_1.rmSync)(scratch, { recursive: true, force: true });
-        (0, fs_1.rmSync)(remoteDir, { recursive: true, force: true });
-        (0, fs_1.rmSync)(machineHome, { recursive: true, force: true });
-        if (originalHome !== undefined) {
-            process.env.HOME = originalHome;
-        }
-        else {
-            delete process.env.HOME;
-        }
-    });
-    // empty remote → backend.pull always misses, so a key mismatch yields cached:false
-    function makeResolved(method) {
-        return {
-            name: 'remote',
-            method,
-            backend: (0, local_cache_backend_1.createLocalCacheBackend)({ type: 'local', path: remoteDir }),
-            implicit: false,
-        };
-    }
-    function makeTask(id, options) {
-        const storedStateKey = options.storedStateKey ?? null;
-        return {
-            id: () => id,
-            name: id,
-            status: { write: vi.fn() },
-            data: {
-                type: 'local-task',
-                name: id,
-                cwd: scratch,
-                cmds: [],
-                generates: [],
-                src: (options.srcFiles ?? []).map((absolutePath) => ({
-                    absolutePath,
-                    source: absolutePath,
-                    matcher: () => true,
-                    inherited: null,
-                    isFile: true,
-                })),
-                envs: { variables: {}, replacements: [] },
-                labels: {},
-                shell: '/bin/sh',
-                caching: options.resolved,
-                description: null,
-                scope: {},
-            },
-            needs: [],
-            deps: options.deps ?? [],
-            requiredBy: [],
-            state: new state_1.State({ type: 'pending', stateKey: null }),
-            runtime: {
-                async initialize() { },
-                async remove() { },
-                async execute() { },
-                async stop() { },
-                async archive() { },
-                async restore() { },
-                async currentStateKey() {
-                    return storedStateKey;
-                },
-            },
-        };
-    }
-    it('reports cached:false when caching method is none', async () => {
-        const env = (0, environment_mock_1.environmentMock)(scratch);
-        const task = makeTask('none-task', { resolved: makeResolved('none') });
-        const result = await (0, enqueue_next_1.checkCacheState)(task, 'checksum', env);
-        expect(result.cached).toBe(false);
-    });
-    it('reports cached:true when the stored key matches the effective key', async () => {
-        const env = (0, environment_mock_1.environmentMock)(scratch);
-        const probe = makeTask('hit-task', { resolved: makeResolved('checksum') });
-        const { stateKey } = await (0, enqueue_next_1.checkCacheState)(probe, 'checksum', env);
-        const task = makeTask('hit-task', { resolved: makeResolved('checksum'), storedStateKey: stateKey });
-        const result = await (0, enqueue_next_1.checkCacheState)(task, 'checksum', env);
-        expect(result.cached).toBe(true);
-        expect(result.stateKey).toBe(stateKey);
-    });
-    it('invalidates a downstream task when an upstream dependency source changes', async () => {
-        const env = (0, environment_mock_1.environmentMock)(scratch);
-        const upstreamSrc = (0, path_1.join)(scratch, 'upstream.txt');
-        (0, fs_1.writeFileSync)(upstreamSrc, 'v1');
-        const makeUpstream = () => makeTask('upstream', { resolved: makeResolved('checksum'), srcFiles: [upstreamSrc] });
-        const makeDownstream = (storedStateKey) => makeTask('downstream', { resolved: makeResolved('checksum'), deps: [makeUpstream()], storedStateKey });
-        // First pass: capture the downstream effective key and pretend it was stored.
-        const keyBefore = (await (0, enqueue_next_1.checkCacheState)(makeDownstream(null), 'checksum', env)).stateKey;
-        const cachedHit = await (0, enqueue_next_1.checkCacheState)(makeDownstream(keyBefore), 'checksum', env);
-        expect(cachedHit.cached).toBe(true);
-        // Change ONLY the upstream source — downstream's own sources are untouched.
-        (0, fs_1.writeFileSync)(upstreamSrc, 'v2-changed');
-        const afterChange = await (0, enqueue_next_1.checkCacheState)(makeDownstream(keyBefore), 'checksum', env);
-        expect(afterChange.stateKey).not.toBe(keyBefore);
-        expect(afterChange.cached).toBe(false);
-    });
-    it('produces a stable key regardless of dependency declaration order', async () => {
-        const env = (0, environment_mock_1.environmentMock)(scratch);
-        const aSrc = (0, path_1.join)(scratch, 'a.txt');
-        const bSrc = (0, path_1.join)(scratch, 'b.txt');
-        (0, fs_1.writeFileSync)(aSrc, 'a');
-        (0, fs_1.writeFileSync)(bSrc, 'b');
-        const depA = () => makeTask('dep-a', { resolved: makeResolved('checksum'), srcFiles: [aSrc] });
-        const depB = () => makeTask('dep-b', { resolved: makeResolved('checksum'), srcFiles: [bSrc] });
-        const forward = makeTask('root', { resolved: makeResolved('checksum'), deps: [depA(), depB()] });
-        const reversed = makeTask('root', { resolved: makeResolved('checksum'), deps: [depB(), depA()] });
-        const keyForward = (await (0, enqueue_next_1.checkCacheState)(forward, 'checksum', env)).stateKey;
-        const keyReversed = (await (0, enqueue_next_1.checkCacheState)(reversed, 'checksum', env)).stateKey;
-        expect(keyForward).toBe(keyReversed);
-    });
-});
-//# sourceMappingURL=enqueue-next.spec.js.map

package/dist/executer/state-resolver.spec.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const state_resolver_1 = require("./state-resolver");
-const state_1 = require("./state");
-const abort_1 = require("./abort");
-describe('state-resolver', () => {
-    it('should resolve state', async () => {
-        const state = new state_1.State('a');
-        const isB = (val) => val === 'b';
-        const result = (0, state_resolver_1.isState)('test-state', state, isB, new AbortController().signal);
-        state.set('c');
-        state.set('a');
-        state.set('b');
-        await result;
-    });
-    it('should resolve state if already in', async () => {
-        const state = new state_1.State('b');
-        const isB = (val) => val === 'b';
-        await (0, state_resolver_1.isState)('test-state', state, isB, new AbortController().signal);
-    });
-    it('isState rejects with AbortError when aborted before the condition is met', async () => {
-        const state = new state_1.State('a');
-        const isB = (val) => val === 'b';
-        const abort = new AbortController();
-        const result = (0, state_resolver_1.isState)('test-state', state, isB, abort.signal);
-        abort.abort();
-        await expect(result).rejects.toBeInstanceOf(abort_1.AbortError);
-    });
-    it('awaitState rejects with AbortError when aborted before the condition is met', async () => {
-        const state = new state_1.State('a');
-        const abort = new AbortController();
-        const result = (0, state_resolver_1.awaitState)('test-state', state, (val) => val === 'b', abort.signal);
-        abort.abort();
-        await expect(result).rejects.toBeInstanceOf(abort_1.AbortError);
-    });
-});
-//# sourceMappingURL=state-resolver.spec.js.map

package/dist/executer/state.spec.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const state_1 = require("./state");
-describe('State', () => {
-    it('exposes the initial value via `current`', () => {
-        const s = new state_1.State(7);
-        expect(s.current).toBe(7);
-    });
-    it('set() updates current and returns the new value', () => {
-        const s = new state_1.State(0);
-        expect(s.set(3)).toBe(3);
-        expect(s.current).toBe(3);
-    });
-    it('notifies every registered listener on set()', () => {
-        const s = new state_1.State(0);
-        const a = vi.fn();
-        const b = vi.fn();
-        s.on('a', a);
-        s.on('b', b);
-        s.set(1);
-        expect(a).toHaveBeenCalledWith(1);
-        expect(b).toHaveBeenCalledWith(1);
-    });
-    it('close() on a listener handle stops further notifications', () => {
-        const s = new state_1.State(0);
-        const cb = vi.fn();
-        const handle = s.on('k', cb);
-        handle.close();
-        s.set(1);
-        expect(cb).not.toHaveBeenCalled();
-    });
-    it('close() on an already-removed listener is a no-op', () => {
-        const s = new state_1.State(0);
-        const handle = s.on('k', vi.fn());
-        handle.close();
-        expect(() => handle.close()).not.toThrow();
-    });
-    it('forwards sub-state changes to its own listeners', () => {
-        const sub = new state_1.State(0);
-        const parent = new state_1.State('p', { subStates: [sub] });
-        const cb = vi.fn();
-        parent.on('any', cb);
-        // emit a 'sub-state-forward' on the sub-state to trigger parent notification
-        sub.set(1); // sub.set notifies its listeners under whatever keys are registered
-        // The parent registered for 'sub-state-forward' on the sub; sub.set calls
-        // notifyListeners which dispatches to all listeners regardless of key, so
-        // the parent's forwarding listener fires and notifies parent listeners.
-        expect(cb).toHaveBeenCalledWith('p');
-    });
-    it('close() runs the onDestroy callback', () => {
-        const onDestroy = vi.fn();
-        const s = new state_1.State(0, { onDestroy });
-        s.close();
-        expect(onDestroy).toHaveBeenCalledTimes(1);
-    });
-    it('close() detaches sub-state forwarders', () => {
-        const sub = new state_1.State(0);
-        const parent = new state_1.State('p', { subStates: [sub] });
-        const cb = vi.fn();
-        parent.on('any', cb);
-        parent.close();
-        sub.set(1);
-        expect(cb).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=state.spec.js.map

package/dist/executer/states.spec.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const states_1 = require("./states");
-describe('getDuration', () => {
-    it('returns the milliseconds elapsed since the given start date', () => {
-        const started = new Date(Date.now() - 250);
-        const d = (0, states_1.getDuration)(started);
-        expect(d).toBeGreaterThanOrEqual(250);
-    });
-    it('returns 0 (or very small) for a start date that is essentially now', () => {
-        expect((0, states_1.getDuration)(new Date())).toBeGreaterThanOrEqual(0);
-    });
-});
-//# sourceMappingURL=states.spec.js.map

package/dist/file/get-file-context.spec.js

@@ -1,178 +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 stream_1 = require("stream");
-const get_file_context_1 = require("./get-file-context");
-describe('getFileContext', () => {
-    let cwd;
-    beforeEach(() => {
-        cwd = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-fc-'));
-    });
-    afterEach(() => {
-        // maxRetries handles Windows' transient ENOTEMPTY/EBUSY when a handle is
-        // released a beat after the test ends (mirrors getFileContext.remove). The
-        // stream tests below also await 'close' so this is only a safety net.
-        (0, fs_1.rmSync)(cwd, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-    });
-    describe('stats', () => {
-        it('reports type "directory" for a directory', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            expect((await fc.stats('.')).type).toBe('directory');
-        });
-        it('reports type "file" with lastModified for a regular file', async () => {
-            (0, fs_1.writeFileSync)((0, path_1.join)(cwd, 'a.txt'), 'x');
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            const s = await fc.stats('a.txt');
-            expect(s.type).toBe('file');
-            if (s.type === 'file') {
-                expect(s.lastModified).toBeGreaterThan(0);
-            }
-        });
-        it('rejects when the path does not exist', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            await expect(fc.stats('missing')).rejects.toThrow();
-        });
-        it('reports type "other" for non-file non-directory entries (symlink to missing)', async () => {
-            const link = (0, path_1.join)(cwd, 'link');
-            try {
-                (0, fs_1.symlinkSync)('/no/such/target', link);
-            }
-            catch {
-                // symlink may not be permitted on this platform — accept either outcome
-                return;
-            }
-            // statSync (used by stats()) follows symlinks; if the target is missing it errors.
-            // That is the existing behavior; we cover the rejection path here.
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            await expect(fc.stats('link')).rejects.toThrow();
-        });
-    });
-    describe('exists', () => {
-        it('resolves true for an existing path and false otherwise', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            expect(await fc.exists('.')).toBe(true);
-            expect(await fc.exists('nope')).toBe(false);
-        });
-    });
-    describe('writeFile / read / appendFile', () => {
-        it('writes, reads, and appends file content', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            await fc.writeFile('f.txt', 'hello');
-            expect(await fc.read('f.txt')).toBe('hello');
-            await fc.appendFile('f.txt', ' world');
-            expect(await fc.read('f.txt')).toBe('hello world');
-        });
-        it('read rejects on missing file', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            await expect(fc.read('missing.txt')).rejects.toThrow();
-        });
-    });
-    describe('listFiles', () => {
-        it('returns the entries in a directory', async () => {
-            (0, fs_1.writeFileSync)((0, path_1.join)(cwd, 'a'), '');
-            (0, fs_1.writeFileSync)((0, path_1.join)(cwd, 'b'), '');
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            expect((await fc.listFiles('.')).sort()).toEqual(['a', 'b']);
-        });
-    });
-    describe('createDirectory / remove', () => {
-        it('creates a directory recursively and removes it', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            await fc.createDirectory((0, path_1.join)('deep', 'inner'));
-            expect(await fc.exists((0, path_1.join)('deep', 'inner'))).toBe(true);
-            await fc.remove('deep');
-            expect(await fc.exists('deep')).toBe(false);
-        });
-        it('remove on a missing path is a no-op', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            await expect(fc.remove('nope')).resolves.toBeUndefined();
-        });
-    });
-    describe('copy', () => {
-        it('copies a file, creating the destination directory if needed', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            await fc.writeFile('src.txt', 'data');
-            await fc.copy('src.txt', (0, path_1.join)('dest', 'src.txt'));
-            expect((0, fs_1.readFileSync)((0, path_1.join)(cwd, 'dest', 'src.txt'), 'utf8')).toBe('data');
-        });
-        it('copies a directory recursively', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            (0, fs_1.mkdirSync)((0, path_1.join)(cwd, 'src', 'sub'), { recursive: true });
-            (0, fs_1.writeFileSync)((0, path_1.join)(cwd, 'src', 'a.txt'), 'a');
-            (0, fs_1.writeFileSync)((0, path_1.join)(cwd, 'src', 'sub', 'b.txt'), 'b');
-            await fc.copy('src', 'dest');
-            expect((0, fs_1.readFileSync)((0, path_1.join)(cwd, 'dest', 'a.txt'), 'utf8')).toBe('a');
-            expect((0, fs_1.readFileSync)((0, path_1.join)(cwd, 'dest', 'sub', 'b.txt'), 'utf8')).toBe('b');
-        });
-        it('copy of a missing source is a no-op', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            await expect(fc.copy('nope', 'dest')).resolves.toBeUndefined();
-            expect((0, fs_1.statSync)((0, path_1.join)(cwd))).toBeDefined(); // cwd still exists
-        });
-        it('copy preserves the destination directory when it already exists', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            await fc.writeFile('src.txt', 'x');
-            (0, fs_1.mkdirSync)((0, path_1.join)(cwd, 'dest'));
-            await fc.copy('src.txt', (0, path_1.join)('dest', 'src.txt'));
-            expect((0, fs_1.readFileSync)((0, path_1.join)(cwd, 'dest', 'src.txt'), 'utf8')).toBe('x');
-        });
-    });
-    describe('streams', () => {
-        it('writeStream pipes a Readable into a file', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            const target = (0, path_1.join)(cwd, 'out.bin');
-            await fc.writeStream(target, stream_1.Readable.from(['part-a', 'part-b']));
-            expect((0, fs_1.readFileSync)(target, 'utf8')).toBe('part-apart-b');
-        });
-        it('createWriteStream returns a writable stream', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            const target = (0, path_1.join)(cwd, 'wstream.txt');
-            const ws = fc.createWriteStream(target);
-            // Wait for 'close' (fd released), not just the end/'finish' callback (data
-            // flushed): on Windows an open write handle locks the file, so the afterEach
-            // rmSync would race it and fail with ENOTEMPTY.
-            await new Promise((resolve, reject) => {
-                ws.on('error', reject);
-                ws.on('close', () => resolve());
-                ws.end('payload');
-            });
-            expect((0, fs_1.readFileSync)(target, 'utf8')).toBe('payload');
-        });
-        it('readStream reads back what writeStream wrote', async () => {
-            const fc = (0, get_file_context_1.getFileContext)(cwd);
-            const target = (0, path_1.join)(cwd, 'r.txt');
-            (0, fs_1.writeFileSync)(target, 'abc');
-            const chunks = [];
-            await new Promise((resolve, reject) => {
-                const rs = fc.readStream(target);
-                rs.on('data', (c) => chunks.push(c));
-                rs.on('error', reject);
-                // 'close' (fd released) fires after 'end'; wait for it so an open read
-                // handle can't block the afterEach cleanup on Windows.
-                rs.on('close', resolve);
-            });
-            expect(Buffer.concat(chunks).toString()).toBe('abc');
-        });
-    });
-    describe('watch', () => {
-        it('returns a handle whose close() is callable; the polling override is honored', async () => {
-            const previous = process.env.HAMMERKIT_WATCH_POLLING;
-            process.env.HAMMERKIT_WATCH_POLLING = 'false';
-            try {
-                const fc = (0, get_file_context_1.getFileContext)(cwd);
-                const handle = fc.watch('.', () => undefined);
-                // close() returns a Promise on chokidar; await it
-                await Promise.resolve(handle.close());
-            }
-            finally {
-                if (previous === undefined)
-                    delete process.env.HAMMERKIT_WATCH_POLLING;
-                else
-                    process.env.HAMMERKIT_WATCH_POLLING = previous;
-            }
-        });
-    });
-});
-//# sourceMappingURL=get-file-context.spec.js.map

package/dist/file/move-files.spec.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const move_files_1 = require("./move-files");
-function context(existing) {
-    const remove = vi.fn(async () => undefined);
-    const copy = vi.fn(async () => undefined);
-    const env = {
-        file: {
-            exists: vi.fn(async (p) => existing.includes(p)),
-            remove,
-            copy,
-        },
-    };
-    return { env, remove, copy };
-}
-const item = { status: { write: vi.fn() } };
-function* once(from, to) {
-    yield { from, to };
-}
-describe('move-files', () => {
-    it('copies an existing folder and removes a pre-existing target first', async () => {
-        const { env, remove, copy } = context(['/a', '/out/a']);
-        await (0, move_files_1.moveFiles)(item, env, () => once('/a', '/out/a'));
-        expect(remove).toHaveBeenCalledWith('/out/a');
-        expect(copy).toHaveBeenCalledWith('/a', '/out/a');
-    });
-    it('does not remove the target when it does not exist yet', async () => {
-        const { env, remove, copy } = context(['/a']);
-        await (0, move_files_1.moveFiles)(item, env, () => once('/a', '/out/a'));
-        expect(remove).not.toHaveBeenCalled();
-        expect(copy).toHaveBeenCalledWith('/a', '/out/a');
-    });
-    it('skips folders whose source does not exist', async () => {
-        const { env, copy } = context([]);
-        await (0, move_files_1.moveFiles)(item, env, () => once('/missing', '/out/m'));
-        expect(copy).not.toHaveBeenCalled();
-    });
-    it('dedupes identical from/to pairs', async () => {
-        const { env, copy } = context(['/a']);
-        function* twice() {
-            yield { from: '/a', to: '/out/a' };
-            yield { from: '/a', to: '/out/a' };
-        }
-        await (0, move_files_1.moveFiles)(item, env, twice);
-        expect(copy).toHaveBeenCalledTimes(1);
-    });
-});
-//# sourceMappingURL=move-files.spec.js.map

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-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