katello 3.6.0.1.rc2 → 3.7.0.rc1

data/webpack/redux/reducers/RedHatRepositories/sets.js

@@ -0,0 +1,41 @@
+import Immutable from 'seamless-immutable';
+import { isEmpty } from 'lodash';
+
+import {
+  REPOSITORY_SETS_REQUEST,
+  REPOSITORY_SETS_SUCCESS,
+  REPOSITORY_SETS_FAILURE,
+} from '../../consts';
+
+import { initialState } from './sets.fixtures.js';
+
+export default (state = initialState, action) => {
+  if (action.type === REPOSITORY_SETS_REQUEST) {
+    return state.set('loading', true);
+  } else if (action.type === REPOSITORY_SETS_SUCCESS) {
+    const {
+      page, per_page, subtotal, results, // eslint-disable-line camelcase
+    } = action.response;
+
+    return Immutable({
+      results,
+      pagination: {
+        page: Number(page),
+        // server can return per_page: null when there's error in the search query,
+        // don't store it in such case
+        // eslint-disable-next-line camelcase
+        perPage: Number(per_page || state.pagination.perPage),
+      },
+      itemCount: Number(subtotal),
+      loading: false,
+      searchIsActive: !isEmpty(action.search),
+      search: action.search,
+    });
+  } else if (action.type === REPOSITORY_SETS_FAILURE) {
+    return Immutable({
+      error: action.error,
+      loading: false,
+    });
+  }
+  return state;
+};

data/webpack/redux/reducers/RedHatRepositories/sets.test.js

@@ -0,0 +1,36 @@
+import * as types from '../../consts';
+
+import {
+  initialState,
+  loadingState,
+  requestSuccessResponse,
+  successState,
+  errorState,
+} from './sets.fixtures';
+import reducer from './sets';
+
+describe('sets reducer', () => {
+  it('should return the initial state', () => {
+    expect(reducer(undefined, {})).toEqual(initialState);
+  });
+
+  it('should keep loading state on REPOSITORY_SETS_REQUEST', () => {
+    expect(reducer(initialState, {
+      type: types.REPOSITORY_SETS_REQUEST,
+    })).toEqual(loadingState);
+  });
+
+  it('should flatten repositories response REPOSITORY_SETS_SUCCESS', () => {
+    expect(reducer(initialState, {
+      type: types.REPOSITORY_SETS_SUCCESS,
+      response: requestSuccessResponse,
+    })).toEqual(successState);
+  });
+
+  it('should have error on REPOSITORY_SETS_FAILURE', () => {
+    expect(reducer(initialState, {
+      type: types.REPOSITORY_SETS_FAILURE,
+      error: 'Unable to process request.',
+    })).toEqual(errorState);
+  });
+});

data/webpack/redux/reducers/index.js

@@ -0,0 +1,14 @@
+import { combineReducers } from 'redux';
+import { organization } from '../../containers/Application';
+import redHatRepositories from './RedHatRepositories';
+import { subscriptions } from '../../scenes/Subscriptions';
+import { upstreamSubscriptions } from '../../scenes/Subscriptions/UpstreamSubscriptions';
+import { manifestHistory } from '../../scenes/Subscriptions/Manifest';
+
+export default combineReducers({
+  organization,
+  redHatRepositories,
+  subscriptions,
+  upstreamSubscriptions,
+  manifestHistory,
+});

data/webpack/scenes/Organizations/OrganizationActions.js

@@ -0,0 +1,60 @@
+import api, { orgId } from '../../services/api';
+import { propsToSnakeCase } from '../../services/index';
+
+import {
+  GET_ORGANIZATION_REQUEST,
+  GET_ORGANIZATION_SUCCESS,
+  GET_ORGANIZATION_FAILURE,
+  SAVE_ORGANIZATION_REQUEST,
+  SAVE_ORGANIZATION_SUCCESS,
+  SAVE_ORGANIZATION_FAILURE,
+} from './OrganizationConstants';
+
+export const loadOrganization = (extendedParams = {}) => (dispatch) => {
+  dispatch({ type: GET_ORGANIZATION_REQUEST });
+
+  const params = {
+    ...propsToSnakeCase(extendedParams),
+  };
+
+  return api
+    .get(`/organizations/${orgId}`, {}, params)
+    .then(({ data }) => {
+      dispatch({
+        type: GET_ORGANIZATION_SUCCESS,
+        response: data,
+      });
+    })
+    .catch((result) => {
+      dispatch({
+        type: GET_ORGANIZATION_FAILURE,
+        result,
+      });
+    });
+};
+
+export const saveOrganization = (extendedParams = {}) => (dispatch) => {
+  dispatch({ type: SAVE_ORGANIZATION_REQUEST });
+
+  const params = {
+    ...{ id: orgId },
+    ...propsToSnakeCase(extendedParams),
+  };
+
+  return api
+    .put(`/organizations/${orgId}`, params)
+    .then(({ data }) => {
+      dispatch({
+        type: SAVE_ORGANIZATION_SUCCESS,
+        response: data,
+      });
+    })
+    .catch((result) => {
+      dispatch({
+        type: SAVE_ORGANIZATION_FAILURE,
+        result,
+      });
+    });
+};
+
+export default loadOrganization;

