foreman-tasks 1.1.2 → 2.0.2

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/__test__/ConfirmModalActions.test.js

@@ -0,0 +1,205 @@
+import taskActions from '../ConfirmModalActions';
+import {
+  CANCEL_MODAL,
+  RESUME_MODAL,
+  CANCEL_SELECTED_MODAL,
+  RESUME_SELECTED_MODAL,
+  FORCE_UNLOCK_SELECTED_MODAL,
+} from '../../../TasksTableConstants';
+
+import { FORCE_UNLOCK_MODAL } from '../../../../TaskActions/TaskActionsConstants';
+
+import {
+  resumeTask,
+  cancelTask,
+  forceCancelTask,
+} from '../../../TasksTableActions';
+import {
+  bulkCancelBySearch,
+  bulkCancelById,
+  bulkResumeBySearch,
+  bulkResumeById,
+  bulkForceCancelBySearch,
+  bulkForceCancelById,
+} from '../../../TasksBulkActions';
+
+jest.mock('../../../TasksBulkActions');
+jest.mock('../../../TasksTableActions');
+
+const bulkCancelBySearchMock = 'bulkCancelBySearchMock';
+const bulkCancelByIdMock = 'bulkCancelByIdMock';
+const bulkResumeBySearchMock = 'bulkResumeBySearchMock';
+const bulkResumeByIdMock = 'bulkResumeByIdMock';
+const bulkForceCancelBySearchMock = 'bulkForceCancelBySearchMock';
+const bulkForceCancelByIdMock = 'bulkForceCancelByIdMock';
+const resumeTaskMock = 'resumeTaskMock';
+const cancelTaskMock = 'cancelTaskMock';
+const forceCancelTaskMock = 'forceCancelTaskMock';
+
+bulkCancelBySearch.mockImplementation(() => bulkCancelBySearchMock);
+bulkCancelById.mockImplementation(() => bulkCancelByIdMock);
+bulkResumeBySearch.mockImplementation(() => bulkResumeBySearchMock);
+bulkResumeById.mockImplementation(() => bulkResumeByIdMock);
+bulkForceCancelBySearch.mockImplementation(() => bulkForceCancelBySearchMock);
+bulkForceCancelById.mockImplementation(() => bulkForceCancelByIdMock);
+resumeTask.mockImplementation(() => resumeTaskMock);
+cancelTask.mockImplementation(() => cancelTaskMock);
+forceCancelTask.mockImplementation(() => forceCancelTaskMock);
+
+const url = 'some-url';
+const query = 'some-query';
+const parentTaskID = 'some-parentTaskID';
+
+const runWithGetState = (state, action, dispatch, ...params) => {
+  const getState = () => state;
+  action(...params)(dispatch, getState);
+};
+
+const clickedState = {
+  foremanTasks: {
+    tasksTable: {
+      tasksTableQuery: {
+        clicked: { taskId: 'some-id', taskName: 'some-name' },
+      },
+    },
+  },
+};
+
+const selectedState = {
+  foremanTasks: {
+    tasksTable: {
+      tasksTableQuery: {
+        allRowsSelected: false,
+        selectedRows: [1, 2, 3],
+      },
+      tasksTableContent: {
+        results: [
+          {
+            id: 1,
+            action: 'action1',
+            available_actions: { cancellable: true },
+          },
+          {
+            id: 2,
+            action: 'action2',
+            available_actions: { resumable: true },
+          },
+        ],
+      },
+    },
+  },
+};
+const allRowsState = {
+  foremanTasks: {
+    tasksTable: {
+      tasksTableQuery: {
+        allRowsSelected: true,
+      },
+    },
+  },
+};
+describe('ConfirmModalActions', () => {
+  const dispatch = jest.fn();
+
+  beforeEach(() => dispatch.mockClear());
+  it('run CANCEL_MODAL', () => {
+    runWithGetState(clickedState, taskActions[CANCEL_MODAL], dispatch, {
+      url,
+      parentTaskID,
+    });
+    expect(dispatch).toBeCalledWith(cancelTaskMock);
+  });
+  it('run RESUME_MODAL', () => {
+    runWithGetState(clickedState, taskActions[RESUME_MODAL], dispatch, {
+      url,
+      parentTaskID,
+    });
+    expect(dispatch).toBeCalledWith(resumeTaskMock);
+  });
+  it('run FORCE_UNLOCK_MODAL', () => {
+    runWithGetState(clickedState, taskActions[FORCE_UNLOCK_MODAL], dispatch, {
+      url,
+      parentTaskID,
+    });
+    expect(dispatch).toBeCalledWith(forceCancelTaskMock);
+  });
+  it('run CANCEL_SELECTED_MODAL by id', () => {
+    runWithGetState(
+      selectedState,
+      taskActions[CANCEL_SELECTED_MODAL],
+      dispatch,
+      {
+        url,
+        query,
+        parentTaskID,
+      }
+    );
+    expect(dispatch).toBeCalledWith(bulkCancelByIdMock);
+  });
+
+  it('run CANCEL_SELECTED_MODAL by search', () => {
+    runWithGetState(
+      allRowsState,
+      taskActions[CANCEL_SELECTED_MODAL],
+      dispatch,
+      {
+        url,
+        query,
+        parentTaskID,
+      }
+    );
+    expect(dispatch).toBeCalledWith(bulkCancelBySearchMock);
+  });
+  it('run RESUME_SELECTED_MODAL by id', () => {
+    runWithGetState(
+      selectedState,
+      taskActions[RESUME_SELECTED_MODAL],
+      dispatch,
+      {
+        url,
+        query,
+        parentTaskID,
+      }
+    );
+    expect(dispatch).toBeCalledWith(bulkResumeByIdMock);
+  });
+  it('run RESUME_SELECTED_MODAL by search', () => {
+    runWithGetState(
+      allRowsState,
+      taskActions[RESUME_SELECTED_MODAL],
+      dispatch,
+      {
+        url,
+        query,
+        parentTaskID,
+      }
+    );
+    expect(dispatch).toBeCalledWith(bulkResumeBySearchMock);
+  });
+  it('run FORCE_UNLOCK_SELECTED_MODAL by id', () => {
+    runWithGetState(
+      selectedState,
+      taskActions[FORCE_UNLOCK_SELECTED_MODAL],
+      dispatch,
+      {
+        url,
+        query,
+        parentTaskID,
+      }
+    );
+    expect(dispatch).toBeCalledWith(bulkForceCancelByIdMock);
+  });
+  it('run FORCE_UNLOCK_SELECTED_MODAL by search', () => {
+    runWithGetState(
+      allRowsState,
+      taskActions[FORCE_UNLOCK_SELECTED_MODAL],
+      dispatch,
+      {
+        url,
+        query,
+        parentTaskID,
+      }
+    );
+    expect(dispatch).toBeCalledWith(bulkForceCancelBySearchMock);
+  });
+});

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/__test__/ConfirmModalReducer.test.js

