foreman_openbolt 1.0.0 → 1.1.1

data/webpack/src/Components/LaunchTask/__tests__/ParametersSection.test.js

@@ -0,0 +1,50 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import ParametersSection from '../ParametersSection';
+
+describe('ParametersSection', () => {
+  test('shows empty state when no task is selected', () => {
+    render(
+      <ParametersSection
+        selectedTask=""
+        taskMetadata={{}}
+        taskParameters={{}}
+        onParameterChange={jest.fn()}
+      />
+    );
+    expect(
+      screen.getByText('Select a task to see parameters')
+    ).toBeInTheDocument();
+  });
+
+  test('shows empty state when task has no parameters', () => {
+    render(
+      <ParametersSection
+        selectedTask="test::task"
+        taskMetadata={{ 'test::task': { parameters: {} } }}
+        taskParameters={{}}
+        onParameterChange={jest.fn()}
+      />
+    );
+    expect(screen.getByText('This task has no parameters')).toBeInTheDocument();
+  });
+
+  test('renders parameter fields when task has parameters', () => {
+    const metadata = {
+      'test::task': {
+        parameters: {
+          name: { type: 'String', description: 'Package name' },
+        },
+      },
+    };
+    render(
+      <ParametersSection
+        selectedTask="test::task"
+        taskMetadata={metadata}
+        taskParameters={{ name: 'nginx' }}
+        onParameterChange={jest.fn()}
+      />
+    );
+    expect(screen.getByText('name')).toBeInTheDocument();
+  });
+});

data/webpack/src/Components/LaunchTask/__tests__/SmartProxySelect.test.js

@@ -0,0 +1,63 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import SmartProxySelect from '../SmartProxySelect';
+
+const proxies = [
+  { id: 1, name: 'proxy-one' },
+  { id: 2, name: 'proxy-two' },
+];
+
+describe('SmartProxySelect', () => {
+  test('renders proxy options', () => {
+    render(
+      <SmartProxySelect
+        smartProxies={proxies}
+        selectedProxy=""
+        onProxyChange={jest.fn()}
+        isLoading={false}
+      />
+    );
+    expect(screen.getByText('proxy-one')).toBeInTheDocument();
+    expect(screen.getByText('proxy-two')).toBeInTheDocument();
+  });
+
+  test('shows loading placeholder when loading', () => {
+    render(
+      <SmartProxySelect
+        smartProxies={[]}
+        selectedProxy=""
+        onProxyChange={jest.fn()}
+        isLoading
+      />
+    );
+    expect(screen.getByText('Loading...')).toBeInTheDocument();
+  });
+
+  test('disables select when loading', () => {
+    const { container } = render(
+      <SmartProxySelect
+        smartProxies={proxies}
+        selectedProxy=""
+        onProxyChange={jest.fn()}
+        isLoading
+      />
+    );
+    const select = container.querySelector('select');
+    expect(select).toBeDisabled();
+  });
+
+  test('calls onProxyChange when selection changes', () => {
+    const handleChange = jest.fn();
+    const { container } = render(
+      <SmartProxySelect
+        smartProxies={proxies}
+        selectedProxy=""
+        onProxyChange={handleChange}
+        isLoading={false}
+      />
+    );
+    const select = container.querySelector('select');
+    fireEvent.change(select, { target: { value: '1' } });
+    expect(handleChange).toHaveBeenCalledWith(expect.anything(), '1');
+  });
+});

data/webpack/src/Components/LaunchTask/__tests__/TaskSelect.test.js

@@ -0,0 +1,39 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import TaskSelect from '../TaskSelect';
+
+const defaultProps = {
+  taskNames: ['mymod::install', 'mymod::mytask'],
+  selectedTask: '',
+  onTaskChange: jest.fn(),
+  onReloadTasks: jest.fn(),
+  isLoading: false,
+  isDisabled: false,
+};
+
+describe('TaskSelect', () => {
+  test('renders task options', () => {
+    render(<TaskSelect {...defaultProps} />);
+    expect(screen.getByText('mymod::install')).toBeInTheDocument();
+    expect(screen.getByText('mymod::mytask')).toBeInTheDocument();
+  });
+
+  test('shows loading placeholder when loading', () => {
+    render(<TaskSelect {...defaultProps} isLoading />);
+    expect(screen.getByText('Loading...')).toBeInTheDocument();
+  });
+
+  test('disables select and button when disabled', () => {
+    const { container } = render(<TaskSelect {...defaultProps} isDisabled />);
+    const select = container.querySelector('select');
+    expect(select).toBeDisabled();
+  });
+
+  test('calls onReloadTasks when reload button is clicked', () => {
+    const handleReload = jest.fn();
+    render(<TaskSelect {...defaultProps} onReloadTasks={handleReload} />);
+    const reloadButton = screen.getByLabelText('Reload tasks from OpenBolt');
+    fireEvent.click(reloadButton);
+    expect(handleReload).toHaveBeenCalled();
+  });
+});