data/webpack/scenes/Organizations/OrganizationConstants.js

@@ -0,0 +1,7 @@
+export const GET_ORGANIZATION_REQUEST = 'GET_ORGANIZATION_REQUEST';
+export const GET_ORGANIZATION_SUCCESS = 'GET_ORGANIZATION_SUCCESS';
+export const GET_ORGANIZATION_FAILURE = 'GET_ORGANIZATION_FAILURE';
+
+export const SAVE_ORGANIZATION_REQUEST = 'SAVE_ORGANIZATION_REQUEST';
+export const SAVE_ORGANIZATION_SUCCESS = 'SAVE_ORGANIZATION_SUCCESS';
+export const SAVE_ORGANIZATION_FAILURE = 'SAVE_ORGANIZATION_FAILURE';

data/webpack/scenes/Organizations/OrganizationReducer.js

@@ -0,0 +1,32 @@
+import Immutable from 'seamless-immutable';
+
+import {
+  GET_ORGANIZATION_REQUEST,
+  GET_ORGANIZATION_SUCCESS,
+  GET_ORGANIZATION_FAILURE,
+  SAVE_ORGANIZATION_REQUEST,
+  SAVE_ORGANIZATION_SUCCESS,
+  SAVE_ORGANIZATION_FAILURE,
+} from './OrganizationConstants';
+
+const initialState = Immutable({ loading: false });
+
+export default (state = initialState, action) => {
+  switch (action.type) {
+    case GET_ORGANIZATION_REQUEST:
+    case SAVE_ORGANIZATION_REQUEST:
+      return state.set('loading', true);
+
+    case GET_ORGANIZATION_SUCCESS:
+    case SAVE_ORGANIZATION_SUCCESS: {
+      return Immutable({ loading: false, ...action.response });
+    }
+
+    case GET_ORGANIZATION_FAILURE:
+    case SAVE_ORGANIZATION_FAILURE:
+      return Immutable({ error: action.error });
+
+    default:
+      return state;
+  }
+};

data/webpack/scenes/Organizations/__tests__/OrganizationActions.test.js

@@ -0,0 +1,59 @@
+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 { mockRequest, mockReset } from '../../../mockRequest';
+import {
+  requestSuccessResponse,
+  getSuccessActions,
+  getFailureActions,
+  saveSuccessActions,
+  saveFailureActions,
+} from './organizations.fixtures';
+
+import { loadOrganization, saveOrganization } from '../OrganizationActions';
+
+const mockStore = configureMockStore([thunk]);
+const store = mockStore({ organization: Immutable({}) });
+
+beforeEach(() => {
+  store.clearActions();
+  mockReset();
+});
+
+describe('organization actions', () => {
+  it('creates GET_ORGANIZATION_REQUEST and then fails with 422', () => {
+    mockRequest({
+      url: '/katello/api/v2/organizations/1',
+      status: 422,
+    });
+    return store.dispatch(loadOrganization())
+      .then(() => expect(store.getActions()).toEqual(getFailureActions));
+  });
+
+  it('creates GET_ORGANIZATION_REQUEST and ends with success', () => {
+    mockRequest({
+      url: '/katello/api/v2/organizations/1',
+      response: requestSuccessResponse,
+    });
+    return store.dispatch(loadOrganization())
+      .then(() => expect(store.getActions()).toEqual(getSuccessActions));
+  });
+
+  it('creates SAVE_ORGANIZATION_REQUEST and then fails with 422', () => {
+    const mock = new MockAdapter(axios);
+    mock.onPut('/katello/api/v2/organizations/1').reply(422);
+
+    return store.dispatch(saveOrganization())
+      .then(() => expect(store.getActions()).toEqual(saveFailureActions));
+  });
+
+  it('creates SAVE_ORGANIZATION_REQUEST and ends with success', () => {
+    const mock = new MockAdapter(axios);
+    mock.onPut('/katello/api/v2/organizations/1').reply(200, requestSuccessResponse);
+
+    return store.dispatch(saveOrganization())
+      .then(() => expect(store.getActions()).toEqual(saveSuccessActions));
+  });
+});

