cdd-cli 3.2.2 → 4.0.0

package/test/ContainerCreationPrompt.dom.test.js

@@ -65,4 +65,249 @@ describe('ContainerCreationPrompt — SuggestionPanel wiring', () => {
     const nginxEls = getAllByText(/nginx/);
     expect(nginxEls.length).toBeGreaterThan(0);
   });
+
+  // FR8 — hubResults wiring
+  test('when hubResults is provided, activeItems = hubResults (replaces suggestions)', () => {
+    const { getByText, queryByText } = render(
+      <ContainerCreationPrompt
+        step={0}
+        imageName="ng"
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={['nginx', 'golang']}
+        hubResults={['hub-nginx', 'hub-node']}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+      />
+    );
+    expect(getByText(/hub-nginx/)).toBeTruthy();
+    expect(queryByText(/golang/)).toBeNull();
+  });
+
+  test('when hubResults is null, falls back to suggestions', () => {
+    const { getByText } = render(
+      <ContainerCreationPrompt
+        step={0}
+        imageName="ng"
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={['nginx', 'golang']}
+        hubResults={null}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+      />
+    );
+    expect(getByText(/golang/)).toBeTruthy();
+  });
+
+  test('when step===0 and isSearchingHub=true, SuggestionPanel is shown even if activeItems is empty', () => {
+    const { getByText } = render(
+      <ContainerCreationPrompt
+        step={0}
+        imageName="ng"
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={[]}
+        hubResults={null}
+        isSearchingHub={true}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+      />
+    );
+    expect(getByText(/searching Docker Hub/)).toBeTruthy();
+  });
+
+  test('when step===0 and isSearchingHub=false and activeItems is empty, SuggestionPanel is NOT shown', () => {
+    const { queryByTestId } = render(
+      <ContainerCreationPrompt
+        step={0}
+        imageName="ng"
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={[]}
+        hubResults={null}
+        isSearchingHub={false}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+      />
+    );
+    expect(queryByTestId('suggestion-panel')).toBeNull();
+  });
+
+  test('isLoading prop is passed down to SuggestionPanel when isSearchingHub=true', () => {
+    const { getByText } = render(
+      <ContainerCreationPrompt
+        step={0}
+        imageName="ng"
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={['nginx']}
+        hubResults={null}
+        isSearchingHub={true}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+      />
+    );
+    expect(getByText(/searching Docker Hub/)).toBeTruthy();
+  });
+});
+
+describe('ContainerCreationPrompt — ControlsHUD wiring', () => {
+  test('step=0, no suggestions: renders ControlsHUD with [Tab] and Search Hub', () => {
+    const { getByText } = render(
+      <ContainerCreationPrompt
+        step={0}
+        imageName=""
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={[]}
+        hubResults={null}
+        isSearchingHub={false}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+      />
+    );
+    expect(getByText('[Tab]')).toBeTruthy();
+    expect(getByText(/Search Hub/)).toBeTruthy();
+  });
+
+  test('does NOT render old static text "Press Enter to continue, Escape to cancel"', () => {
+    const { queryByText } = render(
+      <ContainerCreationPrompt
+        step={0}
+        imageName=""
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={[]}
+        hubResults={null}
+        isSearchingHub={false}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+      />
+    );
+    expect(queryByText(/Press Enter to continue, Escape to cancel/)).toBeNull();
+  });
+
+  test('step=0, hasSuggestions=true: renders [↑↓] not [Tab]', () => {
+    const { getByText, queryByText } = render(
+      <ContainerCreationPrompt
+        step={0}
+        imageName="ng"
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={['nginx', 'golang']}
+        hubResults={null}
+        isSearchingHub={false}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+      />
+    );
+    expect(getByText('[↑↓]')).toBeTruthy();
+    expect(queryByText('[Tab]')).toBeNull();
+  });
+
+  test('step=0, isSearchingHub=true, no suggestions: ControlsHUD does NOT render [Tab] or Navigate, DOES render [Enter] and [Esc]', () => {
+    const { queryByText, getByText } = render(
+      <ContainerCreationPrompt
+        step={0}
+        imageName="ng"
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={[]}
+        hubResults={null}
+        isSearchingHub={true}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+      />
+    );
+    expect(queryByText('[Tab]')).toBeNull();
+    expect(queryByText(/Navigate/)).toBeNull();
+    expect(getByText('[Enter]')).toBeTruthy();
+    expect(getByText('[Esc]')).toBeTruthy();
+  });
+
+  test('step=1: renders [Enter] and [Esc]', () => {
+    const { getByText } = render(
+      <ContainerCreationPrompt
+        step={1}
+        imageName="nginx"
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={[]}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+      />
+    );
+    expect(getByText('[Enter]')).toBeTruthy();
+    expect(getByText('[Esc]')).toBeTruthy();
+  });
+
+  test('step=3, hasSuggestedEnv=true: renders [Tab] in HUD', () => {
+    const { getByText } = render(
+      <ContainerCreationPrompt
+        step={3}
+        imageName="postgres:17-alpine"
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={[]}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+        hasSuggestedEnv={true}
+      />
+    );
+    expect(getByText('[Tab]')).toBeTruthy();
+    expect(getByText(/Insert next env/)).toBeTruthy();
+  });
+
+  test('step=3, hasSuggestedEnv=false: does NOT render [Tab] in HUD', () => {
+    const { queryByText } = render(
+      <ContainerCreationPrompt
+        step={3}
+        imageName="nginx:1.27-alpine"
+        containerName=""
+        portInput=""
+        envInput=""
+        message=""
+        messageColor="yellow"
+        suggestions={[]}
+        selectedSuggestionIndex={-1}
+        visibleOffset={0}
+        hasSuggestedEnv={false}
+      />
+    );
+    expect(queryByText('[Tab]')).toBeNull();
+  });
 });

