foreman_remote_execution 16.6.5 → 17.0.0

data/webpack/JobInvocationDetail/__tests__/TemplateInvocationPolling.test.js

@@ -0,0 +1,254 @@
+import React from 'react';
+import { createStore, applyMiddleware } from 'redux';
+import thunk from 'redux-thunk';
+import { Provider } from 'react-redux';
+import { render, act } from '@testing-library/react';
+import '@testing-library/jest-dom/extend-expect';
+import * as api from 'foremanReact/redux/API';
+import * as selectors from '../JobInvocationSelectors';
+import { TemplateInvocation } from '../TemplateInvocation';
+import { mockTemplateInvocationResponse } from './fixtures';
+
+jest.spyOn(api, 'get');
+jest.mock('../JobInvocationSelectors');
+
+jest.mock('foremanReact/components/ToastsList', () => ({
+  addToast: jest.fn(payload => ({ type: 'ADD_TOAST', payload })),
+}));
+
+describe('TemplateInvocation polling', () => {
+  const noop = () => {};
+  const reducer = (state = {}) => state;
+  const makeStore = () => createStore(reducer, applyMiddleware(thunk));
+
+  const pollingProps = {
+    hostID: '1',
+    jobID: '1',
+    isInTableView: false,
+    isExpanded: true,
+    hostName: 'example-host',
+    hostProxy: { name: 'example-proxy', href: '#' },
+    showOutputType: { stderr: true, stdout: true, debug: true },
+    setShowOutputType: noop,
+    showTemplatePreview: false,
+    setShowTemplatePreview: noop,
+    showCommand: false,
+    setShowCommand: noop,
+  };
+
+  let apiGetSpy;
+
+  beforeEach(() => {
+    jest.useFakeTimers({ legacyFakeTimers: true });
+    selectors.selectTemplateInvocationStatus.mockImplementation(() => () =>
+      'RESOLVED'
+    );
+    selectors.selectTemplateInvocation.mockImplementation(() => () =>
+      mockTemplateInvocationResponse
+    );
+    apiGetSpy = jest
+      .spyOn(api.APIActions, 'get')
+      .mockImplementation(({ handleSuccess }) => {
+        handleSuccess &&
+          handleSuccess({ data: { finished: false, auto_refresh: true } });
+        return { type: 'MOCK_GET' };
+      });
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+    apiGetSpy.mockRestore();
+  });
+
+  it('fetches on mount when isExpanded is true', () => {
+    const localStore = makeStore();
+    render(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} isExpanded />
+      </Provider>
+    );
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not fetch on mount when isExpanded is false', () => {
+    const localStore = makeStore();
+    render(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} isExpanded={false} />
+      </Provider>
+    );
+    expect(apiGetSpy).not.toHaveBeenCalled();
+  });
+
+  it('schedules next poll via setTimeout when auto_refresh is true and not finished', () => {
+    const localStore = makeStore();
+    render(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} />
+      </Provider>
+    );
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    act(() => jest.advanceTimersByTime(5000));
+    expect(apiGetSpy).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not schedule next poll when finished is true', () => {
+    apiGetSpy.mockImplementation(({ handleSuccess }) => {
+      handleSuccess &&
+        handleSuccess({ data: { finished: true, auto_refresh: true } });
+      return { type: 'MOCK_GET' };
+    });
+    const localStore = makeStore();
+    render(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} />
+      </Provider>
+    );
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    act(() => jest.advanceTimersByTime(5000));
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not schedule next poll when auto_refresh is false', () => {
+    apiGetSpy.mockImplementation(({ handleSuccess }) => {
+      handleSuccess &&
+        handleSuccess({ data: { finished: false, auto_refresh: false } });
+      return { type: 'MOCK_GET' };
+    });
+    const localStore = makeStore();
+    render(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} />
+      </Provider>
+    );
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    act(() => jest.advanceTimersByTime(5000));
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('clears the polling timeout and sets cancelled on unmount', () => {
+    const localStore = makeStore();
+    const { unmount } = render(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} />
+      </Provider>
+    );
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    unmount();
+    act(() => jest.advanceTimersByTime(5000));
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('cancels in-flight callback when unmounted before handleSuccess runs', () => {
+    let capturedHandleSuccess;
+    apiGetSpy.mockImplementation(({ handleSuccess }) => {
+      capturedHandleSuccess = handleSuccess;
+      return { type: 'MOCK_GET' };
+    });
+
+    const localStore = makeStore();
+    const { unmount } = render(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} />
+      </Provider>
+    );
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    unmount();
+
+    act(() => {
+      capturedHandleSuccess({ data: { finished: false, auto_refresh: true } });
+      jest.advanceTimersByTime(5000);
+    });
+
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('re-fetches when isExpanded changes from false to true', () => {
+    const localStore = makeStore();
+    const { rerender } = render(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} isExpanded={false} />
+      </Provider>
+    );
+    expect(apiGetSpy).not.toHaveBeenCalled();
+
+    rerender(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} isExpanded />
+      </Provider>
+    );
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not re-fetch on expand when response is already finished', () => {
+    selectors.selectTemplateInvocation.mockImplementation(() => () => ({
+      ...mockTemplateInvocationResponse,
+      finished: true,
+    }));
+    apiGetSpy.mockImplementation(({ handleSuccess }) => {
+      handleSuccess &&
+        handleSuccess({ data: { finished: true, auto_refresh: false } });
+      return { type: 'MOCK_GET' };
+    });
+
+    const localStore = makeStore();
+    const { rerender } = render(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} isExpanded={false} />
+      </Provider>
+    );
+    expect(apiGetSpy).not.toHaveBeenCalled();
+
+    rerender(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} isExpanded />
+      </Provider>
+    );
+    // Selector already returns finished=true → guard skips dispatchFetch
+    expect(apiGetSpy).not.toHaveBeenCalled();
+
+    rerender(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} isExpanded={false} />
+      </Provider>
+    );
+    rerender(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} isExpanded />
+      </Provider>
+    );
+    // Second expand: still finished → still no fetch
+    expect(apiGetSpy).not.toHaveBeenCalled();
+  });
+
+  it('cancels existing poll and starts fresh when isExpanded changes', () => {
+    const localStore = makeStore();
+    const { rerender } = render(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} isExpanded />
+      </Provider>
+    );
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    rerender(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} isExpanded={false} />
+      </Provider>
+    );
+    act(() => jest.advanceTimersByTime(5000));
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    rerender(
+      <Provider store={localStore}>
+        <TemplateInvocation {...pollingProps} isExpanded />
+      </Provider>
+    );
+    expect(apiGetSpy).toHaveBeenCalledTimes(2);
+  });
+});

