katello 3.13.4 → 3.14.0.rc1

data/webpack/scenes/RedHatRepositories/components/EnabledRepository/__tests__/EnabledRepository.test.js

@@ -10,6 +10,9 @@ const store = mockStore({});
 
 describe('Enabled Repositories Component', () => {
   let shallowWrapper;
+  const mockSetRepositoryDisabled = jest.fn();
+  const mockLoadEnabledRepos = jest.fn();
+  const mockDisableRepository = jest.fn();
   beforeEach(() => {
     shallowWrapper = shallow(<EnabledRepository
       store={store}
@@ -20,12 +23,12 @@ describe('Enabled Repositories Component', () => {
       orphaned={false}
       type="foo"
       arch="foo"
-      releaseVer="1.1.1"
+      releasever="1.1.1"
       label="some label"
       pagination={{}}
-      setRepositoryDisabled={() => {}}
-      loadEnabledRepos={() => {}}
-      disableRepository={() => {}}
+      setRepositoryDisabled={mockSetRepositoryDisabled}
+      loadEnabledRepos={mockLoadEnabledRepos}
+      disableRepository={mockDisableRepository}
     />);
   });
 
@@ -36,5 +39,81 @@ describe('Enabled Repositories Component', () => {
   it('should render', async () => {
     expect(toJson(shallowWrapper)).toMatchSnapshot();
   });
-});
 
+  describe('class methods', () => {
+    let instance;
+    beforeEach(() => {
+      instance = shallowWrapper.instance();
+      mockSetRepositoryDisabled.mockClear();
+      mockLoadEnabledRepos.mockClear();
+      mockDisableRepository.mockClear();
+    });
+    it('setDisabled - should call this.props.setRepositoryDisabled', () => {
+      instance.setDisabled();
+      expect(mockSetRepositoryDisabled).toHaveBeenCalled();
+    });
+    it('repoForAction - should return expected object', () => {
+      const expected = {
+        contentId: 1,
+        productId: 1,
+        name: 'foo',
+        type: 'foo',
+        arch: 'foo',
+        releasever: '1.1.1',
+      };
+      expect(instance.repoForAction()).toEqual(expected);
+    });
+    it('reload - calls this.props.loadEnabledRepos with expected data', () => {
+      const expectedData = {
+        search: {},
+      };
+      instance.reload();
+      expect(mockLoadEnabledRepos).toHaveBeenCalledWith(expectedData, true);
+      // this.props.loadEnabledRepos({
+      //   ...this.props.pagination,
+      //   search: this.props.search,
+      // }, true)
+    });
+    it('notifyDisabled - uses window.tfm.toastNotifications object to make a toast', () => {
+      // setup
+      const savedTfm = window.tfm;
+      window.tfm = {
+        toastNotifications: {
+          notify: jest.fn(),
+        },
+      };
+      const expectedData = {
+        message: "Repository 'foo' has been disabled.",
+        type: 'success',
+      };
+      instance.notifyDisabled();
+      expect(window.tfm.toastNotifications.notify).toHaveBeenCalledWith(expectedData);
+      // cleanup
+      window.tfm = savedTfm;
+    });
+    it('reloadAndNotify - calls all 3 async functions', async () => {
+      const result = { success: true };
+      instance.reload = jest.fn();
+      instance.setDisabled = jest.fn();
+      instance.notifyDisabled = jest.fn();
+      await instance.reloadAndNotify(result);
+      expect(instance.reload).toHaveBeenCalled();
+      expect(instance.setDisabled).toHaveBeenCalled();
+      expect(instance.notifyDisabled).toHaveBeenCalled();
+    });
+    it('disableRepository - calls both async functions', async () => {
+      const repoForAction = {
+        contentId: 1,
+        productId: 1,
+        name: 'foo',
+        type: 'foo',
+        arch: 'foo',
+        releasever: '1.1.1',
+      };
+      instance.reloadAndNotify = jest.fn();
+      await instance.disableRepository();
+      expect(mockDisableRepository).toHaveBeenCalledWith(repoForAction);
+      expect(instance.reloadAndNotify).toHaveBeenCalled();
+    });
+  });
+});

data/webpack/scenes/RedHatRepositories/components/RepositorySetRepository/RepositorySetRepository.js

@@ -10,56 +10,55 @@ import '../../index.scss';
 class RepositorySetRepository extends Component {
   constructor(props) {
     super(props);
-
     this.state = {};
+  }
 
-    this.repoForAction = () => {
-      const {
-        productId, contentId, arch, displayArch, releasever, label,
-      } = this.props;
-
-      const derivedArch = arch || displayArch;
-      return {
-        arch: derivedArch,
-        productId,
-        contentId,
-        releasever,
-        label,
-      };
-    };
-
-    this.setEnabled = () => {
-      this.props.setRepositoryEnabled(this.repoForAction());
-    };
-
-    this.reloadEnabledRepos = () => (
-      this.props.loadEnabledRepos({
-        ...this.props.enabledPagination,
-        search: this.props.enabledSearch,
-      }, true)
-    );
-
-    this.notifyEnabled = (data) => {
-      const repoName = data.output.repository.name;
-      window.tfm.toastNotifications.notify({
-        message: sprintf(__("Repository '%(repoName)s' has been enabled."), { repoName }),
-        type: 'success',
-      });
-    };
-
-    this.reloadAndNotify = (result) => {
-      if (result.success) {
-        this.reloadEnabledRepos()
-          .then(this.setEnabled)
-          .then(() => this.notifyEnabled(result.data));
-      }
-    };
-
-    this.enableRepository = () => {
-      this.props.enableRepository(this.repoForAction())
-        .then(this.reloadAndNotify);
+  setEnabled = () => {
+    this.props.setRepositoryEnabled(this.repoForAction());
+  };
+
+  repoForAction = () => {
+    const {
+      productId, contentId, arch, displayArch, releasever, label,
+    } = this.props;
+
+    const derivedArch = arch || displayArch;
+    return {
+      arch: derivedArch,
+      productId,
+      contentId,
+      releasever,
+      label,
     };
-  }
+  };
+
+  reloadEnabledRepos = () => (
+    this.props.loadEnabledRepos({
+      ...this.props.enabledPagination,
+      search: this.props.enabledSearch,
+    }, true)
+  );
+
+  notifyEnabled = (data) => {
+    const repoName = data.output.repository.name;
+    window.tfm.toastNotifications.notify({
+      message: sprintf(__("Repository '%(repoName)s' has been enabled."), { repoName }),
+      type: 'success',
+    });
+  };
+
+  reloadAndNotify = async (result) => {
+    if (result.success) {
+      await this.reloadEnabledRepos();
+      await this.setEnabled();
+      await this.notifyEnabled(result.data);
+    }
+  };
+
+  enableRepository = async () => {
+    await this.props.enableRepository(this.repoForAction());
+    this.reloadAndNotify();
+  };
 
   render() {
     const { displayArch, releasever, type } = this.props;

data/webpack/scenes/RedHatRepositories/helpers.js

@@ -14,7 +14,7 @@ export const getSetsComponent = (repoSetsState, onPaginationChange) => {
     itemCount,
   } = repoSetsState;
 
-  if (itemCount === 0) {
+  if (itemCount === 0 || !results) {
     if (searchIsActive) {
       return <p>{__('No repository sets match your search criteria.')}</p>;
     }

data/webpack/scenes/RedHatRepositories/index.js

@@ -2,109 +2,10 @@
 /* eslint import/no-unresolved: [2, { ignore: [foremanReact/*] }] */
 /* eslint-disable import/no-unresolved */
 
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
 import { connect } from 'react-redux';
-import { Grid, Row, Col } from 'react-bootstrap';
-import { Button } from 'patternfly-react';
-import { translate as __ } from 'foremanReact/common/I18n';
-import { LoadingState } from '../../move_to_pf/LoadingState';
-import { createEnabledRepoParams, loadEnabledRepos } from '../../redux/actions/RedHatRepositories/enabled';
+import { loadEnabledRepos } from '../../redux/actions/RedHatRepositories/enabled';
 import { loadRepositorySets, updateRecommendedRepositorySets } from '../../redux/actions/RedHatRepositories/sets';
-import SearchBar from './components/SearchBar';
-import RecommendedRepositorySetsToggler from './components/RecommendedRepositorySetsToggler';
-import { getSetsComponent, getEnabledComponent } from './helpers';
-import api from '../../services/api';
-
-class RedHatRepositoriesPage extends Component {
-  componentDidMount() {
-    this.loadData();
-  }
-
-  loadData() {
-    this.props.loadEnabledRepos();
-    this.props.loadRepositorySets({ search: { filters: ['rpm'] } });
-  }
-
-  render() {
-    const { enabledRepositories, repositorySets } = this.props;
-    const { repoParams } = createEnabledRepoParams(enabledRepositories);
-
-    return (
-      <Grid id="redhatRepositoriesPage" bsClass="container-fluid">
-        <h1>{__('Red Hat Repositories')}</h1>
-        <Row className="toolbar-pf">
-          <Col sm={12}>
-            <SearchBar />
-          </Col>
-        </Row>
-
-        <Row className="row-eq-height">
-          <Col sm={6} className="available-repositories-container">
-            <div className="available-repositories-header">
-              <h2>{__('Available Repositories')}</h2>
-              <RecommendedRepositorySetsToggler
-                enabled={repositorySets.recommended}
-                onChange={value => this.props.updateRecommendedRepositorySets(value)}
-                className="recommended-repositories-toggler"
-              />
-            </div>
-            <LoadingState loading={repositorySets.loading} loadingText={__('Loading')}>
-              {getSetsComponent(
-                repositorySets,
-                (pagination) => {
-                  this.props.loadRepositorySets({
-                    ...pagination,
-                    search: repositorySets.search,
-                  });
-                },
-              )}
-            </LoadingState>
-          </Col>
-
-          <Col sm={6} className="enabled-repositories-container">
-            <h2>
-              {__('Enabled Repositories')}
-              <Button
-                className="pull-right"
-                onClick={() => { api.open('/repositories.csv', repoParams); }}
-              >
-                {__('Export as CSV')}
-              </Button>
-            </h2>
-
-            <LoadingState loading={enabledRepositories.loading} loadingText={__('Loading')}>
-              {getEnabledComponent(
-                enabledRepositories,
-                (pagination) => {
-                  this.props.loadEnabledRepos({
-                    ...pagination,
-                    search: enabledRepositories.search,
-                  });
-                },
-              )}
-            </LoadingState>
-          </Col>
-        </Row>
-      </Grid>
-    );
-  }
-}
-
-RedHatRepositoriesPage.propTypes = {
-  loadEnabledRepos: PropTypes.func.isRequired,
-  loadRepositorySets: PropTypes.func.isRequired,
-  updateRecommendedRepositorySets: PropTypes.func.isRequired,
-  enabledRepositories: PropTypes.shape({
-    loading: PropTypes.bool,
-    search: PropTypes.shape({}),
-  }).isRequired,
-  repositorySets: PropTypes.shape({
-    recommended: PropTypes.array,
-    loading: PropTypes.bool,
-    search: PropTypes.shape({}),
-  }).isRequired,
-};
+import RedHatRepositoriesPage from './RedHatRepositoriesPage';
 
 const mapStateToProps = ({
   katello: {

data/webpack/scenes/Settings/Tables/TableActions.js

@@ -14,60 +14,59 @@ import {
 
 const getResponseError = ({ data }) => data && (data.displayMessage || data.error);
 
-export const loadTables = () => (dispatch) => {
+export const loadTables = () => async (dispatch) => {
   dispatch({ type: TABLES_REQUEST, params: {} });
 
-  return foremanApi
-    .get(`/users/${userId()}/table_preferences`, {})
-    .then(({ data }) => {
-      dispatch({
-        type: TABLES_SUCCESS,
-        payload: data,
-      });
-    })
-    .catch((result) => {
-      const { response } = result;
-      dispatch({
-        type: TABLES_FAILURE,
-        error: getResponseError(response),
-      });
+  try {
+    const { data } = await foremanApi.get(`/users/${userId()}/table_preferences`, {});
+    return dispatch({
+      type: TABLES_SUCCESS,
+      payload: data,
     });
+  } catch (error) {
+    const { response } = error;
+    return dispatch({
+      type: TABLES_FAILURE,
+      error: getResponseError(response),
+    });
+  }
 };
 
-export const createColumns = (params = {}) => (dispatch) => {
+export const createColumns = (params = {}) => async (dispatch) => {
   dispatch({ type: CREATE_TABLE, params });
 
-  return foremanApi
-    .post(`/users/${userId()}/table_preferences`, params)
-    .then(({ data }) => {
-      dispatch({
-        type: CREATE_TABLE_SUCCESS,
-        payload: [data],
-      });
-    })
-    .catch((result) => {
-      dispatch({
-        type: CREATE_TABLE_FAILURE,
-        error: getResponseError(result.response),
-      });
+  try {
+    const { data } = await foremanApi.post(`/users/${userId()}/table_preferences`, params);
+    return dispatch({
+      type: CREATE_TABLE_SUCCESS,
+      payload: [data],
+    });
+  } catch (error) {
+    const { response } = error;
+    return dispatch({
+      type: CREATE_TABLE_FAILURE,
+      error: getResponseError(response),
     });
+  }
 };
-export const updateColumns = (params = {}) => (dispatch) => {
+
+export const updateColumns = (params = {}) => async (dispatch) => {
   dispatch({ type: UPDATE_TABLE, params });
   const updateParams = { columns: params.columns };
-  return foremanApi
-    .put(`/users/${userId()}/table_preferences/${params.name}`, updateParams)
-    .then(({ data }) => {
-      dispatch({
-        type: UPDATE_TABLE_SUCCESS,
-        payload: [data],
-      });
-    })
-    .catch((result) => {
-      dispatch({
-        type: UPDATE_TABLE_FAILURE,
-        error: getResponseError(result.response),
-      });
+
+  try {
+    const { data } = await foremanApi
+      .put(`/users/${userId()}/table_preferences/${params.name}`, updateParams);
+    return dispatch({
+      type: UPDATE_TABLE_SUCCESS,
+      payload: [data],
+    });
+  } catch (error) {
+    const { response } = error;
+    return dispatch({
+      type: UPDATE_TABLE_FAILURE,
+      error: getResponseError(response),
     });
+  }
 };
 export default loadTables;

data/webpack/scenes/Settings/Tables/__tests__/TableActions.test.js

@@ -32,53 +32,53 @@ beforeEach(() => {
 });
 
 describe('table actions', () => {
-  it('creates TABLES_REQUEST with success', () => {
+  it('creates TABLES_REQUEST with success', async () => {
     mockRequest({
       url: '/api/v2/users/1/table_preferences',
       status: 200,
       response: requestSuccessResponse,
     });
-    return store.dispatch(loadTables())
-      .then(() => expect(store.getActions()).toEqual(getSuccessActions));
+    await store.dispatch(loadTables());
+    expect(store.getActions()).toEqual(getSuccessActions);
   });
-  it('creates TABLES_REQUEST with failure', () => {
+  it('creates TABLES_REQUEST with failure', async () => {
     mockRequest({
       url: '/api/v2/users/1/table_preferences',
       status: 403,
       response: accessDenied,
     });
-    return store.dispatch(loadTables())
-      .then(() => expect(store.getActions()).toEqual(getFailureActions));
+    await store.dispatch(loadTables());
+    expect(store.getActions()).toEqual(getFailureActions);
   });
 
-  it('creates SAVE_CREATE_TABLE and ends with success', () => {
+  it('creates SAVE_CREATE_TABLE and ends with success', async () => {
     const mock = new MockAdapter(axios);
     mock.onPost('/api/v2/users/1/table_preferences').reply(200, tableRecord);
 
-    return store.dispatch(createColumns())
-      .then(() => expect(store.getActions()).toEqual(createSuccessActions));
+    await store.dispatch(createColumns());
+    expect(store.getActions()).toEqual(createSuccessActions);
   });
 
-  it('creates CREATE_TABLE with failure', () => {
+  it('creates CREATE_TABLE with failure', async () => {
     const mock = new MockAdapter(axios);
     mock.onPost('/api/v2/users/1/table_preferences').reply(403, accessDenied);
 
-    return store.dispatch(createColumns({ name: 'Test', columns: [] }))
-      .then(() => expect(store.getActions()).toEqual(createFailureActions));
+    await store.dispatch(createColumns({ name: 'Test', columns: [] }));
+    expect(store.getActions()).toEqual(createFailureActions);
   });
 
-  it('creates UPDATE_TABLE and ends with success', () => {
+  it('creates UPDATE_TABLE and ends with success', async () => {
     const mock = new MockAdapter(axios);
     mock.onPut(`/api/v2/users/1/table_preferences/${testTableName}`).reply(200, tableRecord);
 
-    return store.dispatch(updateColumns(tableRecord))
-      .then(() => expect(store.getActions()).toEqual(updateSuccessActions));
+    await store.dispatch(updateColumns(tableRecord));
+    expect(store.getActions()).toEqual(updateSuccessActions);
   });
-  it('creates UPDATE_TABLE with failure', () => {
+  it('creates UPDATE_TABLE with failure', async () => {
     const mock = new MockAdapter(axios);
     mock.onPut(`/api/v2/users/1/table_preferences/${testTableName}`).reply(403, accessDenied);
 
-    return store.dispatch(updateColumns(tableRecord))
-      .then(() => expect(store.getActions()).toEqual(updateFailureActions));
+    await store.dispatch(updateColumns(tableRecord));
+    expect(store.getActions()).toEqual(updateFailureActions);
   });
 });