package/test/ControlsHUD.dom.test.js

@@ -0,0 +1,125 @@
+/**
+ * @jest-environment jsdom
+ */
+import React from 'react';
+import { render } from '@testing-library/react';
+import { getHints, ControlsHUD } from '../src/components/ControlsHUD.jsx';
+
+describe('getHints — pure function', () => {
+  test('step=0, no suggestions, not searching: includes Tab=Search Hub', () => {
+    const hints = getHints(0, false, false);
+    const keys = hints.map(h => h.key);
+    expect(keys).toContain('Tab');
+    const tabHint = hints.find(h => h.key === 'Tab');
+    expect(tabHint.label).toBe('Search Hub');
+  });
+
+  test('step=0, hasSuggestions=true: includes ↑↓ Navigate, does NOT include Tab', () => {
+    const hints = getHints(0, true, false);
+    const keys = hints.map(h => h.key);
+    expect(keys).toContain('↑↓');
+    expect(keys).not.toContain('Tab');
+    const navHint = hints.find(h => h.key === '↑↓');
+    expect(navHint.label).toBe('Navigate');
+  });
+
+  test('step=0, isSearchingHub=true: does NOT include Tab, includes Enter and Esc', () => {
+    const hints = getHints(0, false, true);
+    const keys = hints.map(h => h.key);
+    expect(keys).not.toContain('Tab');
+    expect(keys).toContain('Enter');
+    expect(keys).toContain('Esc');
+  });
+
+  test('step=1: includes Enter=Continue and Esc=Cancel, no Tab, no ↑↓', () => {
+    const hints = getHints(1, false, false);
+    const keys = hints.map(h => h.key);
+    expect(keys).toContain('Enter');
+    expect(keys).toContain('Esc');
+    expect(keys).not.toContain('Tab');
+    expect(keys).not.toContain('↑↓');
+    const enterHint = hints.find(h => h.key === 'Enter');
+    expect(enterHint.label).toBe('Continue');
+  });
+
+  test('step=2: same as step=1', () => {
+    const hints = getHints(2, false, false);
+    const keys = hints.map(h => h.key);
+    expect(keys).toContain('Enter');
+    expect(keys).toContain('Esc');
+    expect(keys).not.toContain('Tab');
+    expect(keys).not.toContain('↑↓');
+  });
+
+  test('step=3: same as step=1', () => {
+    const hints = getHints(3, false, false);
+    const keys = hints.map(h => h.key);
+    expect(keys).toContain('Enter');
+    expect(keys).toContain('Esc');
+    expect(keys).not.toContain('Tab');
+    expect(keys).not.toContain('↑↓');
+  });
+
+  test('getHints(3, false, false, true) includes Tab=Insert next env', () => {
+    const hints = getHints(3, false, false, true);
+    const keys = hints.map(h => h.key);
+    expect(keys).toContain('Tab');
+    const tabHint = hints.find(h => h.key === 'Tab');
+    expect(tabHint.label).toBe('Insert next env');
+  });
+
+  test('getHints(3, false, false, false) does NOT include Tab hint', () => {
+    const hints = getHints(3, false, false, false);
+    const keys = hints.map(h => h.key);
+    expect(keys).not.toContain('Tab');
+  });
+
+  test('getHints(3, false, false, true) also includes Enter and Esc', () => {
+    const hints = getHints(3, false, false, true);
+    const keys = hints.map(h => h.key);
+    expect(keys).toContain('Enter');
+    expect(keys).toContain('Esc');
+  });
+});
+
+describe('ControlsHUD — component rendering', () => {
+  test('step=0, no suggestions: renders [Tab] and "Search Hub" text', () => {
+    const { getByText } = render(
+      <ControlsHUD step={0} hasSuggestions={false} isSearchingHub={false} />
+    );
+    expect(getByText('[Tab]')).toBeTruthy();
+    expect(getByText(/Search Hub/)).toBeTruthy();
+  });
+
+  test('step=0, hasSuggestions=true: renders [↑↓], does NOT render [Tab]', () => {
+    const { getByText, queryByText } = render(
+      <ControlsHUD step={0} hasSuggestions={true} isSearchingHub={false} />
+    );
+    expect(getByText('[↑↓]')).toBeTruthy();
+    expect(queryByText('[Tab]')).toBeNull();
+  });
+
+  test('step=1: renders [Enter] and [Esc], does NOT render [Tab]', () => {
+    const { getByText, queryByText } = render(
+      <ControlsHUD step={1} hasSuggestions={false} isSearchingHub={false} />
+    );
+    expect(getByText('[Enter]')).toBeTruthy();
+    expect(getByText('[Esc]')).toBeTruthy();
+    expect(queryByText('[Tab]')).toBeNull();
+  });
+
+  test('step=3, hasSuggestedEnv=true: renders [Tab] and "Insert next env"', () => {
+    const { getByText } = render(
+      <ControlsHUD step={3} hasSuggestions={false} isSearchingHub={false} hasSuggestedEnv={true} />
+    );
+    expect(getByText('[Tab]')).toBeTruthy();
+    expect(getByText(/Insert next env/)).toBeTruthy();
+  });
+
+  test('step=3, hasSuggestedEnv=false: does NOT render [Tab]', () => {
+    const { queryByText } = render(
+      <ControlsHUD step={3} hasSuggestions={false} isSearchingHub={false} hasSuggestedEnv={false} />
+    );
+    expect(queryByText('[Tab]')).toBeNull();
+  });
+});

