katello 3.15.0.rc1.3 → 3.15.0.rc2

data/webpack/scenes/Subscriptions/__tests__/__snapshots__/SubscriptionsSelectors.test.js.snap

@@ -6,24 +6,14 @@ exports[`Subscriptions selectors should select delete-modal-opened 1`] = `false`
 
 exports[`Subscriptions selectors should select search-query 1`] = `"some-query"`;
 
-exports[`Subscriptions selectors should select subscriptions tasks 1`] = `
-Array [
-  "task1",
-  "task2",
-]
-`;
-
-exports[`Subscriptions selectors should select task-modal-opened 1`] = `false`;
+exports[`Subscriptions selectors should select subscriptions task 1`] = `Object {}`;
 
 exports[`Subscriptions selectors should select the subscriptions state 1`] = `
 Object {
   "deleteButtonDisabled": true,
   "deleteModalOpened": false,
   "searchQuery": "some-query",
+  "task": Object {},
   "taskModalOpened": false,
-  "tasks": Array [
-    "task1",
-    "task2",
-  ],
 }
 `;

data/webpack/scenes/Subscriptions/__tests__/subscriptions.fixtures.js

@@ -11,7 +11,7 @@ export const initialState = Immutable({
   itemCount: 0,
   quantitiesLoading: false,
   availableQuantities: null,
-  tasks: [],
+  task: undefined,
   tableColumns: [],
   selectedTableColumns: [],
 });
@@ -248,7 +248,6 @@ export const groupedSubscriptions = Immutable({
   itemCount: 81,
   quantitiesLoading: false,
   availableQuantities: null,
-  tasks: [],
   tableColumns: [],
   selectedTableColumns: [],
 });
@@ -318,7 +317,6 @@ export const successState = Immutable({
   itemCount: 81,
   quantitiesLoading: false,
   availableQuantities: null,
-  tasks: [],
   tableColumns: [],
   selectedTableColumns: [],
 });
@@ -335,7 +333,6 @@ export const permissionDeniedState = Immutable({
   itemCount: 0,
   quantitiesLoading: false,
   availableQuantities: null,
-  tasks: [],
   tableColumns: [],
   selectedTableColumns: [],
 });
@@ -366,7 +363,6 @@ export const errorState = Immutable({
   results: [],
   quantitiesLoading: false,
   availableQuantities: null,
-  tasks: [],
   tableColumns: [],
   selectedTableColumns: [],
 });