data/webpack/src/Components/LaunchTask/hooks/__tests__/useOpenBoltOptions.test.js

@@ -0,0 +1,90 @@
+import React from 'react';
+import { renderHook, act } from '@testing-library/react-hooks';
+import { Provider } from 'react-redux';
+import { createStore } from 'redux';
+import { API } from 'foremanReact/redux/API';
+import { addToast } from 'foremanReact/components/ToastsList';
+import { useOpenBoltOptions } from '../useOpenBoltOptions';
+
+const mockStore = createStore(() => ({}));
+const wrapper = ({ children }) => (
+  <Provider store={mockStore}>{children}</Provider>
+);
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('useOpenBoltOptions', () => {
+  test('returns null and does not call API when proxyId is falsy', async () => {
+    const { result } = renderHook(() => useOpenBoltOptions(), { wrapper });
+
+    let returnValue;
+    await act(async () => {
+      returnValue = await result.current.fetchOpenBoltOptions(null);
+    });
+
+    expect(returnValue).toBeNull();
+    expect(API.get).not.toHaveBeenCalled();
+  });
+
+  test('fetches options and extracts defaults', async () => {
+    const options = {
+      transport: { type: 'string', default: 'ssh' },
+      user: { type: 'string' },
+      verbose: { type: 'boolean', default: false },
+    };
+    API.get.mockResolvedValue({ data: options });
+
+    const { result } = renderHook(() => useOpenBoltOptions(), { wrapper });
+
+    await act(async () => {
+      await result.current.fetchOpenBoltOptions(42);
+    });
+
+    expect(result.current.openBoltOptionsMetadata).toEqual(options);
+    expect(result.current.openBoltOptions).toEqual({
+      transport: 'ssh',
+      verbose: false,
+    });
+    expect(result.current.openBoltOptions.user).toBeUndefined();
+  });
+
+  test('resets state before fetching', async () => {
+    API.get.mockResolvedValue({ data: { transport: { default: 'ssh' } } });
+
+    const { result } = renderHook(() => useOpenBoltOptions(), { wrapper });
+
+    await act(async () => {
+      await result.current.fetchOpenBoltOptions(1);
+    });
+    expect(result.current.openBoltOptions).toEqual({ transport: 'ssh' });
+
+    API.get.mockResolvedValue({ data: { user: { default: 'root' } } });
+    await act(async () => {
+      await result.current.fetchOpenBoltOptions(2);
+    });
+    expect(result.current.openBoltOptions).toEqual({ user: 'root' });
+    expect(result.current.openBoltOptions.transport).toBeUndefined();
+  });
+
+  test('handles errors and shows toast', async () => {
+    API.get.mockRejectedValue({ message: 'Connection refused' });
+
+    const { result } = renderHook(() => useOpenBoltOptions(), { wrapper });
+
+    let returnValue;
+    await act(async () => {
+      returnValue = await result.current.fetchOpenBoltOptions(42);
+    });
+
+    expect(returnValue).toBeNull();
+    expect(result.current.isLoadingOptions).toBe(false);
+    expect(addToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'danger',
+        message: expect.stringContaining('Failed to load OpenBolt options'),
+      })
+    );
+  });
+});

data/webpack/src/Components/LaunchTask/hooks/__tests__/useSmartProxies.test.js