package/test/SuggestionPanel.dom.test.js

@@ -50,4 +50,34 @@ describe('SuggestionPanel', () => {
     const el = getByText(/caddy/);
     expect(el.textContent).not.toMatch(/›/);
   });
+
+  // FR8 — isLoading prop
+  test('renders [searching Docker Hub...] row when isLoading=true', () => {
+    const { getByText } = render(
+      <SuggestionPanel items={[]} selectedIndex={-1} visibleOffset={0} isLoading={true} />
+    );
+    expect(getByText(/searching Docker Hub/)).toBeTruthy();
+  });
+
+  test('loading row is NOT selectable — no › prefix on loading row', () => {
+    const { getByText } = render(
+      <SuggestionPanel items={items} selectedIndex={-1} visibleOffset={0} maxVisible={5} isLoading={true} />
+    );
+    const loadingEl = getByText(/searching Docker Hub/);
+    expect(loadingEl.textContent).not.toMatch(/›/);
+  });
+
+  test('does NOT render loading row when isLoading=false', () => {
+    const { queryByText } = render(
+      <SuggestionPanel items={items} selectedIndex={-1} visibleOffset={0} maxVisible={5} isLoading={false} />
+    );
+    expect(queryByText(/searching Docker Hub/)).toBeNull();
+  });
+
+  test('renders panel even when items is empty but isLoading=true', () => {
+    const { getByText } = render(
+      <SuggestionPanel items={[]} selectedIndex={-1} visibleOffset={0} isLoading={true} />
+    );
+    expect(getByText(/searching Docker Hub/)).toBeTruthy();
+  });
 });

package/test/constants.test.js