@@ -0,0 +1,27 @@
+import { testReducerSnapshotWithFixtures } from '@theforeman/test';
+import {
+  UPDATE_MODAL,
+  CANCEL_MODAL,
+  RESUME_SELECTED_MODAL,
+} from '../../../TasksTableConstants';
+
+import reducer from '../ConfirmModalReducer';
+
+const fixtures = {
+  'should return the initial state': {},
+  'should handle UPDATE_MODAL to cancel': {
+    action: {
+      type: UPDATE_MODAL,
+      payload: { modalID: CANCEL_MODAL },
+    },
+  },
+  'should handle UPDATE_MODAL to resume': {
+    action: {
+      type: UPDATE_MODAL,
+      payload: { modalID: RESUME_SELECTED_MODAL },
+    },
+  },
+};
+
+describe('ConfirmModalReducer reducer', () =>
+  testReducerSnapshotWithFixtures(reducer, fixtures));

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/__test__/ConfirmModalSelectors.test.js

@@ -0,0 +1,55 @@
+import { testSelectorsSnapshotWithFixtures } from '@theforeman/test';
+import {
+  selectActionText,
+  selectActionState,
+  selectActionType,
+  selectSelectedTasks,
+  selectSelectedRowsLen,
+} from '../ConfirmModalSelectors';
+import { CANCEL_MODAL } from '../../../TasksTableConstants';
+
+const state = {
+  foremanTasks: {
+    confirmModal: {
+      actionText: 'some-text',
+      actionState: 'some-state',
+      actionType: 'some-type',
+    },
+    tasksTable: {
+      tasksTableContent: {
+        results: [
+          {
+            id: 1,
+            action: 'action1',
+            available_actions: { cancellable: true },
+            can_edit: true,
+          },
+          { id: 2, action: 'action2', available_actions: { resumable: true } },
+        ],
+        itemCount: 10,
+      },
+      tasksTableQuery: { selectedRows: [1, 2, 3] },
+    },
+  },
+};
+
+const fixtures = {
+  'should select actionText': () => selectActionText(state),
+  'should select actionState': () => selectActionState(state),
+  'should select actionType': () => selectActionType(state),
+  'should select selectedTasks': () => selectSelectedTasks(state),
+  'should select selectedRowsLen 1': () =>
+    selectSelectedRowsLen({
+      ...state,
+      foremanTasks: { confirmModal: { actionType: CANCEL_MODAL } },
+    }),
+  'should select selectedRowsLen all': () => selectSelectedRowsLen(state),
+  'should select selectedRowsLen some': () =>
+    selectSelectedRowsLen({
+      ...state,
+      tasksTable: { tasksTableQuery: { allRowsSelected: true } },
+    }),
+};
+
+describe('TasksDashboard - Selectors', () =>
+  testSelectorsSnapshotWithFixtures(fixtures));

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/__test__/__snapshots__/ConfirmModal.test.js.snap