@@ -0,0 +1,69 @@
+import React from 'react';
+import { renderHook } from '@testing-library/react-hooks';
+import { Provider } from 'react-redux';
+import { createStore } from 'redux';
+import { API } from 'foremanReact/redux/API';
+import { addToast } from 'foremanReact/components/ToastsList';
+import { useSmartProxies } from '../useSmartProxies';
+
+const mockStore = createStore(() => ({}));
+const wrapper = ({ children }) => (
+  <Provider store={mockStore}>{children}</Provider>
+);
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('useSmartProxies', () => {
+  test('fetches proxies on mount and returns results', async () => {
+    const proxies = [
+      { id: 1, name: 'proxy1' },
+      { id: 2, name: 'proxy2' },
+    ];
+    API.get.mockResolvedValue({ data: { results: proxies } });
+
+    const { result, waitForNextUpdate } = renderHook(() => useSmartProxies(), {
+      wrapper,
+    });
+
+    expect(result.current.isLoadingProxies).toBe(true);
+
+    await waitForNextUpdate();
+
+    expect(result.current.isLoadingProxies).toBe(false);
+    expect(result.current.smartProxies).toEqual(proxies);
+    expect(API.get).toHaveBeenCalledWith(
+      expect.stringContaining('/api/smart_proxies')
+    );
+  });
+
+  test('returns empty array when no proxies found', async () => {
+    API.get.mockResolvedValue({ data: { results: [] } });
+
+    const { result, waitForNextUpdate } = renderHook(() => useSmartProxies(), {
+      wrapper,
+    });
+    await waitForNextUpdate();
+
+    expect(result.current.smartProxies).toEqual([]);
+  });
+
+  test('handles fetch error and shows toast', async () => {
+    API.get.mockRejectedValue({ message: 'Network error' });
+
+    const { result, waitForNextUpdate } = renderHook(() => useSmartProxies(), {
+      wrapper,
+    });
+    await waitForNextUpdate();
+
+    expect(result.current.isLoadingProxies).toBe(false);
+    expect(result.current.smartProxies).toEqual([]);
+    expect(addToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'danger',
+        message: expect.stringContaining('Failed to load Smart Proxies'),
+      })
+    );
+  });
+});

data/webpack/src/Components/LaunchTask/hooks/__tests__/useTasksData.test.js

@@ -0,0 +1,103 @@
+import React from 'react';
+import { renderHook, act } from '@testing-library/react-hooks';
+import { Provider } from 'react-redux';
+import { createStore } from 'redux';
+import { API } from 'foremanReact/redux/API';
+import { addToast } from 'foremanReact/components/ToastsList';
+import { useTasksData } from '../useTasksData';
+
+const mockStore = createStore(() => ({}));
+const wrapper = ({ children }) => (
+  <Provider store={mockStore}>{children}</Provider>
+);
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('useTasksData', () => {
+  test('fetchTasks returns null and does not call API when proxyId is falsy', async () => {
+    const { result } = renderHook(() => useTasksData(), { wrapper });
+
+    let returnValue;
+    await act(async () => {
+      returnValue = await result.current.fetchTasks(null);
+    });
+
+    expect(returnValue).toBeNull();
+    expect(API.get).not.toHaveBeenCalled();
+  });
+
+  test('fetchTasks fetches tasks from the normal endpoint', async () => {
+    const tasks = { 'mymod::install': { description: 'Install a package' } };
+    API.get.mockResolvedValue({ data: tasks });
+
+    const { result } = renderHook(() => useTasksData(), { wrapper });
+
+    await act(async () => {
+      await result.current.fetchTasks(42);
+    });
+
+    expect(API.get).toHaveBeenCalledWith(
+      expect.stringContaining('fetch_tasks')
+    );
+    expect(API.get).toHaveBeenCalledWith(
+      expect.stringContaining('proxy_id=42')
+    );
+    expect(result.current.taskMetadata).toEqual(tasks);
+    expect(result.current.isLoadingTasks).toBe(false);
+  });
+
+  test('fetchTasks uses reload endpoint when forceReload is true', async () => {
+    API.get.mockResolvedValue({ data: {} });
+
+    const { result } = renderHook(() => useTasksData(), { wrapper });
+
+    await act(async () => {
+      await result.current.fetchTasks(42, true);
+    });
+
+    expect(API.get).toHaveBeenCalledWith(
+      expect.stringContaining('reload_tasks')
+    );
+  });
+
+  test('fetchTasks resets state before fetching', async () => {
+    API.get.mockResolvedValue({ data: { 'task::one': {} } });
+
+    const { result } = renderHook(() => useTasksData(), { wrapper });
+
+    // First fetch
+    await act(async () => {
+      await result.current.fetchTasks(1);
+    });
+    expect(Object.keys(result.current.taskMetadata)).toHaveLength(1);
+
+    // Second fetch should reset
+    API.get.mockResolvedValue({ data: { 'task::two': {}, 'task::three': {} } });
+    await act(async () => {
+      await result.current.fetchTasks(2);
+    });
+    expect(Object.keys(result.current.taskMetadata)).toHaveLength(2);
+  });
+
+  test('fetchTasks handles errors and shows toast', async () => {
+    API.get.mockRejectedValue({ message: 'Network error' });
+
+    const { result } = renderHook(() => useTasksData(), { wrapper });
+
+    let returnValue;
+    await act(async () => {
+      returnValue = await result.current.fetchTasks(42);
+    });
+
+    expect(returnValue).toBeNull();
+    expect(result.current.isLoadingTasks).toBe(false);
+    expect(addToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'danger',
+        message: expect.stringContaining('Failed to load tasks'),
+      })
+    );
+  });
+});

