cdd-cli 3.1.3 → 3.1.5

package/test/containerActions.test.js

@@ -0,0 +1,138 @@
+import { jest } from '@jest/globals';
+
+describe('containerActions service functions (mocked ESM imports)', () => {
+  afterEach(() => jest.resetModules());
+
+  test('createContainer returns id when image exists', async () => {
+    // mock imageUtils and dockerService before importing the module under test
+    const imageUtilsMock = {
+      imageExists: jest.fn().mockResolvedValue(true),
+      pullImage: jest.fn()
+    };
+
+    const inspectMock = jest.fn().mockResolvedValue({ Config: { ExposedPorts: {} } });
+    const dockerMock = {
+      createContainer: jest.fn().mockResolvedValue({ id: 'cid-123' }),
+      getImage: jest.fn().mockReturnValue({ inspect: inspectMock }),
+      listContainers: jest.fn().mockResolvedValue([])
+    };
+
+    await jest.unstable_mockModule('../src/helpers/dockerService/serviceComponents/imageUtils.js', () => ({
+      ...imageUtilsMock
+    }));
+
+    await jest.unstable_mockModule('../src/helpers/dockerService/dockerService.js', () => ({
+      docker: dockerMock
+    }));
+
+    const mod = await import('../src/helpers/dockerService/serviceComponents/containerActions.js');
+
+    const id = await mod.createContainer('nginx:latest', { Name: 'test' });
+    expect(id).toBe('cid-123');
+    const imageUtils = await import('../src/helpers/dockerService/serviceComponents/imageUtils.js');
+    expect(imageUtils.imageExists).toHaveBeenCalledWith('nginx:latest');
+    const ds = await import('../src/helpers/dockerService/dockerService.js');
+    expect(ds.docker.createContainer).toHaveBeenCalled();
+    expect(ds.docker.getImage).toHaveBeenCalledWith('nginx:latest');
+  });
+
+  test('createContainer pulls image when not present and returns Id', async () => {
+    const imageUtilsMock = {
+      imageExists: jest.fn().mockResolvedValue(false),
+      pullImage: jest.fn().mockResolvedValue(true)
+    };
+
+    const inspectMock = jest.fn().mockResolvedValue({ Config: { ExposedPorts: {} } });
+    const dockerMock = {
+      createContainer: jest.fn().mockResolvedValue({ Id: 'CID-456' }),
+      getImage: jest.fn().mockReturnValue({ inspect: inspectMock }),
+      listContainers: jest.fn().mockResolvedValue([])
+    };
+
+    await jest.unstable_mockModule('../src/helpers/dockerService/serviceComponents/imageUtils.js', () => ({
+      ...imageUtilsMock
+    }));
+
+    await jest.unstable_mockModule('../src/helpers/dockerService/dockerService.js', () => ({
+      docker: dockerMock
+    }));
+
+    const mod = await import('../src/helpers/dockerService/serviceComponents/containerActions.js');
+    const id = await mod.createContainer('busybox:1.0');
+    expect(id).toBe('CID-456');
+    const imageUtils = await import('../src/helpers/dockerService/serviceComponents/imageUtils.js');
+    expect(imageUtils.pullImage).toHaveBeenCalledWith('busybox:1.0');
+  });
+
+  test('createContainer auto maps exposed ports when ports not provided', async () => {
+    const imageUtilsMock = {
+      imageExists: jest.fn().mockResolvedValue(true),
+      pullImage: jest.fn()
+    };
+
+    const inspectMock = jest.fn().mockResolvedValue({ Config: { ExposedPorts: { '80/tcp': {} } } });
+    const createContainerMock = jest.fn().mockResolvedValue({ id: 'cid-auto' });
+    const dockerMock = {
+      createContainer: createContainerMock,
+      getImage: jest.fn().mockReturnValue({ inspect: inspectMock }),
+      listContainers: jest.fn().mockResolvedValue([
+        { Ports: [{ PublicPort: 80, PrivatePort: 80 }] }
+      ])
+    };
+
+    await jest.unstable_mockModule('../src/helpers/dockerService/serviceComponents/imageUtils.js', () => ({
+      ...imageUtilsMock
+    }));
+
+    await jest.unstable_mockModule('../src/helpers/dockerService/dockerService.js', () => ({
+      docker: dockerMock
+    }));
+
+    const mod = await import('../src/helpers/dockerService/serviceComponents/containerActions.js');
+    await mod.createContainer('nginx:alpine');
+
+    const [[createArgs]] = createContainerMock.mock.calls;
+    expect(createArgs.ExposedPorts).toEqual({ '80/tcp': {} });
+    expect(createArgs.HostConfig.PortBindings['80/tcp']).toEqual([{ HostPort: '81' }]);
+    expect(dockerMock.listContainers).toHaveBeenCalled();
+  });
+
+  test('removeContainer calls docker.remove with force', async () => {
+    const removeMock = jest.fn().mockResolvedValue(undefined);
+    const dockerMock = {
+      getContainer: jest.fn().mockReturnValue({ remove: removeMock })
+    };
+
+    await jest.unstable_mockModule('../src/helpers/dockerService/dockerService.js', () => ({ docker: dockerMock }));
+    await jest.unstable_mockModule('../src/helpers/dockerService/serviceComponents/imageUtils.js', () => ({ imageExists: jest.fn(), pullImage: jest.fn() }));
+
+    const mod = await import('../src/helpers/dockerService/serviceComponents/containerActions.js');
+    await mod.removeContainer('abc');
+    const ds = await import('../src/helpers/dockerService/dockerService.js');
+    expect(ds.docker.getContainer).toHaveBeenCalledWith('abc');
+    expect(removeMock).toHaveBeenCalledWith({ force: true });
+  });
+
+  test('start/stop/restart call respective container methods', async () => {
+    const startMock = jest.fn().mockResolvedValue(undefined);
+    const stopMock = jest.fn().mockResolvedValue(undefined);
+    const restartMock = jest.fn().mockResolvedValue(undefined);
+
+    const dockerMock = {
+      getContainer: jest.fn().mockReturnValue({ start: startMock, stop: stopMock, restart: restartMock })
+    };
+
+    await jest.unstable_mockModule('../src/helpers/dockerService/dockerService.js', () => ({ docker: dockerMock }));
+    await jest.unstable_mockModule('../src/helpers/dockerService/serviceComponents/imageUtils.js', () => ({ imageExists: jest.fn(), pullImage: jest.fn() }));
+
+    const mod = await import('../src/helpers/dockerService/serviceComponents/containerActions.js');
+
+    await mod.startContainer('c1');
+    await mod.stopContainer('c1');
+    await mod.restartContainer('c1');
+
+    expect(startMock).toHaveBeenCalled();
+    expect(stopMock).toHaveBeenCalled();
+    expect(restartMock).toHaveBeenCalled();
+  });
+});

