foreman-tasks 12.2.3 → 13.0.0

data/webpack/ForemanTasks/Components/TaskDetails/TaskDetails.js

@@ -1,15 +1,17 @@
 import React, { useEffect, useState } from 'react';
 import PropTypes from 'prop-types';
 import { Tabs, Tab, TabTitleText } from '@patternfly/react-core';
-import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import { translate as __ } from 'foremanReact/common/I18n';
 import { STATUS } from 'foremanReact/constants';
-import MessageBox from 'foremanReact/components/common/MessageBox';
+import { usePermissions } from 'foremanReact/common/hooks/Permissions/permissionHooks';
+import { ResourceLoadFailedEmptyState } from 'foremanReact/components/common/EmptyState';
 import Task from './Components/Task';
 import RunningSteps from './Components/RunningSteps';
 import Errors from './Components/Errors';
 import Locks from './Components/Locks';
 import Raw from './Components/Raw';
 import Dependencies from './Components/Dependencies';
+import { TASKS_PATH, VIEW_FOREMAN_TASKS } from './TaskDetailsConstants';
 import { getTaskID } from './TasksDetailsHelper';
 import { TaskSkeleton } from './Components/TaskSkeleton';
 
@@ -26,12 +28,15 @@ const TaskDetails = ({
   cancelStep,
   taskReloadStart,
   taskReloadStop,
-  APIerror,
+  apiStatus,
+  apiErrorMessage,
+  apiErrorCode,
   ...props
 }) => {
   const id = getTaskID();
-  const { taskReload, status, isLoading, result } = props;
+  const { taskReload, isLoading, result } = props;
   const [activeTabKey, setActiveTabKey] = useState(1);
+  const hasViewPermission = usePermissions([VIEW_FOREMAN_TASKS]);
 
   useEffect(() => {
     taskReloadStart(id);
@@ -48,15 +53,25 @@ const TaskDetails = ({
     }
   };
 
-  if (status === STATUS.ERROR) {
+  if (apiStatus === STATUS.ERROR || !hasViewPermission) {
     return (
-      <MessageBox
-        key="task-details-error"
-        icontype="error-circle-o"
-        msg={sprintf(__('Could not receive data: %s'), APIerror?.message)}
+      <ResourceLoadFailedEmptyState
+        resourceLabel={__('task')}
+        resourceId={id}
+        httpStatus={apiErrorCode}
+        errorMessage={apiErrorMessage}
+        viewPermissions={['view_foreman_tasks']}
+        requiredPermissions={['view_foreman_tasks']}
+        ouiaIdPrefix="task-details-empty-state"
+        primaryAction={{
+          label: __('Back to tasks'),
+          url: TASKS_PATH,
+          ouiaId: 'task-details-empty-state-tasks-list',
+        }}
       />
     );
   }
+
   const resumable = executionPlan ? executionPlan.state === 'paused' : false;
   const cancellable = executionPlan ? executionPlan.cancellable : false;
   const lockRecords = locks.concat(links);
@@ -66,13 +81,12 @@ const TaskDetails = ({
     cancellable,
     resumable,
     id,
-    status,
     taskProgressToggle,
     taskReloadStart,
   };
 
   return (
-    <div className="task-details-react well">
+    <div className="task-details-react">
       <Tabs
         id="task-details-tabs"
         ouiaId="task-details-tabs"
@@ -159,8 +173,9 @@ TaskDetails.propTypes = {
   runningSteps: PropTypes.array,
   cancelStep: PropTypes.func.isRequired,
   taskReload: PropTypes.bool.isRequired,
-  status: PropTypes.oneOf(Object.keys(STATUS)),
-  APIerror: PropTypes.object,
+  apiStatus: PropTypes.oneOf(Object.keys(STATUS)),
+  apiErrorMessage: PropTypes.string,
+  apiErrorCode: PropTypes.number,
   taskReloadStop: PropTypes.func.isRequired,
   taskReloadStart: PropTypes.func.isRequired,
   links: PropTypes.array,
@@ -175,8 +190,7 @@ TaskDetails.propTypes = {
 TaskDetails.defaultProps = {
   label: '',
   runningSteps: [],
-  APIerror: null,
-  status: STATUS.PENDING,
+  apiErrorMessage: '',
   links: [],
   dependsOn: [],
   blocks: [],

data/webpack/ForemanTasks/Components/TaskDetails/TaskDetails.scss

@@ -1,10 +1,6 @@
 .task-details-react {
-  .progress-label-top-right {
-    font-size: 11px;
-    text-align: right;
-  }
   a,
-  button {
+  #pf-tab-section-1-task-details-tabs > button {
     margin-right: 3px;
   }
   .container {

data/webpack/ForemanTasks/Components/TaskDetails/TaskDetailsConstants.js

@@ -1,4 +1,5 @@
 export const FOREMAN_TASK_DETAILS = 'FOREMAN_TASK_DETAILS';
 export const FOREMAN_TASK_DETAILS_SUCCESS = 'FOREMAN_TASK_DETAILS_SUCCESS';
-
+export const TASKS_PATH = '/foreman_tasks/tasks';
 export const TASK_STEP_CANCEL = 'TASK_STEP_CANCEL';
+export const VIEW_FOREMAN_TASKS = 'view_foreman_tasks';

data/webpack/ForemanTasks/Components/TaskDetails/TaskDetailsSelectors.js

@@ -1,7 +1,8 @@
 /* eslint-disable camelcase */
 import {
   selectAPIResponse,
-  selectAPIByKey,
+  selectAPIStatus as selectAPIStatusByKey,
+  selectAPIError as selectAPIErrorByKey,
 } from 'foremanReact/redux/API/APISelectors';
 import { selectDoesIntervalExist } from 'foremanReact/redux/middlewares/IntervalMiddleware/IntervalSelectors';
 import { STATUS } from 'foremanReact/constants';
@@ -101,14 +102,28 @@ export const selectDynflowEnableConsole = state =>
 export const selectCanEdit = state =>
   selectTaskDetailsResponse(state).can_edit || false;
 
-export const selectStatus = state => selectTaskDetailsResponse(state).status;
+export const selectAPIStatus = state =>
+  selectAPIStatusByKey(state, FOREMAN_TASK_DETAILS);
 
 export const selectAPIError = state =>
-  selectTaskDetailsResponse(state)?.APIerror;
+  selectAPIErrorByKey(state, FOREMAN_TASK_DETAILS);
+
+export const selectAPIErrorMessage = state => {
+  const apiError = selectAPIError(state);
+
+  if (apiError?.response?.data?.error) {
+    return apiError.response.data.error.message;
+  }
+
+  return apiError?.message;
+};
+
+export const selectAPIErrorCode = state =>
+  selectAPIError(state)?.response?.status;
 
 export const selectIsLoading = state =>
-  !!selectAPIByKey(state, FOREMAN_TASK_DETAILS).response &&
-  selectStatus(state) === STATUS.PENDING;
+  !Object.keys(selectTaskDetailsResponse(state) ?? {}).length &&
+  selectAPIStatus(state) === STATUS.PENDING;
 
 export const selectDependsOn = state =>
   selectTaskDetailsResponse(state).depends_on || [];

data/webpack/ForemanTasks/Components/TaskDetails/__tests__/TaskDetails.fixtures.js

@@ -4,5 +4,5 @@ export const minProps = {
   taskReloadStop: jest.fn(),
   taskReloadStart: jest.fn(),
   taskProgressToggle: jest.fn(),
-  status: 'RESOLVED',
+  apiStatus: 'RESOLVED',
 };

data/webpack/ForemanTasks/Components/TaskDetails/__tests__/TaskDetails.test.js

@@ -1,38 +1,125 @@
 import React from 'react';
 import { render, screen } from '@testing-library/react';
 import '@testing-library/jest-dom';
+import { configureStore } from '@reduxjs/toolkit';
+import { Provider } from 'react-redux';
+import { createMemoryHistory } from 'history';
+import { Router } from 'react-router-dom';
 
 import TaskDetails from '../TaskDetails';
 import { minProps } from './TaskDetails.fixtures';
+import { VIEW_FOREMAN_TASKS } from '../TaskDetailsConstants';
+
+const mockUseForemanPermissions = jest.fn(
+  () => new Set(['view_foreman_tasks'])
+);
+
+jest.mock('foremanReact/Root/Context/ForemanContext', () => ({
+  ...jest.requireActual('foremanReact/Root/Context/ForemanContext'),
+  useForemanPermissions: (...args) => mockUseForemanPermissions(...args),
+}));
 
 delete window.location;
 window.location = new URL(
   'https://foreman.com/foreman_tasks/tasks/a15dd820-32f1-4ced-9ab7-c0fab8234c47/'
 );
 
+const store = configureStore({ reducer: state => state || {} });
+
+function renderTaskDetails(props = {}) {
+  const history = createMemoryHistory();
+
+  return render(
+    <Router history={history}>
+      <Provider store={store}>
+        <TaskDetails {...minProps} {...props} />
+      </Provider>
+    </Router>
+  );
+}
+
 describe('TaskDetails', () => {
-  it('shows error message when status is ERROR', () => {
-    render(
-      <TaskDetails
-        {...minProps}
-        status="ERROR"
-        APIerror={{ message: 'some-error' }}
-      />
+  beforeEach(() => {
+    mockUseForemanPermissions.mockImplementation(
+      () => new Set(['view_foreman_tasks'])
     );
+  });
+
+  it(`shows ResourceLoadFailedEmptyState when ${VIEW_FOREMAN_TASKS} is absent`, () => {
+    mockUseForemanPermissions.mockImplementation(() => new Set());
+
+    renderTaskDetails();
+
+    expect(
+      screen.getByRole('heading', { name: /permission denied/i })
+    ).toBeInTheDocument();
+    expect(screen.getByText(VIEW_FOREMAN_TASKS)).toBeInTheDocument();
+    expect(
+      screen.getByRole('button', { name: /back to tasks/i })
+    ).toBeInTheDocument();
+    expect(screen.queryByRole('tab', { name: /^task$/i })).not.toBeInTheDocument();
+  });
+
+  it('shows ResourceLoadFailedEmptyState when apiStatus is ERROR', () => {
+    renderTaskDetails({
+      apiStatus: 'ERROR',
+      apiErrorMessage: 'some-error',
+    });
+
+    expect(
+      screen.getByRole('heading', { name: /unable to load task/i })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText('Server returned: some-error')
+    ).toBeInTheDocument();
+    expect(screen.queryByRole('tab', { name: /^task$/i })).not.toBeInTheDocument();
+  });
+
+  it('shows permission denied when apiErrorCode is 403', () => {
+    renderTaskDetails({
+      apiStatus: 'ERROR',
+      apiErrorCode: 403,
+      apiErrorMessage: 'Forbidden',
+    });
+
+    expect(
+      screen.getByRole('heading', { name: /permission denied/i })
+    ).toBeInTheDocument();
+    expect(screen.getByText('view_foreman_tasks')).toBeInTheDocument();
+    expect(
+      screen.getByText('Server returned: Forbidden')
+    ).toBeInTheDocument();
+    expect(screen.queryByRole('tab', { name: /^task$/i })).not.toBeInTheDocument();
+  });
+
+  it('shows not found messaging when apiErrorCode is 404', () => {
+    renderTaskDetails({
+      apiStatus: 'ERROR',
+      apiErrorCode: 404,
+      apiErrorMessage: 'Task missing',
+    });
+
+    expect(
+      screen.getByRole('heading', { name: /unable to load task/i })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(/could not be found/i)
+    ).toBeInTheDocument();
     expect(
-      screen.getByText(/could not receive data: some-error/i)
+      screen.getByText('Server returned: Task missing')
     ).toBeInTheDocument();
+    expect(screen.queryByRole('tab', { name: /^task$/i })).not.toBeInTheDocument();
   });
 
   it('shows skeleton while loading on the Task tab', () => {
-    const { container } = render(<TaskDetails {...minProps} isLoading />);
+    const { container } = renderTaskDetails({ isLoading: true });
     expect(
       container.querySelector('.react-loading-skeleton')
     ).toBeInTheDocument();
   });
 
   it('renders six tabs with expected labels', () => {
-    render(<TaskDetails {...minProps} />);
+    renderTaskDetails();
     expect(document.getElementById('task-details-tabs')).toBeInTheDocument();
     expect(screen.getByRole('tab', { name: /^task$/i })).toBeInTheDocument();
     expect(

data/webpack/ForemanTasks/Components/TaskDetails/__tests__/TaskDetailsSelectors.test.js

@@ -0,0 +1,81 @@
+import { STATUS } from 'foremanReact/constants';
+
+import { FOREMAN_TASK_DETAILS } from '../TaskDetailsConstants';
+import {
+  selectAPIError,
+  selectAPIErrorCode,
+  selectAPIErrorMessage,
+} from '../TaskDetailsSelectors';
+
+const axiosErrorWithApiBody = {
+  message: 'Request failed with status code 404',
+  response: {
+    status: 404,
+    data: {
+      error: {
+        message: 'Task not found',
+      },
+    },
+  },
+};
+
+const plainError = {
+  message: 'Network Error',
+};
+
+const forbiddenError = {
+  message: 'Request failed with status code 403',
+  response: {
+    status: 403,
+    data: {
+      error: {
+        message: 'Forbidden',
+      },
+    },
+  },
+};
+
+const buildState = (response, status = STATUS.ERROR) => ({
+  API: {
+    [FOREMAN_TASK_DETAILS]: {
+      payload: {},
+      response,
+      status,
+    },
+  },
+});
+
+describe('TaskDetailsSelectors - API error selectors', () => {
+  it('selectAPIError returns null when API status is not ERROR', () => {
+    expect(selectAPIError(buildState({}, STATUS.RESOLVED))).toBeNull();
+  });
+
+  it('selectAPIError returns the stored response when API status is ERROR', () => {
+    expect(selectAPIError(buildState(plainError))).toEqual(plainError);
+  });
+
+  it('selectAPIErrorMessage prefers the API error body message', () => {
+    expect(
+      selectAPIErrorMessage(buildState(axiosErrorWithApiBody))
+    ).toBe('Task not found');
+  });
+
+  it('selectAPIErrorMessage falls back to the top-level error message', () => {
+    expect(selectAPIErrorMessage(buildState(plainError))).toBe('Network Error');
+  });
+
+  it('selectAPIErrorMessage returns undefined when there is no API error', () => {
+    expect(
+      selectAPIErrorMessage(buildState({}, STATUS.RESOLVED))
+    ).toBeUndefined();
+  });
+
+  it('selectAPIErrorCode returns the HTTP status from the error response', () => {
+    expect(selectAPIErrorCode(buildState(axiosErrorWithApiBody))).toBe(404);
+    expect(selectAPIErrorCode(buildState(forbiddenError))).toBe(403);
+  });
+
+  it('selectAPIErrorCode returns undefined when the error response has no status', () => {
+    expect(selectAPIErrorCode(buildState(plainError))).toBeUndefined();
+  });
+});

data/webpack/ForemanTasks/Components/TaskDetails/index.js

@@ -33,8 +33,9 @@ import {
   selectExternalId,
   selectDynflowEnableConsole,
   selectCanEdit,
-  selectStatus,
-  selectAPIError,
+  selectAPIStatus,
+  selectAPIErrorMessage,
+  selectAPIErrorCode,
   selectIsLoading,
   selectDependsOn,
   selectBlocks,
@@ -70,8 +71,9 @@ const mapStateToProps = state => ({
   externalId: selectExternalId(state),
   dynflowEnableConsole: selectDynflowEnableConsole(state),
   canEdit: selectCanEdit(state),
-  status: selectStatus(state),
-  APIerror: selectAPIError(state),
+  apiStatus: selectAPIStatus(state),
+  apiErrorMessage: selectAPIErrorMessage(state),
+  apiErrorCode: selectAPIErrorCode(state),
   isLoading: selectIsLoading(state),
   dependsOn: selectDependsOn(state),
   blocks: selectBlocks(state),

data/webpack/ForemanTasks/Components/TasksDashboard/__tests__/TasksDashboard.test.js

@@ -1,13 +1,100 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
 
+import { TASKS_DASHBOARD_AVAILABLE_TIMES } from '../TasksDashboardConstants';
+import { getQueryFromUrl } from '../TasksDashboardHelper';
 import TasksDashboard from '../TasksDashboard';
 
-const fixtures = {
-  'render without Props': { history: {} },
-  /** fixtures, props for the component */
-};
+jest.mock('../TasksDashboardHelper', () => ({
+  ...jest.requireActual('../TasksDashboardHelper'),
+  getQueryFromUrl: jest.fn(() => ({})),
+}));
+
+jest.mock(
+  '../Components/TasksCardsGrid/Components/TasksDonutChart/TasksDonutChart',
+  () => {
+    const React = require('react');
+    const Stub = () => <div data-testid="tasks-donut-chart-stub" />;
+    Stub.displayName = 'TasksDonutChart';
+
+    return Stub;
+  }
+);
 
 describe('TasksDashboard', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(TasksDashboard, fixtures));
+  const cardIds = [
+    'running-tasks-card',
+    'paused-tasks-card',
+    'stopped-tasks-card',
+    'scheduled-tasks-card',
+  ];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    getQueryFromUrl.mockReturnValue({});
+  });
+
+  it('renders the dashboard grid with time picker and task cards', () => {
+    const { container } = render(<TasksDashboard history={{}} />);
+
+    expect(container.querySelector('.tasks-dashboard-grid')).toBeInTheDocument();
+    expect(screen.getByText('With focus on last')).toBeInTheDocument();
+    expect(
+      screen.getByRole('button', { name: /24h/i })
+    ).toBeInTheDocument();
+
+    cardIds.forEach(id => {
+      expect(container.querySelector(`#${id}`)).toBeInTheDocument();
+    });
+  });
+
+  it('initializes the dashboard and fetches the summary on mount', () => {
+    const initializeDashboard = jest.fn();
+    const fetchTasksSummary = jest.fn();
+
+    render(
+      <TasksDashboard
+        history={{}}
+        initializeDashboard={initializeDashboard}
+        fetchTasksSummary={fetchTasksSummary}
+      />
+    );
+
+    expect(initializeDashboard).toHaveBeenCalledWith({
+      time: undefined,
+      query: {},
+    });
+    expect(fetchTasksSummary).toHaveBeenCalledWith(
+      TASKS_DASHBOARD_AVAILABLE_TIMES.H24,
+      ''
+    );
+  });
+
+  it('fetches the summary again when time changes', () => {
+    const fetchTasksSummary = jest.fn();
+
+    const { rerender } = render(
+      <TasksDashboard
+        history={{}}
+        fetchTasksSummary={fetchTasksSummary}
+        time={TASKS_DASHBOARD_AVAILABLE_TIMES.H24}
+      />
+    );
+
+    fetchTasksSummary.mockClear();
+
+    rerender(
+      <TasksDashboard
+        history={{}}
+        fetchTasksSummary={fetchTasksSummary}
+        time={TASKS_DASHBOARD_AVAILABLE_TIMES.H12}
+      />
+    );
+
+    expect(fetchTasksSummary).toHaveBeenCalledWith(
+      TASKS_DASHBOARD_AVAILABLE_TIMES.H12,
+      ''
+    );
+  });
 });

data/webpack/ForemanTasks/Components/TasksDashboard/__tests__/TasksDashboardActions.test.js

@@ -1,6 +1,13 @@
-import { testActionSnapshotWithFixtures } from '@theforeman/test';
 import { API } from 'foremanReact/redux/API';
-import { timeToHoursNumber } from '../TasksDashboardHelper';
+import {
+  FOREMAN_TASKS_DASHBOARD_INIT,
+  FOREMAN_TASKS_DASHBOARD_UPDATE_TIME,
+  FOREMAN_TASKS_DASHBOARD_UPDATE_QUERY,
+  FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_REQUEST,
+  FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_SUCCESS,
+  FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_FAILURE,
+} from '../TasksDashboardConstants';
+import { timeToHoursNumber, resolveQuery } from '../TasksDashboardHelper';
 import {
   initializeDashboard,
   updateTime,
@@ -12,25 +19,99 @@ import {
   wrongTime,
   parentTaskID,
   apiGetMock,
+  taskSummary,
+  subtaskSummary,
 } from './TaskDashboard.fixtures';
 
 jest.mock('foremanReact/redux/API');
 jest.mock('../TasksDashboardHelper');
 
 timeToHoursNumber.mockImplementation(arg => arg);
+resolveQuery.mockImplementation(() => {});
 API.get.mockImplementation(apiGetMock);
 
-const fixtures = {
-  'should initialize-dashboard': () =>
-    initializeDashboard({ time: 'some-time', query: 'some-query' }),
-  'should update-time': () => updateTime('some-time'),
-  'should update-query': () => updateQuery('some-query'),
-  'should fetch-tasks-summary and success': () =>
-    fetchTasksSummary(correctTime),
-  'should fetch-tasks-summary for subtasks and success': () =>
-    fetchTasksSummary(correctTime, parentTaskID),
-  'should fetch-tasks-summary and fail': () => fetchTasksSummary(wrongTime),
-};
-
-describe('TasksDashboard - Actions', () =>
-  testActionSnapshotWithFixtures(fixtures));
+describe('TasksDashboard - Actions', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    timeToHoursNumber.mockImplementation(arg => arg);
+    resolveQuery.mockImplementation(() => {});
+    API.get.mockImplementation(apiGetMock);
+  });
+
+  it('should initialize-dashboard', () => {
+    expect(
+      initializeDashboard({ time: 'some-time', query: 'some-query' })
+    ).toEqual({
+      type: FOREMAN_TASKS_DASHBOARD_INIT,
+      payload: { time: 'some-time', query: 'some-query' },
+    });
+  });
+
+  it('should update-time', () => {
+    expect(updateTime('some-time')).toEqual({
+      type: FOREMAN_TASKS_DASHBOARD_UPDATE_TIME,
+      payload: 'some-time',
+    });
+  });
+
+  it('should update-query', () => {
+    const dispatch = jest.fn();
+    const getState = jest.fn();
+    const history = { push: jest.fn(), replace: jest.fn() };
+    const query = { state: 'running' };
+
+    updateQuery(query, history)(dispatch, getState);
+
+    expect(resolveQuery).toHaveBeenCalledWith(query, history);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FOREMAN_TASKS_DASHBOARD_UPDATE_QUERY,
+      payload: query,
+    });
+  });
+
+  it('should fetch-tasks-summary and success', async () => {
+    const dispatch = jest.fn();
+
+    await fetchTasksSummary(correctTime)(dispatch);
+
+    expect(dispatch).toHaveBeenCalledTimes(2);
+    expect(dispatch.mock.calls[0][0]).toEqual({
+      type: FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_REQUEST,
+    });
+    expect(dispatch.mock.calls[1][0]).toEqual({
+      type: FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_SUCCESS,
+      payload: taskSummary,
+    });
+  });
+
+  it('should fetch-tasks-summary for subtasks and success', async () => {
+    const dispatch = jest.fn();
+
+    await fetchTasksSummary(correctTime, parentTaskID)(dispatch);
+
+    expect(dispatch).toHaveBeenCalledTimes(2);
+    expect(dispatch.mock.calls[0][0]).toEqual({
+      type: FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_REQUEST,
+    });
+    expect(dispatch.mock.calls[1][0]).toEqual({
+      type: FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_SUCCESS,
+      payload: subtaskSummary,
+    });
+  });
+
+  it('should fetch-tasks-summary and fail', async () => {
+    const dispatch = jest.fn();
+
+    await fetchTasksSummary(wrongTime)(dispatch);
+
+    expect(dispatch).toHaveBeenCalledTimes(2);
+    expect(dispatch.mock.calls[0][0]).toEqual({
+      type: FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_REQUEST,
+    });
+    expect(dispatch.mock.calls[1][0].type).toBe(
+      FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_FAILURE
+    );
+    expect(dispatch.mock.calls[1][0].payload).toEqual(expect.any(Error));
+    expect(dispatch.mock.calls[1][0].payload.message).toBe('wrong time');
+  });
+});