foreman_remote_execution 16.7.0 → 17.1.0

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

@@ -0,0 +1,369 @@
+import React from 'react';
+import { render, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { Provider } from 'react-redux';
+import configureMockStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
+import { Router } from 'react-router-dom';
+import { createMemoryHistory } from 'history';
+import { APIActions } from 'foremanReact/redux/API';
+import { createForemanContextWrapper } from './foremanTestHelpers';
+import JobInvocationHostTable from '../JobInvocationHostTable';
+import { JOB_INVOCATION_HOSTS } from '../JobInvocationConstants';
+
+jest.useFakeTimers();
+
+jest.mock('foremanReact/redux/API/APISelectors', () =>
+  jest.requireActual('foremanReact/redux/API/APISelectors')
+);
+
+jest.mock('foremanReact/common/hooks/Permissions/permissionHooks', () => ({
+  usePermissions: jest.fn(() => true),
+}));
+
+jest.mock('../TemplateInvocation', () => ({
+  TemplateInvocation: () => <div data-testid="template-invocation" />,
+}));
+
+jest.mock('../TemplateInvocationComponents/TemplateActionButtons', () => ({
+  RowActions: () => <div data-testid="row-actions" />,
+}));
+
+const mockStore = configureMockStore([thunk]);
+
+const hostsResponse = {
+  total: 1,
+  subtotal: 1,
+  page: 1,
+  per_page: 20,
+  results: [
+    {
+      id: 1,
+      name: 'host1.example.com',
+      operatingsystem_id: 1,
+      operatingsystem_name: 'RHEL 9',
+      hostgroup_id: 1,
+      hostgroup_name: 'default',
+      job_status: 'success',
+      smart_proxy_id: 1,
+      smart_proxy_name: 'proxy1',
+    },
+  ],
+};
+
+let apiGetSpy;
+let hostsCalls;
+let pendingCallbacks;
+
+const createStore = () =>
+  mockStore({
+    API: {},
+  });
+
+const flushPendingCallbacks = () => {
+  const batch = [...pendingCallbacks];
+  pendingCallbacks = [];
+  batch.forEach(cb => cb());
+};
+
+const renderTable = (props = {}) => {
+  const store = createStore();
+  const history = createMemoryHistory();
+  const Wrapper = createForemanContextWrapper();
+
+  const defaultProps = {
+    id: '42',
+    targeting: { targeting_type: 'static_query', search_query: '' },
+    initialFilter: 'all_statuses',
+    jobFinished: false,
+    onFilterUpdate: jest.fn(),
+    ...props,
+  };
+
+  const result = render(
+    <Provider store={store}>
+      <Router history={history}>
+        <Wrapper>
+          <JobInvocationHostTable {...defaultProps} />
+        </Wrapper>
+      </Router>
+    </Provider>
+  );
+
+  return { ...result, store, history };
+};
+
+const setupSuccessMock = () => {
+  apiGetSpy = jest
+    .spyOn(APIActions, 'get')
+    .mockImplementation(opts => dispatch => {
+      if (opts.key === JOB_INVOCATION_HOSTS) {
+        hostsCalls.push(opts);
+        if (opts.handleSuccess) {
+          pendingCallbacks.push(() =>
+            opts.handleSuccess({ data: hostsResponse })
+          );
+        }
+      }
+    });
+};
+
+const setupErrorMock = () => {
+  apiGetSpy = jest
+    .spyOn(APIActions, 'get')
+    .mockImplementation(opts => dispatch => {
+      if (opts.key === JOB_INVOCATION_HOSTS) {
+        hostsCalls.push(opts);
+        if (opts.handleError) {
+          pendingCallbacks.push(() => opts.handleError());
+        }
+      }
+    });
+};
+
+describe('JobInvocationHostTable polling', () => {
+  beforeEach(() => {
+    hostsCalls = [];
+    pendingCallbacks = [];
+    setupSuccessMock();
+  });
+
+  afterEach(() => {
+    apiGetSpy.mockRestore();
+    jest.clearAllTimers();
+  });
+
+  it('schedules a poll after the initial fetch succeeds', () => {
+    renderTable();
+
+    expect(hostsCalls).toHaveLength(1);
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(1);
+
+    act(() => {
+      jest.advanceTimersByTime(5000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(2);
+
+    act(() => {
+      jest.advanceTimersByTime(5000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(3);
+  });
+
+  it('does not schedule a poll when jobFinished is true', () => {
+    renderTable({ jobFinished: true });
+
+    expect(hostsCalls).toHaveLength(1);
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    act(() => {
+      jest.advanceTimersByTime(10000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(1);
+  });
+
+  it('stops polling when jobFinished transitions to true', () => {
+    const { rerender } = renderTable();
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(1);
+
+    const store = createStore();
+    const history = createMemoryHistory();
+    const Wrapper = createForemanContextWrapper();
+
+    act(() => {
+      rerender(
+        <Provider store={store}>
+          <Router history={history}>
+            <Wrapper>
+              <JobInvocationHostTable
+                id="42"
+                targeting={{
+                  targeting_type: 'static_query',
+                  search_query: '',
+                }}
+                initialFilter="all_statuses"
+                jobFinished
+                onFilterUpdate={jest.fn()}
+              />
+            </Wrapper>
+          </Router>
+        </Provider>
+      );
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    const callsAtTransition = hostsCalls.length;
+
+    act(() => {
+      jest.advanceTimersByTime(10000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(callsAtTransition);
+  });
+
+  it('cleans up the poll timer on unmount', () => {
+    const { unmount } = renderTable();
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    const callsBeforeUnmount = hostsCalls.length;
+
+    unmount();
+
+    act(() => {
+      jest.advanceTimersByTime(10000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(callsBeforeUnmount);
+  });
+
+  it('restarts polling when filter changes', () => {
+    const { rerender } = renderTable({ initialFilter: 'all_statuses' });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    const callsBeforeFilterChange = hostsCalls.length;
+
+    const store = createStore();
+    const history = createMemoryHistory();
+    const Wrapper = createForemanContextWrapper();
+
+    act(() => {
+      rerender(
+        <Provider store={store}>
+          <Router history={history}>
+            <Wrapper>
+              <JobInvocationHostTable
+                id="42"
+                targeting={{
+                  targeting_type: 'static_query',
+                  search_query: '',
+                }}
+                initialFilter="success"
+                jobFinished={false}
+                onFilterUpdate={jest.fn()}
+              />
+            </Wrapper>
+          </Router>
+        </Provider>
+      );
+    });
+
+    expect(hostsCalls.length).toBeGreaterThan(callsBeforeFilterChange);
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    const callsAfterFilterChange = hostsCalls.length;
+
+    act(() => {
+      jest.advanceTimersByTime(5000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls.length).toBeGreaterThan(callsAfterFilterChange);
+  });
+
+  it('sends include_permissions only on the first request', () => {
+    renderTable();
+
+    expect(hostsCalls).toHaveLength(1);
+    expect(hostsCalls[0].params.include_permissions).toBe(true);
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    act(() => {
+      jest.advanceTimersByTime(5000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(2);
+    expect(hostsCalls[1].params.include_permissions).toBeUndefined();
+
+    act(() => {
+      jest.advanceTimersByTime(5000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(3);
+    expect(hostsCalls[2].params.include_permissions).toBeUndefined();
+  });
+
+  it('stops polling on API error', () => {
+    apiGetSpy.mockRestore();
+    setupErrorMock();
+
+    renderTable();
+
+    expect(hostsCalls).toHaveLength(1);
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    act(() => {
+      jest.advanceTimersByTime(10000);
+    });
+
+    act(() => {
+      flushPendingCallbacks();
+    });
+
+    expect(hostsCalls).toHaveLength(1);
+  });
+});

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

@@ -0,0 +1,228 @@
+import { createStore, applyMiddleware } from 'redux';
+import thunk from 'redux-thunk';
+import { APIActions } from 'foremanReact/redux/API';
+import {
+  getJobInvocation,
+  stopJobInvocationPolling,
+} from '../JobInvocationActions';
+import {
+  JOB_INVOCATION_KEY,
+  AUTO_REFRESH_INTERVAL_MS,
+} from '../JobInvocationConstants';
+
+jest.useFakeTimers();
+
+const reducer = (state = {}) => state;
+const makeStore = () => createStore(reducer, applyMiddleware(thunk));
+const makeRef = () => ({ current: { timeoutId: null, cancel: () => {} } });
+
+const runningData = { status_label: 'running' };
+const succeededData = { status_label: 'succeeded' };
+const failedData = { status_label: 'failed' };
+const cancelledData = { status_label: 'cancelled' };
+
+let apiGetSpy;
+
+const setupGetMock = responseData => {
+  apiGetSpy = jest
+    .spyOn(APIActions, 'get')
+    .mockImplementation(({ handleSuccess, ...action }) => dispatch => {
+      handleSuccess && handleSuccess({ data: responseData });
+      return dispatch({ type: 'MOCK_GET', ...action });
+    });
+};
+
+const url = '/api/job_invocations/1';
+
+describe('job invocation polling', () => {
+  let ref;
+
+  beforeEach(() => {
+    ref = makeRef();
+    jest.clearAllTimers();
+  });
+
+  afterEach(() => {
+    if (apiGetSpy) {
+      apiGetSpy.mockRestore();
+    }
+  });
+
+  it('sends include_permissions and include_hosts on the initial fetch', () => {
+    setupGetMock(succeededData);
+    const store = makeStore();
+
+    store.dispatch(getJobInvocation(url, ref));
+
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+    expect(apiGetSpy.mock.calls[0][0]).toMatchObject({
+      key: JOB_INVOCATION_KEY,
+      url,
+      params: { include_hosts: false, include_permissions: true },
+    });
+  });
+
+  it('schedules the next poll when job is still running', () => {
+    setupGetMock(runningData);
+    const store = makeStore();
+
+    store.dispatch(getJobInvocation(url, ref));
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    jest.advanceTimersByTime(AUTO_REFRESH_INTERVAL_MS);
+    expect(apiGetSpy).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not include include_permissions on subsequent poll calls', () => {
+    setupGetMock(runningData);
+    const store = makeStore();
+
+    store.dispatch(getJobInvocation(url, ref));
+    jest.advanceTimersByTime(AUTO_REFRESH_INTERVAL_MS);
+
+    expect(apiGetSpy).toHaveBeenCalledTimes(2);
+    expect(apiGetSpy.mock.calls[1][0].params).toMatchObject({
+      include_hosts: false,
+    });
+    expect(apiGetSpy.mock.calls[1][0].params).not.toHaveProperty(
+      'include_permissions'
+    );
+  });
+
+  it('stops polling when job succeeds', () => {
+    setupGetMock(succeededData);
+    const store = makeStore();
+
+    store.dispatch(getJobInvocation(url, ref));
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    jest.advanceTimersByTime(AUTO_REFRESH_INTERVAL_MS);
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('stops polling when job fails', () => {
+    setupGetMock(failedData);
+    const store = makeStore();
+
+    store.dispatch(getJobInvocation(url, ref));
+    jest.advanceTimersByTime(AUTO_REFRESH_INTERVAL_MS);
+
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('stops polling when job is cancelled', () => {
+    setupGetMock(cancelledData);
+    const store = makeStore();
+
+    store.dispatch(getJobInvocation(url, ref));
+    jest.advanceTimersByTime(AUTO_REFRESH_INTERVAL_MS);
+
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('stops polling on fetch error', () => {
+    apiGetSpy = jest
+      .spyOn(APIActions, 'get')
+      .mockImplementation(({ handleError, ...action }) => dispatch => {
+        handleError && handleError();
+        return dispatch({ type: 'MOCK_GET', ...action });
+      });
+    const store = makeStore();
+
+    store.dispatch(getJobInvocation(url, ref));
+    jest.advanceTimersByTime(AUTO_REFRESH_INTERVAL_MS);
+
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('stopJobInvocationPolling cancels a pending timeout', () => {
+    setupGetMock(runningData);
+    const store = makeStore();
+
+    store.dispatch(getJobInvocation(url, ref));
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    stopJobInvocationPolling(ref);
+    jest.advanceTimersByTime(AUTO_REFRESH_INTERVAL_MS);
+
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('cancels pending timeout before starting a new poll when called multiple times', () => {
+    setupGetMock(runningData);
+    const store = makeStore();
+
+    store.dispatch(getJobInvocation(url, ref));
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    // Second call before the timeout fires cancels the first timeout and starts fresh
+    store.dispatch(getJobInvocation(url, ref));
+    expect(apiGetSpy).toHaveBeenCalledTimes(2);
+
+    jest.advanceTimersByTime(AUTO_REFRESH_INTERVAL_MS);
+
+    // Only the second poll chain fires (first was cancelled)
+    expect(apiGetSpy).toHaveBeenCalledTimes(3);
+  });
+
+  it('keeps polling as long as the job is running', () => {
+    setupGetMock(runningData);
+    const store = makeStore();
+
+    store.dispatch(getJobInvocation(url, ref));
+    jest.advanceTimersByTime(AUTO_REFRESH_INTERVAL_MS * 3);
+
+    expect(apiGetSpy).toHaveBeenCalledTimes(4);
+  });
+
+  it('cancels in-flight callback when new poll starts before previous resolves', () => {
+    let firstCallHandleSuccess;
+    let callCount = 0;
+    apiGetSpy = jest
+      .spyOn(APIActions, 'get')
+      .mockImplementation(({ handleSuccess, handleError }) => dispatch => {
+        callCount++;
+        if (callCount === 1) {
+          firstCallHandleSuccess = handleSuccess;
+        }
+        return dispatch({ type: 'MOCK_GET' });
+      });
+
+    const store = makeStore();
+    store.dispatch(getJobInvocation(url, ref));
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    // Start a new poll cycle before the first resolves
+    store.dispatch(getJobInvocation(url, ref));
+    expect(apiGetSpy).toHaveBeenCalledTimes(2);
+
+    // Old callback from first call tries to schedule next poll
+    firstCallHandleSuccess({ data: runningData });
+
+    // Timeout should not be set by the stale callback
+    expect(ref.current.timeoutId).toBeNull();
+  });
+
+  it('ignores a stale response resolving after stopJobInvocationPolling (e.g. unmount)', () => {
+    let capturedHandleSuccess;
+    apiGetSpy = jest
+      .spyOn(APIActions, 'get')
+      .mockImplementation(({ handleSuccess }) => dispatch => {
+        capturedHandleSuccess = handleSuccess;
+        return dispatch({ type: 'MOCK_GET' });
+      });
+
+    const store = makeStore();
+    store.dispatch(getJobInvocation(url, ref));
+    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+
+    // Simulate unmount: stop polling while the request is still in flight.
+    stopJobInvocationPolling(ref);
+
+    // The in-flight request resolves after the "unmount".
+    capturedHandleSuccess({ data: runningData });
+
+    // The stale response must not revive polling.
+    expect(ref.current.timeoutId).toBeNull();
+  });
+});