data/webpack/scenes/Organizations/__tests__/OrganizationReducer.test.js

@@ -0,0 +1,56 @@
+import * as types from '../OrganizationConstants';
+
+import {
+  initialState,
+  loadingState,
+  requestSuccessResponse,
+  successState,
+  errorState,
+} from './organizations.fixtures';
+import reducer from '../OrganizationReducer';
+
+describe('organizations reducer', () => {
+  it('should return the initial state', () => {
+    expect(reducer(undefined, {})).toEqual(initialState);
+  });
+
+  it('should keep loading state on GET_ORGANIZATION_REQUEST', () => {
+    expect(reducer(initialState, {
+      type: types.GET_ORGANIZATION_REQUEST,
+    })).toEqual(loadingState);
+  });
+
+  it('should flatten organization response GET_ORGANIZATION_SUCCESS', () => {
+    expect(reducer(initialState, {
+      type: types.GET_ORGANIZATION_SUCCESS,
+      response: requestSuccessResponse,
+    })).toEqual(successState);
+  });
+
+  it('should have error on GET_ORGANIZATION_FAILURE', () => {
+    expect(reducer(initialState, {
+      type: types.GET_ORGANIZATION_FAILURE,
+      error: 'Unable to process request.',
+    })).toEqual(errorState);
+  });
+
+  it('should keep loading state on SAVE_ORGANIZATION_REQUEST', () => {
+    expect(reducer(initialState, {
+      type: types.SAVE_ORGANIZATION_REQUEST,
+    })).toEqual(loadingState);
+  });
+
+  it('should flatten organization response SAVE_ORGANIZATION_SUCCESS', () => {
+    expect(reducer(initialState, {
+      type: types.SAVE_ORGANIZATION_SUCCESS,
+      response: requestSuccessResponse,
+    })).toEqual(successState);
+  });
+
+  it('should have error on SAVE_ORGANIZATION_FAILURE', () => {
+    expect(reducer(initialState, {
+      type: types.SAVE_ORGANIZATION_FAILURE,
+      error: 'Unable to process request.',
+    })).toEqual(errorState);
+  });
+});

data/webpack/scenes/Organizations/__tests__/organizations.fixtures.js

@@ -0,0 +1,99 @@
+import Immutable from 'seamless-immutable';
+
+export const initialState = Immutable({
+  loading: false,
+});
+
+export const loadingState = Immutable({
+  loading: true,
+});
+
+export const requestSuccessResponse = Immutable({
+  label: 'Default_Organization',
+  owner_details: {
+    parentOwner: null,
+    id: 'ff8080815ea5ea44015ea5f0eb5c0001',
+    key: 'Default_Organization',
+    displayName: 'Default Organization',
+    contentPrefix: '/Default_Organization/$env',
+    defaultServiceLevel: null,
+    upstreamConsumer: null,
+  },
+  redhat_repository_url: 'https://cdn.redhat.com',
+  service_levels: [],
+  service_level: null,
+  select_all_types: [],
+  description: null,
+  created_at: '2017-09-21 15:36:18 -0400',
+  updated_at: '2017-09-21 15:36:18 -0400',
+  ancestry: null,
+  parent_id: null,
+  parent_name: null,
+  id: 1,
+  name: 'Default Organization',
+  title: 'Default Organization',
+  users: [],
+  smart_proxies: [],
+  subnets: [],
+  compute_resources: [],
+  media: [],
+  config_templates: [],
+  ptables: [],
+  provisioning_templates: [],
+  domains: [],
+  realms: [],
+  environments: [],
+  hostgroups: [],
+  locations: [],
+  hosts_count: 2,
+  parameters: [],
+  default_content_view_id: 1,
+  library_id: 1,
+});
+
+export const successState = Immutable({ loading: false, ...requestSuccessResponse });
+
+export const errorState = Immutable({
+  error: 'Unable to process request.',
+});
+
+
+export const getSuccessActions = [
+  {
+    type: 'GET_ORGANIZATION_REQUEST',
+  },
+  {
+    response: requestSuccessResponse,
+    type: 'GET_ORGANIZATION_SUCCESS',
+  },
+];
+
+export const getFailureActions = [
+  {
+    type: 'GET_ORGANIZATION_REQUEST',
+  },
+  {
+    result: new Error('Request failed with status code 422'),
+    type: 'GET_ORGANIZATION_FAILURE',
+  },
+];
+
+export const saveSuccessActions = [
+  {
+    type: 'SAVE_ORGANIZATION_REQUEST',
+  },
+  {
+    response: requestSuccessResponse,
+    type: 'SAVE_ORGANIZATION_SUCCESS',
+  },
+];
+
+export const saveFailureActions = [
+  {
+    type: 'SAVE_ORGANIZATION_REQUEST',
+  },
+  {
+    result: new Error('Request failed with status code 422'),
+    type: 'SAVE_ORGANIZATION_FAILURE',
+  },
+];

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