data/webpack/src/Components/LaunchTask/hooks/useOpenBoltOptions.js

@@ -1,8 +1,8 @@
 import { useState, useCallback } from 'react';
-import { translate as __ } from 'foremanReact/common/I18n';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
 import { API } from 'foremanReact/redux/API';
 import { ROUTES } from '../../common/constants';
-import { useShowMessage } from '../../common/helpers';
+import { useShowMessage, extractErrorMessage } from '../../common/helpers';
 
 export const useOpenBoltOptions = () => {
   const showMessage = useShowMessage();
@@ -20,17 +20,10 @@ export const useOpenBoltOptions = () => {
       setOpenBoltOptions({});
 
       try {
-        const { data, status } = await API.get(
+        const { data } = await API.get(
           `${ROUTES.API.FETCH_OPENBOLT_OPTIONS}?proxy_id=${proxyId}`
         );
 
-        if (status !== 200) {
-          const error = data
-            ? data.error || JSON.stringify(data)
-            : 'Unknown error';
-          throw new Error(`HTTP ${status} - ${error}`);
-        }
-
         setOpenBoltOptionsMetadata(data || {});
 
         // Set defaults
@@ -44,7 +37,12 @@ export const useOpenBoltOptions = () => {
 
         return data;
       } catch (error) {
-        showMessage(__('Failed to load OpenBolt options: ') + error.message);
+        showMessage(
+          sprintf(
+            __('Failed to load OpenBolt options: %s'),
+            extractErrorMessage(error)
+          )
+        );
         return null;
       } finally {
         setIsLoadingOptions(false);

data/webpack/src/Components/LaunchTask/hooks/useSmartProxies.js

@@ -1,7 +1,7 @@
 import { useState, useEffect } from 'react';
-import { translate as __ } from 'foremanReact/common/I18n';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
 import { API } from 'foremanReact/redux/API';
-import { useShowMessage } from '../../common/helpers';
+import { useShowMessage, extractErrorMessage } from '../../common/helpers';
 
 export const useSmartProxies = () => {
   const showMessage = useShowMessage();
@@ -16,18 +16,12 @@ export const useSmartProxies = () => {
           per_page: 'all',
           search: 'feature=OpenBolt',
         })}`;
-        const { data, status } = await API.get(endpoint);
+        const { data } = await API.get(endpoint);
 
-        if (status !== 200) {
-          const error = data
-            ? data.error || JSON.stringify(data)
-            : 'Unknown error';
-          throw new Error(`HTTP ${status} - ${error}`);
-        }
-
-        setSmartProxies(data.results || []);
+        const results = data.results || [];
+        setSmartProxies(results);
 
-        if (data.results.length === 0) {
+        if (results.length === 0) {
           showMessage(
             __(
               'No Smart Proxies found. Please check that one or more proxy has the smart_proxy_openbolt package installed and enabled.'
@@ -35,7 +29,12 @@ export const useSmartProxies = () => {
           );
         }
       } catch (error) {
-        showMessage(__('Failed to load Smart Proxies: ') + error.message);
+        showMessage(
+          sprintf(
+            __('Failed to load Smart Proxies: %s'),
+            extractErrorMessage(error)
+          )
+        );
       } finally {
         setIsLoadingProxies(false);
       }

data/webpack/src/Components/LaunchTask/hooks/useTasksData.js

@@ -1,8 +1,8 @@
 import { useState, useCallback } from 'react';
-import { translate as __ } from 'foremanReact/common/I18n';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
 import { API } from 'foremanReact/redux/API';
 import { ROUTES } from '../../common/constants';
-import { useShowMessage } from '../../common/helpers';
+import { useShowMessage, extractErrorMessage } from '../../common/helpers';
 
 export const useTasksData = () => {
   const showMessage = useShowMessage();
@@ -24,16 +24,7 @@ export const useTasksData = () => {
         const endpoint = forceReload
           ? ROUTES.API.RELOAD_TASKS
           : ROUTES.API.FETCH_TASKS;
-        const { data, status } = await API.get(
-          `${endpoint}?proxy_id=${proxyId}`
-        );
-
-        if (status !== 200) {
-          const error = data
-            ? data.error || JSON.stringify(data)
-            : 'Unknown error';
-          throw new Error(`HTTP ${status} - ${error}`);
-        }
+        const { data } = await API.get(`${endpoint}?proxy_id=${proxyId}`);
 
         setTaskMetadata(data || {});
 
@@ -43,7 +34,9 @@ export const useTasksData = () => {
 
         return data;
       } catch (error) {
-        showMessage(__('Failed to load tasks: ') + error.message);
+        showMessage(
+          sprintf(__('Failed to load tasks: %s'), extractErrorMessage(error))
+        );
         return null;
       } finally {
         setIsLoadingTasks(false);

data/webpack/src/Components/LaunchTask/index.js

@@ -1,7 +1,6 @@
-// TODO: More a11y tags
 import React, { useState, useCallback } from 'react';
 import { useHistory } from 'react-router-dom';
-import { translate as __ } from 'foremanReact/common/I18n';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
 
 import { API } from 'foremanReact/redux/API';
 import {
@@ -28,7 +27,7 @@ import HostSelector from './HostSelector';
 import { useSmartProxies } from './hooks/useSmartProxies';
 import { useTasksData } from './hooks/useTasksData';
 import { useOpenBoltOptions } from './hooks/useOpenBoltOptions';
-import { useShowMessage } from '../common/helpers';
+import { useShowMessage, extractErrorMessage } from '../common/helpers';
 
 const LaunchTask = () => {
   const history = useHistory();
@@ -96,7 +95,7 @@ const LaunchTask = () => {
             defaults[paramName] = paramMeta.default;
           } else if (
             ['boolean', 'optional[boolean]'].includes(
-              paramMeta.type.toLowerCase()
+              paramMeta.type?.toLowerCase()
             )
           ) {
             defaults[paramName] = false;
@@ -174,36 +173,18 @@ const LaunchTask = () => {
           options: visibleOptions,
         };
 
-        const { data, status } = await API.post(ROUTES.API.LAUNCH_TASK, body);
-
-        // TODO: On non-200, the post above automatically throws an exception, so
-        // figure out how to handle it instead to extract the message in the
-        // response body.
-        if (status !== 200) {
-          const error = data
-            ? data.error || JSON.stringify(data)
-            : 'Unknown error';
-          throw new Error(`HTTP ${status} - ${error}`);
-        }
-
-        const selectedProxyData = smartProxies.find(
-          p => p.id.toString() === selectedProxy.toString()
-        );
+        const { data } = await API.post(ROUTES.API.LAUNCH_TASK, body);
 
         history.push({
           pathname: ROUTES.PAGES.TASK_EXECUTION,
           search: new URLSearchParams({
-            proxy_id: selectedProxy,
             job_id: data.job_id,
-            proxy_name: selectedProxyData?.name || 'Unknown',
           }).toString(),
         });
       } catch (error) {
-        const errorMessage =
-          error.response?.data?.error ||
-          error.message ||
-          __('Unknown error occurred');
-        showMessage(__('Failed to launch task: ') + errorMessage);
+        showMessage(
+          sprintf(__('Failed to launch task: %s'), extractErrorMessage(error))
+        );
       } finally {
         setIsSubmitting(false);
       }
@@ -265,7 +246,8 @@ const LaunchTask = () => {
                   isDisabled={!isFormValid}
                   isLoading={isSubmitting}
                 >
-                  {`🚀 ${__('Launch Task')}`}
+                  <span aria-hidden="true">🚀</span>
+                  {` ${__('Launch Task')}`}
                 </Button>
               </FlexItem>
             </Flex>