foreman-tasks 1.0.1 → 2.0.1

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

@@ -67,7 +67,7 @@ const createTasksTableSchema = (
     sortableColumn('started_at', __('Started at'), 3, sortController, [
       dateCellFormmatter,
     ]),
-    sortableColumn('duration', __('Duration'), 3, sortController, [
+    sortableColumn('duration', __('Duration'), 2, sortController, [
       durationCellFormmatter,
     ]),
     column(
@@ -76,7 +76,7 @@ const createTasksTableSchema = (
       headFormat,
       [actionCellFormatter(taskActions)],
       {
-        className: 'col-md-1',
+        className: 'col-md-2',
       }
     ),
   ];

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

@@ -24,9 +24,6 @@ export const selectActionName = state =>
 export const selectSelectedRows = state =>
   selectTasksTableQuery(state).selectedRows || [];
 
-export const selectClicked = state =>
-  selectTasksTableQuery(state).clicked || {};
-
 export const selectResults = createSelector(
   selectTasksTableContent,
   ({ results }) =>
@@ -38,7 +35,10 @@ export const selectResults = createSelector(
       username: result.username || '',
       state: result.state + (result.frozen ? ` ${__('Disabled')}` : ''),
       duration: getDuration(result.started_at, result.ended_at),
-      availableActions: result.available_actions,
+      availableActions: {
+        ...result.available_actions,
+        stoppable: result.state !== 'stopped',
+      },
     }))
 );
 
@@ -48,3 +48,12 @@ 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;
+
+export const selectModalID = state =>
+  selectTasksTableQuery(state).modalID || '';

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

@@ -0,0 +1,147 @@
+import { testActionSnapshotWithFixtures } from '@theforeman/test';
+import { API } from 'foremanReact/redux/API';
+import {
+  bulkCancelById,
+  bulkCancelBySearch,
+  bulkResumeById,
+  bulkResumeBySearch,
+  bulkForceCancelById,
+  bulkForceCancelBySearch,
+} from '../TasksBulkActions';
+
+jest.mock('foremanReact/components/common/table', () => ({
+  getTableItemsAction: jest.fn(controller => controller),
+}));
+
+jest.mock('foremanReact/redux/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 bulkForceCancelById requests': () => {
+    const selected = [{ ...task, isCancellable: true }];
+
+    API.post.mockImplementation(() => ({
+      data: {
+        stopped_length: 2,
+        skipped_length: 4,
+      },
+    }));
+    return bulkForceCancelById({ selected, url: 'some-url' });
+  },
+
+  'handles bulkForceCancelById requests that fail': () => {
+    const selected = [{ ...task, isResumable: true }];
+
+    API.post.mockImplementation(() =>
+      Promise.reject(new Error('Network Error'))
+    );
+    return bulkForceCancelById({ 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 bulkForceCancelById requests that are stopped': () => {
+    const selected = [{ ...task, isResumable: false, state: 'stopped' }];
+    return bulkForceCancelById({ 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',
+    });
+  },
+  'handles bulkForceCancelBySearch requests': () =>
+    bulkForceCancelBySearch({
+      query: { search: {} },
+      url: 'some-url',
+      parentTaskID: 'parent',
+    }),
+};
+
+describe('TasksTable bulk actions', () => {
+  testActionSnapshotWithFixtures(fixtures);
+});

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

@@ -4,9 +4,7 @@ export const minProps = {
   getTableItems: jest.fn(),
   getBreadcrumbs: jest.fn(),
   itemCount: 2,
-  cancelTask: jest.fn(),
-  resumeTask: jest.fn(),
-  actionSelected: jest.fn(),
+  selectPage: jest.fn(),
   selectAllRows: jest.fn(),
   unselectAllRows: jest.fn(),
   selectRow: jest.fn(),
@@ -17,19 +15,14 @@ export const minProps = {
     perPage: 10,
   },
   history: { location: { search: '' } },
-  status: STATUS.RESOLVED,
   results: ['a', 'b'],
   sort: {
     by: 'q',
     order: 'w',
   },
   openClickedModal: jest.fn(),
-  modalProps: {
-    cancelSelectedModal: {},
-    resumeSelectedModal: {},
-    cancelModal: {},
-    resumeModal: {},
-  },
+  openModalAction: jest.fn(),
+  openModal: jest.fn(),
 };
 
 export default {

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

@@ -1,93 +1,65 @@
-import { testActionSnapshotWithFixtures } from '@theforeman/test';
-import API from 'foremanReact/API';
-import { TASKS_TABLE_ID, CANCEL, RESUME } from '../TasksTableConstants';
+import {
+  testActionSnapshotWithFixtures,
+  IntegrationTestHelper,
+} from '@theforeman/test';
+import { TASKS_TABLE_ID } from '../TasksTableConstants';
 import {
   getTableItems,
   cancelTask,
-  cancelTaskRequest,
   resumeTask,
-  resumeTaskRequest,
-  actionSelected,
+  forceCancelTask,
+  selectPage,
+  openClickedModal,
+  openModalAction,
 } from '../TasksTableActions';
 
 jest.mock('foremanReact/components/common/table', () => ({
   getTableItemsAction: jest.fn(controller => controller),
 }));
 
-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'),
-  'should cancelTaskRequest and fail': () => {
-    API.post.mockImplementation(() =>
-      Promise.reject(new Error('Network Error'))
-    );
-    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');
-  },
-  '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');
-  },
+  'should selectPage and succeed': () => selectPage([{ id: 'some-id' }]),
+  'handles openClickedModal': () =>
+    openClickedModal({ ...taskInfo, setModalOpen: jest.fn() }),
+  'handles openModalAction': () => openModalAction('some-modal-id', jest.fn()),
 };
 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);
