foreman_remote_execution 16.7.0 → 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/index.js

@@ -5,13 +5,12 @@ import {
   PageSectionVariants,
   Skeleton,
 } from '@patternfly/react-core';
-import React, { useEffect, useMemo, 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 { STATUS as API_STATUS } from 'foremanReact/constants';
 import {
   selectAPIErrorMessage,
@@ -25,12 +24,15 @@ 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 {
   DATE_OPTIONS,
   JOB_INVOCATION_KEY,
-  STATUS,
   STATUS_UPPERCASE,
 } from './JobInvocationConstants';
 import { selectItems } from './JobInvocationSelectors';
@@ -50,11 +52,8 @@ 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;
+  const finished = isJobFinished(statusLabel);
+  const pollTimeoutRef = useRef({ timeoutId: null, cancel: () => {} });
   const jobInvocationApiStatus = useSelector(state =>
     selectAPIStatus(state, JOB_INVOCATION_KEY)
   );
@@ -82,21 +81,11 @@ const JobInvocationDetailPage = ({
   }
 
   useEffect(() => {
-    dispatch(getJobInvocation(`/api/job_invocations/${id}`));
-    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]);
-
-  const taskId = task?.id;
-  useEffect(() => {
-    if (taskId !== undefined) {
-      dispatch(getTask(`${taskId}`));
-    }
-  }, [dispatch, taskId]);
+  }, [dispatch, id]);
 
   const apiFailed = jobInvocationApiStatus === API_STATUS.ERROR;
 
@@ -216,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/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.7.0
+  version: 17.0.0
 platform: ruby
 authors:
 - Foreman Remote Execution team
 bindir: bin
 cert_chain: []
-date: 2026-07-13 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
@@ -397,10 +398,13 @@ files:
 - 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
@@ -564,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.