foreman_remote_execution 18.0.1 → 18.1.0

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

@@ -1,25 +1,40 @@
+/* eslint-disable max-lines */
 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 { render, act, cleanup, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import API from 'foremanReact/API';
+import { addToast } from 'foremanReact/components/ToastsList';
 import * as api from 'foremanReact/redux/API';
 import * as selectors from '../JobInvocationSelectors';
 import { TemplateInvocation } from '../TemplateInvocation';
-import { mockTemplateInvocationResponse } from './fixtures';
+import {
+  OUTPUT_MAX_REFRESH_INTERVAL_MS,
+  OUTPUT_REFRESH_INTERVAL_MS,
+} from '../JobInvocationConstants';
+import {
+  jobInvocationOutput,
+  mockTemplateInvocationResponse,
+} from './fixtures';
 
-jest.spyOn(api, 'get');
+jest.mock('foremanReact/API');
 jest.mock('../JobInvocationSelectors');
 
 jest.mock('foremanReact/components/ToastsList', () => ({
   addToast: jest.fn(payload => ({ type: 'ADD_TOAST', payload })),
 }));
 
+const apiActionsGetSpy = jest.spyOn(api.APIActions, 'get');
+
 describe('TemplateInvocation polling', () => {
   const noop = () => {};
   const reducer = (state = {}) => state;
   const makeStore = () => createStore(reducer, applyMiddleware(thunk));
+  const outputURL = '/api/job_invocations/1/hosts/1';
+  const detailsURL = '/show_template_invocation_by_host/1/job_invocation/1';
 
   const pollingProps = {
     hostID: '1',
@@ -35,8 +50,28 @@ describe('TemplateInvocation polling', () => {
     showCommand: false,
     setShowCommand: noop,
   };
+  const renderInvocation = (props = {}) =>
+    render(
+      <Provider store={makeStore()}>
+        <TemplateInvocation {...pollingProps} {...props} />
+      </Provider>
+    );
+
+  const respond = (request, overrides = {}) => {
+    const data = {
+      ...mockTemplateInvocationResponse,
+      finished: false,
+      auto_refresh: true,
+      ...overrides.details,
+    };
+    if (request.handleSuccess) request.handleSuccess({ data });
+    return { type: 'MOCK_GET' };
+  };
+
+  const outputResponse = (overrides = {}) =>
+    Promise.resolve({ data: { output: [], refresh: true, ...overrides } });
 
-  let apiGetSpy;
+  const flushPromises = () => act(async () => {});
 
   beforeEach(() => {
     jest.useFakeTimers({ legacyFakeTimers: true });
@@ -46,209 +81,373 @@ describe('TemplateInvocation polling', () => {
     selectors.selectTemplateInvocation.mockImplementation(() => () =>
       mockTemplateInvocationResponse
     );
-    apiGetSpy = jest
-      .spyOn(api.APIActions, 'get')
-      .mockImplementation(({ handleSuccess }) => {
-        handleSuccess &&
-          handleSuccess({ data: { finished: false, auto_refresh: true } });
-        return { type: 'MOCK_GET' };
-      });
+    API.get.mockImplementation(() => outputResponse());
+    apiActionsGetSpy.mockImplementation(request => respond(request));
   });
 
   afterEach(() => {
+    cleanup();
     jest.clearAllTimers();
     jest.useRealTimers();
-    apiGetSpy.mockRestore();
+    API.get.mockReset();
+    apiActionsGetSpy.mockReset();
+    addToast.mockClear();
   });
 
-  it('fetches on mount when isExpanded is true', () => {
-    const localStore = makeStore();
-    render(
-      <Provider store={localStore}>
-        <TemplateInvocation {...pollingProps} isExpanded />
-      </Provider>
+  it('requests only output added since the latest displayed chunk', () => {
+    renderInvocation();
+
+    expect(API.get).toHaveBeenCalledWith(
+      outputURL,
+      {},
+      {
+        since: jobInvocationOutput[jobInvocationOutput.length - 1].timestamp,
+      }
     );
-    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>
+  it('uses newly appended output as the cursor for the next poll', async () => {
+    const latestTimestamp = 1733931150.2044532;
+    API.get.mockImplementation(() =>
+      outputResponse({
+        output: [
+          {
+            output_type: 'stdout',
+            output: 'New live output\n',
+            timestamp: latestTimestamp,
+          },
+        ],
+      })
     );
-    expect(apiGetSpy).not.toHaveBeenCalled();
+
+    renderInvocation();
+    await flushPromises();
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+
+    expect(API.get.mock.calls[1]).toEqual([
+      outputURL,
+      {},
+      { since: latestTimestamp },
+    ]);
   });
 
-  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);
+  it('polls output once per output refresh interval', async () => {
+    renderInvocation();
+    expect(API.get).toHaveBeenCalledTimes(1);
+
+    await flushPromises();
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
 
-    act(() => jest.advanceTimersByTime(5000));
-    expect(apiGetSpy).toHaveBeenCalledTimes(2);
+    expect(API.get).toHaveBeenCalledTimes(2);
+    expect(API.get.mock.calls[1][0]).toBe(outputURL);
   });
 
-  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' };
+  it('gradually backs off while the job produces no output', async () => {
+    renderInvocation();
+    await flushPromises();
+
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+    expect(API.get).toHaveBeenCalledTimes(2);
+    await flushPromises();
+
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+    expect(API.get).toHaveBeenCalledTimes(2);
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+    expect(API.get).toHaveBeenCalledTimes(3);
+    await flushPromises();
+
+    act(() =>
+      jest.advanceTimersByTime(
+        OUTPUT_MAX_REFRESH_INTERVAL_MS - OUTPUT_REFRESH_INTERVAL_MS
+      )
+    );
+    expect(API.get).toHaveBeenCalledTimes(3);
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+    expect(API.get).toHaveBeenCalledTimes(4);
+  });
+
+  it('returns to fast polling when new output arrives', async () => {
+    let outputRequests = 0;
+    API.get.mockImplementation(() => {
+      outputRequests += 1;
+      return outputResponse({
+        output:
+          outputRequests === 3
+            ? [
+                {
+                  output_type: 'stdout',
+                  output: 'New live output\n',
+                  timestamp: 1733931150.2044532,
+                },
+              ]
+            : [],
+      });
     });
-    const localStore = makeStore();
-    render(
-      <Provider store={localStore}>
-        <TemplateInvocation {...pollingProps} />
-      </Provider>
+
+    renderInvocation();
+    await flushPromises();
+
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+    await flushPromises();
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS * 2));
+    expect(API.get).toHaveBeenCalledTimes(3);
+    await flushPromises();
+
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+    expect(API.get).toHaveBeenCalledTimes(4);
+  });
+
+  it('appends new output without replacing the displayed output', async () => {
+    API.get.mockImplementation(() =>
+      outputResponse({
+        output: [
+          {
+            output_type: 'stdout',
+            output: 'New live output\n',
+            timestamp: 1733931150.2044532,
+          },
+        ],
+      })
     );
-    expect(apiGetSpy).toHaveBeenCalledTimes(1);
 
-    act(() => jest.advanceTimersByTime(5000));
-    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+    renderInvocation();
+    await flushPromises();
+
+    expect(screen.getByText('This is red text')).toBeInTheDocument();
+    expect(screen.getByText('New live output')).toBeInTheDocument();
   });
 
-  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' };
-    });
+  it('does not replace live output with a later Redux update', async () => {
+    let response = mockTemplateInvocationResponse;
     const localStore = makeStore();
+    selectors.selectTemplateInvocation.mockImplementation(() => () => response);
+    API.get.mockImplementation(() =>
+      outputResponse({
+        output: [
+          {
+            output_type: 'stdout',
+            output: 'New live output\n',
+            timestamp: 1733931150.2044532,
+          },
+        ],
+      })
+    );
+
     render(
       <Provider store={localStore}>
         <TemplateInvocation {...pollingProps} />
       </Provider>
     );
-    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+    await flushPromises();
+
+    response = {
+      ...mockTemplateInvocationResponse,
+      output: [
+        {
+          output_type: 'stdout',
+          output: 'Stale Redux output\n',
+          timestamp: 1,
+        },
+      ],
+    };
+    act(() => {
+      localStore.dispatch({ type: 'UPDATE' });
+    });
 
-    act(() => jest.advanceTimersByTime(5000));
-    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+    expect(screen.getByText('New live output')).toBeInTheDocument();
+    expect(screen.queryByText('Stale Redux output')).not.toBeInTheDocument();
   });
 
-  it('clears the polling timeout and sets cancelled on unmount', () => {
-    const localStore = makeStore();
-    const { unmount } = render(
-      <Provider store={localStore}>
-        <TemplateInvocation {...pollingProps} />
-      </Provider>
+  it('refreshes the complete details once after host output finishes', async () => {
+    API.get.mockImplementation(() => outputResponse({ refresh: false }));
+    apiActionsGetSpy.mockImplementation(request =>
+      respond(request, { details: { finished: false, auto_refresh: true } })
     );
-    expect(apiGetSpy).toHaveBeenCalledTimes(1);
 
-    unmount();
-    act(() => jest.advanceTimersByTime(5000));
-    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+    renderInvocation();
+    await flushPromises();
+
+    expect(API.get).toHaveBeenCalledTimes(1);
+    expect(API.get.mock.calls[0][0]).toBe(outputURL);
+    expect(apiActionsGetSpy).toHaveBeenCalledTimes(1);
+    expect(apiActionsGetSpy.mock.calls[0][0].url).toBe(detailsURL);
+
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS * 2));
+
+    expect(API.get).toHaveBeenCalledTimes(1);
+    expect(apiActionsGetSpy).toHaveBeenCalledTimes(1);
   });
 
-  it('cancels in-flight callback when unmounted before handleSuccess runs', () => {
-    let capturedHandleSuccess;
-    apiGetSpy.mockImplementation(({ handleSuccess }) => {
-      capturedHandleSuccess = handleSuccess;
-      return { type: 'MOCK_GET' };
-    });
+  it('loads complete details first when no cached response exists', () => {
+    selectors.selectTemplateInvocation.mockImplementation(() => () =>
+      undefined
+    );
 
-    const localStore = makeStore();
-    const { unmount } = render(
-      <Provider store={localStore}>
-        <TemplateInvocation {...pollingProps} />
-      </Provider>
+    renderInvocation();
+
+    expect(apiActionsGetSpy).toHaveBeenCalledTimes(1);
+    expect(apiActionsGetSpy.mock.calls[0][0].url).toBe(detailsURL);
+
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+
+    expect(API.get).toHaveBeenCalledTimes(1);
+    expect(API.get.mock.calls[0][0]).toBe(outputURL);
+  });
+
+  it('does not poll output when complete details disable auto refresh', () => {
+    selectors.selectTemplateInvocation.mockImplementation(() => () =>
+      undefined
+    );
+    apiActionsGetSpy.mockImplementation(request =>
+      respond(request, { details: { auto_refresh: false } })
     );
-    expect(apiGetSpy).toHaveBeenCalledTimes(1);
 
-    unmount();
+    renderInvocation();
 
-    act(() => {
-      capturedHandleSuccess({ data: { finished: false, auto_refresh: true } });
-      jest.advanceTimersByTime(5000);
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS * 2));
+
+    expect(apiActionsGetSpy).toHaveBeenCalledTimes(1);
+    expect(apiActionsGetSpy.mock.calls[0][0].url).toBe(detailsURL);
+    expect(API.get).not.toHaveBeenCalled();
+  });
+
+  it('retries failed output requests with backoff and one toast', async () => {
+    API.get.mockRejectedValue({
+      response: { data: { error: { message: 'Output request failed' } } },
     });
 
-    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+    renderInvocation();
+    await flushPromises();
+
+    expect(API.get).toHaveBeenCalledTimes(1);
+    expect(addToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'danger',
+        message: 'Output request failed',
+      })
+    );
+
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+    expect(API.get).toHaveBeenCalledTimes(2);
+    await flushPromises();
+
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+    expect(API.get).toHaveBeenCalledTimes(2);
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+
+    expect(API.get).toHaveBeenCalledTimes(3);
+    expect(addToast).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>
+  it('does not start output polling after a details request fails', () => {
+    selectors.selectTemplateInvocation.mockImplementation(() => () =>
+      undefined
     );
-    expect(apiGetSpy).not.toHaveBeenCalled();
+    apiActionsGetSpy.mockImplementation(request => {
+      request.handleError();
+      return { type: 'MOCK_GET' };
+    });
 
-    rerender(
-      <Provider store={localStore}>
-        <TemplateInvocation {...pollingProps} isExpanded />
-      </Provider>
+    renderInvocation();
+    act(() => jest.advanceTimersByTime(OUTPUT_MAX_REFRESH_INTERVAL_MS));
+
+    expect(apiActionsGetSpy).toHaveBeenCalledTimes(1);
+    expect(apiActionsGetSpy.mock.calls[0][0].url).toBe(detailsURL);
+    expect(API.get).not.toHaveBeenCalled();
+  });
+
+  it('does not fetch while collapsed', () => {
+    renderInvocation({ isExpanded: false });
+
+    expect(API.get).not.toHaveBeenCalled();
+    expect(apiActionsGetSpy).not.toHaveBeenCalled();
+  });
+
+  it('pauses output requests while the document is hidden', () => {
+    const visibilityState = Object.getOwnPropertyDescriptor(
+      document,
+      'visibilityState'
     );
-    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+    Object.defineProperty(document, 'visibilityState', {
+      configurable: true,
+      value: 'hidden',
+    });
+
+    try {
+      renderInvocation();
+      act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+      expect(API.get).not.toHaveBeenCalled();
+
+      Object.defineProperty(document, 'visibilityState', {
+        configurable: true,
+        value: 'visible',
+      });
+      act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+      expect(API.get).toHaveBeenCalledTimes(1);
+    } finally {
+      if (visibilityState) {
+        Object.defineProperty(document, 'visibilityState', visibilityState);
+      } else {
+        delete document.visibilityState;
+      }
+    }
   });
 
-  it('does not re-fetch on expand when response is already finished', () => {
+  it('does not fetch when the cached 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' };
-    });
 
+    renderInvocation();
+
+    expect(API.get).not.toHaveBeenCalled();
+    expect(apiActionsGetSpy).not.toHaveBeenCalled();
+  });
+
+  it('cancels a scheduled poll when collapsed', () => {
     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 />
+        <TemplateInvocation {...pollingProps} />
       </Provider>
     );
-    // Selector already returns finished=true → guard skips dispatchFetch
-    expect(apiGetSpy).not.toHaveBeenCalled();
+    expect(API.get).toHaveBeenCalledTimes(1);
 
     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();
+    act(() => jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS));
+
+    expect(API.get).toHaveBeenCalledTimes(1);
   });
 
-  it('cancels existing poll and starts fresh when isExpanded changes', () => {
-    const localStore = makeStore();
-    const { rerender } = render(
-      <Provider store={localStore}>
-        <TemplateInvocation {...pollingProps} isExpanded />
-      </Provider>
+  it('ignores an in-flight response after unmount', async () => {
+    let resolveRequest;
+    API.get.mockImplementation(
+      () =>
+        new Promise(resolve => {
+          resolveRequest = resolve;
+        })
     );
-    expect(apiGetSpy).toHaveBeenCalledTimes(1);
 
-    rerender(
-      <Provider store={localStore}>
-        <TemplateInvocation {...pollingProps} isExpanded={false} />
+    const { unmount } = render(
+      <Provider store={makeStore()}>
+        <TemplateInvocation {...pollingProps} />
       </Provider>
     );
-    act(() => jest.advanceTimersByTime(5000));
-    expect(apiGetSpy).toHaveBeenCalledTimes(1);
+    expect(API.get).toHaveBeenCalledTimes(1);
 
-    rerender(
-      <Provider store={localStore}>
-        <TemplateInvocation {...pollingProps} isExpanded />
-      </Provider>
-    );
-    expect(apiGetSpy).toHaveBeenCalledTimes(2);
+    unmount();
+    await act(async () => {
+      resolveRequest({ data: { output: [], refresh: true } });
+    });
+    act(() => {
+      jest.advanceTimersByTime(OUTPUT_REFRESH_INTERVAL_MS);
+    });
+
+    expect(API.get).toHaveBeenCalledTimes(1);
   });
 });