@@ -0,0 +1,41 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`ConfirmModal renders ConfirmModal 1`] = `
+<ForemanModal
+  id="modalID"
+  title="Some Text Selected Tasks"
+>
+  This will some text 1 task(s), putting them in the some state state. Are you sure?
+  <Component>
+    <Button
+      active={false}
+      block={false}
+      bsClass="btn"
+      bsStyle="default"
+      disabled={false}
+      onClick={[MockFunction]}
+    >
+      No
+    </Button>
+    <Button
+      active={false}
+      block={false}
+      bsClass="btn"
+      bsStyle="primary"
+      className="confirm-button"
+      disabled={false}
+      onClick={[Function]}
+    >
+      Yes
+    </Button>
+  </Component>
+</ForemanModal>
+`;
+
+exports[`ConfirmModal renders ConfirmModal for unlock  1`] = `
+<ForceUnlockModal
+  id="modalID"
+  onClick={[Function]}
+  selectedRowsLen={1}
+/>
+`;

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/__test__/__snapshots__/ConfirmModalReducer.test.js.snap

@@ -0,0 +1,19 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`ConfirmModalReducer reducer should handle UPDATE_MODAL to cancel 1`] = `
+Object {
+  "actionState": "stopped",
+  "actionText": "cancel",
+  "actionType": "cancelConfirmModal",
+}
+`;
+
+exports[`ConfirmModalReducer reducer should handle UPDATE_MODAL to resume 1`] = `
+Object {
+  "actionState": "running",
+  "actionText": "resume",
+  "actionType": "resumeSelectedConfirmModal",
+}
+`;
+
+exports[`ConfirmModalReducer reducer should return the initial state 1`] = `Object {}`;

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/__test__/__snapshots__/ConfirmModalSelectors.test.js.snap