@@ -436,18 +432,16 @@ export const poolsUpdate = [{
 export const updateQuantitySuccessActions = [
   {
     type: 'UPDATE_QUANTITY_REQUEST',
-    quantities: poolsUpdate,
   },
   {
-    response: requestSuccessResponse,
     type: 'UPDATE_QUANTITY_SUCCESS',
+    response: requestSuccessResponse,
   },
 ];
 
 export const updateQuantityFailureActions = [
   {
     type: 'UPDATE_QUANTITY_REQUEST',
-    quantities: poolsUpdate,
   },
   failureAction('UPDATE_QUANTITY_FAILURE'),
   toastErrorAction(),

data/webpack/scenes/Subscriptions/components/SubscriptionsTable/SubscriptionsTable.js

@@ -128,16 +128,12 @@ class SubscriptionsTable extends Component {
   getUpdateDialogProps = () => {
     const { showUpdateConfirmDialog: show, updatedQuantity } = this.state;
     const {
-      updateQuantity, bulkSearch, organization, task,
+      updateQuantity,
     } = this.props;
     return {
-      bulkSearch,
-      organization,
       show,
-      task,
       updatedQuantity,
       updateQuantity,
-      confirmEdit: this.confirmEdit,
       enableEditing: this.enableEditing,
       showUpdateConfirm: this.showUpdateConfirm,
     };
@@ -198,7 +194,6 @@ class SubscriptionsTable extends Component {
 
     groupedSubscriptions[groupId].open = !open;
 
-
     const rows = buildTableRows(
       groupedSubscriptions,
       subscriptions.availableQuantities,
@@ -287,21 +282,11 @@ SubscriptionsTable.propTypes = {
   onDeleteSubscriptions: PropTypes.func.isRequired,
   onSubscriptionDeleteModalClose: PropTypes.func.isRequired,
   toggleDeleteButton: PropTypes.func.isRequired,
-  task: PropTypes.shape({}),
-  bulkSearch: PropTypes.func,
-  organization: PropTypes.shape({
-    owner_details: PropTypes.shape({
-      displayName: PropTypes.string,
-    }),
-  }),
   selectedRows: PropTypes.instanceOf(Array).isRequired,
   onSelectedRowsChange: PropTypes.func.isRequired,
 };
 
 SubscriptionsTable.defaultProps = {
-  task: { humanized: {} },
-  bulkSearch: undefined,
-  organization: undefined,
   canManageSubscriptionAllocations: false,
 };
 

data/webpack/scenes/Subscriptions/components/SubscriptionsTable/__tests__/__snapshots__/SubscriptionsTable.test.js.snap

@@ -23,7 +23,7 @@ exports[`subscriptions table should render a loading state 1`] = `
       "results": Array [],
       "selectedTableColumns": Array [],
       "tableColumns": Array [],
-      "tasks": Array [],
+      "task": undefined,
     }
   }
   tableColumns={
@@ -35,11 +35,6 @@ exports[`subscriptions table should render a loading state 1`] = `
       "end_date",
     ]
   }
-  task={
-    Object {
-      "humanized": Object {},
-    }
-  }
   toggleDeleteButton={[Function]}
   updateQuantity={[Function]}
 >

data/webpack/scenes/Subscriptions/components/SubscriptionsTable/components/Dialogs/UpdateDialog.js

@@ -3,17 +3,12 @@ import PropTypes from 'prop-types';
 import { sprintf, translate as __ } from 'foremanReact/common/I18n';
 import { MessageDialog } from 'patternfly-react';
 import { buildPools } from '../../SubscriptionsTableHelpers';
-import { renderTaskStartedToast } from '../../../../../Tasks/helpers';
-import { BLOCKING_FOREMAN_TASK_TYPES } from '../../../../SubscriptionConstants';
 
 const UpdateDialog = ({
   show,
   updatedQuantity,
   updateQuantity,
   showUpdateConfirm,
-  bulkSearch,
-  organization,
-  task,
   enableEditing,
 }) => {
   const quantityLength = Object.keys(updatedQuantity).length;
@@ -21,12 +16,6 @@ const UpdateDialog = ({
     showUpdateConfirm(false);
     if (quantityLength > 0) {
       await updateQuantity(buildPools(updatedQuantity));
-      await bulkSearch({
-        action: `organization '${organization.owner_details.displayName}'`,
-        result: 'pending',
-        label: BLOCKING_FOREMAN_TASK_TYPES.join(' or '),
-      });
-      renderTaskStartedToast(task);
     }
     enableEditing(false);
   };
@@ -60,21 +49,7 @@ UpdateDialog.propTypes = {
   updateQuantity: PropTypes.func.isRequired,
   updatedQuantity: PropTypes.shape(PropTypes.Object).isRequired,
   showUpdateConfirm: PropTypes.func.isRequired,
-  bulkSearch: PropTypes.func,
-  organization: PropTypes.shape({
-    owner_details: PropTypes.shape({
-      displayName: PropTypes.string,
-    }),
-  }),
-  task: PropTypes.shape({}),
   enableEditing: PropTypes.func.isRequired,
 };
 
-UpdateDialog.defaultProps = {
-  task: { humanized: {} },
-  bulkSearch: undefined,
-  organization: undefined,
-};
-
-
 export default UpdateDialog;

data/webpack/scenes/Subscriptions/index.js

@@ -11,9 +11,8 @@ import {
   selectSubscriptionsState,
   selectSearchQuery,
   selectDeleteModalOpened,
-  selectTaskModalOpened,
   selectDeleteButtonDisabled,
-  selectSubscriptionsTasks,
+  selectSubscriptionsTask,
   selectActivePermissions,
   selectTableSettings,
 } from './SubscriptionsSelectors';
@@ -33,13 +32,11 @@ const mapStateToProps = (state) => {
     subscriptionTableSettings,
     activePermissions: selectActivePermissions(state),
     simpleContentAccess: selectSimpleContentAccessEnabled(state),
-    tasks: selectSubscriptionsTasks(state),
+    task: selectSubscriptionsTask(state),
     searchQuery: selectSearchQuery(state),
     deleteModalOpened: selectDeleteModalOpened(state),
-    taskModalOpened: selectTaskModalOpened(state),
     deleteButtonDisabled: selectDeleteButtonDisabled(state),
     organization: state.katello.organization,
-    taskDetails: state.katello.manifestHistory.taskDetails,
   };
 };
 

data/webpack/scenes/Tasks/TaskActions.js

@@ -1,111 +1,41 @@
+import { addToast } from 'foremanReact/redux/actions/toasts';
 import { propsToSnakeCase } from 'foremanReact/common/helpers';
+import { get } from 'foremanReact/redux/API';
+import { stopInterval, withInterval } from 'foremanReact/redux/middlewares/IntervalMiddleware';
+import { foremanTasksApi } from '../../services/api';
+import { bulkSearchKey, pollTaskKey, taskFinishedToast } from './helpers';
+
+export const toastTaskFinished = task => async dispatch =>
+  dispatch(addToast(taskFinishedToast(task)));
+
+const taskBulkSearchParams = params => ({
+  search: Object.entries(propsToSnakeCase(params))
+    .map((item) => {
+      if (item[0] === 'action') {
+        return `${item[0]}~${item[1]}`;
+      }
+      return `${item[0]}=${item[1]}`;
+    })
+    .join(' and '),
+});
 
-import { foremanTasksApi as api } from '../../services/api';
-import {
-  GET_TASK_REQUEST,
-  GET_TASK_SUCCESS,
-  GET_TASK_FAILURE,
-  TASK_BULK_SEARCH_REQUEST,
-  TASK_BULK_SEARCH_SUCCESS,
-  TASK_BULK_SEARCH_FAILURE,
-  RESET_TASKS,
-} from './TaskConstants';
-
-export const bulkSearch = (extendedParams = {}) => async (dispatch) => {
-  const params = {
-    search: Object.entries(propsToSnakeCase(extendedParams))
-      .map((item) => {
-        if (item[0] === 'action') {
-          return `${item[0]}~${item[1]}`;
-        }
-        return `${item[0]}=${item[1]}`;
-      })
-      .join(' and '),
-  };
-
-  dispatch({ type: TASK_BULK_SEARCH_REQUEST });
-
-  try {
-    const { data } = await api.get('/tasks', {}, params);
-    return dispatch({
-      type: TASK_BULK_SEARCH_SUCCESS,
-      response: data,
-    });
-  } catch (error) {
-    return dispatch({
-      type: TASK_BULK_SEARCH_FAILURE,
-      result: error,
-    });
-  }
-};
-
-export const resetTasks = () => (dispatch) => {
-  dispatch({
-    type: RESET_TASKS,
-  });
-};
-
-export const loadTask = (taskId, extendedParams = {}) => async (dispatch) => {
-  dispatch({ type: GET_TASK_REQUEST });
-
-  const params = {
-    ...propsToSnakeCase(extendedParams),
-  };
-
-  try {
-    const { data } = await api.get(`/tasks/${taskId}`, {}, params);
-    return dispatch({
-      type: GET_TASK_SUCCESS,
-      response: data,
-    });
-  } catch (error) {
-    return dispatch({
-      type: GET_TASK_FAILURE,
-      result: error,
-    });
-  }
-};
+const getTasks = (key, params = {}) => get({
+  key,
+  url: `${foremanTasksApi.baseApiPath}/tasks`,
+  params: taskBulkSearchParams(params),
+});
 
-const isUnauthorized = (action = {}) => (action.result
-    && action.result
-    && action.result.response
-    && action.result.response.status === 401);
+export const startPollingTasks = (key, taskSearchParams = {}) =>
+  withInterval(getTasks(bulkSearchKey(key), taskSearchParams));
 
+export const stopPollingTasks = key => stopInterval(bulkSearchKey(key));
 
-export const pollBulkSearch = (extendedParams = {}, interval, orgId) =>
-  async (dispatch, getState) => {
-    const triggerPolling = (action) => {
-      const { id } = getState().katello.organization;
-      if (!isUnauthorized(action)) {
-        if (id === orgId) {
-          setTimeout(() => dispatch(pollBulkSearch(extendedParams, interval, orgId)), interval);
-        }
-      }
-    };
-    const { id, loading } = getState().katello.organization;
-    if (id === orgId && !loading) {
-      const dispatchedAction = await dispatch(await bulkSearch(extendedParams));
-      triggerPolling(dispatchedAction);
-      return dispatchedAction;
-    }
+const getTask = (key, task) => get({
+  key,
+  url: `${foremanTasksApi.baseApiPath}/tasks/${task.id}`,
+});
 
-    return dispatch({ type: 'POLLING_IS_SKIPPED' });
-  };
+export const startPollingTask = (key, task) =>
+  withInterval(getTask(pollTaskKey(key), task));
 
-export const pollTaskUntilDone = (taskId, extendedParams = {}, interval, orgId) =>
-  (dispatch, getState) => new Promise((resolve, reject) => {
-    const pollUntilDone = (action) => {
-      const { id, loading } = getState().katello.organization;
-
-      if (isUnauthorized(action) || id !== orgId || loading) {
-        reject(action.result);
-      } else if (action.response && action.response.pending) {
-        // eslint-disable-next-line promise/prefer-await-to-then
-        setTimeout(() => dispatch(loadTask(taskId, extendedParams)).then(pollUntilDone), interval);
-      } else {
-        resolve(action.response);
-      }
-    };
-    // eslint-disable-next-line promise/prefer-await-to-then
-    return dispatch(loadTask(taskId, extendedParams)).then(pollUntilDone);
-  });
+export const stopPollingTask = key => stopInterval(pollTaskKey(key));

data/webpack/scenes/Tasks/TaskSelectors.js

@@ -0,0 +1,7 @@
+import { selectDoesIntervalExist } from 'foremanReact/redux/middlewares/IntervalMiddleware/IntervalSelectors';
+import { bulkSearchKey, pollTaskKey } from './helpers';
+
+export const selectIsPollingTask = (state, key) => selectDoesIntervalExist(state, pollTaskKey(key));
+
+export const selectIsPollingTasks = (state, key) =>
+  selectDoesIntervalExist(state, bulkSearchKey(key));

data/webpack/scenes/Tasks/__tests__/TaskActions.test.js

@@ -1,155 +1,18 @@
-import axios from 'axios';
-import MockAdapter from 'axios-mock-adapter';
-import thunk from 'redux-thunk';
-import Immutable from 'seamless-immutable';
-import configureMockStore from 'redux-mock-store';
-import {
-  bulkSearchSuccessResponse,
-  bulkSearchSuccessActions,
-  buildBulkSearchFailureActions,
-  getTaskSuccessResponse,
-  getTaskSuccessActions,
-  buildTaskFailureActions,
-  getTaskPendingResponse,
-  getTaskPendingActions,
-} from './task.fixtures';
-
-import { bulkSearch, loadTask, pollTaskUntilDone, pollBulkSearch } from '../TaskActions';
-
-const mockStore = configureMockStore([thunk]);
-const store = mockStore({
-  tasks: Immutable({}),
-  katello: { organization: { id: 1, loading: false } },
-});
-const mockApi = new MockAdapter(axios);
-
-beforeEach(() => {
-  store.clearActions();
-  mockApi.reset();
-});
-
-let originalTimeout;
-let setTimeoutSpy;
-
-beforeEach(() => {
-  setTimeoutSpy = jest.spyOn(window, 'setTimeout');
-
-  originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
-  jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
-});
-
-afterEach(() => {
-  setTimeoutSpy.mockReset();
-  setTimeoutSpy.mockRestore();
-
-  jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
-});
-
-describe('task actions', () => {
-  describe('creates TASK_BULK_SEARCH_REQUEST', () => {
-    const url = '/foreman_tasks/api/tasks';
-
-    it('and then fails with 422', async () => {
-      mockApi.onGet(url).reply(422);
-
-      await store.dispatch(bulkSearch());
-      expect(store.getActions()).toEqual(buildBulkSearchFailureActions());
-    });
-
-    it('and ends with success', async () => {
-      mockApi.onGet(url).reply(200, bulkSearchSuccessResponse);
-
-      await store.dispatch(bulkSearch());
-      expect(store.getActions()).toEqual(bulkSearchSuccessActions);
-    });
-  });
-
-  describe('creates GET_TASK_REQUEST', () => {
-    const taskId = 'eb1b6271-8a69-4d98-84fc-bea06ddcc166';
-    const url = `/foreman_tasks/api/tasks/${taskId}`;
-
-    it('and then fails with 422', async () => {
-      mockApi.onGet(url).reply(422);
-
-      await store.dispatch(loadTask(taskId));
-      expect(store.getActions()).toEqual(buildTaskFailureActions());
-    });
+import { testActionSnapshotWithFixtures } from 'react-redux-test-utils';
+import { getTaskSuccessResponse } from './task.fixtures';
 
-    it('and ends with success', async () => {
-      mockApi.onGet(url).reply(200, getTaskSuccessResponse);
-
-      await store.dispatch(loadTask(taskId));
-      expect(store.getActions()).toEqual(getTaskSuccessActions);
-    });
-  });
-
-  describe('pollTaskUntilDone', () => {
-    const taskId = 'eb1b6271-8a69-4d98-84fc-bea06ddcc166';
-    const url = `/foreman_tasks/api/tasks/${taskId}`;
-
-    it("doesn't start polling when the task has finished", async () => {
-      mockApi.onGet(url).replyOnce(200, getTaskSuccessResponse);
-
-      await store.dispatch(pollTaskUntilDone(taskId, {}, 1, 1));
-      expect(store.getActions()).toEqual(getTaskSuccessActions);
-      expect(setTimeoutSpy).toHaveBeenCalledTimes(0);
-    });
-
-    it('polls until a task is done', async () => {
-      mockApi
-        .onGet(url)
-        .replyOnce(200, getTaskPendingResponse)
-        .onGet(url)
-        .replyOnce(200, getTaskPendingResponse)
-        .onGet(url)
-        .replyOnce(200, getTaskSuccessResponse);
-
-      const expectedActions = getTaskPendingActions
-        .concat(getTaskPendingActions)
-        .concat(getTaskSuccessActions);
-
-      await store.dispatch(pollTaskUntilDone(taskId, {}, 1, 1));
-      expect(store.getActions()).toEqual(expectedActions);
-      expect(setTimeoutSpy).toHaveBeenCalledTimes(2);
-    });
-
-    it('stops polling on unauthorized response', async () => {
-      mockApi
-        .onGet(url).replyOnce(200, getTaskPendingResponse)
-        .onGet(url).replyOnce(401);
-
-      const expectedActions = getTaskPendingActions
-        .concat(buildTaskFailureActions(401));
-
-      try {
-        await store.dispatch(pollTaskUntilDone(taskId, {}, 1, 1));
-      } catch (e) {
-        expect(store.getActions()).toEqual(expectedActions);
-        expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
-      }
-    });
-  });
-
-  describe('pollBulkSearch', () => {
-    const url = '/foreman_tasks/api/tasks';
-
-    it('polls', async () => {
-      mockApi
-        .onGet(url)
-        .replyOnce(200, bulkSearchSuccessResponse);
-
-      await store.dispatch(pollBulkSearch({}, 1, 1));
-      expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
-      expect(store.getActions()).toEqual(bulkSearchSuccessActions);
-    });
-
-    it('stops polling on unauthorized response', async () => {
-      mockApi
-        .onGet(url).replyOnce(401);
-
-      await store.dispatch(pollBulkSearch({}, 1, 1));
-      expect(store.getActions()).toEqual(buildBulkSearchFailureActions(401));
-      expect(setTimeoutSpy).toHaveBeenCalledTimes(0);
-    });
-  });
-});
+import {
+  startPollingTask,
+  stopPollingTask,
+  startPollingTasks,
+  stopPollingTasks,
+  toastTaskFinished,
+} from '../TaskActions';
+
+describe('task actions', () => testActionSnapshotWithFixtures({
+  'can search tasks': () => startPollingTasks('TEST'),
+  'can stop searching tasks': () => stopPollingTasks('TEST'),
+  'can poll a task': () => startPollingTask('TEST', { id: '12345' }),
+  'can stop polling a task': () => stopPollingTask('TEST'),
+  'can toast a finished task': () => toastTaskFinished(getTaskSuccessResponse),
+}));