package/test/containerList.test.js

@@ -0,0 +1,79 @@
+import { jest } from '@jest/globals';
+
+describe('containerList.getContainers', () => {
+  afterEach(() => jest.resetModules());
+
+  const baseContainer = {
+    Id: 'abc123',
+    Image: 'nginx:latest',
+    State: 'running',
+    Status: 'Up 5 minutes',
+    Ports: []
+  };
+
+  test('falls back to container.Name when Names array is missing', async () => {
+    const dockerMock = {
+      listContainers: jest.fn().mockResolvedValue([
+        {
+          ...baseContainer,
+          Names: undefined,
+          Name: '/custom-container'
+        }
+      ])
+    };
+
+    await jest.unstable_mockModule('../src/helpers/dockerService/dockerService.js', () => ({
+      docker: dockerMock
+    }));
+
+    const mod = await import('../src/helpers/dockerService/serviceComponents/containerList.js');
+    const containers = await mod.getContainers();
+
+    expect(containers).toHaveLength(1);
+    expect(containers[0].name).toBe('custom-container');
+  });
+
+  test('returns Unknown when no usable name data is present', async () => {
+    const dockerMock = {
+      listContainers: jest.fn().mockResolvedValue([
+        {
+          ...baseContainer,
+          Names: [],
+          Name: '',
+          Id: 'def456'
+        }
+      ])
+    };
+
+    await jest.unstable_mockModule('../src/helpers/dockerService/dockerService.js', () => ({
+      docker: dockerMock
+    }));
+
+    const mod = await import('../src/helpers/dockerService/serviceComponents/containerList.js');
+    const containers = await mod.getContainers();
+
+    expect(containers).toHaveLength(1);
+    expect(containers[0].name).toBe('Unknown');
+  });
+
+  test('normalizes first entry in Names array', async () => {
+    const dockerMock = {
+      listContainers: jest.fn().mockResolvedValue([
+        {
+          ...baseContainer,
+          Names: ['///leading/slash', '/ignored-second']
+        }
+      ])
+    };
+
+    await jest.unstable_mockModule('../src/helpers/dockerService/dockerService.js', () => ({
+      docker: dockerMock
+    }));
+
+    const mod = await import('../src/helpers/dockerService/serviceComponents/containerList.js');
+    const containers = await mod.getContainers();
+
+    expect(containers).toHaveLength(1);
+    expect(containers[0].name).toBe('leading/slash');
+  });
+});