@@ -0,0 +1,32 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`TasksDashboard - Selectors should select actionState 1`] = `"some-state"`;
+
+exports[`TasksDashboard - Selectors should select actionText 1`] = `"some-text"`;
+
+exports[`TasksDashboard - Selectors should select actionType 1`] = `"some-type"`;
+
+exports[`TasksDashboard - Selectors should select selectedRowsLen 1 1`] = `1`;
+
+exports[`TasksDashboard - Selectors should select selectedRowsLen all 1`] = `3`;
+
+exports[`TasksDashboard - Selectors should select selectedRowsLen some 1`] = `3`;
+
+exports[`TasksDashboard - Selectors should select selectedTasks 1`] = `
+Array [
+  Object {
+    "canEdit": true,
+    "id": 1,
+    "isCancellable": true,
+    "isResumable": undefined,
+    "name": "action1",
+  },
+  Object {
+    "canEdit": undefined,
+    "id": 2,
+    "isCancellable": undefined,
+    "isResumable": true,
+    "name": "action2",
+  },
+]
+`;

data/webpack/ForemanTasks/Components/TasksTable/Components/ConfirmModal/index.js

@@ -0,0 +1,29 @@
+import { connect } from 'react-redux';
+import { bindActionCreators } from 'redux';
+import { ConfirmModal } from './ConfirmModal';
+import reducer from './ConfirmModalReducer';
+import tasksActions from './ConfirmModalActions';
+import {
+  selectActionText,
+  selectActionState,
+  selectActionType,
+  selectClicked,
+  selectSelectedRowsLen,
+} from './ConfirmModalSelectors';
+import { selectAllRowsSelected } from '../../TasksTableSelectors';
+
+const mapStateToProps = state => ({
+  actionText: selectActionText(state),
+  actionType: selectActionType(state),
+  actionState: selectActionState(state),
+  allRowsSelected: selectAllRowsSelected(state),
+  clicked: selectClicked(state),
+  selectedRowsLen: selectSelectedRowsLen(state),
+});
+
+const mapDispatchToProps = dispatch =>
+  bindActionCreators(tasksActions, dispatch);
+
+export const reducers = { confirmModal: reducer };
+
+export default connect(mapStateToProps, mapDispatchToProps)(ConfirmModal);

data/webpack/ForemanTasks/Components/TasksTable/Components/__test__/ActionSelectButton.test.js

@@ -6,6 +6,7 @@ const fixtures = {
   'renders with minimal props': {
     onCancel: jest.fn(),
     onResume: jest.fn(),
+    onForceCancel: jest.fn(),
   },
 };
 

data/webpack/ForemanTasks/Components/TasksTable/Components/__test__/__snapshots__/ActionSelectButton.test.js.snap

@@ -28,5 +28,16 @@ exports[`ActionSelectButton renders with minimal props 1`] = `
   >
     Resume Selected
   </MenuItem>
+  <MenuItem
+    bsClass="dropdown"
+    disabled={false}
+    divider={false}
+    eventKey="3"
+    header={false}
+    onClick={[MockFunction]}
+    title="Force Cancel selected tasks"
+  >
+    Force Cancel Selected
+  </MenuItem>
 </DropdownButton>
 `;

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

@@ -1,7 +1,11 @@
-import API from 'foremanReact/API';
+import { API } from 'foremanReact/redux/API';
 import { addToast } from 'foremanReact/redux/actions/toasts';
