kova-node-cli 0.1.0

package/dist/__tests__/deployment-executor.test.js

@@ -0,0 +1,332 @@
+// tests for DeploymentExecutor - deployment lifecycle, shell sessions, events
+jest.mock('../lib/logger.js', () => ({
+    logger: { info: jest.fn(), error: jest.fn(), warn: jest.fn(), debug: jest.fn() }
+}));
+// mock dockerode
+const mockStream = {
+    on: jest.fn(),
+    write: jest.fn(),
+    end: jest.fn()
+};
+const mockExec = {
+    start: jest.fn().mockResolvedValue(mockStream),
+    resize: jest.fn()
+};
+const mockContainerInstance = {
+    id: 'ctr-abc123',
+    start: jest.fn().mockResolvedValue(undefined),
+    stop: jest.fn().mockResolvedValue(undefined),
+    remove: jest.fn().mockResolvedValue(undefined),
+    inspect: jest.fn().mockResolvedValue({
+        State: { Running: true, Status: 'running', StartedAt: new Date().toISOString(), FinishedAt: '0001-01-01T00:00:00Z', ExitCode: 0 },
+        Config: { Image: 'node:20-alpine', Env: [], WorkingDir: '/', ExposedPorts: {} },
+        HostConfig: { NetworkMode: 'bridge', Binds: [] },
+        RestartCount: 0,
+        Mounts: [],
+        NetworkSettings: { Networks: {} }
+    }),
+    exec: jest.fn().mockResolvedValue(mockExec),
+    logs: jest.fn().mockImplementation((_opts, cb) => {
+        // noop - just don't call cb to avoid issues
+    }),
+    modem: {
+        demuxStream: jest.fn()
+    }
+};
+const mockNetwork = {
+    id: 'net-123',
+    remove: jest.fn().mockResolvedValue(undefined)
+};
+const mockVolume = {
+    Name: 'kova-deploy1-web-data',
+    remove: jest.fn().mockResolvedValue(undefined)
+};
+const mockDocker = {
+    createContainer: jest.fn().mockResolvedValue(mockContainerInstance),
+    createNetwork: jest.fn().mockResolvedValue(mockNetwork),
+    createVolume: jest.fn().mockResolvedValue(mockVolume),
+    getContainer: jest.fn().mockReturnValue(mockContainerInstance),
+    getNetwork: jest.fn().mockReturnValue(mockNetwork),
+    getVolume: jest.fn().mockReturnValue(mockVolume),
+    listContainers: jest.fn().mockResolvedValue([]),
+    listNetworks: jest.fn().mockResolvedValue([]),
+    listVolumes: jest.fn().mockResolvedValue({ Volumes: [] }),
+    pull: jest.fn().mockImplementation((_image, _optsOrCb, maybeCb) => {
+        // handle both pull(image, cb) and pull(image, opts, cb) signatures
+        const cb = typeof maybeCb === 'function' ? maybeCb : _optsOrCb;
+        const fakeStream = { on: jest.fn() };
+        cb(null, fakeStream);
+    }),
+    modem: {
+        followProgress: jest.fn().mockImplementation((_stream, onFinish) => {
+            onFinish(null);
+        })
+    },
+    run: jest.fn().mockResolvedValue(undefined)
+};
+jest.mock('dockerode', () => {
+    return jest.fn().mockImplementation(() => mockDocker);
+});
+import { DeploymentExecutor } from '../services/deployment-executor';
+describe('DeploymentExecutor', () => {
+    let executor;
+    const simpleManifest = {
+        version: '2.0',
+        services: {
+            web: {
+                image: 'nginx:latest',
+                expose: [{ port: 80, as: 80, to: [{ global: true }] }]
+            }
+        },
+        profiles: {
+            compute: {
+                webProfile: {
+                    resources: {
+                        cpu: { units: 2 },
+                        memory: { size: '512Mi' }
+                    }
+                }
+            }
+        },
+        deployment: {
+            web: {
+                myProvider: { profile: 'webProfile', count: 1 }
+            }
+        }
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // reset container inspect to say it's not running (for create flow)
+        mockContainerInstance.inspect.mockRejectedValue(new Error('not found'));
+        executor = new DeploymentExecutor({
+            orchestratorUrl: 'http://localhost:3000',
+            apiKey: 'sk_test_key'
+        });
+    });
+    // -- executeDeployment --
+    it('should create network, pull image, create and start container', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        expect(mockDocker.createNetwork).toHaveBeenCalledWith(expect.objectContaining({
+            Name: expect.stringContaining('kova-deploy-'),
+            Driver: 'bridge'
+        }));
+        expect(mockDocker.pull).toHaveBeenCalledWith('nginx:latest', expect.any(Object), expect.any(Function));
+        expect(mockDocker.createContainer).toHaveBeenCalledWith(expect.objectContaining({
+            Image: 'nginx:latest',
+            Labels: expect.objectContaining({
+                'kova.deployment': 'deploy-1',
+                'kova.service': 'web'
+            })
+        }));
+        expect(mockContainerInstance.start).toHaveBeenCalled();
+    });
+    it('should emit deployment-started event', async () => {
+        const events = [];
+        executor.on('deployment-started', (data) => events.push(data));
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        expect(events).toHaveLength(1);
+        expect(events[0].deploymentId).toBe('deploy-1');
+        expect(events[0].leaseId).toBe('lease-1');
+    });
+    it('should track deployment in running list', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        expect(executor.getRunningDeployments()).toContain('deploy-1');
+    });
+    it('should return deployment info via getDeployment', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        const dep = executor.getDeployment('deploy-1');
+        expect(dep).toBeDefined();
+        expect(dep.deploymentId).toBe('deploy-1');
+        expect(dep.leaseId).toBe('lease-1');
+    });
+    it('should return undefined for unknown deployment', () => {
+        expect(executor.getDeployment('nope')).toBeUndefined();
+    });
+    // -- resource limits from manifest --
+    it('should apply memory limit from compute profile', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        const containerConfig = mockDocker.createContainer.mock.calls[0][0];
+        // 512Mi = 512 * 1024^2 = 536870912 bytes
+        expect(containerConfig.HostConfig.Memory).toBe(536870912);
+    });
+    it('should apply cpu limit from compute profile', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        const containerConfig = mockDocker.createContainer.mock.calls[0][0];
+        // 2 cores: CpuQuota = 2 * 100000 = 200000
+        expect(containerConfig.HostConfig.CpuQuota).toBe(200000);
+    });
+    // -- stopDeployment --
+    it('should stop containers but preserve volumes', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        await executor.stopDeployment('deploy-1');
+        expect(mockContainerInstance.stop).toHaveBeenCalled();
+        expect(mockContainerInstance.remove).toHaveBeenCalled();
+        expect(executor.getRunningDeployments()).not.toContain('deploy-1');
+    });
+    it('should silently handle stop for unknown deployment', async () => {
+        await executor.stopDeployment('nonexistent');
+        // no throw
+    });
+    // -- closeDeployment --
+    it('should stop containers and delete volumes', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        await executor.closeDeployment('deploy-1');
+        expect(mockContainerInstance.stop).toHaveBeenCalled();
+        expect(executor.getRunningDeployments()).not.toContain('deploy-1');
+        // should attempt to list and cleanup volumes
+        expect(mockDocker.listVolumes).toHaveBeenCalled();
+    });
+    it('should attempt volume cleanup even if deployment is not in memory', async () => {
+        await executor.closeDeployment('orphaned-deploy');
+        expect(mockDocker.listVolumes).toHaveBeenCalledWith({
+            filters: { name: ['kova-orphaned-deploy'] }
+        });
+    });
+    // -- shell sessions --
+    it('should start shell session in deployment container', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        // mock container inspect to say it's running for shell
+        mockContainerInstance.inspect.mockResolvedValue({
+            State: { Running: true, Status: 'running', StartedAt: new Date().toISOString(), FinishedAt: '0001-01-01T00:00:00Z', ExitCode: 0 },
+            Config: { Image: 'node:20-alpine', Env: [], WorkingDir: '/', ExposedPorts: {} },
+            HostConfig: { NetworkMode: 'bridge', Binds: [] },
+            RestartCount: 0,
+            Mounts: [],
+            NetworkSettings: { Networks: {} }
+        });
+        const onOutput = jest.fn();
+        const result = await executor.startShellSession('sess-1', 'deploy-1', 'web', onOutput);
+        expect(result).toEqual({ success: true });
+        expect(mockContainerInstance.exec).toHaveBeenCalledWith(expect.objectContaining({
+            Cmd: ['/bin/sh'],
+            AttachStdin: true,
+            AttachStdout: true,
+            Tty: true
+        }));
+    });
+    it('should return error for shell on unknown deployment', async () => {
+        const result = await executor.startShellSession('sess-1', 'nope', 'web', jest.fn());
+        expect(result.success).toBe(false);
+        expect(result.error).toBeDefined();
+    });
+    it('should send input to shell session', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        mockContainerInstance.inspect.mockResolvedValue({
+            State: { Running: true }, Config: { Image: 'test', Env: [], WorkingDir: '/', ExposedPorts: {} },
+            HostConfig: { NetworkMode: 'bridge', Binds: [] }, RestartCount: 0, Mounts: [], NetworkSettings: { Networks: {} }
+        });
+        await executor.startShellSession('sess-1', 'deploy-1', 'web', jest.fn());
+        const ok = executor.sendShellInput('sess-1', 'ls\n');
+        expect(ok).toBe(true);
+        expect(mockStream.write).toHaveBeenCalledWith('ls\n');
+    });
+    it('should return false for input to nonexistent session', () => {
+        expect(executor.sendShellInput('nope', 'ls')).toBe(false);
+    });
+    it('should resize shell terminal', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        mockContainerInstance.inspect.mockResolvedValue({
+            State: { Running: true }, Config: { Image: 'test', Env: [], WorkingDir: '/', ExposedPorts: {} },
+            HostConfig: { NetworkMode: 'bridge', Binds: [] }, RestartCount: 0, Mounts: [], NetworkSettings: { Networks: {} }
+        });
+        await executor.startShellSession('sess-1', 'deploy-1', 'web', jest.fn());
+        const ok = executor.resizeShell('sess-1', 120, 40);
+        expect(ok).toBe(true);
+        expect(mockExec.resize).toHaveBeenCalledWith({ h: 40, w: 120 });
+    });
+    it('should close shell session', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        mockContainerInstance.inspect.mockResolvedValue({
+            State: { Running: true }, Config: { Image: 'test', Env: [], WorkingDir: '/', ExposedPorts: {} },
+            HostConfig: { NetworkMode: 'bridge', Binds: [] }, RestartCount: 0, Mounts: [], NetworkSettings: { Networks: {} }
+        });
+        await executor.startShellSession('sess-1', 'deploy-1', 'web', jest.fn());
+        executor.closeShellSession('sess-1');
+        expect(mockStream.end).toHaveBeenCalled();
+        // session should be gone now
+        expect(executor.sendShellInput('sess-1', 'test')).toBe(false);
+    });
+    // -- security --
+    it('should set security options on container', async () => {
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: simpleManifest
+        });
+        const containerConfig = mockDocker.createContainer.mock.calls[0][0];
+        expect(containerConfig.HostConfig.Privileged).toBe(false);
+        expect(containerConfig.HostConfig.CapDrop).toContain('ALL');
+        expect(containerConfig.HostConfig.SecurityOpt).toContain('no-new-privileges:true');
+    });
+    // -- multi-service --
+    it('should start multiple services from manifest', async () => {
+        const multiManifest = {
+            ...simpleManifest,
+            services: {
+                web: { image: 'nginx:latest' },
+                api: { image: 'node:20' }
+            },
+            deployment: {
+                web: { myProvider: { profile: 'webProfile', count: 1 } },
+                api: { myProvider: { profile: 'webProfile', count: 1 } }
+            }
+        };
+        await executor.executeDeployment({
+            deploymentId: 'deploy-1',
+            leaseId: 'lease-1',
+            manifest: multiManifest
+        });
+        // should have pulled both images
+        expect(mockDocker.pull).toHaveBeenCalledTimes(2);
+        // should have created 2 containers
+        expect(mockDocker.createContainer).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/__tests__/heartbeat.test.js

@@ -0,0 +1,191 @@
+// tests for HeartbeatService - heartbeat lifecycle, events, payload
+jest.mock('../lib/logger.js', () => ({
+    logger: { info: jest.fn(), error: jest.fn(), warn: jest.fn(), debug: jest.fn() }
+}));
+import { HeartbeatService } from '../services/heartbeat';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+// mock resource monitor
+const mockMonitor = {
+    getAvailableResources: jest.fn().mockResolvedValue({
+        cpu: { cores: 8, available: 6 },
+        memory: { total: 32, available: 24 },
+        disk: [{ path: '/', total: 500, available: 400 }],
+        network: { bandwidth: 100 },
+        gpu: [{ vendor: 'nvidia', model: 'rtx 4090', vram: 24 }]
+    }),
+    start: jest.fn(),
+    stop: jest.fn()
+};
+// mock limit manager
+const mockLimitManager = {
+    getLimits: jest.fn().mockReturnValue({ cpu: 4, memory: 16, disk: 200 }),
+    getAvailableResources: jest.fn().mockReturnValue({ cpu: 3, memory: 12, disk: 150 }),
+    getCurrentUsage: jest.fn().mockReturnValue({ cpu: 1, memory: 4, disk: 50 })
+};
+describe('HeartbeatService', () => {
+    let hb;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.useFakeTimers();
+        hb = new HeartbeatService('node-abc', 'http://localhost:3000', mockMonitor, mockLimitManager, 30 // 30s interval
+        );
+    });
+    afterEach(async () => {
+        await hb.stop();
+        jest.useRealTimers();
+    });
+    // -- start/stop --
+    it('should send initial heartbeat on start', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ timestamp: Date.now() })
+        });
+        await hb.start();
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/nodes/node-abc/heartbeat', expect.objectContaining({
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' }
+        }));
+    });
+    it('should mark as active after start', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({})
+        });
+        expect(hb.isActive()).toBe(false);
+        await hb.start();
+        expect(hb.isActive()).toBe(true);
+    });
+    it('should mark as inactive after stop', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({})
+        });
+        await hb.start();
+        await hb.stop();
+        expect(hb.isActive()).toBe(false);
+    });
+    it('should not start twice', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({})
+        });
+        await hb.start();
+        await hb.start();
+        // only 1 initial heartbeat
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+    });
+    // -- heartbeat payload --
+    it('should send provider limits in payload, not raw system resources', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({})
+        });
+        await hb.start();
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        // should use limit manager values, not monitor values
+        expect(body.resources.cpu.cores).toBe(4); // from getLimits()
+        expect(body.resources.cpu.available).toBe(3); // from getAvailableResources()
+        expect(body.resources.memory.total).toBe(16);
+        expect(body.resources.memory.available).toBe(12);
+    });
+    it('should include gpu info from monitor', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({})
+        });
+        await hb.start();
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.resources.gpu).toHaveLength(1);
+        expect(body.resources.gpu[0].vendor).toBe('nvidia');
+    });
+    // -- events --
+    it('should emit heartbeat-success on ok response', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ timestamp: 12345 })
+        });
+        const events = [];
+        hb.on('heartbeat-success', (data) => events.push(data));
+        await hb.start();
+        expect(events).toHaveLength(1);
+        expect(events[0].timestamp).toBe(12345);
+        expect(events[0].resources).toBeDefined();
+    });
+    it('should emit heartbeat-error on non-ok response', async () => {
+        mockFetch.mockResolvedValue({
+            ok: false,
+            status: 500,
+            text: async () => 'server error'
+        });
+        const errors = [];
+        hb.on('heartbeat-error', (data) => errors.push(data));
+        await hb.start();
+        expect(errors).toHaveLength(1);
+        expect(errors[0].status).toBe(500);
+    });
+    it('should emit heartbeat-error on network failure', async () => {
+        mockFetch.mockRejectedValue(new Error('connection refused'));
+        const errors = [];
+        hb.on('heartbeat-error', (data) => errors.push(data));
+        await hb.start();
+        expect(errors).toHaveLength(1);
+        expect(errors[0].error).toBeInstanceOf(Error);
+    });
+    it('should emit pending-jobs when orchestrator returns them', async () => {
+        const pendingJobs = [
+            { id: 'job-1', manifest: {} },
+            { id: 'job-2', manifest: {} }
+        ];
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ timestamp: Date.now(), pendingJobs })
+        });
+        const received = [];
+        hb.on('pending-jobs', (jobs) => received.push(jobs));
+        await hb.start();
+        expect(received).toHaveLength(1);
+        expect(received[0]).toEqual(pendingJobs);
+    });
+    it('should not emit pending-jobs when list is empty', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({ timestamp: Date.now(), pendingJobs: [] })
+        });
+        const received = [];
+        hb.on('pending-jobs', (jobs) => received.push(jobs));
+        await hb.start();
+        expect(received).toHaveLength(0);
+    });
+    // -- triggerHeartbeat --
+    it('should allow manual heartbeat trigger', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({})
+        });
+        await hb.start();
+        mockFetch.mockClear();
+        await hb.triggerHeartbeat();
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+    });
+    // -- interval --
+    it('should send periodic heartbeats', async () => {
+        jest.useRealTimers(); // real timers needed for this test
+        const shortHb = new HeartbeatService('node-abc', 'http://localhost:3000', mockMonitor, mockLimitManager, 1 // 1 second interval
+        );
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => ({})
+        });
+        await shortHb.start();
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        // wait a bit over 1 second for the interval to fire
+        await new Promise(r => setTimeout(r, 1500));
+        expect(mockFetch.mock.calls.length).toBeGreaterThanOrEqual(2);
+        await shortHb.stop();
+    });
+});
+function flushPromises() {
+    return new Promise((resolve) => setImmediate(resolve));
+}