package/test/jest.setup.js

@@ -0,0 +1,7 @@
+// Minimal test setup for React/DOM environment
+// Could add more global matchers here
+import '@testing-library/jest-dom';
+
+// Silence act() warnings in environments where receiver isn't concurrent
+// (react-test-renderer/act warnings are printed, but tests can proceed)
+// If needed, configure global helpers here.

package/test/safeCall.test.js

@@ -0,0 +1,25 @@
+import { safeCall } from '../src/helpers/safeCall.js';
+
+describe('safeCall', () => {
+  test('calls function and returns value', () => {
+    function fn(a, b) {
+      fn.called = true;
+      fn.args = [a, b];
+      return a + b;
+    }
+    const res = safeCall(fn, 2, 3);
+    expect(fn.called).toBe(true);
+    expect(fn.args).toEqual([2, 3]);
+    expect(res).toBe(5);
+  });
+
+  test('returns undefined when fn is not a function', () => {
+    const res = safeCall(undefined, 1, 2);
+    expect(res).toBeUndefined();
+  });
+
+  test('catches errors thrown by function and does not rethrow', () => {
+    const bad = () => { throw new Error('boom'); };
+    expect(() => safeCall(bad)).not.toThrow();
+  });
+});

package/test/useContainerCreation.dom.test.js

@@ -0,0 +1,97 @@
+import React, { useEffect } from 'react';
+import { render, act } from '@testing-library/react';
+import { useContainerCreation } from '../src/hooks/creation/useContainerCreation.js';
+
+function HookTester({ onCreate, onCancel, dbImages, expose }) {
+  const hook = useContainerCreation({ onCreate, onCancel, dbImages });
+  // keep exposing the latest hook values on every render
+  useEffect(() => {
+    if (expose) expose.current = hook;
+  });
+  return null;
+}
+
+describe('useContainerCreation (DOM render)', () => {
+  test('image empty shows error and does not advance', () => {
+    const expose = { current: null };
+    render(<HookTester onCreate={() => {}} onCancel={() => {}} dbImages={[]} expose={expose} />);
+
+      expect(expose.current.step).toBe(0);
+
+      act(() => {
+        expose.current.nextStep();
+      });
+
+      expect(expose.current.message).toBe('Image name cannot be empty.');
+      expect(expose.current.step).toBe(0);
+  });
+
+  test('ports validation: invalid ports shows error', () => {
+    const expose = { current: null };
+    render(<HookTester onCreate={() => {}} onCancel={() => {}} dbImages={[]} expose={expose} />);
+
+      act(() => {
+        expose.current.setImageName('nginx');
+      });
+
+      act(() => {
+        expose.current.nextStep(); // to name
+      });
+
+      act(() => {
+        expose.current.nextStep(); // to ports
+      });
+
+      expect(expose.current.step).toBe(2);
+
+      act(() => {
+        expose.current.setPortInput('notaport');
+      });
+
+      act(() => {
+        expose.current.nextStep();
+      });
+
+      expect(expose.current.message).toBe('Port format must be host:container and both must be numbers (e.g. 8080:80)');
+      expect(expose.current.step).toBe(2);
+  });
+
+  test('complete flow calls onCreate with data', () => {
+    const created = [];
+    const onCreate = (data) => created.push(data);
+    const expose = { current: null };
+
+    render(<HookTester onCreate={onCreate} onCancel={() => {}} dbImages={[]} expose={expose} />);
+
+      act(() => {
+        expose.current.setImageName('redis');
+      });
+
+      act(() => {
+        expose.current.nextStep(); // to name
+      });
+
+      act(() => {
+        expose.current.nextStep(); // to ports
+      });
+
+      act(() => {
+        expose.current.setPortInput('');
+      });
+
+      act(() => {
+        expose.current.nextStep(); // to env
+      });
+
+      act(() => {
+        expose.current.setEnvInput('FOO=bar');
+      });
+
+      act(() => {
+        expose.current.nextStep(); // final create
+      });
+
+      expect(created.length).toBe(1);
+      expect(created[0]).toEqual({ imageName: 'redis', containerName: '', portInput: '', envInput: 'FOO=bar' });
+  });
+});

package/test/validationHelpers.test.js

@@ -24,8 +24,8 @@ describe('validatePorts', () => {
     expect(validatePorts('eighty:80')).toBe(false);
   });
 
-  test('empty input returns false (must specify at least one port)', () => {
-    expect(validatePorts('')).toBe(false);
+  test('empty input is valid (ports are optional)', () => {
+    expect(validatePorts('')).toBe(true);
   });
 });