-import { translate as __ } from 'foremanReact/common/I18n';
-import { TOAST_TYPES } from '../common/ToastTypesConstants';
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import {
+  BULK_CANCEL_PATH,
+  BULK_RESUME_PATH,
+  BULK_FORCE_CANCEL_PATH,
+} from './TasksTableConstants';
 import {
   TASKS_RESUME_REQUEST,
   TASKS_RESUME_SUCCESS,
@@ -9,16 +13,23 @@ import {
   TASKS_CANCEL_REQUEST,
   TASKS_CANCEL_SUCCESS,
   TASKS_CANCEL_FAILURE,
-  BULK_CANCEL_PATH,
-  BULK_RESUME_PATH,
-} from './TasksTableConstants';
+  TASKS_FORCE_CANCEL_REQUEST,
+  TASKS_FORCE_CANCEL_SUCCESS,
+  TASKS_FORCE_CANCEL_FAILURE,
+} from '../TaskActions/TaskActionsConstants';
 import { reloadPage } from './TasksTableActions';
 import {
   convertDashboardQuery,
   resumeToastInfo,
   cancelToastInfo,
   toastDispatch,
-} from './TasksTableActionHelpers';
+} from '../TaskActions/TaskActionHelpers';
+import {
+  successToastData,
+  errorToastData,
+  warningToastData,
+  infoToastData,
+} from '../common/ToastsHelpers';
 
 export const bulkByIdRequest = (resumeTasks, path) => {
   const ids = resumeTasks.map(task => task.id);
@@ -41,10 +52,9 @@ export const bulkBySearchRequest = ({ query, parentTaskID, path }) => {
 const handleErrorResume = (error, dispatch) => {
   dispatch({ type: TASKS_RESUME_FAILURE, error });
   dispatch(
-    addToast({
-      type: TOAST_TYPES.ERROR,
-      message: `${__(`Cannot resume tasks at the moment`)} ${error}`,
-    })
+    addToast(
+      errorToastData(`${__(`Cannot resume tasks at the moment`)} ${error}`)
+    )
   );
 };
 
@@ -53,13 +63,12 @@ export const bulkResumeById = ({
   url,
   parentTaskID,
 }) => async dispatch => {
-  const resumeTasks = selected.filter(task => task.isResumable);
+  const resumeTasks = selected.filter(task => task.isResumable && task.canEdit);
   if (resumeTasks.length < selected.length)
     dispatch(
-      addToast({
-        type: TOAST_TYPES.WARNING,
-        message: __('Not all the selected tasks can be resumed'),
-      })
+      addToast(
+        warningToastData(__('Not all the selected tasks can be resumed'))
+      )
     );
   if (resumeTasks.length) {
     dispatch({ type: TASKS_RESUME_REQUEST });
@@ -78,7 +87,7 @@ export const bulkResumeById = ({
           });
       });
       if (data.resumed) {
-        reloadPage(url, parentTaskID, dispatch);
+        reloadPage(url, parentTaskID)(dispatch);
       }
     } catch (error) {
       handleErrorResume(error, dispatch);
@@ -92,10 +101,9 @@ export const bulkResumeBySearch = ({
 }) => async dispatch => {
   dispatch({ type: TASKS_RESUME_REQUEST });
   dispatch(
-    addToast({
-      type: 'info',
-      message: __('Resuming selected tasks, this might take a while'),
-    })
+    addToast(
+      infoToastData(__('Resuming selected tasks, this might take a while'))
+    )
   );
   await bulkBySearchRequest({ query, path: BULK_RESUME_PATH, parentTaskID });
 };
@@ -103,10 +111,9 @@ export const bulkResumeBySearch = ({
 const handleErrorCancel = (error, dispatch) => {
   dispatch({ type: TASKS_CANCEL_FAILURE, error });
   dispatch(
-    addToast({
-      type: TOAST_TYPES.ERROR,
-      message: `${__(`Cannot cancel tasks at the moment`)} ${error}`,
-    })
+    addToast(
+      errorToastData(`${__(`Cannot cancel tasks at the moment`)} ${error}`)
+    )
   );
 };
 
@@ -116,10 +123,9 @@ export const bulkCancelBySearch = ({
 }) => async dispatch => {
   dispatch({ type: TASKS_CANCEL_REQUEST });
   dispatch(
-    addToast({
-      type: 'info',
-      message: __('Canceling selected tasks, this might take a while'),
-    })
+    addToast(
+      infoToastData(__('Canceling selected tasks, this might take a while'))
+    )
   );
   await bulkBySearchRequest({ query, path: BULK_CANCEL_PATH, parentTaskID });
 };
@@ -129,13 +135,14 @@ export const bulkCancelById = ({
   url,
   parentTaskID,
 }) => async dispatch => {
-  const cancelTasks = selected.filter(task => task.isCancellable);
+  const cancelTasks = selected.filter(
+    task => task.isCancellable && task.canEdit
+  );
   if (cancelTasks.length < selected.length)
     dispatch(
-      addToast({
-        type: TOAST_TYPES.WARNING,
-        message: __('Not all the selected tasks can be cancelled'),
-      })
+      addToast(
+        warningToastData(__('Not all the selected tasks can be cancelled'))
+      )
     );
   if (cancelTasks.length) {
     dispatch({ type: TASKS_CANCEL_REQUEST });
@@ -155,10 +162,103 @@ export const bulkCancelById = ({
           });
       });
       if (data.cancelled) {
-        reloadPage(url, parentTaskID, dispatch);
+        reloadPage(url, parentTaskID)(dispatch);
       }
     } catch (error) {
       handleErrorCancel(error, dispatch);
     }
   }
 };
+
+const handleErrorForceCancel = (error, dispatch) => {
+  dispatch({ type: TASKS_FORCE_CANCEL_FAILURE, error });
+  dispatch(
+    addToast(
+      errorToastData(
+        `${__(`Cannot force cancel tasks at the moment`)} ${error}`
+      )
+    )
+  );
+};
+
+export const bulkForceCancelById = ({
+  selected,
+  url,
+  parentTaskID,
+}) => async dispatch => {
+  const stopTasks = selected.filter(task => task.state !== 'stopped');
+  const authorisedTasks = stopTasks.filter(task => task.canEdit);
+  if (authorisedTasks.length < stopTasks.length)
+    dispatch(
+      addToast(
+        warningToastData(
+          sprintf(
+            'User has no permission for %s task(s)',
+            stopTasks.length - authorisedTasks.length
+          )
+        )
+      )
+    );
+  if (stopTasks.length < selected.length)
+    dispatch(
+      addToast(
+        warningToastData(
+          sprintf(
+            '%s task(s) are already stopped',
+            selected.length - stopTasks.length
+          )
+        )
+      )
+    );
+  if (authorisedTasks.length > 0) {
+    dispatch({ type: TASKS_FORCE_CANCEL_REQUEST });
+    try {
+      const { data } = await bulkByIdRequest(
+        authorisedTasks,
+        BULK_FORCE_CANCEL_PATH
+      );
+      dispatch({ type: TASKS_FORCE_CANCEL_SUCCESS });
+      if (data.stopped_length) {
+        dispatch(
+          addToast(
+            successToastData(
+              sprintf('%s task(s) cancelled with force', data.stopped_length)
+            )
+          )
+        );
+      }
+      if (data.skipped_length > 0)
+        dispatch(
+          addToast(
+            warningToastData(
+              sprintf('%s task(s) are already stopped', data.skipped_length)
+            )
+          )
+        );
+      if (data.stopped_length > 0) {
+        reloadPage(url, parentTaskID)(dispatch);
+      }
+    } catch (error) {
+      handleErrorForceCancel(error, dispatch);
+    }
+  }
+};
+
+export const bulkForceCancelBySearch = ({
+  query,
+  parentTaskID,
+}) => async dispatch => {
+  dispatch({ type: TASKS_FORCE_CANCEL_REQUEST });
+  dispatch(
+    addToast(
+      infoToastData(
+        __('Canceling with force selected tasks, this might take a while')
+      )
+    )
+  );
+  await bulkBySearchRequest({
+    query,
+    path: BULK_FORCE_CANCEL_PATH,
+    parentTaskID,
+  });
+};