katello 3.7.0.rc2 → 3.7.0

data/webpack/scenes/Subscriptions/UpstreamSubscriptions/UpstreamSubscriptionsReducer.js

@@ -38,7 +38,7 @@ export default (state = initialState, action) => {
 
     case UPSTREAM_SUBSCRIPTIONS_FAILURE:
       return state.merge({
-        error: action.error,
+        error: action.payload.message,
         loading: false,
       });
 
@@ -49,8 +49,7 @@ export default (state = initialState, action) => {
       return state.set('task', action.response).set('loading', false);
 
     case SAVE_UPSTREAM_SUBSCRIPTIONS_FAILURE: {
-      const error = action.result.response.data;
-      return state.set('error', error).set('loading', false);
+      return state.set('error', action.payload.message).set('loading', false);
     }
 
     default:

data/webpack/scenes/Subscriptions/UpstreamSubscriptions/UpstreamSubscriptionsTableSchema.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { FormGroup, FormControl, ControlLabel } from 'react-bootstrap';
+import { FormGroup, FormControl, ControlLabel, HelpBlock } from 'react-bootstrap';
 import helpers from '../../../move_to_foreman/common/helpers';
 import {
   headerFormatter,
@@ -71,7 +71,7 @@ export const columns = (controller, selectionController) => [
     },
   },
   {
-    property: 'quantity',
+    property: 'available',
     header: {
       label: __('Available Entitlements'),
       formatters: [headerFormatter],
@@ -96,22 +96,27 @@ export const columns = (controller, selectionController) => [
       formatters: [
         (value, { rowData }) => (
           <td>
-            <FormGroup>
+            <FormGroup
+              validationState={controller.quantityValidationInput(rowData)}
+            >
               <ControlLabel srOnly>{__('Number to Allocate')}</ControlLabel>
               <FormControl
                 type="text"
                 onBlur={e => controller.onChange(e.target.value, rowData)}
                 defaultValue={rowData.updatedQuantity}
+                onChange={(e) => {
+                  controller.onChange(e.target.value, rowData);
+                }}
                 onKeyDown={(e) => {
                   const key = e.charCode ? e.charCode : e.keyCode;
                   if (key === 13) {
-                    controller.onChange(e.target.value, rowData);
                     controller.saveUpstreamSubscriptions();
                     e.preventDefault();
                   }
                 }}
               />
-              <div>{__('Max')} {rowData.quantity}</div>
+              {controller.quantityValidationInput(rowData) === 'error' &&
+                <HelpBlock>{controller.quantityValidation(rowData)[1]}</HelpBlock>}
             </FormGroup>
           </td>
         ),

data/webpack/scenes/Subscriptions/UpstreamSubscriptions/__tests__/UpstreamSubscriptionsActions.test.js

@@ -1,5 +1,3 @@
-import axios from 'axios';
-import MockAdapter from 'axios-mock-adapter';
 import configureMockStore from 'redux-mock-store';
 import thunk from 'redux-thunk';
 import Immutable from 'seamless-immutable';
@@ -13,10 +11,10 @@ import {
 import { getTaskSuccessResponse } from '../../../Tasks/__tests__/task.fixtures';
 
 import { loadUpstreamSubscriptions, saveUpstreamSubscriptions } from '../UpstreamSubscriptionsActions';
+import { mock as mockApi, mockErrorRequest } from '../../../../mockRequest';
 
 const mockStore = configureMockStore([thunk]);
 const store = mockStore({ subscriptions: Immutable({}) });
-const mockApi = new MockAdapter(axios);
 
 afterEach(() => {
   store.clearActions();
@@ -28,7 +26,10 @@ describe('upstream subscription actions', () => {
 
   describe('creates UPSTREAM_SUBSCRIPTIONS_REQUEST', () => {
     it('and then fails with 422', () => {
-      mockApi.onGet(url).reply(422);
+      mockErrorRequest({
+        url,
+        status: 422,
+      });
 
       return store.dispatch(loadUpstreamSubscriptions())
         .then(() => expect(store.getActions()).toEqual(getFailureActions));
@@ -48,7 +49,11 @@ describe('upstream subscription actions', () => {
     };
 
     it('and then fails with 422', () => {
-      mockApi.onPost(url).reply(422);
+      mockErrorRequest({
+        url,
+        status: 422,
+        method: 'POST',
+      });
 
       return store.dispatch(saveUpstreamSubscriptions(subscriptionData))
         .then(() => expect(store.getActions()).toEqual(saveFailureActions));

data/webpack/scenes/Subscriptions/UpstreamSubscriptions/__tests__/UpstreamSubscriptionsPage.test.js

@@ -6,17 +6,62 @@ import { successState } from './upstreamSubscriptions.fixtures';
 import { loadUpstreamSubscriptions, saveUpstreamSubscriptions } from '../UpstreamSubscriptionsActions';
 
 jest.mock('../../../../move_to_foreman/foreman_toast_notifications');
+jest.mock('foremanReact/components/BreadcrumbBar');
 
 describe('upstream subscriptions page', () => {
-  const mockHistory = { push: () => {} };
-
-  it('should render', async () => {
-    const page = shallow(<UpstreamSubscriptionsPage
+  let shallowWrapper;
+  beforeEach(() => {
+    shallowWrapper = shallow(<UpstreamSubscriptionsPage
       upstreamSubscriptions={successState}
       loadUpstreamSubscriptions={loadUpstreamSubscriptions}
       saveUpstreamSubscriptions={saveUpstreamSubscriptions}
       history={mockHistory}
     />);
-    expect(toJson(page)).toMatchSnapshot();
+  });
+  const mockHistory = { push: () => {} };
+
+  it('should render', async () => {
+    expect(toJson(shallowWrapper)).toMatchSnapshot();
+  });
+
+  it('should validate correct subscription quantities', async () => {
+    const validPools = [
+      { available: 10, updatedQuantity: 5 },
+      { available: 10, updatedQuantity: '5' },
+      { available: 10, updatedQuantity: '10' },
+      { available: 10, updatedQuantity: '1' },
+      { available: -1, updatedQuantity: '1000' },
+    ];
+    validPools.forEach((pool, i) => {
+      // using object with index attribute to print out index on failure,
+      // jest doesn't support messages on failure :(
+      const result = shallowWrapper.instance().quantityValidation(pool)[0];
+      expect({ index: i, result }).toEqual({ index: i, result: true });
+    });
+  });
+
+  it('should invalidate incorrect subscription quantities', async () => {
+    const invalidPools = [
+      { available: 10, updatedQuantity: 11 },
+      { available: 10, updatedQuantity: 'foo' },
+      { available: 10, updatedQuantity: 0 },
+      { available: 10, updatedQuantity: '0' },
+      { available: 10, updatedQuantity: '11' },
+      { available: 10, updatedQuantity: '2.0' },
+      { available: 10, updatedQuantity: '2/3' },
+      { available: -1, updatedQuantity: '-1' },
+      { available: -1, updatedQuantity: '0' },
+      { available: -1, updatedQuantity: 'foo' },
+      { available: -1, updatedQuantity: '2/3' },
+      { available: -1, updatedQuantity: '2.0' },
+      { available: -1, updatedQuantity: '99999999999' },
+    ];
+
+    invalidPools.forEach((pool, i) => {
+      // using object with index attribute to print out index on failure,
+      // jest doesn't support messages on failure :(
+      const result = shallowWrapper.instance().quantityValidation(pool)[0];
+      expect({ index: i, result }).toEqual({ index: i, result: false });
+    });
   });
 });

data/webpack/scenes/Subscriptions/UpstreamSubscriptions/__tests__/UpstreamSubscriptionsReducer.test.js

@@ -37,7 +37,9 @@ describe('upstream subscriptions reducer', () => {
   it('should have error on UPSTREAM_SUBSCRIPTIONS_FAILURE', () => {
     expect(reducer(initialState, {
       type: types.UPSTREAM_SUBSCRIPTIONS_FAILURE,
-      error: 'Unable to process request.',
+      payload: {
+        message: 'Unable to process request.',
+      },
     })).toEqual(errorState);
   });
 
@@ -48,10 +50,13 @@ describe('upstream subscriptions reducer', () => {
     })).toEqual(saveSuccessState);
   });
 
-  it('should have error on SAVE_UPSTREAM_SUBSCRIPTIONS_SUCCESS', () => {
+  it('should have error on SAVE_UPSTREAM_SUBSCRIPTIONS_FAILURE', () => {
     expect(reducer(initialSaveState, {
       type: types.SAVE_UPSTREAM_SUBSCRIPTIONS_FAILURE,
-      result: errorResult,
+      payload: {
+        message: 'Unable to process request.',
+        result: errorResult,
+      },
     })).toEqual(saveErrorState);
   });
 });

data/webpack/scenes/Subscriptions/UpstreamSubscriptions/__tests__/__snapshots__/UpstreamSubscriptionsPage.test.js.snap

@@ -6,9 +6,22 @@ exports[`upstream subscriptions page should render 1`] = `
   componentClass="div"
   fluid={false}
 >
-  <h1>
-    Add Subscriptions
-  </h1>
+  <BreadcrumbsBar
+    data={
+      Object {
+        "breadcrumbItems": Array [
+          Object {
+            "caption": "Subscriptions",
+            "onClick": [Function],
+          },
+          Object {
+            "caption": "Add Subscriptions",
+          },
+        ],
+        "isSwitchable": false,
+      }
+    }
+  />
   <LoadingState
     loading={false}
     loadingText="Loading"
@@ -107,7 +120,7 @@ exports[`upstream subscriptions page should render 1`] = `
                   ],
                   "label": "Available Entitlements",
                 },
-                "property": "quantity",
+                "property": "available",
               },
               Object {
                 "cell": Object {
@@ -193,7 +206,7 @@ exports[`upstream subscriptions page should render 1`] = `
           block={false}
           bsClass="btn"
           bsStyle="primary"
-          disabled={false}
+          disabled={true}
           onClick={[Function]}
           type="submit"
         >

data/webpack/scenes/Subscriptions/UpstreamSubscriptions/__tests__/upstreamSubscriptions.fixtures.js

@@ -1,5 +1,6 @@
 import Immutable from 'seamless-immutable';
 import { getTaskSuccessResponse } from '../../../Tasks/__tests__/task.fixtures';
+import { toastErrorAction, failureAction } from '../../../../services/api/testHelpers';
 
 export const initialState = Immutable({
   loading: true,
@@ -135,10 +136,8 @@ export const getFailureActions = [
   {
     type: 'UPSTREAM_SUBSCRIPTIONS_REQUEST',
   },
-  {
-    result: new Error('Request failed with status code 422'),
-    type: 'UPSTREAM_SUBSCRIPTIONS_FAILURE',
-  },
+  failureAction('UPSTREAM_SUBSCRIPTIONS_FAILURE'),
+  toastErrorAction(),
 ];
 
 export const saveSuccessActions = [
@@ -155,8 +154,6 @@ export const saveFailureActions = [
   {
     type: 'SAVE_UPSTREAM_SUBSCRIPTIONS_REQUEST',
   },
-  {
-    result: new Error('Request failed with status code 422'),
-    type: 'SAVE_UPSTREAM_SUBSCRIPTIONS_FAILURE',
-  },
+  failureAction('SAVE_UPSTREAM_SUBSCRIPTIONS_FAILURE'),
+  toastErrorAction(),
 ];

data/webpack/scenes/Subscriptions/__tests__/SubscriptionsReducer.test.js

@@ -34,14 +34,18 @@ describe('subscriptions reducer', () => {
   it('should have error on SUBSCRIPTIONS_FAILURE', () => {
     expect(reducer(initialState, {
       type: types.SUBSCRIPTIONS_FAILURE,
-      error: 'Unable to process request.',
+      payload: {
+        message: 'Unable to process request.',
+      },
     })).toEqual(errorState);
   });
 
   it('should have error on UPDATE_QUANTITY_FAILURE', () => {
     expect(reducer(initialState, {
       type: types.UPDATE_QUANTITY_FAILURE,
-      error: 'Unable to process request.',
+      payload: {
+        message: 'Unable to process request.',
+      },
     })).toEqual(errorState);
   });
 
@@ -61,7 +65,9 @@ describe('subscriptions reducer', () => {
   it('should have error on SUBSCRIPTIONS_QUANTITIES_FAILURE', () => {
     expect(reducer(successState, {
       type: types.SUBSCRIPTIONS_QUANTITIES_FAILURE,
-      error: 'Unable to process request.',
+      payload: {
+        message: 'Unable to process request.',
+      },
     })).toEqual(quantitiesErrorState);
   });
 });

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

@@ -181,6 +181,7 @@ exports[`subscriptions page should render 1`] = `
               ],
               "search": undefined,
               "searchIsActive": false,
+              "tasks": Array [],
             }
           }
           toggleDeleteButton={[Function]}

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

@@ -1,4 +1,5 @@
 import Immutable from 'seamless-immutable';
+import { toastErrorAction, failureAction } from '../../../services/api/testHelpers';
 
 export const initialState = Immutable({
   loading: true,
@@ -10,6 +11,7 @@ export const initialState = Immutable({
   itemCount: 0,
   quantitiesLoading: false,
   availableQuantities: {},
+  tasks: [],
 });
 
 export const loadingState = Immutable({
@@ -242,11 +244,11 @@ export const successState = Immutable({
   itemCount: 81,
   quantitiesLoading: false,
   availableQuantities: {},
+  tasks: [],
 });
 
 export const errorState = Immutable({
   loading: false,
-  error: 'Unable to process request.',
   pagination: {
     page: 0,
     perPage: 20,
@@ -255,6 +257,7 @@ export const errorState = Immutable({
   results: [],
   quantitiesLoading: false,
   availableQuantities: {},
+  tasks: [],
 });
 
 export const quantitiesSuccessState = Immutable({
@@ -275,7 +278,6 @@ export const loadingQuantitiesState = Immutable({
 export const quantitiesErrorState = Immutable({
   ...successState,
   quantitiesLoading: false,
-  quantitiesError: 'Unable to process request.',
 });
 
 export const successActions = [
@@ -307,10 +309,8 @@ export const failureActions = [
   {
     type: 'SUBSCRIPTIONS_REQUEST',
   },
-  {
-    error: 'Request failed with status code 422',
-    type: 'SUBSCRIPTIONS_FAILURE',
-  },
+  failureAction('SUBSCRIPTIONS_FAILURE'),
+  toastErrorAction(),
 ];
 
 export const poolsUpdate = [{
@@ -337,20 +337,16 @@ export const updateQuantityFailureActions = [
     type: 'UPDATE_QUANTITY_REQUEST',
     quantities: poolsUpdate,
   },
-  {
-    error: 'Request failed with status code 422',
-    type: 'UPDATE_QUANTITY_FAILURE',
-  },
+  failureAction('UPDATE_QUANTITY_FAILURE'),
+  toastErrorAction(),
 ];
 
 export const loadQuantitiesFailureActions = [
   {
     type: 'SUBSCRIPTIONS_QUANTITIES_REQUEST',
   },
-  {
-    error: 'Request failed with status code 500',
-    type: 'SUBSCRIPTIONS_QUANTITIES_FAILURE',
-  },
+  failureAction('SUBSCRIPTIONS_QUANTITIES_FAILURE', 'Request failed with status code 500'),
+  toastErrorAction('Request failed with status code 500'),
 ];
 
 export const loadQuantitiesSuccessActions = [

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

@@ -3,7 +3,7 @@ import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import { sprintf } from 'jed';
 import { cloneDeep, findIndex, isEqual } from 'lodash';
-import { Table, Alert } from 'patternfly-react';
+import { Table } from 'patternfly-react';
 import { LoadingState } from '../../../../move_to_pf/LoadingState';
 import { Table as ForemanTable, TableBody as ForemanTableBody } from '../../../../move_to_foreman/components/common/table';
 import ConfirmDialog from '../../../../move_to_foreman/components/common/ConfirmDialog';
@@ -25,23 +25,6 @@ const emptyStateData = {
   },
 };
 
-const ErrorAlerts = ({ errors }) => {
-  const alerts = errors.filter(Boolean).map(e => (
-    <Alert type={Alert.ALERT_TYPE_ERROR} key={e}>
-      <span>{e}</span>
-    </Alert>
-  ));
-
-  return (
-    <div>
-      {alerts}
-    </div>
-  );
-};
-ErrorAlerts.propTypes = {
-  errors: PropTypes.arrayOf(PropTypes.string).isRequired,
-};
-
 class SubscriptionsTable extends Component {
   constructor(props) {
     super(props);
@@ -49,7 +32,7 @@ class SubscriptionsTable extends Component {
     this.state = {
       rows: undefined,
       subscriptions: undefined,
-      groupdSubscriptions: undefined,
+      groupedSubscriptions: undefined,
       updatedQuantity: {},
       editing: false,
       showUpdateConfirmDialog: false,
@@ -64,14 +47,14 @@ class SubscriptionsTable extends Component {
       nextProps.subscriptions !== undefined &&
       !isEqual(nextProps.subscriptions, prevState.subscriptions)
     ) {
-      const groupdSubscriptions = groupSubscriptionsByProductId(nextProps.subscriptions);
+      const groupedSubscriptions = groupSubscriptionsByProductId(nextProps.subscriptions);
       const rows = buildTableRows(
-        groupdSubscriptions,
+        groupedSubscriptions,
         nextProps.subscriptions.availableQuantities,
         prevState.updatedQuantity,
       );
 
-      return { rows, groupdSubscriptions, subscriptions: nextProps.subscriptions };
+      return { rows, groupedSubscriptions, subscriptions: nextProps.subscriptions };
     }
 
     return null;
@@ -79,19 +62,19 @@ class SubscriptionsTable extends Component {
 
   toggleSubscriptionGroup(groupId) {
     const { subscriptions } = this.props;
-    const { groupdSubscriptions, updatedQuantity } = this.state;
-    const { open } = groupdSubscriptions[groupId];
+    const { groupedSubscriptions, updatedQuantity } = this.state;
+    const { open } = groupedSubscriptions[groupId];
 
-    groupdSubscriptions[groupId].open = !open;
+    groupedSubscriptions[groupId].open = !open;
 
 
     const rows = buildTableRows(
-      groupdSubscriptions,
+      groupedSubscriptions,
       subscriptions.availableQuantities,
       updatedQuantity,
     );
 
-    this.setState({ rows, groupdSubscriptions });
+    this.setState({ rows, groupedSubscriptions });
   }
 
   enableEditing(editingState) {
@@ -102,11 +85,11 @@ class SubscriptionsTable extends Component {
   }
 
   updateRows(updatedQuantity) {
-    const { groupdSubscriptions } = this.state;
+    const { groupedSubscriptions } = this.state;
     const { subscriptions } = this.props;
 
     const rows = buildTableRows(
-      groupdSubscriptions,
+      groupedSubscriptions,
       subscriptions.availableQuantities,
       updatedQuantity,
     );
@@ -158,15 +141,15 @@ class SubscriptionsTable extends Component {
 
   render() {
     const { subscriptions } = this.props;
-    const { groupdSubscriptions } = this.state;
+    const { groupedSubscriptions } = this.state;
 
     const groupingController = {
       isCollapseable: ({ rowData }) =>
         // it is the first subscription in the group
-        rowData.id === groupdSubscriptions[rowData.product_id].subscriptions[0].id &&
+        rowData.id === groupedSubscriptions[rowData.product_id].subscriptions[0].id &&
         // the group contains more then one subscription
-        groupdSubscriptions[rowData.product_id].subscriptions.length > 1,
-      isCollapsed: ({ rowData }) => !groupdSubscriptions[rowData.product_id].open,
+        groupedSubscriptions[rowData.product_id].subscriptions.length > 1,
+      isCollapsed: ({ rowData }) => !groupedSubscriptions[rowData.product_id].open,
       toggle: ({ rowData }) => this.toggleSubscriptionGroup(rowData.product_id),
     };
 
@@ -258,12 +241,6 @@ class SubscriptionsTable extends Component {
 
     return (
       <LoadingState loading={subscriptions.loading} loadingText={__('Loading')}>
-        <ErrorAlerts
-          errors={[
-            subscriptions.error,
-            subscriptions.quantitiesError,
-          ]}
-        />
         <ForemanTable
           columns={columnsDefinition}
           emptyState={emptyStateData}