foreman_openbolt 1.0.0 → 1.1.1

data/webpack/src/Components/TaskExecution/hooks/__tests__/useJobPolling.test.js

@@ -0,0 +1,177 @@
+import { renderHook, act } from '@testing-library/react-hooks';
+import { API } from 'foremanReact/redux/API';
+import useJobPolling from '../useJobPolling';
+
+jest.useFakeTimers();
+
+afterEach(() => {
+  jest.clearAllMocks();
+  jest.clearAllTimers();
+});
+
+describe('useJobPolling', () => {
+  test('returns undefined state when jobId is null', () => {
+    const { result } = renderHook(() => useJobPolling(null));
+    expect(result.current.status).toBe('pending');
+    expect(result.current.isPolling).toBe(false);
+    expect(result.current.result).toBeNull();
+  });
+
+  test('polls for status and completes when job succeeds', async () => {
+    const statusData = {
+      status: 'success',
+      submitted_at: '2026-01-01T00:00:00Z',
+      completed_at: '2026-01-01T00:01:00Z',
+      task_name: 'test::task',
+      task_description: 'A test task',
+      task_parameters: { name: 'nginx' },
+      targets: ['host1.example.com'],
+      smart_proxy: { id: 1, name: 'proxy1' },
+    };
+    const resultData = {
+      command: 'bolt task run test::task',
+      value: { items: [{ status: 'success' }] },
+      log: 'Task completed',
+    };
+
+    API.get
+      .mockResolvedValueOnce({ data: statusData })
+      .mockResolvedValueOnce({ data: resultData });
+
+    let hookResult;
+    await act(async () => {
+      hookResult = renderHook(() => useJobPolling('job-123'));
+      // Let the poll promise resolve
+      await new Promise(resolve => setImmediate(resolve));
+    });
+
+    const { result } = hookResult;
+    expect(result.current.status).toBe('success');
+    expect(result.current.taskName).toBe('test::task');
+    expect(result.current.targets).toEqual(['host1.example.com']);
+    expect(result.current.result).toEqual({
+      command: 'bolt task run test::task',
+      result: { items: [{ status: 'success' }] },
+      log: 'Task completed',
+    });
+    expect(result.current.isPolling).toBe(false);
+  });
+
+  test('does not fetch result for INVALID status', async () => {
+    const statusData = {
+      status: 'invalid',
+      task_name: 'broken::task',
+      targets: [],
+    };
+
+    API.get.mockResolvedValueOnce({ data: statusData });
+
+    let hookResult;
+    await act(async () => {
+      hookResult = renderHook(() => useJobPolling('job-456'));
+      await new Promise(resolve => setImmediate(resolve));
+    });
+
+    const { result } = hookResult;
+    expect(result.current.status).toBe('invalid');
+    expect(result.current.result).toBeNull();
+    // Only one API call (status), no result fetch
+    expect(API.get).toHaveBeenCalledTimes(1);
+  });
+
+  test('sets error when status endpoint fails', async () => {
+    API.get.mockRejectedValueOnce({ message: 'Connection refused' });
+
+    let hookResult;
+    await act(async () => {
+      hookResult = renderHook(() => useJobPolling('job-789'));
+      await new Promise(resolve => setImmediate(resolve));
+    });
+
+    const { result } = hookResult;
+    expect(result.current.error).toContain('Connection refused');
+    expect(result.current.isPolling).toBe(false);
+  });
+
+  test('handles result fetch failure gracefully', async () => {
+    const statusData = {
+      status: 'success',
+      task_name: 'test::task',
+      targets: [],
+    };
+
+    API.get
+      .mockResolvedValueOnce({ data: statusData })
+      .mockRejectedValueOnce({ message: 'Result unavailable' });
+
+    let hookResult;
+    await act(async () => {
+      hookResult = renderHook(() => useJobPolling('job-fail'));
+      await new Promise(resolve => setImmediate(resolve));
+    });
+
+    const { result } = hookResult;
+    expect(result.current.status).toBe('success');
+    expect(result.current.error).toContain('Result unavailable');
+    expect(result.current.result).toEqual({ result: null, log: '' });
+  });
+
+  test('cancels polling on unmount', async () => {
+    const statusData = {
+      status: 'running',
+      task_name: 'long::task',
+      targets: [],
+    };
+    API.get.mockResolvedValue({ data: statusData });
+
+    let hookResult;
+    await act(async () => {
+      hookResult = renderHook(() => useJobPolling('job-cancel'));
+      await new Promise(resolve => setImmediate(resolve));
+    });
+
+    // Unmount while still polling
+    hookResult.unmount();
+
+    // Advance timers past the polling interval
+    jest.advanceTimersByTime(10000);
+
+    // API should have been called once for the initial poll, not more
+    const callCount = API.get.mock.calls.length;
+    jest.advanceTimersByTime(10000);
+    expect(API.get.mock.calls).toHaveLength(callCount);
+  });
+
+  test('loads metadata only once across multiple polls', async () => {
+    API.get
+      .mockResolvedValueOnce({
+        data: { status: 'running', task_name: 'my::task', targets: ['host1'] },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          status: 'success',
+          task_name: 'changed::name',
+          targets: ['host2'],
+        },
+      })
+      .mockResolvedValueOnce({
+        data: { command: 'bolt', value: {}, log: '' },
+      });
+
+    let hookResult;
+    await act(async () => {
+      hookResult = renderHook(() => useJobPolling('job-meta'));
+      // First poll resolves (running)
+      await new Promise(resolve => setImmediate(resolve));
+      // Advance past the polling interval
+      jest.advanceTimersByTime(5000);
+      // Second poll resolves (success) + result fetch
+      await new Promise(resolve => setImmediate(resolve));
+    });
+
+    const { result } = hookResult;
+    // Task name should be from the first poll, not the second
+    expect(result.current.taskName).toBe('my::task');
+    expect(result.current.targets).toEqual(['host1']);
+  });
+});