@@ -31,4 +31,11 @@ describe('IMAGE_PROFILES', () => {
   test('node has suggestedEnv with NODE_ENV hint', () => {
     expect(IMAGE_PROFILES.node.suggestedEnv).toContain('NODE_ENV=production');
   });
+
+  test('every entry has defaultTag as a non-empty string', () => {
+    for (const [key, profile] of Object.entries(IMAGE_PROFILES)) {
+      expect(typeof profile.defaultTag).toBe('string');
+      expect(profile.defaultTag.length).toBeGreaterThan(0);
+    }
+  });
 });

package/test/dockerHubService.test.js

@@ -0,0 +1,213 @@
+/**
+ * @jest-environment node
+ */
+import { jest } from '@jest/globals';
+import { formatHubResult } from '../src/helpers/dockerHubService.js';
+
+// We mock fetch at the global level using jest.spyOn
+// The module under test is imported dynamically after spy setup
+
+describe('searchDockerHub — unit tests', () => {
+  let searchDockerHub;
+  let fetchSpy;
+
+  beforeEach(async () => {
+    // Reset modules so each test gets fresh state
+    jest.resetModules();
+    // Dynamically import after setting up spy
+    ({ searchDockerHub } = await import('../src/helpers/dockerHubService.js'));
+  });
+
+  afterEach(() => {
+    if (fetchSpy) fetchSpy.mockRestore();
+    fetchSpy = null;
+  });
+
+  // ── 1. Query trim & encode ──────────────────────────────────────────────
+
+  test('trims whitespace from query before encoding', async () => {
+    fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ results: [] }),
+    });
+
+    await searchDockerHub('  nginx  ');
+
+    const calledUrl = fetchSpy.mock.calls[0][0];
+    expect(calledUrl).toContain('query=nginx');
+    expect(calledUrl).not.toContain('query=+nginx');
+    expect(calledUrl).not.toContain('  ');
+  });
+
+  test('encodes special characters in query', async () => {
+    fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ results: [] }),
+    });
+
+    await searchDockerHub('hello world');
+
+    const calledUrl = fetchSpy.mock.calls[0][0];
+    expect(calledUrl).toContain('query=hello%20world');
+  });
+
+  test('returns [] immediately for empty query (no fetch call)', async () => {
+    fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ results: [] }),
+    });
+
+    const result = await searchDockerHub('   ');
+
+    expect(result).toEqual([]);
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  // ── 2. AbortSignal.timeout(5000) default ──────────────────────────────
+
+  test('uses AbortSignal.timeout(5000) by default when no signal provided', async () => {
+    const timeoutSignalSpy = jest.spyOn(AbortSignal, 'timeout');
+    fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ results: [] }),
+    });
+
+    await searchDockerHub('nginx');
+
+    expect(timeoutSignalSpy).toHaveBeenCalledWith(5000);
+    timeoutSignalSpy.mockRestore();
+  });
+
+  test('does NOT call AbortSignal.timeout when signal is injected', async () => {
+    const timeoutSignalSpy = jest.spyOn(AbortSignal, 'timeout');
+    const controller = new AbortController();
+    fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ results: [] }),
+    });
+
+    await searchDockerHub('nginx', { signal: controller.signal });
+
+    expect(timeoutSignalSpy).not.toHaveBeenCalled();
+    timeoutSignalSpy.mockRestore();
+  });
+
+  // ── 3. Injected signal is passed to fetch ──────────────────────────────
+
+  test('passes injected signal to fetch', async () => {
+    const controller = new AbortController();
+    fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ results: [] }),
+    });
+
+    await searchDockerHub('nginx', { signal: controller.signal });
+
+    const fetchOptions = fetchSpy.mock.calls[0][1];
+    expect(fetchOptions.signal).toBe(controller.signal);
+  });
+
+  // ── 4. Result mapping ──────────────────────────────────────────────────
+
+  test('maps results to normalized objects with name, isOfficial, pullCount, description', async () => {
+    fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        results: [
+          {
+            repo_name: 'library/nginx',
+            is_official: true,
+            pull_count: 1000000000,
+            short_description: 'Official nginx image',
+          },
+          {
+            repo_name: 'bitnami/nginx',
+            is_official: false,
+            pull_count: 50000000,
+            short_description: 'Bitnami nginx image',
+          },
+        ],
+      }),
+    });
+
+    const results = await searchDockerHub('nginx');
+
+    expect(results).toHaveLength(2);
+    expect(results[0]).toEqual({
+      name: 'library/nginx',
+      isOfficial: true,
+      pullCount: 1000000000,
+      description: 'Official nginx image',
+    });
+    expect(results[1]).toEqual({
+      name: 'bitnami/nginx',
+      isOfficial: false,
+      pullCount: 50000000,
+      description: 'Bitnami nginx image',
+    });
+  });
+
+  test('returns empty array when results is missing from response', async () => {
+    fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({}),
+    });
+
+    const results = await searchDockerHub('nginx');
+    expect(results).toEqual([]);
+  });
+
+  // ── 5. Non-OK rejection ────────────────────────────────────────────────
+
+  test('throws when response.ok is false', async () => {
+    fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValue({
+      ok: false,
+      status: 429,
+      json: async () => ({}),
+    });
+
+    await expect(searchDockerHub('nginx')).rejects.toThrow(
+      'Docker Hub search failed: 429'
+    );
+  });
+
+  test('re-throws AbortError from fetch', async () => {
+    const abortErr = new DOMException('Aborted', 'AbortError');
+    fetchSpy = jest.spyOn(global, 'fetch').mockRejectedValue(abortErr);
+
+    await expect(searchDockerHub('nginx')).rejects.toThrow('Aborted');
+  });
+});
+
+describe('formatHubResult — unit tests', () => {
+  test('official repo includes [★ official]', () => {
+    const result = formatHubResult({ name: 'library/nginx', isOfficial: true, pullCount: 0 });
+    expect(result).toContain('[★ official]');
+    expect(result).toContain('library/nginx');
+  });
+
+  test('high pull count (≥1B) is formatted as 1B+', () => {
+    const result = formatHubResult({ name: 'nginx', isOfficial: true, pullCount: 1e9 });
+    expect(result).toContain('[1B+ pulls]');
+  });
+
+  test('pull count ≥1M is formatted as NM+', () => {
+    const result = formatHubResult({ name: 'myimage', isOfficial: false, pullCount: 500e6 });
+    expect(result).toContain('[500M+ pulls]');
+  });
+
+  test('pull count ≥1K is formatted as NK+', () => {
+    const result = formatHubResult({ name: 'myimage', isOfficial: false, pullCount: 500e3 });
+    expect(result).toContain('[500K+ pulls]');
+  });
+
+  test('no pull count → just name (no suffix)', () => {
+    const result = formatHubResult({ name: 'myimage', isOfficial: false, pullCount: 0 });
+    expect(result).toBe('myimage');
+  });
+
+  test('unofficial + low pull count → just name with raw count', () => {
+    const result = formatHubResult({ name: 'myimage', isOfficial: false, pullCount: 42 });
+    expect(result).toBe('myimage [42 pulls]');
+  });
+});

