foreman-tasks 1.0.0 → 1.1.3

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

@@ -8,21 +8,23 @@ import {
   SELECT_ROWS,
   UNSELECT_ROWS,
   UNSELECT_ALL_ROWS,
-  TASKS_TABLE_SELECTED_MODAL,
-  CLOSED,
+  UPDATE_CLICKED,
+  SELECT_ALL_ROWS,
+  OPEN_SELECT_ALL,
 } from './TasksTableConstants';
 
 const initialState = Immutable({
   selectedRows: [],
-  modalStatus: CLOSED,
 });
 
 export const TasksTableQueryReducer = (state = initialState, action) => {
-  const { type, payload } = action;
+  const { type, payload, response } = action;
   const { subtotal, page, per_page: perPageString, action_name: actionName } =
-    payload || {};
+    response || {};
   const ACTION_TYPES = createTableActionTypes(TASKS_TABLE_ID);
   switch (type) {
+    case SELECT_ALL_ROWS:
+      return state.set('allRowsSelected', true);
     case ACTION_TYPES.SUCCESS:
       return Immutable.merge(state, {
         itemCount: subtotal,
@@ -35,15 +37,30 @@ export const TasksTableQueryReducer = (state = initialState, action) => {
       });
     case SELECT_ROWS:
       return state.set('selectedRows', union(payload, state.selectedRows));
+    case OPEN_SELECT_ALL:
+      return state.set('showSelectAll', true);
     case UNSELECT_ROWS:
+      if (state.allRowsSelected) {
+        // User can unselect rows if only the page rows are selected
+        return state
+          .set(
+            'selectedRows',
+            payload.results.map(row => row.id).filter(row => row !== payload.id)
+          )
+          .set('allRowsSelected', false)
+          .set('showSelectAll', false);
+      }
       return state.set(
         'selectedRows',
-        state.selectedRows.filter(row => row !== payload)
+        state.selectedRows.filter(row => row !== payload.id)
       );
     case UNSELECT_ALL_ROWS:
-      return state.set('selectedRows', []);
-    case TASKS_TABLE_SELECTED_MODAL:
-      return state.set('modalStatus', payload);
+      return state
+        .set('selectedRows', [])
+        .set('allRowsSelected', false)
+        .set('showSelectAll', false);
+    case UPDATE_CLICKED:
+      return state.set('clicked', payload.clicked);
     default:
       return state;
   }

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

@@ -1,7 +1,7 @@
+import { createSelector } from 'reselect';
 import { translate as __ } from 'foremanReact/common/I18n';
 import { selectForemanTasks } from '../../ForemanTasksSelectors';
 import { getDuration } from './TasksTableHelpers';
-import { CLOSED } from './TasksTableConstants';
 
 export const selectTasksTable = state =>
   selectForemanTasks(state).tasksTable || {};
@@ -24,21 +24,23 @@ export const selectActionName = state =>
 export const selectSelectedRows = state =>
   selectTasksTableQuery(state).selectedRows || [];
 
-export const selectModalStatus = state =>
-  selectTasksTableQuery(state).modalStatus || CLOSED;
-
-export const selectResults = state => {
-  const { results } = selectTasksTableContent(state);
-  if (!results) return [];
-  return results.map(result => ({
-    ...result,
-    action: result.action || result.label.replace(/::/g, ' '),
-    username: result.username || '',
-    state: result.state + (result.frozen ? ` ${__('Disabled')}` : ''),
-    duration: getDuration(result.started_at, result.ended_at),
-    availableActions: result.available_actions,
-  }));
-};
+export const selectClicked = state =>
+  selectTasksTableQuery(state).clicked || {};
+
+export const selectResults = createSelector(
+  selectTasksTableContent,
+  ({ results }) =>
+    results.map(result => ({
+      ...result,
+      action:
+        result.action ||
+        (result.label ? result.label.replace(/::/g, ' ') : result.id),
+      username: result.username || '',
+      state: result.state + (result.frozen ? ` ${__('Disabled')}` : ''),
+      duration: getDuration(result.started_at, result.ended_at),
+      availableActions: result.available_actions,
+    }))
+);
 
 export const selectStatus = state => selectTasksTableContent(state).status;
 
@@ -46,3 +48,9 @@ export const selectError = state => selectTasksTableContent(state).error;
 
 export const selectSort = state =>
   selectTasksTableQuery(state).sort || { by: 'started_at', order: 'DESC' };
+
+export const selectAllRowsSelected = state =>
+  selectTasksTableQuery(state).allRowsSelected;
+
+export const selectShowSelectAll = state =>
+  selectTasksTableQuery(state).showSelectAll;

data/webpack/ForemanTasks/Components/TasksTable/__tests__/SubTasksPage.test.js

@@ -1,4 +1,4 @@
-import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
 import { SubTasksPage } from '../SubTasksPage';
 import { minProps } from './TasksTable.fixtures';
 

data/webpack/ForemanTasks/Components/TasksTable/__tests__/TasksBulkActions.test.js

@@ -0,0 +1,112 @@
+import { testActionSnapshotWithFixtures } from '@theforeman/test';
+import API from 'foremanReact/API';
+import {
+  bulkCancelById,
+  bulkCancelBySearch,
+  bulkResumeById,
+  bulkResumeBySearch,
+} from '../TasksBulkActions';
+
+jest.mock('foremanReact/components/common/table', () => ({
+  getTableItemsAction: jest.fn(controller => controller),
+}));
+
+jest.mock('foremanReact/API');
+
+const task = {
+  id: 'some-id',
+  name: 'some-name',
+};
+
+const fixtures = {
+  'handles bulkResumeById requests that fail': () => {
+    const selected = [{ ...task, isResumable: true }];
+
+    API.post.mockImplementation(() =>
+      Promise.reject(new Error('Network Error'))
+    );
+    return bulkResumeById({ selected, url: 'some-url' });
+  },
+  'handles resumable bulkResumeById requests': () => {
+    const selected = [{ ...task, isResumable: true }];
+
+    API.post.mockImplementation(() => ({
+      data: {
+        resumed: [{ action: 'I am resumed' }],
+        failed: [{ action: 'I am failed' }],
+      },
+    }));
+    return bulkResumeById({ selected, url: 'some-url' });
+  },
+  'handles bulkCancelById requests': () => {
+    const selected = [{ ...task, isCancellable: true }];
+
+    API.post.mockImplementation(() => ({
+      data: {
+        cancelled: [{ action: 'I am cancelled' }],
+      },
+    }));
+    return bulkCancelById({ selected, url: 'some-url' });
+  },
+  'handles skipped bulkResumeById requests': () => {
+    const selected = [{ ...task, isResumable: true }];
+
+    API.post.mockImplementation(() => ({
+      data: {
+        skipped: [{ action: 'I am skipped' }],
+      },
+    }));
+    return bulkResumeById({ selected, url: 'some-url' });
+  },
+  'handles skipped bulkCancelById requests': () => {
+    const selected = [{ ...task, isCancellable: true }];
+
+    API.post.mockImplementation(() => ({
+      data: {
+        skipped: [{ action: 'I am skipped' }],
+      },
+    }));
+    return bulkCancelById({ selected, url: 'some-url' });
+  },
+  'handles bulkCancelById requests that are not cancellable': () => {
+    const selected = [{ ...task, isCancellable: false }];
+    return bulkCancelById({ selected, url: 'some-url' });
+  },
+  'handles bulkResumeById requests that are not resumable': () => {
+    const selected = [{ ...task, isResumable: false, isCancellable: false }];
+    return bulkResumeById({ selected, url: 'some-url' });
+  },
+
+  'handles bulkCancelBySearch requests': () => {
+    API.post.mockImplementation(() => ({
+      data: {
+        cancelled: [{ action: 'I am cancelled' }],
+        skipped: [{ action: 'I am skipped' }],
+      },
+    }));
+    return bulkCancelBySearch({
+      query: { search: {} },
+      url: 'some-url',
+      parentTaskID: 'parent',
+    });
+  },
+
+  'handles bulkResumeBySearch requests': () => {
+    API.post.mockImplementation(() => ({
+      data: {
+        cancelled: [{ action: 'I am cancelled' }],
+        skipped: [{ action: 'I am skipped' }],
+        failed: [{ action: 'I am failed' }],
+      },
+    }));
+    return bulkResumeBySearch({
+      query: { search: {} },
+      url: 'some-url',
+      parentTaskID: 'parent',
+    });
+  },
+};
+
+describe('TasksTable bulk actions', () => {
+  testActionSnapshotWithFixtures(fixtures);
+});

data/webpack/ForemanTasks/Components/TasksTable/__tests__/TasksIndexPage.test.js

@@ -1,4 +1,4 @@
-import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
 import { TasksIndexPage } from '../TasksIndexPage';
 import { minProps } from './TasksTable.fixtures';
 

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

@@ -6,7 +6,11 @@ export const minProps = {
   itemCount: 2,
   cancelTask: jest.fn(),
   resumeTask: jest.fn(),
-  actionSelected: jest.fn(),
+  bulkResumeById: jest.fn(),
+  bulkCancelById: jest.fn(),
+  bulkResumeBySearch: jest.fn(),
+  bulkCancelBySearch: jest.fn(),
+  selectPage: jest.fn(),
   selectAllRows: jest.fn(),
   unselectAllRows: jest.fn(),
   selectRow: jest.fn(),
@@ -17,15 +21,18 @@ export const minProps = {
     perPage: 10,
   },
   history: { location: { search: '' } },
-  status: STATUS.RESOLVED,
   results: ['a', 'b'],
   sort: {
     by: 'q',
     order: 'w',
   },
-  showResumeSelcetedModal: jest.fn(),
-  showCancelSelcetedModal: jest.fn(),
-  hideSelcetedModal: jest.fn(),
+  openClickedModal: jest.fn(),
+  modalProps: {
+    cancelSelectedModal: {},
+    resumeSelectedModal: {},
+    cancelModal: {},
+    resumeModal: {},
+  },
 };
 
 export default {

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

@@ -1,4 +1,4 @@
-import { testComponentSnapshotsWithFixtures } from 'react-redux-test-utils';
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
 import TasksTable from '../TasksTable';
 import fixtures from './TasksTable.fixtures';
 

data/webpack/ForemanTasks/Components/TasksTable/__tests__/TasksTableActionHelpers.test.js

@@ -0,0 +1,46 @@
+import { convertDashboardQuery } from '../TasksTableActionHelpers';
+import {
+  TASKS_DASHBOARD_JS_QUERY_MODES,
+  TASKS_DASHBOARD_AVAILABLE_TIMES,
+} from '../../TasksDashboard/TasksDashboardConstants';
+
+let realDate;
+
+describe('convertDashboardQuery', () => {
+  it('convertDashboardQuery should work with full query', () => {
+    // Setup
+    const currentDate = new Date('2020-05-08T11:01:58.135Z');
+    realDate = Date;
+    global.Date = class extends Date {
+      constructor(date) {
+        if (date) {
+          // eslint-disable-next-line constructor-super
+          return super(date);
+        }
+        return currentDate;
+      }
+    };
+    const query = {
+      time_mode: TASKS_DASHBOARD_JS_QUERY_MODES.RECENT,
+      time_horizon: TASKS_DASHBOARD_AVAILABLE_TIMES.WEEK,
+      state: 'stopped',
+      result: 'error',
+      search: 'action~job',
+    };
+    expect(convertDashboardQuery(query)).toEqual(
+      'state=stopped and result=error and action~job and (state_updated_at>2020-05-01T11:01:58.135Z or state_updated_at = NULL)'
+    );
+    // Cleanup
+    global.Date = realDate;
+  });
+  it('convertDashboardQuery should work with only search query', () => {
+    const query = {
+      search: 'action~job',
+    };
+    expect(convertDashboardQuery(query)).toEqual('action~job');
+  });
+  it('convertDashboardQuery should work with no query', () => {
+    const query = {};
+    expect(convertDashboardQuery(query)).toEqual('');
+  });
+});

data/webpack/ForemanTasks/Components/TasksTable/__tests__/TasksTableActions.test.js

@@ -1,13 +1,16 @@
-import { testActionSnapshotWithFixtures } from 'react-redux-test-utils';
+import {
+  testActionSnapshotWithFixtures,
+  IntegrationTestHelper,
+} from '@theforeman/test';
 import API from 'foremanReact/API';
-import { TASKS_TABLE_ID, CANCEL, RESUME } from '../TasksTableConstants';
+import { TASKS_TABLE_ID } from '../TasksTableConstants';
 import {
   getTableItems,
   cancelTask,
   cancelTaskRequest,
   resumeTask,
   resumeTaskRequest,
-  actionSelected,
+  selectPage,
 } from '../TasksTableActions';
 
 jest.mock('foremanReact/components/common/table', () => ({
@@ -18,10 +21,14 @@ jest.mock('foremanReact/API');
 
 API.post.mockImplementation(() => ({ data: 'some-data' }));
 
+const taskInfo = {
+  taskId: 'some-id',
+  taskName: 'some-name',
+};
+
 const fixtures = {
-  'should cancelTask': () => cancelTask('some-id', 'some-name', 'some-url'),
   'should cancelTaskRequest and succeed': () =>
-    cancelTaskRequest('some-id', 'some-name', 'some-url'),
+    cancelTaskRequest('some-id', 'some-name'),
   'should cancelTaskRequest and fail': () => {
     API.post.mockImplementation(() =>
       Promise.reject(new Error('Network Error'))
@@ -29,65 +36,34 @@ const fixtures = {
     return cancelTaskRequest('some-id', 'some-name');
   },
 
-  'should resumeTask': () => resumeTask('some-id', 'some-name', 'some-url'),
   'should resumeTaskRequest and succeed': () => {
     API.post.mockImplementation(() => ({ data: 'some-data' }));
-    return resumeTaskRequest('some-id', 'some-name', 'some-url');
+    return resumeTaskRequest('some-id', 'some-name');
   },
   'should resumeTaskRequest and fail': () => {
     API.post.mockImplementation(() =>
       Promise.reject(new Error('Network Error'))
     );
-    return resumeTaskRequest('some-id', 'some-name', 'some-url');
-  },
-  'should actionSelected CANCEL not cancelleble': () => {
-    const selected = [
-      {
-        id: '',
-        name: '',
-        isResumeble: false,
-        isCancelleble: false,
-      },
-    ];
-    return actionSelected(CANCEL, selected, 'some-url');
-  },
-  'should actionSelected CANCEL cancelleble': () => {
-    const selected = [
-      {
-        id: '',
-        name: '',
-        isResumeble: false,
-        isCancelleble: true,
-      },
-    ];
-    return actionSelected(CANCEL, selected, 'some-url');
-  },
-  'should actionSelected RESUME not resumable': () => {
-    const selected = [
-      {
-        id: '',
-        name: '',
-        isResumeble: false,
-        isCancelleble: false,
-      },
-    ];
-    return actionSelected(RESUME, selected, 'some-url');
-  },
-  'should actionSelected RESUME resumable': () => {
-    const selected = [
-      {
-        id: '',
-        name: '',
-        isResumeble: true,
-        isCancelleble: false,
-      },
-    ];
-    return actionSelected(RESUME, selected, 'some-url');
+    return resumeTaskRequest('some-id', 'some-name');
   },
+  'should selectPage and succeed': () => selectPage([{ id: 'some-id' }]),
 };
 describe('TasksTable actions', () => {
   it('getTableItems should reuse common/table/getTableItemsAction', () => {
     expect(getTableItems('')).toEqual(TASKS_TABLE_ID);
   });
+
+  it('should resumeTask', async () => {
+    const dispatch = jest.fn();
+    resumeTask({ ...taskInfo, url: 'some-url' })(dispatch);
+    await IntegrationTestHelper.flushAllPromises();
+    expect(dispatch.mock.calls).toHaveLength(3);
+  });
+  it('should cancelTask', async () => {
+    const dispatch = jest.fn();
+    cancelTask({ ...taskInfo, url: 'some-url' })(dispatch);
+    await IntegrationTestHelper.flushAllPromises();
+    expect(dispatch.mock.calls).toHaveLength(3);
+  });
   testActionSnapshotWithFixtures(fixtures);
 });