foreman_remote_execution 16.6.5 → 17.0.0

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

@@ -1,17 +1,20 @@
+/* eslint-disable max-lines */
 import React from 'react';
-import configureMockStore from 'redux-mock-store';
-import { fireEvent, render, screen, act } from '@testing-library/react';
-import '@testing-library/jest-dom/extend-expect';
-import { Provider } from 'react-redux';
-import thunk from 'redux-thunk';
+import { fireEvent, screen, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { createMemoryHistory } from 'history';
+import { Router } from 'react-router-dom';
+import { rtlHelpers } from 'foremanReact/common/testHelpers';
+import { STATUS } from 'foremanReact/constants';
 import { foremanUrl } from 'foremanReact/common/helpers';
+import { usePermissions } from 'foremanReact/common/hooks/Permissions/permissionHooks';
 import * as api from 'foremanReact/redux/API';
+import { APIActions } from 'foremanReact/redux/API';
 import JobInvocationDetailPage from '../index';
 import {
   jobInvocationData,
   jobInvocationDataScheduled,
   jobInvocationDataRecurring,
-  mockPermissionsData,
   mockReportTemplatesResponse,
   mockReportTemplateInputsResponse,
 } from './fixtures';
@@ -20,6 +23,7 @@ import {
   enableRecurringLogic,
   cancelRecurringLogic,
 } from '../JobInvocationActions';
+import { createForemanContextWrapper } from './foremanTestHelpers';
 import {
   CANCEL_JOB,
   CANCEL_RECURRING_LOGIC,
@@ -29,14 +33,38 @@ import {
   JOB_INVOCATION_KEY,
 } from '../JobInvocationConstants';
 
+const { renderWithStore } = rtlHelpers;
+
+jest.mock('foremanReact/redux/API/APISelectors', () =>
+  jest.requireActual('foremanReact/redux/API/APISelectors')
+);
+
+jest.mock('foremanReact/common/hooks/Permissions/permissionHooks');
+jest.mock('../JobInvocationActions', () => {
+  const actual = jest.requireActual('../JobInvocationActions');
+
+  return {
+    ...actual,
+    getJobInvocation: jest.fn(() => () => undefined),
+    stopJobInvocationPolling: jest.fn(),
+  };
+});
+
 jest.spyOn(api, 'get');
+jest.spyOn(APIActions, 'post');
+jest.spyOn(APIActions, 'put');
+
+usePermissions.mockReturnValue(true);
 
 // Mock toLocaleString to always use UTC timezone for consistent test results
 const originalToLocaleString = Date.prototype.toLocaleString;
 beforeAll(() => {
   // eslint-disable-next-line no-extend-native
-  Date.prototype.toLocaleString = function (locale, options) {
-    return originalToLocaleString.call(this, locale, { ...options, timeZone: 'UTC' });
+  Date.prototype.toLocaleString = function toLocaleStringUTC(locale, options) {
+    return originalToLocaleString.call(this, locale, {
+      ...options,
+      timeZone: 'UTC',
+    });
   };
 });
 afterAll(() => {
@@ -44,12 +72,6 @@ afterAll(() => {
   Date.prototype.toLocaleString = originalToLocaleString;
 });
 
-jest.mock('foremanReact/common/hooks/API/APIHooks', () => ({
-  useAPI: jest.fn(() => ({
-    response: mockPermissionsData,
-  })),
-}));
-
 jest.mock('foremanReact/routes/common/PageLayout/PageLayout', () =>
   jest.fn(props => (
     <div>
@@ -60,36 +82,50 @@ jest.mock('foremanReact/routes/common/PageLayout/PageLayout', () =>
   ))
 );
 
-const initialState = {
-  JOB_INVOCATION_KEY: {
-    response: jobInvocationData,
-  },
-  GET_REPORT_TEMPLATES: mockReportTemplatesResponse,
-  extendable: {},
-};
+const setupApiMocks = () => {
+  api.get.mockImplementation(({ handleSuccess, key, ...action }) => {
+    if (key === GET_REPORT_TEMPLATES) {
+      if (handleSuccess) {
+        handleSuccess({
+          data: mockReportTemplatesResponse,
+        });
+      }
+    } else if (key === GET_REPORT_TEMPLATE_INPUTS) {
+      if (handleSuccess) {
+        handleSuccess({
+          data: mockReportTemplateInputsResponse,
+        });
+      }
+    }
 
-const initialStateScheduled = {
-  JOB_INVOCATION_KEY: {
-    response: jobInvocationDataScheduled,
-  },
-  extendable: {},
+    return { type: 'get', key, ...action };
+  });
+  APIActions.post.mockImplementation(payload => ({ type: 'post', ...payload }));
+  APIActions.put.mockImplementation(payload => ({ type: 'put', ...payload }));
 };
 
-api.get.mockImplementation(({ handleSuccess, ...action }) => {
-  if (action.key === 'GET_REPORT_TEMPLATES') {
-    handleSuccess &&
-      handleSuccess({
-        data: mockReportTemplatesResponse,
-      });
-  } else if (action.key === 'GET_REPORT_TEMPLATE_INPUTS') {
-    handleSuccess &&
-      handleSuccess({
-        data: mockReportTemplateInputsResponse,
-      });
-  }
+const createJobInvocationDetailState = ({
+  jobInvocation = jobInvocationData,
+  jobInvocationStatus = STATUS.RESOLVED,
+  jobInvocationError = null,
+} = {}) => {
+  const jobInvocationResponse =
+    jobInvocationError || JSON.parse(JSON.stringify(jobInvocation));
 
-  return { type: 'get', ...action };
-});
+  return {
+    API: {
+      [JOB_INVOCATION_KEY]: jobInvocationError
+        ? {
+            response: jobInvocationResponse,
+            status: STATUS.ERROR,
+          }
+        : {
+            response: jobInvocationResponse,
+            status: jobInvocationStatus,
+          },
+    },
+  };
+};
 
 jest.mock('../JobInvocationHostTable.js', () => () => (
   <div data-testid="mock-table">Mock Table</div>
@@ -97,21 +133,62 @@ jest.mock('../JobInvocationHostTable.js', () => () => (
 
 const reportTemplateJobId = mockReportTemplatesResponse.results[0].id;
 
-const mockStore = configureMockStore([thunk]);
-const props = { history: { push: jest.fn() } };
+const defaultHistory = { push: jest.fn() };
+
+const renderJobInvocationDetailPage = (
+  initialState,
+  { jobId, history = defaultHistory } = {}
+) => {
+  const id =
+    jobId ?? initialState.API?.[JOB_INVOCATION_KEY]?.response?.id ?? '1';
+
+  return renderWithStore(
+    <JobInvocationDetailPage
+      match={{ params: { id: `${id}` } }}
+      history={history}
+    />,
+    initialState,
+    undefined
+  );
+};
 
 describe('JobInvocationDetailPage', () => {
+  beforeEach(() => {
+    setupApiMocks();
+    usePermissions.mockReturnValue(true);
+
+    const { getJobInvocation } = jest.requireMock('../JobInvocationActions');
+    getJobInvocation.mockImplementation(() => () => undefined);
+  });
+
+  afterEach(() => {
+    api.get.mockClear();
+    APIActions.post.mockClear();
+    APIActions.put.mockClear();
+  });
+
+  it('shows scheduled date', async () => {
+    const scheduledJobInvocation = JSON.parse(
+      JSON.stringify(jobInvocationDataScheduled)
+    );
+
+    renderJobInvocationDetailPage(
+      createJobInvocationDetailState({
+        jobInvocation: scheduledJobInvocation,
+      }),
+      { jobId: jobInvocationDataScheduled.id }
+    );
+
+    expect(screen.getByText('Scheduled at:')).toBeInTheDocument();
+    expect(screen.getByText('Jan 1, 3000, 11:34 UTC')).toBeInTheDocument();
+    expect(screen.getByText('Not yet')).toBeInTheDocument();
+  });
+
   it('renders main information', async () => {
     const jobId = jobInvocationData.id;
-    const store = mockStore(initialState);
-
-    const { container } = render(
-      <Provider store={store}>
-        <JobInvocationDetailPage
-          match={{ params: { id: `${jobId}` } }}
-          {...props}
-        />
-      </Provider>
+
+    const { container } = renderJobInvocationDetailPage(
+      createJobInvocationDetailState()
     );
 
     expect(screen.getByText('Description')).toBeInTheDocument();
@@ -198,87 +275,159 @@ describe('JobInvocationDetailPage', () => {
     ).toEqual(`/legacy/job_invocations/${jobId}`);
   });
 
-  it('shows scheduled date', async () => {
-    const store = mockStore(initialStateScheduled);
-    render(
-      <Provider store={store}>
-        <JobInvocationDetailPage
-          match={{ params: { id: `${jobInvocationDataScheduled.id}` } }}
-          {...props}
-        />
-      </Provider>
+  it('keeps toolbar buttons mounted while job invocation data is refreshing', async () => {
+    renderJobInvocationDetailPage(
+      createJobInvocationDetailState({
+        jobInvocationStatus: STATUS.PENDING,
+      })
     );
 
-    expect(screen.getByText('Scheduled at:')).toBeInTheDocument();
-    expect(screen.getByText('Jan 1, 3000, 11:34 UTC')).toBeInTheDocument();
-    expect(screen.getByText('Not yet')).toBeInTheDocument();
+    expect(screen.getByText('Create report')).toBeInTheDocument();
+    expect(screen.getByText('Rerun all')).toBeInTheDocument();
+  });
+
+  it('disables Create report when the job task state is running', async () => {
+    usePermissions.mockImplementation(requiredPermissions =>
+      requiredPermissions.includes('generate_report_templates')
+    );
+
+    renderJobInvocationDetailPage(
+      createJobInvocationDetailState({
+        jobInvocation: {
+          ...jobInvocationData,
+          task: { ...jobInvocationData.task, state: 'running' },
+        },
+      })
+    );
+
+    const createReportButton = screen.getByRole('link', {
+      name: 'Create report',
+    });
+
+    expect(createReportButton).toHaveAttribute('aria-disabled', 'true');
+    expect(createReportButton).toHaveClass('pf-m-disabled');
   });
 
   it('should dispatch global actions', async () => {
-    // recurring in the future
     const jobId = jobInvocationDataRecurring.id;
     const recurrenceId = jobInvocationDataRecurring.recurrence.id;
-    const store = mockStore(jobInvocationDataRecurring);
-    render(
-      <Provider store={store}>
-        <JobInvocationDetailPage
-          match={{ params: { id: `${jobId}` } }}
-          {...props}
-        />
-      </Provider>
+
+    const { store } = renderJobInvocationDetailPage(
+      createJobInvocationDetailState({
+        jobInvocation: jobInvocationDataRecurring,
+      }),
+      { jobId }
     );
 
-    const expectedActions = [
-      { key: GET_REPORT_TEMPLATES, url: '/api/report_templates' },
-      {
-        key: JOB_INVOCATION_KEY,
-        url: `/api/job_invocations/${jobId}?host_status=true`,
-      },
-      {
+    expect(api.get).toHaveBeenCalledWith(
+      expect.objectContaining({
+        key: GET_REPORT_TEMPLATES,
+        url: '/api/report_templates',
+      })
+    );
+    expect(api.get).toHaveBeenCalledWith(
+      expect.objectContaining({
         key: GET_REPORT_TEMPLATE_INPUTS,
         url: `/api/templates/${reportTemplateJobId}/template_inputs`,
-      },
-      {
+      })
+    );
+
+    api.get.mockClear();
+    APIActions.post.mockClear();
+    APIActions.put.mockClear();
+
+    store.dispatch(cancelJob(jobId, false));
+    store.dispatch(cancelJob(jobId, true));
+    store.dispatch(enableRecurringLogic(recurrenceId, true));
+    store.dispatch(enableRecurringLogic(recurrenceId, false));
+    store.dispatch(cancelRecurringLogic(recurrenceId));
+
+    expect(APIActions.post).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
         key: CANCEL_JOB,
         url: `/job_invocations/${jobId}/cancel`,
-      },
-      {
+      })
+    );
+    expect(APIActions.post).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
         key: CANCEL_JOB,
         url: `/job_invocations/${jobId}/cancel?force=true`,
-      },
-      {
+      })
+    );
+    expect(APIActions.put).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
         key: CHANGE_ENABLED_RECURRING_LOGIC,
         url: `/foreman_tasks/api/recurring_logics/${recurrenceId}`,
-      },
-      {
+      })
+    );
+    expect(APIActions.put).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
         key: CHANGE_ENABLED_RECURRING_LOGIC,
         url: `/foreman_tasks/api/recurring_logics/${recurrenceId}`,
-      },
-      {
+      })
+    );
+    expect(APIActions.post).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
         key: CANCEL_RECURRING_LOGIC,
         url: `/foreman_tasks/recurring_logics/${recurrenceId}/cancel`,
-      },
-    ];
+      })
+    );
+  });
 
-    store.dispatch(cancelJob(jobId, false));
-    store.dispatch(cancelJob(jobId, true));
-    store.dispatch(enableRecurringLogic(recurrenceId, true, jobId));
-    store.dispatch(enableRecurringLogic(recurrenceId, false, jobId));
-    store.dispatch(cancelRecurringLogic(recurrenceId, jobId));
-
-    const actualActions = store.getActions();
-    expect(actualActions).toHaveLength(expectedActions.length);
-
-    expectedActions.forEach((expectedAction, index) => {
-      if (actualActions[index].type === 'WITH_INTERVAL') {
-        expect(actualActions[index].key.key).toEqual(expectedAction.key);
-        expect(actualActions[index].key.url).toEqual(expectedAction.url);
-      } else {
-        expect(actualActions[index].key).toEqual(expectedAction.key);
-        if (expectedAction.url) {
-          expect(actualActions[index].url).toEqual(expectedAction.url);
-        }
-      }
-    });
+  it('renders empty state when the job invocation fails to load', () => {
+    const jobId = '99';
+    const errorMessage = 'Record not found';
+    const history = createMemoryHistory();
+    const ForemanContextWrapper = createForemanContextWrapper();
+
+    renderWithStore(
+      <Router history={history}>
+        <ForemanContextWrapper>
+          <JobInvocationDetailPage
+            match={{ params: { id: jobId } }}
+            history={history}
+          />
+        </ForemanContextWrapper>
+      </Router>,
+      createJobInvocationDetailState({
+        jobInvocationError: {
+          message: errorMessage,
+          response: { status: 404 },
+        },
+      }),
+      undefined
+    );
+
+    expect(
+      screen.getByRole('heading', {
+        name: 'Unable to load job invocation',
+        level: 5,
+      })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        (_, element) =>
+          element?.tagName === 'P' &&
+          element.textContent?.includes(
+            `The job invocation with id ${jobId} could not be found. It may have been deleted or may not be available in your current organization or location scope.`
+          )
+      )
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(`Server returned: ${errorMessage}`)
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('button', { name: 'Go to job invocations' })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('button', { name: 'Create a new job invocation' })
+    ).toBeInTheDocument();
+    expect(screen.queryByText('Description')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('mock-table')).not.toBeInTheDocument();
   });
 });

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

@@ -2,6 +2,7 @@ import '@testing-library/jest-dom/extend-expect';
 import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import axios from 'axios';
 import { foremanUrl } from 'foremanReact/common/helpers';
+import { usePermissions } from 'foremanReact/common/hooks/Permissions/permissionHooks';
 import { useAPI } from 'foremanReact/common/hooks/API/APIHooks';
 import React from 'react';
 import { Provider } from 'react-redux';
@@ -13,6 +14,7 @@ import { PopupAlert } from '../OpenAllInvocationsModal';
 
 jest.mock('axios');
 jest.mock('foremanReact/common/hooks/API/APIHooks');
+jest.mock('foremanReact/common/hooks/Permissions/permissionHooks');
 jest.mock('../JobInvocationSelectors');
 
 jest.mock('../JobInvocationConstants', () => ({
@@ -26,8 +28,8 @@ jest.mock('../JobInvocationConstants', () => ({
 selectors.selectItems.mockImplementation(() => ({
   targeting: { search_query: 'name~*' },
 }));
-selectors.selectHasPermission.mockImplementation(() => () => true);
 selectors.selectTaskCancelable.mockImplementation(() => true);
+usePermissions.mockReturnValue(true);
 
 const mockStore = configureStore([]);
 const store = mockStore({});