package/test/logger.test.js

@@ -0,0 +1,58 @@
+/**
+ * Tests for src/helpers/logger.js
+ * Verifies that console output is suppressed when Ink listeners are active.
+ */
+import { jest } from '@jest/globals';
+
+const { logger } = await import('../src/helpers/logger.js');
+
+describe('logger — console output suppression', () => {
+  let consoleSpy;
+  let warnSpy;
+
+  beforeEach(() => {
+    consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+
+  test('when NO listeners are registered, logger.error calls console.error (fallback)', () => {
+    logger.error('test error no listener');
+    expect(consoleSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test('when a listener IS registered, logger.error does NOT call console.error', () => {
+    const unsubscribe = logger.subscribe(() => {});
+    logger.error('test error with listener');
+    expect(consoleSpy).not.toHaveBeenCalled();
+    unsubscribe();
+  });
+
+  test('when a listener IS registered, logger.warn does NOT call console.warn', () => {
+    const unsubscribe = logger.subscribe(() => {});
+    logger.warn('test warn with listener');
+    expect(warnSpy).not.toHaveBeenCalled();
+    unsubscribe();
+  });
+
+  test('after unsubscribing last listener, logger.error resumes calling console.error', () => {
+    const unsubscribe = logger.subscribe(() => {});
+    unsubscribe();
+    logger.error('after unsubscribe');
+    expect(consoleSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test('listener is invoked with the log entry even when console output is suppressed', () => {
+    const received = [];
+    const unsubscribe = logger.subscribe((entry) => received.push(entry));
+    logger.error('entry delivered', 'extra-arg');
+    expect(received).toHaveLength(1);
+    expect(received[0].level).toBe('error');
+    expect(received[0].message).toBe('entry delivered');
+    unsubscribe();
+  });
+});