@@ -0,0 +1,114 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import cx from 'classnames';
+import { ListView, Spinner, OverlayTrigger, Tooltip } from 'patternfly-react';
+import { connect } from 'react-redux';
+
+import RepositoryTypeIcon from './RepositoryTypeIcon';
+import { setRepositoryDisabled } from '../../../redux/actions/RedHatRepositories/enabled';
+import api from '../../../services/api';
+
+class EnabledRepository extends Component {
+  constructor(props) {
+    super(props);
+
+    this.state = { loading: false };
+    this.setDisabled = () => {
+      const {
+        productId, contentId, arch, releasever, name, type,
+      } = this.props;
+
+      const disabledRepo = {
+        contentId,
+        productId,
+        name,
+        type,
+        arch,
+        releasever,
+      };
+
+      this.props.setRepositoryDisabled(disabledRepo);
+    };
+
+    this.disableRepository = () => {
+      this.setState({ loading: true });
+
+      const {
+        productId, contentId, arch, releasever,
+      } = this.props;
+
+      const url = `/products/${productId}/repository_sets/${contentId}/disable`;
+
+      const data = {
+        id: contentId,
+        product_id: productId,
+        basearch: arch,
+        releasever,
+      };
+
+      api
+        .put(url, data)
+        .then(this.setDisabled)
+        .catch(() => {
+          this.setState({ loading: false });
+          // TODO: Add error component
+        });
+    };
+
+    this.disableTooltipId = `disable-${props.id}`;
+  }
+
+  render() {
+    const {
+      arch, name, id, type, releasever,
+    } = this.props;
+
+    return (
+      <ListView.Item
+        key={id}
+        actions={
+          <Spinner loading={this.state.loading} inline>
+            <OverlayTrigger
+              overlay={<Tooltip id={this.disableTooltipId}>{__('Disable')}</Tooltip>}
+              placement="bottom"
+              trigger={['hover', 'focus']}
+              rootClose={false}
+            >
+              <button
+                onClick={this.disableRepository}
+                style={{
+                  backgroundColor: 'initial',
+                  border: 'none',
+                  color: '#0388ce',
+                }}
+              >
+                <i className={cx('fa-2x', 'fa fa-minus-circle')} />
+              </button>
+            </OverlayTrigger>
+          </Spinner>
+        }
+        leftContent={<RepositoryTypeIcon id={id} type={type} />}
+        heading={name}
+        description={`${arch} ${releasever || ''}`}
+        stacked
+      />
+    );
+  }
+}
+
+EnabledRepository.propTypes = {
+  id: PropTypes.number.isRequired,
+  contentId: PropTypes.number.isRequired,
+  productId: PropTypes.number.isRequired,
+  name: PropTypes.string.isRequired,
+  type: PropTypes.string.isRequired,
+  arch: PropTypes.string.isRequired,
+  releasever: PropTypes.string,
+  setRepositoryDisabled: PropTypes.func.isRequired,
+};
+
+EnabledRepository.defaultProps = {
+  releasever: '',
+};
+
+export default connect(null, { setRepositoryDisabled })(EnabledRepository);