+  });
+  it('should forceCancelTask', async () => {
+    const dispatch = jest.fn();
+    forceCancelTask({ ...taskInfo, url: 'some-url' })(dispatch);
+    await IntegrationTestHelper.flushAllPromises();
+    expect(dispatch.mock.calls).toHaveLength(3);
+  });
+  it('openClickedModal opens modal', () => {
+    const setModalOpen = jest.fn();
+    openClickedModal({ ...taskInfo, setModalOpen });
+    expect(setModalOpen).toHaveBeenCalled();
+  });
+  it('openModalAction opens modal', () => {
+    const setModalOpen = jest.fn();
+    openModalAction('some-modal-id', setModalOpen);
+    expect(setModalOpen).toHaveBeenCalled();
+  });
   testActionSnapshotWithFixtures(fixtures);
 });

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

@@ -1,4 +1,4 @@
-import { updateURlQuery, getDuration } from '../TasksTableHelpers';
+import { updateURlQuery, getDuration, getCSVurl } from '../TasksTableHelpers';
 
 describe('updateURlQuery', () => {
   it('should use url with new query', () => {
@@ -26,3 +26,19 @@ describe('updateURlQuery', () => {
     expect(duration.tooltip).toEqual('Task was canceled');
   });
 });
+
+describe('getCSVurl', () => {
+  it('should return currect url for tasks with search', () => {
+    const url = '/foreman_tasks/tasks';
+    const query = { state: 'stopped' };
+    expect(getCSVurl(url, query)).toEqual(
+      '/foreman_tasks/tasks.csv?state=stopped'
+    );
+  });
+  it('should return currect url for subtasks', () => {
+    const url = '/foreman_tasks/tasks/some-id/sub_tasks';
+    expect(getCSVurl(url, {})).toEqual(
+      '/foreman_tasks/tasks/some-id/sub_tasks.csv'
+    );
+  });
+});

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

@@ -2,11 +2,19 @@ import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
 import TasksTablePage from '../TasksTablePage';
 import { minProps } from './TasksTable.fixtures';
 
+jest.mock('foremanReact/common/helpers', () => ({
+  getURIQuery: () => ({ state: 'stopped' }),
+}));
+
+const history = {
+  location: { pathname: '/foreman_tasks/tasks', search: '?action="some-name"' },
+};
 const fixtures = {
-  'render with minimal props': minProps,
+  'render with minimal props': { ...minProps, history },
 
   'render with Breadcrubs': {
     ...minProps,
+    history,
     getBreadcrumbs: () => ({
       breadcrumbItems: [
         { caption: 'Tasks', url: `/foreman_tasks/tasks` },

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

@@ -1,3 +1,4 @@
+import Immutable from 'seamless-immutable';
 import { testReducerSnapshotWithFixtures } from '@theforeman/test';
 import {
   TASKS_TABLE_ID,
@@ -7,6 +8,8 @@ import {
   UNSELECT_ROWS,
   UNSELECT_ALL_ROWS,
   UPDATE_CLICKED,
+  SELECT_ALL_ROWS,
+  OPEN_SELECT_ALL,
 } from '../TasksTableConstants';
 import reducer from '../TasksTableReducer';
 
@@ -44,7 +47,7 @@ const fixtures = {
   'should handle UNSELECT_ROWS': {
     action: {
       type: UNSELECT_ROWS,
-      payload: 4,
+      payload: [{ id: 4 }],
     },
   },
   'should handle UNSELECT_ALL_ROWS': {
@@ -58,6 +61,24 @@ const fixtures = {
       payload: { clicked: 'task' },
     },
   },
+  'should handle SELECT_ALL_ROWS': {
+    action: {
+      type: SELECT_ALL_ROWS,
+      payload: { clicked: 'task' },
+    },
+  },
+  'should handle OPEN_SELECT_ALL': {
+    action: {
+      type: OPEN_SELECT_ALL,
+    },
+  },
+  'should handle UNSELECT_ROWS with all rows selected': {
+    state: Immutable({ tasksTableQuery: { allRowsSelected: true } }),
+    action: {
+      type: UNSELECT_ROWS,
+      payload: { id: [4], results: [{ id: 3 }, { id: 4 }, { id: 5 }] },
+    },
+  },
 };
 
 describe('TasksTableReducer reducer', () =>