data/webpack/JobInvocationDetail/__tests__/fixtures.js

@@ -42,6 +42,7 @@ export const jobInvocationData = {
     id: '37ad5ead-51de-4798-bc73-a17687c4d5aa',
     state: 'stopped',
     started_at: '2024-01-01 12:34:56 +0100',
+    cancellable: true,
   },
   template_invocations: [
     {
@@ -113,6 +114,7 @@ export const jobInvocationDataRecurring = {
   task: {
     id: '37ad5ead-51de-4798-bc73-a17687c4d5aa',
     state: 'scheduled',
+    cancellable: true,
   },
   mode: 'recurring',
   recurrence: {

data/webpack/JobInvocationDetail/__tests__/foremanTestHelpers.js

@@ -0,0 +1,30 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { getForemanContext } from 'foremanReact/Root/Context/ForemanContext';
+
+export const createForemanContextWrapper = (
+  permissions = ['view_job_invocations', 'create_job_invocations']
+) => {
+  const foremanContextValue = {
+    context: {
+      metadata: {
+        permissions: new Set(permissions),
+        UISettings: { perPage: 20 },
+      },
+    },
+    setContext: jest.fn(),
+  };
+  const ForemanContext = getForemanContext(foremanContextValue);
+
+  const ForemanContextWrapper = ({ children }) => (
+    <ForemanContext.Provider value={foremanContextValue}>
+      {children}
+    </ForemanContext.Provider>
+  );
+
+  ForemanContextWrapper.propTypes = {
+    children: PropTypes.node.isRequired,
+  };
+
+  return ForemanContextWrapper;
+};

data/webpack/JobInvocationDetail/index.js

@@ -5,29 +5,35 @@ import {
   PageSectionVariants,
   Skeleton,
 } from '@patternfly/react-core';
-import React, { useEffect, useState } from 'react';
+import React, { useEffect, useMemo, useRef, useState } from 'react';
 import { translate as __, documentLocale } from 'foremanReact/common/I18n';
 import { useDispatch, useSelector } from 'react-redux';
 import PageLayout from 'foremanReact/routes/common/PageLayout/PageLayout';
 import PropTypes from 'prop-types';
 import SkeletonLoader from 'foremanReact/components/common/SkeletonLoader';
-import { stopInterval } from 'foremanReact/redux/middlewares/IntervalMiddleware';
-import { useAPI } from 'foremanReact/common/hooks/API/APIHooks';
+import { STATUS as API_STATUS } from 'foremanReact/constants';
+import {
+  selectAPIErrorMessage,
+  selectAPIHttpStatus,
+  selectAPIStatus,
+} from 'foremanReact/redux/API/APISelectors';
 
 import { JobAdditionInfo } from './JobAdditionInfo';
 import JobInvocationHostTable from './JobInvocationHostTable';
 import JobInvocationOverview from './JobInvocationOverview';
 import JobInvocationSystemStatusChart from './JobInvocationSystemStatusChart';
+import JobInvocationEmptyState from './JobInvocationEmptyState';
 import JobInvocationToolbarButtons from './JobInvocationToolbarButtons';
-import { getJobInvocation, getTask } from './JobInvocationActions';
+import {
+  getJobInvocation,
+  stopJobInvocationPolling,
+  isJobFinished,
+} from './JobInvocationActions';
 import './JobInvocationDetail.scss';
 import {
-  CURRENT_PERMISSIONS,
   DATE_OPTIONS,
   JOB_INVOCATION_KEY,
-  STATUS,
   STATUS_UPPERCASE,
-  currentPermissionsUrl,
 } from './JobInvocationConstants';
 import { selectItems } from './JobInvocationSelectors';
 
@@ -46,14 +52,17 @@ const JobInvocationDetailPage = ({
     start_at: startAt,
     targeting = {},
   } = items;
-  const finished =
-    statusLabel === STATUS.FAILED ||
-    statusLabel === STATUS.SUCCEEDED ||
-    statusLabel === STATUS.CANCELLED;
-  const autoRefresh = task?.state === STATUS.PENDING || false;
-  useAPI('get', currentPermissionsUrl, {
-    key: CURRENT_PERMISSIONS,
-  });
+  const finished = isJobFinished(statusLabel);
+  const pollTimeoutRef = useRef({ timeoutId: null, cancel: () => {} });
+  const jobInvocationApiStatus = useSelector(state =>
+    selectAPIStatus(state, JOB_INVOCATION_KEY)
+  );
+  const jobInvocationErrorMessage = useSelector(state =>
+    selectAPIErrorMessage(state, JOB_INVOCATION_KEY)
+  );
+  const jobInvocationHttpStatus = useSelector(state =>
+    selectAPIHttpStatus(state, JOB_INVOCATION_KEY)
+  );
   const [selectedFilter, setSelectedFilter] = useState('');
 
   const handleFilterChange = newFilter => {
@@ -72,21 +81,30 @@ const JobInvocationDetailPage = ({
   }
 
   useEffect(() => {
-    dispatch(getJobInvocation(`/api/job_invocations/${id}?host_status=true`));
-    if (finished && !autoRefresh) {
-      dispatch(stopInterval(JOB_INVOCATION_KEY));
-    }
+    dispatch(getJobInvocation(`/api/job_invocations/${id}`, pollTimeoutRef));
     return () => {
-      dispatch(stopInterval(JOB_INVOCATION_KEY));
+      stopJobInvocationPolling(pollTimeoutRef);
     };
-  }, [dispatch, id, finished, autoRefresh]);
+  }, [dispatch, id]);
 
-  const taskId = task?.id;
-  useEffect(() => {
-    if (taskId !== undefined) {
-      dispatch(getTask(`${taskId}`));
+  const apiFailed = jobInvocationApiStatus === API_STATUS.ERROR;
+
+  const backendErrorMessage = useMemo(() => {
+    if (jobInvocationApiStatus === API_STATUS.ERROR) {
+      return jobInvocationErrorMessage || null;
     }
-  }, [dispatch, taskId]);
+    return null;
+  }, [jobInvocationApiStatus, jobInvocationErrorMessage]);
+
+  if (apiFailed) {
+    return (
+      <JobInvocationEmptyState
+        jobInvocationId={id}
+        httpStatus={jobInvocationHttpStatus}
+        errorMessage={backendErrorMessage}
+      />
+    );
+  }
 
   const pageStatus =
     items.id === undefined
@@ -123,7 +141,11 @@ const JobInvocationDetailPage = ({
       <PageLayout
         header={description}
         breadcrumbOptions={breadcrumbOptions}
-        toolbarButtons={<JobInvocationToolbarButtons jobId={id} data={items} />}
+        toolbarButtons={
+          items.id !== undefined && (
+            <JobInvocationToolbarButtons jobId={id} data={items} />
+          )
+        }
         searchable={false}
       >
         <Flex className="job-invocation-detail-flex">
@@ -183,10 +205,8 @@ const JobInvocationDetailPage = ({
           <JobInvocationHostTable
             id={id}
             targeting={targeting}
-            finished={finished}
-            autoRefresh={autoRefresh}
             initialFilter={selectedFilter}
-            statusLabel={statusLabel}
+            jobFinished={finished}
             onFilterUpdate={handleFilterChange}
           />
         </SkeletonLoader>

data/webpack/__mocks__/foremanReact/Root/Context/ForemanContext/index.js

@@ -1,6 +1,21 @@
+import React from 'react';
+
+const getForemanContext = contextData => {
+  window.tfm_forced_singletons = window.tfm_forced_singletons || {};
+
+  if (!window.tfm_forced_singletons.Context) {
+    window.tfm_forced_singletons.Context = React.createContext(contextData);
+  }
+
+  return window.tfm_forced_singletons.Context;
+};
+
+export { getForemanContext };
 export const useForemanOrganization = () => ({ id: 1 });
 export const useForemanLocation = () => ({ id: 2 });
 export const useForemanVersion = () => '3.7';
 export const useForemanHostsPageUrl = () => '/hosts';
 export const useForemanHostDetailsPageUrl = () => '/hosts/';
 export const useForemanSettings = () => ({ perPage: 20 });
+export const useForemanPermissions = () =>
+  new Set(['view_job_invocations', 'create_job_invocations']);

data/webpack/__mocks__/foremanReact/common/hooks/Permissions/permissionHooks.js

@@ -0,0 +1 @@
+export const usePermissions = jest.fn(() => true);

data/webpack/__mocks__/foremanReact/redux/API/APISelectors.js

@@ -19,3 +19,8 @@ export const selectAPIErrorMessage = (state, key) => {
   const error = selectAPIError(state, key);
   return error && error.message;
 };
+
+export const selectAPIHttpStatus = (state, key) => {
+  const error = selectAPIError(state, key);
+  return error?.response?.status;
+};

data/webpack/test_setup.js

@@ -1,13 +1 @@
-import 'core-js/shim';
-import 'regenerator-runtime/runtime';
-
-import { configure } from '@theforeman/test';
-// eslint-disable-next-line import/no-extraneous-dependencies
-import Adapter from 'enzyme-adapter-react-16';
-
-configure({ adapter: new Adapter() });
-
-// Mocking translation function
-global.__ = str => str;
-global.n__ = str => str;
-global.Jed = { sprintf: str => str };
+import 'foremanJSTestSetup';

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foreman_remote_execution
 version: !ruby/object:Gem::Version
-  version: 16.6.5
+  version: 17.0.0
 platform: ruby
 authors:
 - Foreman Remote Execution team
 bindir: bin
 cert_chain: []
-date: 2026-06-23 00:00:00.000000000 Z
+date: 2026-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deface
@@ -202,6 +202,7 @@ files:
 - app/views/job_invocations/show.js.erb
 - app/views/job_invocations/show.json.erb
 - app/views/job_invocations/welcome.html.erb
+- app/views/job_templates/_alerts.html.erb
 - app/views/job_templates/_custom_tab_headers.html.erb
 - app/views/job_templates/_custom_tabs.html.erb
 - app/views/job_templates/_import_job_template_modal.html.erb
@@ -382,6 +383,7 @@ files:
 - webpack/JobInvocationDetail/JobInvocationActions.js
 - webpack/JobInvocationDetail/JobInvocationConstants.js
 - webpack/JobInvocationDetail/JobInvocationDetail.scss
+- webpack/JobInvocationDetail/JobInvocationEmptyState.js
 - webpack/JobInvocationDetail/JobInvocationHostTable.js
 - webpack/JobInvocationDetail/JobInvocationOverview.js
 - webpack/JobInvocationDetail/JobInvocationSelectors.js
@@ -395,11 +397,16 @@ files:
 - webpack/JobInvocationDetail/TemplateInvocationComponents/TemplateActionButtons.js
 - webpack/JobInvocationDetail/TemplateInvocationComponents/index.scss
 - webpack/JobInvocationDetail/TemplateInvocationPage.js
+- webpack/JobInvocationDetail/__tests__/JobInvocationDetailEmptyState.test.js
+- webpack/JobInvocationDetail/__tests__/JobInvocationHostTablePolling.test.js
+- webpack/JobInvocationDetail/__tests__/JobInvocationPolling.test.js
 - webpack/JobInvocationDetail/__tests__/MainInformation.test.js
 - webpack/JobInvocationDetail/__tests__/OutputCodeBlock.test.js
 - webpack/JobInvocationDetail/__tests__/TableToolbarActions.test.js
 - webpack/JobInvocationDetail/__tests__/TemplateInvocation.test.js
+- webpack/JobInvocationDetail/__tests__/TemplateInvocationPolling.test.js
 - webpack/JobInvocationDetail/__tests__/fixtures.js
+- webpack/JobInvocationDetail/__tests__/foremanTestHelpers.js
 - webpack/JobInvocationDetail/index.js
 - webpack/JobWizard/Footer.js
 - webpack/JobWizard/JobWizard.js
@@ -469,6 +476,7 @@ files:
 - webpack/__mocks__/foremanReact/common/globalIdHelpers.js
 - webpack/__mocks__/foremanReact/common/helpers.js
 - webpack/__mocks__/foremanReact/common/hooks/API/APIHooks.js
+- webpack/__mocks__/foremanReact/common/hooks/Permissions/permissionHooks.js
 - webpack/__mocks__/foremanReact/components/AutoComplete/AutoCompleteActions.js
 - webpack/__mocks__/foremanReact/components/AutoComplete/AutoCompleteConstants.js
 - webpack/__mocks__/foremanReact/components/BreadcrumbBar/index.js
@@ -560,7 +568,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A plugin bringing remote execution to the Foreman, completing the config
   management functionality with remote management functionality.