data/webpack/src/Components/TaskExecution/hooks/useJobPolling.js

@@ -1,7 +1,8 @@
 /* eslint-disable no-await-in-loop */
-import { useState, useEffect } from 'react';
-import { translate as __ } from 'foremanReact/common/I18n';
+import { useState, useEffect, useRef } from 'react';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
 import { API } from 'foremanReact/redux/API';
+import { extractErrorMessage } from '../../common/helpers';
 import {
   STATUS,
   COMPLETED_STATUSES,
@@ -9,13 +10,7 @@ import {
   ROUTES,
 } from '../../common/constants';
 
-/**
- * Custom hook for polling job status
- * @param {string} proxyId - Smart Proxy ID
- * @param {string} jobId - Job ID to poll
- * @returns {Object}
- */
-const useJobPolling = (proxyId, jobId) => {
+const useJobPolling = jobId => {
   const [status, setStatus] = useState(STATUS.PENDING);
   const [result, setResult] = useState(null);
   const [error, setError] = useState(null);
@@ -26,13 +21,15 @@ const useJobPolling = (proxyId, jobId) => {
   const [taskDescription, setTaskDescription] = useState(null);
   const [taskParameters, setTaskParameters] = useState({});
   const [targets, setTargets] = useState([]);
+  const [smartProxy, setSmartProxy] = useState(null);
+  const metadataLoaded = useRef(false);
 
   // There are a bunch of checks of 'cancelled' here so that if the
   // user navigates away while polling, we don't keep trying to update state.
   useEffect(() => {
     // Have to return undefined since we are returning a cleanup function
     // otherwise and React wants all code paths to return something.
-    if (!proxyId || !jobId) return undefined;
+    if (!jobId) return undefined;
 
     let cancelled = false;
 
@@ -41,41 +38,40 @@ const useJobPolling = (proxyId, jobId) => {
 
       while (!cancelled) {
         try {
-          const { data: statusData, status: statusCode } = await API.get(
-            `${ROUTES.API.JOB_STATUS}?proxy_id=${proxyId}&job_id=${jobId}`
+          const { data: statusData } = await API.get(
+            `${ROUTES.API.JOB_STATUS}?job_id=${jobId}`
           );
 
           if (cancelled) break;
 
-          if (statusCode !== 200) {
-            const errorMsg = statusData
-              ? statusData.error || JSON.stringify(statusData)
-              : 'Unknown error';
-            throw new Error(`HTTP ${statusCode} - ${errorMsg}`);
-          }
-
           const jobStatus = statusData?.status;
           if (!jobStatus) {
-            throw new Error('No job status returned');
+            throw new Error(__('No job status returned'));
           }
 
           setStatus(jobStatus);
-          setSubmittedAt(statusData.submitted_at || null);
           setCompletedAt(statusData.completed_at || null);
-          setTaskName(statusData.task_name || null);
-          setTaskDescription(statusData.task_description || null);
-          setTaskParameters(statusData.task_parameters || {});
-          setTargets(statusData.targets || []);
+
+          // Task metadata only needs to be set once since it never changes
+          if (!metadataLoaded.current) {
+            setSubmittedAt(statusData.submitted_at || null);
+            setTaskName(statusData.task_name || null);
+            setTaskDescription(statusData.task_description || null);
+            setTaskParameters(statusData.task_parameters || {});
+            setTargets(statusData.targets || []);
+            setSmartProxy(statusData.smart_proxy || null);
+            metadataLoaded.current = true;
+          }
 
           // If job is complete, fetch results and break
           if (COMPLETED_STATUSES.includes(jobStatus)) {
             if (jobStatus === STATUS.INVALID) break;
             try {
-              const { data: resultData, status: resultCode } = await API.get(
-                `${ROUTES.API.JOB_RESULT}?proxy_id=${proxyId}&job_id=${jobId}`
+              const { data: resultData } = await API.get(
+                `${ROUTES.API.JOB_RESULT}?job_id=${jobId}`
               );
 
-              if (!cancelled && resultCode === 200 && resultData) {
+              if (!cancelled && resultData) {
                 setResult({
                   command: resultData.command || '',
                   result: resultData.value,
@@ -86,8 +82,10 @@ const useJobPolling = (proxyId, jobId) => {
               // Don't fail the whole thing if result fetch fails
               if (!cancelled) {
                 setError(
-                  __('Failed to fetch job result: ') +
-                    (resultError.message || 'Unknown error')
+                  sprintf(
+                    __('Failed to fetch job result: %s'),
+                    extractErrorMessage(resultError)
+                  )
                 );
                 setResult({ result: null, log: '' });
               }
@@ -104,8 +102,10 @@ const useJobPolling = (proxyId, jobId) => {
         } catch (err) {
           if (!cancelled) {
             setError(
-              __('Failed to fetch job status: ') +
-                (err.message || 'Unknown error')
+              sprintf(
+                __('Failed to fetch job status: %s'),
+                extractErrorMessage(err)
+              )
             );
           }
           break;
@@ -123,7 +123,7 @@ const useJobPolling = (proxyId, jobId) => {
       cancelled = true;
       setIsPolling(false);
     };
-  }, [proxyId, jobId]);
+  }, [jobId]);
 
   return {
     status,
@@ -136,6 +136,7 @@ const useJobPolling = (proxyId, jobId) => {
     taskDescription,
     taskParameters,
     targets,
+    smartProxy,
   };
 };
 

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

@@ -16,9 +16,7 @@ const TaskExecution = () => {
   const showMessage = useShowMessage();
 
   const params = new URLSearchParams(location.search);
-  const proxyId = params.get('proxy_id');
   const jobId = params.get('job_id');
-  const proxyName = params.get('proxy_name');
 
   const {
     status: jobStatus,
@@ -31,7 +29,8 @@ const TaskExecution = () => {
     taskDescription,
     taskParameters,
     targets,
-  } = useJobPolling(proxyId, jobId);
+    smartProxy,
+  } = useJobPolling(jobId);
 
   useEffect(() => {
     if (pollError) {
@@ -41,16 +40,14 @@ const TaskExecution = () => {
 
   // Redirect if missing required params
   useEffect(() => {
-    if (!proxyId || !jobId) {
-      showMessage(
-        __('Invalid task execution URL - missing required parameters')
-      );
+    if (!jobId) {
+      showMessage(__('Invalid task execution URL - missing job ID'));
       history.push(ROUTES.PAGES.LAUNCH_TASK);
     }
-  }, [proxyId, jobId, showMessage, history]);
+  }, [jobId, showMessage, history]);
 
   // Don't render if missing required params
-  if (!proxyId || !jobId) {
+  if (!jobId) {
     return null;
   }
 
@@ -66,7 +63,9 @@ const TaskExecution = () => {
   const isComplete = COMPLETED_STATUSES.includes(jobStatus);
   const jobCommand = jobData?.command;
   const jobResult = jobData?.result;
-  const jobLog = `OpenBolt command: ${jobCommand}\n${stripAnsi(jobData?.log)}`;
+  const jobLog = jobData
+    ? `OpenBolt command: ${jobCommand}\n${stripAnsi(jobData.log)}`
+    : '';
 
   return (
     <Stack hasGutter>
@@ -82,8 +81,7 @@ const TaskExecution = () => {
 
       <StackItem>
         <ExecutionDisplay
-          proxyId={proxyId}
-          proxyName={proxyName}
+          smartProxy={smartProxy}
           jobId={jobId}
           jobStatus={jobStatus}
           isPolling={isPolling}

data/webpack/src/Components/TaskHistory/TaskPopover.js

@@ -1,23 +1,14 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import { translate as __ } from 'foremanReact/common/I18n';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
 import { Popover, Button } from '@patternfly/react-core';
 import { Table, Thead, Tbody, Tr, Th, Td } from '@patternfly/react-table';
+import { displayValue } from '../common/helpers';
 
 const TaskPopover = ({ taskName, taskDescription, taskParameters }) => {
   const hasParameters =
     taskParameters && Object.keys(taskParameters).length > 0;
 
-  const displayValue = value => {
-    if (value === null || value === undefined) {
-      return '-';
-    }
-    if (typeof value === 'object') {
-      return JSON.stringify(value);
-    }
-    return String(value);
-  };
-
   const popoverContent = (
     <div style={{ maxWidth: '500px' }}>
       {taskDescription && (
@@ -41,6 +32,7 @@ const TaskPopover = ({ taskName, taskDescription, taskParameters }) => {
               borders
               isStriped
               isStickyHeader
+              aria-label={__('Task parameters')}
               style={{
                 border: '1px solid var(--pf-v5-global--BorderColor--100)',
               }}
@@ -74,7 +66,12 @@ const TaskPopover = ({ taskName, taskDescription, taskParameters }) => {
 
   return (
     <Popover bodyContent={popoverContent} position="right">
-      <Button variant="link" isInline className="pf-v5-u-font-family-monospace">
+      <Button
+        variant="link"
+        isInline
+        className="pf-v5-u-font-family-monospace"
+        aria-label={sprintf(__('View details for task %s'), taskName)}
+      >
         {taskName}
       </Button>
     </Popover>

data/webpack/src/Components/TaskHistory/__tests__/TaskHistory.test.js

@@ -0,0 +1,109 @@
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import { createStore } from 'redux';
+import { API } from 'foremanReact/redux/API';
+import { addToast } from 'foremanReact/components/ToastsList';
+import TaskHistory from '../index';
+
+const mockStore = createStore(() => ({}));
+const wrapper = ({ children }) => (
+  <Provider store={mockStore}>{children}</Provider>
+);
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+const sampleJobs = [
+  {
+    job_id: 'job-1',
+    task_name: 'mymod::install',
+    task_description: 'Install a package',
+    task_parameters: { name: 'nginx' },
+    status: 'success',
+    targets: ['host1.example.com'],
+    submitted_at: '2026-01-15T10:00:00Z',
+    completed_at: '2026-01-15T10:01:00Z',
+    duration: 60,
+  },
+  {
+    job_id: 'job-2',
+    task_name: 'mymod::mytask',
+    task_description: 'Restart a service',
+    task_parameters: {},
+    status: 'running',
+    targets: ['host2.example.com'],
+    submitted_at: '2026-01-15T11:00:00Z',
+    completed_at: null,
+    duration: null,
+  },
+];
+
+describe('TaskHistory', () => {
+  test('shows loading spinner initially', () => {
+    API.get.mockReturnValue(new Promise(() => {}));
+    render(<TaskHistory />, { wrapper });
+    expect(screen.getByLabelText('Loading task history')).toBeInTheDocument();
+  });
+
+  test('renders task history table with jobs', async () => {
+    API.get.mockResolvedValue({
+      data: { results: sampleJobs, total: 2 },
+    });
+
+    render(<TaskHistory />, { wrapper });
+
+    await waitFor(() => {
+      expect(screen.getByText('mymod::install')).toBeInTheDocument();
+    });
+    expect(screen.getByText('mymod::mytask')).toBeInTheDocument();
+    expect(screen.getByText('success')).toBeInTheDocument();
+    expect(screen.getByText('running')).toBeInTheDocument();
+  });
+
+  test('shows empty state when no jobs exist', async () => {
+    API.get.mockResolvedValue({
+      data: { results: [], total: 0 },
+    });
+
+    render(<TaskHistory />, { wrapper });
+
+    await waitFor(() => {
+      expect(screen.getByText('No task history found')).toBeInTheDocument();
+    });
+  });
+
+  test('shows toast and stops loading when API call fails', async () => {
+    API.get.mockRejectedValue({ message: 'Network error' });
+
+    render(<TaskHistory />, { wrapper });
+
+    await waitFor(() => {
+      expect(
+        screen.queryByLabelText('Loading task history')
+      ).not.toBeInTheDocument();
+    });
+    expect(addToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'danger',
+        message: expect.stringContaining('Failed to load task history'),
+      })
+    );
+  });
+
+  test('calls API with page and per_page params', async () => {
+    API.get.mockResolvedValue({
+      data: { results: [], total: 0 },
+    });
+
+    render(<TaskHistory />, { wrapper });
+
+    await waitFor(() => {
+      expect(API.get).toHaveBeenCalledWith(expect.stringContaining('page=1'));
+      expect(API.get).toHaveBeenCalledWith(
+        expect.stringContaining('per_page=20')
+      );
+    });
+  });
+});

data/webpack/src/Components/TaskHistory/__tests__/TaskPopover.test.js

@@ -0,0 +1,26 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import TaskPopover from '../TaskPopover';
+
+describe('TaskPopover', () => {
+  test('renders task name as button', () => {
+    render(<TaskPopover taskName="mymod::install" />);
+    expect(screen.getByText('mymod::install')).toBeInTheDocument();
+    expect(
+      screen.getByRole('button', { name: /mymod::install/ })
+    ).toBeInTheDocument();
+  });
+
+  test('renders task name button with description and parameters provided', () => {
+    render(
+      <TaskPopover
+        taskName="test::task"
+        taskDescription="A test task"
+        taskParameters={{ name: 'nginx' }}
+      />
+    );
+    expect(
+      screen.getByRole('button', { name: /test::task/ })
+    ).toBeInTheDocument();
+  });
+});

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

@@ -1,5 +1,5 @@
 import React, { 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 {
   Label,
@@ -22,7 +22,12 @@ import {
   UnknownIcon,
 } from '@patternfly/react-icons';
 import { ROUTES, STATUS } from '../common/constants';
-import { useShowMessage } from '../common/helpers';
+import {
+  useShowMessage,
+  extractErrorMessage,
+  formatDuration,
+  formatDate,
+} from '../common/helpers';
 import HostsPopover from '../common/HostsPopover';
 import TaskPopover from './TaskPopover';
 
@@ -44,21 +49,6 @@ const getStatusLabel = status => {
   );
 };
 
-const formatDuration = duration => {
-  if (!duration) return '-';
-  const seconds = Math.round(duration);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  const remainingSeconds = seconds % 60;
-  return `${minutes}m ${remainingSeconds}s`;
-};
-
-const formatDate = dateString => {
-  if (!dateString) return '-';
-  const date = new Date(dateString);
-  return date.toLocaleString();
-};
-
 const TaskHistory = () => {
   const [taskHistory, setTaskHistory] = useState([]);
   const [isLoadingTaskHistory, setIsLoadingTaskHistory] = useState(true);
@@ -75,17 +65,23 @@ const TaskHistory = () => {
       setIsLoadingTaskHistory(true);
 
       try {
-        const { data, status } = await API.get(
+        const { data } = await API.get(
           `${ROUTES.API.TASK_HISTORY}?page=${page}&per_page=${perPage}`
         );
 
-        if (!cancelled && status === 200 && data) {
+        if (!cancelled && data) {
           setTaskHistory(data.results || []);
           setTotal(data.total || 0);
         }
       } catch (error) {
-        if (!cancelled)
-          showMessage(__('Failed to load task history: ') + error.message);
+        if (!cancelled) {
+          showMessage(
+            sprintf(
+              __('Failed to load task history: %s'),
+              extractErrorMessage(error)
+            )
+          );
+        }
       } finally {
         if (!cancelled) setIsLoadingTaskHistory(false);
       }
@@ -100,7 +96,7 @@ const TaskHistory = () => {
 
   const spinner = () => (
     <Bullseye>
-      <Spinner size="xl" />
+      <Spinner size="xl" aria-label={__('Loading task history')} />
     </Bullseye>
   );
 
@@ -120,7 +116,7 @@ const TaskHistory = () => {
   const jobTable = () => (
     <>
       <Table
-        aria-label="Task history table"
+        aria-label={__('Task history table')}
         borders
         isStriped
         isStickyHeader
@@ -131,7 +127,7 @@ const TaskHistory = () => {
             <Th modifier="wrap">{__('Task Name')}</Th>
             <Th modifier="wrap">{__('Status')}</Th>
             <Th modifier="wrap">{__('Targets')}</Th>
-            <Th modifier="wrap">{__('Started')}</Th>
+            <Th modifier="wrap">{__('Submitted')}</Th>
             <Th modifier="wrap">{__('Completed')}</Th>
             <Th modifier="wrap">{__('Duration')}</Th>
             <Th modifier="wrap">{__('Details')}</Th>
@@ -158,11 +154,7 @@ const TaskHistory = () => {
               <Td hasRightBorder>{formatDuration(job.duration)}</Td>
               <Td hasRightBorder>
                 <a
-                  href={`${ROUTES.PAGES.TASK_EXECUTION}?proxy_id=${
-                    job.smart_proxy.id
-                  }&job_id=${job.job_id}&proxy_name=${encodeURIComponent(
-                    job.smart_proxy.name
-                  )}`}
+                  href={`${ROUTES.PAGES.TASK_EXECUTION}?job_id=${job.job_id}`}
                   aria-label={__('View Details')}
                   title={__('View Details')}
                 >