foreman-tasks 12.2.3 → 12.2.4

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { render, screen } from '@testing-library/react';
+import { render, screen, fireEvent } from '@testing-library/react';
 import '@testing-library/jest-dom';
 
 import Errors from '../Errors';
@@ -20,6 +20,8 @@ const failedStepFixture = {
   output: '{}\n',
 };
 
+const executionPlan = { state: 'paused', cancellable: false };
+
 describe('Errors', () => {
   it('renders warning when execution plan is missing', () => {
     render(<Errors failedSteps={[]} executionPlan={null} />);
@@ -30,30 +32,176 @@ describe('Errors', () => {
 
   it('renders success state when there are no failed steps', () => {
     render(<Errors failedSteps={[]} executionPlan={{ state: 'paused' }} />);
-    const noErrors = screen.getAllByText(/^no errors$/i);
-    expect(noErrors.length).toBeGreaterThanOrEqual(1);
+    expect(
+      screen.getByRole('heading', { level: 2, name: /no errors found/i })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(/the task finished with no errors or warnings/i)
+    ).toBeInTheDocument();
   });
 
   it('renders failed step details when failedSteps is non-empty', () => {
     const { container } = render(
       <Errors
-        executionPlan={{ state: 'paused', cancellable: false }}
+        executionPlan={executionPlan}
         failedSteps={[failedStepFixture]}
       />
     );
-    const stepAlert = container.querySelector(
+    const errorTab = container.querySelector(
       '[data-ouia-component-id="task-error-0"]'
     );
-    expect(stepAlert).toBeInTheDocument();
-    expect(stepAlert).toHaveClass('pf-m-inline');
+    expect(errorTab).toBeInTheDocument();
+    expect(
+      screen.getByRole('tab', {
+        name: /action actions::katello::eventqueue::monitor is already active/i,
+      })
+    ).toBeInTheDocument();
     expect(
-      screen.getByText('Actions::Katello::EventQueue::Monitor')
+      screen.getByLabelText(/failed task errors/i)
     ).toBeInTheDocument();
+    expect(screen.getByText('Input')).toBeInTheDocument();
+    expect(screen.getByText('Output')).toBeInTheDocument();
+    expect(screen.getByText('Exception:')).toBeInTheDocument();
+    expect(screen.getByText('Backtrace')).toBeInTheDocument();
     expect(screen.getByText(/runtimeerror/i)).toBeInTheDocument();
+    expect(screen.getByText(/singleton_lock/i)).toBeInTheDocument();
+  });
+
+  it('switches detail pane when a different error tab is clicked', () => {
+    const firstStep = {
+      ...failedStepFixture,
+      action_class: 'Action::First',
+      input: 'INPUT_FROM_FIRST_STEP',
+      output: '{}',
+    };
+    const secondStep = {
+      ...failedStepFixture,
+      action_class: 'Action::Second',
+      error: {
+        exception_class: 'StandardError',
+        message: 'second step failure',
+        backtrace: [],
+      },
+      input: 'INPUT_FROM_SECOND_STEP',
+      output: 'OUTPUT_SECOND',
+      state: 'error',
+    };
+
+    render(
+      <Errors
+        executionPlan={executionPlan}
+        failedSteps={[firstStep, secondStep]}
+      />
+    );
+
+    expect(screen.getByText('INPUT_FROM_FIRST_STEP')).toBeInTheDocument();
+    expect(screen.queryByText('INPUT_FROM_SECOND_STEP')).not.toBeInTheDocument();
+
+    const tabs = screen.getAllByRole('tab');
+    expect(tabs[0]).toHaveAttribute('aria-selected', 'true');
+    expect(tabs[1]).toHaveAttribute('aria-selected', 'false');
+
+    fireEvent.click(tabs[1]);
+
+    expect(screen.getByText('INPUT_FROM_SECOND_STEP')).toBeInTheDocument();
+    expect(screen.queryByText('INPUT_FROM_FIRST_STEP')).not.toBeInTheDocument();
+    expect(tabs[0]).toHaveAttribute('aria-selected', 'false');
+    expect(tabs[1]).toHaveAttribute('aria-selected', 'true');
+    expect(screen.getByText('OUTPUT_SECOND')).toBeInTheDocument();
+  });
+
+  it('clamps selection when failedSteps shrinks', () => {
+    const firstStep = {
+      ...failedStepFixture,
+      action_class: 'Action::First',
+      input: 'AFTER_CLAMP',
+      output: '{}',
+    };
+    const secondStep = {
+      ...failedStepFixture,
+      action_class: 'Action::Second',
+      input: 'REMOVED',
+      output: '{}',
+      state: 'error',
+    };
+
+    const { rerender } = render(
+      <Errors
+        executionPlan={executionPlan}
+        failedSteps={[firstStep, secondStep]}
+      />
+    );
+
+    fireEvent.click(screen.getAllByRole('tab')[1]);
+    expect(screen.getByText('REMOVED')).toBeInTheDocument();
+
+    rerender(
+      <Errors executionPlan={executionPlan} failedSteps={[firstStep]} />
+    );
+
+    expect(screen.getAllByRole('tab')).toHaveLength(1);
+    expect(screen.getByText('AFTER_CLAMP')).toBeInTheDocument();
+  });
+
+  it('truncates long tab titles to 120 characters with ellipsis', () => {
+    const longMessage = 'x'.repeat(150);
+    const longStep = {
+      ...failedStepFixture,
+      error: {
+        ...failedStepFixture.error,
+        message: longMessage,
+      },
+    };
+
+    const { container } = render(
+      <Errors executionPlan={executionPlan} failedSteps={[longStep]} />
+    );
+
+    const tabTitle = container.querySelector('.task-errors-tab-title');
+    expect(tabTitle.textContent).toHaveLength(120);
+    expect(tabTitle.textContent.endsWith('...')).toBe(true);
+    expect(
+      screen.getByRole('tab', { name: longMessage })
+    ).toBeInTheDocument();
+  });
+
+  it('uses warning styling for skipped steps', () => {
+    const skippedStep = {
+      action_class: 'Actions::Example',
+      state: 'skipped',
+      input: '{}',
+      output: '{}',
+    };
+
+    const { container } = render(
+      <Errors executionPlan={executionPlan} failedSteps={[skippedStep]} />
+    );
+
     expect(
-      screen.getByText(
-        /action actions::katello::eventqueue::monitor is already active/i
-      )
+      screen.getByRole('tab', { name: /actions::example/i })
     ).toBeInTheDocument();
+
+    const errorTab = container.querySelector(
+      '[data-ouia-component-id="task-error-0"]'
+    );
+    expect(errorTab.querySelector('.pf-m-warning')).toBeInTheDocument();
+  });
+
+  it('omits exception and backtrace when step has no error object', () => {
+    const stepWithoutError = {
+      action_class: 'Actions::NoError',
+      state: 'error',
+      input: 'plain-input',
+      output: 'plain-output',
+    };
+
+    render(
+      <Errors executionPlan={executionPlan} failedSteps={[stepWithoutError]} />
+    );
+
+    expect(screen.getByText('plain-input')).toBeInTheDocument();
+    expect(screen.getByText('plain-output')).toBeInTheDocument();
+    expect(screen.queryByText('Exception:')).not.toBeInTheDocument();
+    expect(screen.queryByText('Backtrace')).not.toBeInTheDocument();
   });
 });

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');
+  });
+});

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

@@ -1,5 +1,3 @@
-import { testReducerSnapshotWithFixtures } from '@theforeman/test';
-
 import {
   FOREMAN_TASKS_DASHBOARD_INIT,
   FOREMAN_TASKS_DASHBOARD_UPDATE_TIME,
@@ -7,52 +5,120 @@ import {
   FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_REQUEST,
   FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_SUCCESS,
   FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_FAILURE,
+  TASKS_DASHBOARD_AVAILABLE_QUERY_STATES,
+  TASKS_DASHBOARD_AVAILABLE_TIMES,
+  TASKS_SUMMARY_ZERO,
 } from '../TasksDashboardConstants';
 import reducer from '../TasksDashboardReducer';
 
-const fixtures = {
-  'should return the initial state': {},
-  'should handle FOREMAN_TASKS_DASHBOARD_INIT': {
-    action: {
-      type: FOREMAN_TASKS_DASHBOARD_INIT,
-    },
-  },
-  'should handle FOREMAN_TASKS_DASHBOARD_INIT with data': {
-    action: {
-      type: FOREMAN_TASKS_DASHBOARD_INIT,
-      payload: { time: 'some-time', query: 'some-query' },
-    },
-  },
-  'should handle FOREMAN_TASKS_DASHBOARD_UPDATE_TIME': {
-    action: {
-      type: FOREMAN_TASKS_DASHBOARD_UPDATE_TIME,
-      payload: 'some-time',
-    },
-  },
-  'should handle FOREMAN_TASKS_DASHBOARD_UPDATE_QUERY': {
-    action: {
-      type: FOREMAN_TASKS_DASHBOARD_UPDATE_QUERY,
-      payload: 'some-query',
-    },
-  },
-  'should handle FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_REQUEST': {
-    action: {
-      type: FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_REQUEST,
-    },
-  },
-  'should handle FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_SUCCESS': {
-    action: {
-      type: FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_SUCCESS,
-      payload: 'some-payload',
-    },
-  },
-  'should handle FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_FAILURE': {
-    action: {
-      type: FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_FAILURE,
-      payload: new Error('some error'),
-    },
-  },
+const dashboardQuery = {
+  state: TASKS_DASHBOARD_AVAILABLE_QUERY_STATES.RUNNING,
+};
+
+const initialState = {
+  time: TASKS_DASHBOARD_AVAILABLE_TIMES.H24,
+  isLoadingTasksSummary: false,
+  error: null,
+  tasksSummary: TASKS_SUMMARY_ZERO,
 };
 
-describe('BreadcrumbBar reducer', () =>
-  testReducerSnapshotWithFixtures(reducer, fixtures));
+const runReducer = (state, action) =>
+  reducer(state, action).asMutable({ deep: true });
+
+describe('TasksDashboard reducer', () => {
+  it('should return the initial state', () => {
+    expect(runReducer(undefined, {})).toEqual(initialState);
+  });
+
+  it('should handle FOREMAN_TASKS_DASHBOARD_INIT', () => {
+    expect(
+      runReducer(undefined, {
+        type: FOREMAN_TASKS_DASHBOARD_INIT,
+      })
+    ).toEqual({
+      ...initialState,
+      query: undefined,
+    });
+  });
+
+  it('should handle FOREMAN_TASKS_DASHBOARD_INIT with data', () => {
+    expect(
+      runReducer(undefined, {
+        type: FOREMAN_TASKS_DASHBOARD_INIT,
+        payload: {
+          time: TASKS_DASHBOARD_AVAILABLE_TIMES.WEEK,
+          query: dashboardQuery,
+        },
+      })
+    ).toEqual({
+      ...initialState,
+      time: TASKS_DASHBOARD_AVAILABLE_TIMES.WEEK,
+      query: dashboardQuery,
+    });
+  });
+
+  it('should handle FOREMAN_TASKS_DASHBOARD_UPDATE_TIME', () => {
+    expect(
+      runReducer(undefined, {
+        type: FOREMAN_TASKS_DASHBOARD_UPDATE_TIME,
+        payload: TASKS_DASHBOARD_AVAILABLE_TIMES.WEEK,
+      })
+    ).toEqual({
+      ...initialState,
+      time: TASKS_DASHBOARD_AVAILABLE_TIMES.WEEK,
+    });
+  });
+
+  it('should handle FOREMAN_TASKS_DASHBOARD_UPDATE_QUERY', () => {
+    expect(
+      runReducer(undefined, {
+        type: FOREMAN_TASKS_DASHBOARD_UPDATE_QUERY,
+        payload: dashboardQuery,
+      })
+    ).toEqual({
+      ...initialState,
+      query: dashboardQuery,
+    });
+  });
+
+  it('should handle FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_REQUEST', () => {
+    expect(
+      runReducer(undefined, {
+        type: FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_REQUEST,
+      })
+    ).toEqual({
+      ...initialState,
+      isLoading: true,
+    });
+  });
+
+  it('should handle FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_SUCCESS', () => {
+    expect(
+      runReducer(undefined, {
+        type: FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_SUCCESS,
+        payload: 'some-payload',
+      })
+    ).toEqual({
+      ...initialState,
+      tasksSummary: 'some-payload',
+      isLoading: false,
+      error: null,
+    });
+  });
+
+  it('should handle FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_FAILURE', () => {
+    const error = new Error('some error');
+
+    expect(
+      runReducer(undefined, {
+        type: FOREMAN_TASKS_DASHBOARD_FETCH_TASKS_SUMMARY_FAILURE,
+        payload: error,
+      })
+    ).toEqual({
+      ...initialState,
+      tasksSummary: TASKS_SUMMARY_ZERO,
+      isLoading: false,
+      error,
+    });
+  });
+});