foreman-tasks 12.2.2 → 12.2.4

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

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

@@ -1,4 +1,3 @@
-import { testSelectorsSnapshotWithFixtures } from '@theforeman/test';
 import {
   selectTasksDashboard,
   selectTime,
@@ -6,6 +5,7 @@ import {
   selectTasksSummary,
   calcStoppedOther,
 } from '../TasksDashboardSelectors';
+import { TASKS_DASHBOARD_AVAILABLE_TIMES } from '../TasksDashboardConstants';
 
 const stoppedResult = {
   error: {
@@ -55,19 +55,107 @@ const state = {
   },
 };
 
-const fixtures = {
-  'should select tasks-dashboard': () => selectTasksDashboard(state),
-  'should select tasks-dashboard when state is empty': () =>
-    selectTasksDashboard({}),
-  'should select time': () => selectTime(state),
-  'should select time when state is empty': () => selectTime({}),
-  'should select query': () => selectQuery(state),
-  'should select query when state is empty': () => selectQuery({}),
-  'should select tasks-summary': () => selectTasksSummary(state),
-  'should select tasks-summary when state is empty': () =>
-    selectTasksSummary({}),
-  'should calcStoppedOther': () => calcStoppedOther(stoppedResult),
+const emptyTasksSummary = {
+  paused: {
+    last: 0,
+    older: 0,
+  },
+  running: {
+    last: 0,
+    older: 0,
+  },
+  scheduled: 0,
+  stopped: {
+    other: 0,
+    results: {
+      error: {
+        last: 0,
+        total: 0,
+      },
+      success: {
+        last: 0,
+        total: 0,
+      },
+      warning: {
+        last: 0,
+        total: 0,
+      },
+    },
+  },
 };
 
-describe('TasksDashboard - Selectors', () =>
-  testSelectorsSnapshotWithFixtures(fixtures));
+describe('TasksDashboard - Selectors', () => {
+  it('should select tasks-dashboard', () => {
+    expect(selectTasksDashboard(state)).toEqual(
+      state.foremanTasks.tasksDashboard
+    );
+  });
+
+  it('should select tasks-dashboard when state is empty', () => {
+    expect(selectTasksDashboard({})).toEqual({});
+  });
+
+  it('should select time', () => {
+    expect(selectTime(state)).toBe('some-time');
+  });
+
+  it('should select time when state is empty', () => {
+    expect(selectTime({})).toBe(TASKS_DASHBOARD_AVAILABLE_TIMES.H24);
+  });
+
+  it('should select query', () => {
+    const query = { state: 'running' };
+    const stateWithQuery = {
+      ...state,
+      foremanTasks: {
+        ...state.foremanTasks,
+        tasksDashboard: { ...state.foremanTasks.tasksDashboard, query },
+      },
+    };
+
+    expect(selectQuery(stateWithQuery)).toEqual(query);
+  });
+
+  it('should select query when state is empty', () => {
+    expect(selectQuery({})).toEqual({});
+  });
+
+  it('should select tasks-summary', () => {
+    expect(selectTasksSummary(state)).toEqual({
+      paused: {
+        last: 2,
+        older: 7,
+      },
+      running: {
+        last: 3,
+        older: 5,
+      },
+      scheduled: 6,
+      stopped: {
+        other: 16,
+        results: {
+          error: {
+            last: 1,
+            total: 9,
+          },
+          success: {
+            last: 3,
+            total: 7,
+          },
+          warning: {
+            last: 2,
+            total: 8,
+          },
+        },
+      },
+    });
+  });
+
+  it('should select tasks-summary when state is empty', () => {
+    expect(selectTasksSummary({})).toEqual(emptyTasksSummary);
+  });
+
+  it('should calcStoppedOther', () => {
+    expect(calcStoppedOther(stoppedResult)).toBe(16);
+  });
+});

data/webpack/ForemanTasks/Components/TasksTable/TasksTableConstants.js

@@ -5,7 +5,7 @@ export const BULK_RESUME_PATH = 'bulk_resume';
 export const BULK_FORCE_CANCEL_PATH = 'bulk_stop';
 
 export const TASKS_SEARCH_PROPS = {
-  ...getControllerSearchProps('tasks'),
+  ...getControllerSearchProps('/foreman_tasks/tasks'),
   controller: 'foreman_tasks_tasks',
 };
 

data/webpack/Routes/routes.js

@@ -1,6 +1,5 @@
 import React from 'react';
 import TasksTableIndexPage from '../ForemanTasks/Components/TasksTable/TasksIndexPage';
-import ShowTask from '../ForemanTasks/Routes/ShowTask/ShowTask';
 
 const ForemanTasksRoutes = [
   {
@@ -13,10 +12,6 @@ const ForemanTasksRoutes = [
     exact: true,
     render: props => <TasksTableIndexPage {...props} />,
   },
-  {
-    path: '/foreman_tasks/ex_tasks/:id',
-    render: props => <ShowTask {...props} />,
-  },
 ];
 
 export default ForemanTasksRoutes;

data/webpack/Routes/routes.test.js

@@ -12,14 +12,6 @@ jest.mock(
     }
 );
 
-jest.mock(
-  '../ForemanTasks/Routes/ShowTask/ShowTask',
-  () =>
-    function ShowTaskStub() {
-      return <div data-testid="show-task-stub" />;
-    }
-);
-
 const routerProps = {
   history: { push: jest.fn(), replace: jest.fn(), go: jest.fn() },
   location: {
@@ -43,7 +35,6 @@ describe('ForemanTasks routes', () => {
     ).toEqual([
       { path: '/foreman_tasks/tasks', exact: true },
       { path: '/foreman_tasks/tasks/:id/sub_tasks', exact: true },
-      { path: '/foreman_tasks/ex_tasks/:id', exact: undefined },
     ]);
   });
 
@@ -67,15 +58,6 @@ describe('ForemanTasks routes', () => {
           url: '/foreman_tasks/tasks/7/sub_tasks',
         },
       },
-      {
-        ...routerProps,
-        match: {
-          ...routerProps.match,
-          params: { id: '42' },
-          path: '/foreman_tasks/ex_tasks/:id',
-          url: '/foreman_tasks/ex_tasks/42',
-        },
-      },
     ];
 
     ForemanTasksRoutes.forEach((route, index) => {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks
 version: !ruby/object:Gem::Version
-  version: 12.2.2
+  version: 12.2.4
 platform: ruby
 authors:
 - Ivan Nečas
@@ -368,10 +368,10 @@ files:
 - webpack/ForemanTasks/Components/TaskActions/TaskActionHelpers.js
 - webpack/ForemanTasks/Components/TaskActions/TaskActionHelpers.test.js
 - webpack/ForemanTasks/Components/TaskActions/TaskActionsConstants.js
-- webpack/ForemanTasks/Components/TaskActions/__snapshots__/TaskAction.test.js.snap
 - webpack/ForemanTasks/Components/TaskActions/index.js
 - webpack/ForemanTasks/Components/TaskDetails/Components/Dependencies.js
 - webpack/ForemanTasks/Components/TaskDetails/Components/Errors.js
+- webpack/ForemanTasks/Components/TaskDetails/Components/Errors.scss
 - webpack/ForemanTasks/Components/TaskDetails/Components/Locks.js
 - webpack/ForemanTasks/Components/TaskDetails/Components/Raw.js
 - webpack/ForemanTasks/Components/TaskDetails/Components/RunningSteps.js
@@ -447,10 +447,6 @@ files:
 - webpack/ForemanTasks/Components/TasksDashboard/__tests__/TasksDashboardHelper.test.js
 - webpack/ForemanTasks/Components/TasksDashboard/__tests__/TasksDashboardReducer.test.js
 - webpack/ForemanTasks/Components/TasksDashboard/__tests__/TasksDashboardSelectors.test.js
-- webpack/ForemanTasks/Components/TasksDashboard/__tests__/__snapshots__/TasksDashboard.test.js.snap
-- webpack/ForemanTasks/Components/TasksDashboard/__tests__/__snapshots__/TasksDashboardActions.test.js.snap
-- webpack/ForemanTasks/Components/TasksDashboard/__tests__/__snapshots__/TasksDashboardReducer.test.js.snap
-- webpack/ForemanTasks/Components/TasksDashboard/__tests__/__snapshots__/TasksDashboardSelectors.test.js.snap
 - webpack/ForemanTasks/Components/TasksDashboard/index.js
 - webpack/ForemanTasks/Components/TasksTable/Components/ActionSelectButton.js
 - webpack/ForemanTasks/Components/TasksTable/Components/CellActionButton.js
@@ -478,11 +474,6 @@ files:
 - webpack/ForemanTasks/Components/common/urlHelpers.js
 - webpack/ForemanTasks/ForemanTasksReducers.js
 - webpack/ForemanTasks/ForemanTasksSelectors.js
-- webpack/ForemanTasks/Routes/ShowTask/ShowTask.js
-- webpack/ForemanTasks/Routes/ShowTask/__tests__/ShowTask.test.js
-- webpack/ForemanTasks/Routes/ShowTask/__tests__/__snapshots__/ShowTask.test.js.snap
-- webpack/ForemanTasks/Routes/ShowTask/index.js
-- webpack/ForemanTasks/Routes/ShowTask/showTask.scss
 - webpack/Routes/routes.js
 - webpack/Routes/routes.test.js
 - webpack/global_index.js