katello 3.8.1 → 3.9.0.rc1

data/webpack/redux/consts.js

@@ -10,6 +10,14 @@ export const ENABLED_REPOSITORIES_REQUEST = 'ENABLED_REPOSITORIES_REQUEST';
 export const ENABLED_REPOSITORIES_SUCCESS = 'ENABLED_REPOSITORIES_SUCCESS';
 export const ENABLED_REPOSITORIES_FAILURE = 'ENABLED_REPOSITORIES_FAILURE';
 
+export const DISABLE_REPOSITORY_REQUEST = 'DISABLE_REPOSITORY_REQUEST';
+export const DISABLE_REPOSITORY_SUCCESS = 'DISABLE_REPOSITORY_SUCCESS';
+export const DISABLE_REPOSITORY_FAILURE = 'DISABLE_REPOSITORY_FAILURE';
+
+export const ENABLE_REPOSITORY_REQUEST = 'ENABLE_REPOSITORY_REQUEST';
+export const ENABLE_REPOSITORY_SUCCESS = 'ENABLE_REPOSITORY_SUCCESS';
+export const ENABLE_REPOSITORY_FAILURE = 'ENABLE_REPOSITORY_FAILURE';
+
 export const REPOSITORY_SET_REPOSITORIES_REQUEST = 'REPOSITORY_SET_REPOSITORIES_REQUEST';
 export const REPOSITORY_SET_REPOSITORIES_SUCCESS = 'REPOSITORY_SET_REPOSITORIES_SUCCESS';
 export const REPOSITORY_SET_REPOSITORIES_FAILURE = 'REPOSITORY_SET_REPOSITORIES_FAILURE';

data/webpack/redux/reducers/RedHatRepositories/__tests__/enabled.test.js

@@ -0,0 +1,62 @@
+import * as types from '../../../consts';
+
+import {
+  initialState,
+  loadingState,
+  requestSuccessResponse,
+  successState,
+  errorState,
+  disablingState,
+  disabledIndex,
+  disablingFailedState,
+} from '../enabled.fixtures';
+import reducer from '../enabled';
+
+describe('enabled reducer', () => {
+  it('should return the initial state', () => {
+    expect(reducer(undefined, {})).toEqual(initialState);
+  });
+
+  it('should keep loading state on ENABLED_REPOSITORIES_REQUEST', () => {
+    expect(reducer(initialState, {
+      type: types.ENABLED_REPOSITORIES_REQUEST,
+    })).toEqual(loadingState);
+  });
+
+  it('does not set loading state on silent ENABLED_REPOSITORIES_REQUEST', () => {
+    expect(reducer(successState, {
+      type: types.ENABLED_REPOSITORIES_REQUEST,
+      silent: true,
+    })).toEqual(successState);
+  });
+
+  it('should flatten repositories response ENABLED_REPOSITORIES_SUCCESS', () => {
+    expect(reducer(initialState, {
+      type: types.ENABLED_REPOSITORIES_SUCCESS,
+      response: requestSuccessResponse,
+    })).toEqual(successState);
+  });
+
+  it('should have error on ENABLED_REPOSITORIES_FAILURE', () => {
+    expect(reducer(initialState, {
+      type: types.ENABLED_REPOSITORIES_FAILURE,
+      error: 'Unable to process request.',
+    })).toEqual(errorState);
+  });
+
+  it('sets loading for a repo on DISABLE_REPOSITORY_REQUEST', () => {
+    expect(reducer(successState, {
+      type: types.DISABLE_REPOSITORY_REQUEST,
+      repository: successState.repositories[disabledIndex],
+    })).toEqual(disablingState);
+  });
+
+  it('sets loading for a repo on DISABLE_REPOSITORY_FAILURE', () => {
+    expect(reducer(disablingState, {
+      type: types.DISABLE_REPOSITORY_FAILURE,
+      payload: {
+        repository: successState.repositories[disabledIndex],
+      },
+    })).toEqual(disablingFailedState);
+  });
+});

data/webpack/redux/reducers/RedHatRepositories/{repositorySetRepositories.test.js → __tests__/repositorySetRepositories.test.js}

@@ -1,4 +1,4 @@
-import * as types from '../../consts';
+import * as types from '../../../consts';
 
 import {
   contentId,
@@ -9,8 +9,11 @@ import {
   successState,
   errorState,
   enabledState,
-} from './repositorySetRepositories.fixtures';
-import reducer from './repositorySetRepositories';
+  enablingState,
+  enablingFailedState,
+
+} from '../repositorySetRepositories.fixtures';
+import reducer from '../repositorySetRepositories';
 
 describe('repositorySetRepositories reducer', () => {
   it('should return the initial state', () => {
@@ -63,4 +66,29 @@ describe('repositorySetRepositories reducer', () => {
       error: 'Unable to process request.',
     })).toEqual(successState);
   });
+
+  it('sets loading of a repo to true on ENABLE_REPOSITORY_REQUEST', () => {
+    expect(reducer(successState, {
+      type: types.ENABLE_REPOSITORY_REQUEST,
+      repository: {
+        contentId,
+        releasever: '7.2',
+        arch: 'x86_64',
+      },
+    })).toEqual(enablingState);
+  });
+
+  it('sets loading of a repo to false and error to true on ENABLE_REPOSITORY_FAILURE', () => {
+    expect(reducer(successState, {
+      type: types.ENABLE_REPOSITORY_FAILURE,
+      payload: {
+        repository: {
+          contentId,
+          releasever: '7.2',
+          arch: 'x86_64',
+        },
+        error: 'Unable to process request.',
+      },
+    })).toEqual(enablingFailedState);
+  });
 });

data/webpack/redux/reducers/RedHatRepositories/{sets.test.js → __tests__/sets.test.js}

@@ -1,4 +1,4 @@
-import * as types from '../../consts';
+import * as types from '../../../consts';
 
 import {
   initialState,
@@ -7,8 +7,8 @@ import {
   requestSuccessResponse,
   successState,
   errorState,
-} from './sets.fixtures';
-import reducer from './sets';
+} from '../sets.fixtures';
+import reducer from '../sets';
 
 describe('sets reducer', () => {
   it('should return the initial state', () => {

data/webpack/redux/reducers/RedHatRepositories/enabled.fixtures.js

@@ -1,5 +1,7 @@
 import Immutable from 'seamless-immutable';
 
+export const disabledIndex = 1;
+
 export const initialState = Immutable({
   loading: true,
   repositories: [],
@@ -118,7 +120,9 @@ export const successState = Immutable({
       arch: 'x86_64',
       contentId: 4455,
       id: 2,
+      label: 'rhel-7-server-rhceph-1.3-tools-rpms',
       name: 'Red Hat Ceph Storage Tools 1.3 for Red Hat Enterprise Linux 7 Server RPMs x86_64 7.0',
+      orphaned: undefined,
       productId: 20,
       releasever: '7.0',
       type: 'yum',
@@ -127,7 +131,9 @@ export const successState = Immutable({
       arch: 'x86_64',
       contentId: 4456,
       id: 4,
+      label: 'rhel-7-server-rhceph-1.3-tools-rpms',
       name: 'Red Hat Ceph Storage Tools 1.3 for Red Hat Enterprise Linux 7 Server RPMs x86_64 7.1',
+      orphaned: undefined,
       productId: 20,
       releasever: '7.1',
       type: 'yum',
@@ -147,3 +153,13 @@ export const errorState = Immutable({
   repositories: [],
   error: 'Unable to process request.',
 });
+
+export const disablingState = successState.setIn(
+  ['repositories', disabledIndex, 'loading'],
+  true,
+);
+
+export const disablingFailedState = successState.setIn(
+  ['repositories', disabledIndex, 'loading'],
+  false,
+);

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

@@ -5,8 +5,8 @@ import {
   ENABLED_REPOSITORIES_REQUEST,
   ENABLED_REPOSITORIES_SUCCESS,
   ENABLED_REPOSITORIES_FAILURE,
-  REPOSITORY_ENABLED,
-  REPOSITORY_DISABLED,
+  DISABLE_REPOSITORY_REQUEST,
+  DISABLE_REPOSITORY_FAILURE,
 } from '../../consts';
 
 import { initialState } from './enabled.fixtures.js';
@@ -17,14 +17,17 @@ const mapRepo = (repo) => {
     id,
     name,
     minor,
+    content_label: label,
   } = repo;
 
   return ({
     arch,
     id,
     name,
+    label,
     releasever: minor,
     type: repo.content_type,
+    orphaned: repo.product.orphaned,
     contentId: parseInt(repo.content_id, 10),
     productId: parseInt(repo.product.id, 10),
   });
@@ -32,24 +35,37 @@ const mapRepo = (repo) => {
 
 const mapRepositories = sets => sets.map(mapRepo);
 
-export default (state = initialState, action) => {
-  if (action.type === REPOSITORY_ENABLED) {
-    return state.set('repositories', state.repositories.concat([action.repository]));
-  } else if (action.type === REPOSITORY_DISABLED) {
-    return state.set(
-      'repositories',
-      state.repositories.filter((repo) => {
-        const isMatch =
-          action.repository.arch === repo.arch &&
-          action.repository.contentId === repo.contentId &&
-          action.repository.productId === repo.productId &&
-          action.repository.releasever === repo.releasever;
+const reposMatch = (repoA, repoB) => (
+  repoA.arch === repoB.arch &&
+  repoA.contentId === repoB.contentId &&
+  repoA.productId === repoB.productId &&
+  repoA.releasever === repoB.releasever
+);
+
+const changeRepoState = (state, repoToChange, stateDiff) => (
+  state.set(
+    'repositories',
+    state.repositories.map((repo) => {
+      if (reposMatch(repo, repoToChange)) {
+        return {
+          ...repo,
+          ...stateDiff,
+        };
+      }
+      return repo;
+    }),
+  )
+);
 
-        return !isMatch;
-      }),
-    );
+export default (state = initialState, action) => {
+  if (action.type === DISABLE_REPOSITORY_REQUEST) {
+    return changeRepoState(state, action.repository, { loading: true });
+  } else if (action.type === DISABLE_REPOSITORY_FAILURE) {
+    return changeRepoState(state, action.payload.repository, { loading: false });
   } else if (action.type === ENABLED_REPOSITORIES_REQUEST) {
-    return state.set(['loading'], true);
+    if (!action.silent) {
+      return state.set(['loading'], true);
+    }
   } else if (action.type === ENABLED_REPOSITORIES_SUCCESS) {
     const {
       page, per_page, subtotal, results, // eslint-disable-line camelcase

data/webpack/redux/reducers/RedHatRepositories/repositorySetRepositories.fixtures.js

@@ -133,3 +133,13 @@ export const enabledState = successState.setIn(
   [contentId, 'repositories', enabledIndex, 'enabled'],
   true,
 );
+
+export const enablingState = successState.setIn(
+  [contentId, 'repositories', enabledIndex, 'loading'],
+  true,
+);
+
+export const enablingFailedState = successState.setIn(
+  [contentId, 'repositories', enabledIndex, 'error'],
+  true,
+);

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

@@ -4,19 +4,49 @@ import {
   REPOSITORY_SET_REPOSITORIES_REQUEST,
   REPOSITORY_SET_REPOSITORIES_SUCCESS,
   REPOSITORY_SET_REPOSITORIES_FAILURE,
+  ENABLE_REPOSITORY_REQUEST,
+  ENABLE_REPOSITORY_FAILURE,
   REPOSITORY_ENABLED,
   REPOSITORY_DISABLED,
 } from '../../consts';
 
 import { normalizeContentSetRepositories } from '../../actions/RedHatRepositories/repositorySetRepositories';
 
+const reposMatch = (repoA, repoB) => (
+  repoA.arch === repoB.arch &&
+  repoA.releasever === repoB.releasever
+);
+
+const changeRepoState = (state, repoToChange, stateDiff) => {
+  const existingRepositorySet = state[repoToChange.contentId];
+
+  if (existingRepositorySet) {
+    const index = existingRepositorySet
+      .repositories
+      .findIndex(repo => reposMatch(repo, repoToChange));
+
+    if (index >= 0) {
+      const repo = existingRepositorySet.repositories[index];
+      return state.setIn([repoToChange.contentId, 'repositories', index], {
+        ...repo,
+        ...stateDiff,
+      });
+    }
+  }
+
+  return state;
+};
+
 const initialState = Immutable({});
 
 export default (state = initialState, action) => {
-  let existingRepositorySet;
-  let index;
-
   switch (action.type) {
+    case ENABLE_REPOSITORY_REQUEST:
+      return changeRepoState(state, action.repository, { loading: true });
+
+    case ENABLE_REPOSITORY_FAILURE:
+      return changeRepoState(state, action.payload.repository, { loading: false, error: true });
+
     case REPOSITORY_SET_REPOSITORIES_REQUEST:
       return state.set(action.contentId, {
         loading: true,
@@ -43,53 +73,14 @@ export default (state = initialState, action) => {
       });
 
     case REPOSITORY_ENABLED:
-      existingRepositorySet = state[action.repository.contentId];
-
-      if (existingRepositorySet) {
-        index = existingRepositorySet.repositories.findIndex(({ arch, releasever }) => {
-          if (arch !== action.repository.arch) {
-            return false;
-          }
-
-          if (releasever) {
-            return releasever === action.repository.releasever;
-          }
-
-          return true;
-        });
-
-        if (index >= 0) {
-          return state.setIn([action.repository.contentId, 'repositories', index, 'enabled'], true);
-        }
-      }
-
-      return state;
+      return changeRepoState(state, action.repository, {
+        enabled: true,
+        loading: false,
+        error: false,
+      });
 
     case REPOSITORY_DISABLED:
-      existingRepositorySet = state[action.repository.contentId];
-
-      if (existingRepositorySet) {
-        index = existingRepositorySet.repositories.findIndex((repo) => {
-          if (repo.arch !== action.repository.arch) {
-            return false;
-          }
-
-          if (repo.releasever) {
-            return repo.releasever === action.repository.releasever;
-          }
-
-          return true;
-        });
-
-        if (index >= 0) {
-          return state.setIn(
-            [action.repository.contentId, 'repositories', index, 'enabled'],
-            false,
-          );
-        }
-      }
-
-      return state;
+      return changeRepoState(state, action.repository, { enabled: false });
 
     default:
       return state;

data/webpack/redux/reducers/index.js

@@ -4,8 +4,11 @@ import redHatRepositories from './RedHatRepositories';
 import { subscriptions } from '../../scenes/Subscriptions';
 import { upstreamSubscriptions } from '../../scenes/Subscriptions/UpstreamSubscriptions';
 import { manifestHistory } from '../../scenes/Subscriptions/Manifest';
+import settings from '../../scenes/Settings';
 import { subscriptionDetails } from '../../scenes/Subscriptions/Details';
 import { setOrganization } from '../../components/SelectOrg/SetOrganization';
+import { moduleStreams } from '../../scenes/ModuleStreams';
+import { moduleStreamDetails } from '../../scenes/ModuleStreams/Details';
 
 export default combineReducers({
   organization,
@@ -13,6 +16,9 @@ export default combineReducers({
   subscriptions,
   upstreamSubscriptions,
   manifestHistory,
+  settings,
   subscriptionDetails,
   setOrganization,
+  moduleStreams,
+  moduleStreamDetails,
 });

data/webpack/scenes/ModuleStreams/Details/ModuleStreamDetailArtifacts.js

@@ -0,0 +1,19 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+const ModuleStreamDetailArtifacts = ({ artifacts }) => (
+  <div>
+    <ul>
+      {artifacts.map(({ id, name }) => <li key={id}>{name}</li>)}
+    </ul>
+  </div>
+);
+
+ModuleStreamDetailArtifacts.propTypes = {
+  artifacts: PropTypes.arrayOf(PropTypes.shape({
+    id: PropTypes.number,
+    name: PropTypes.string,
+  })).isRequired,
+};
+
+export default ModuleStreamDetailArtifacts;

data/webpack/scenes/ModuleStreams/Details/ModuleStreamDetailInfo.js

@@ -0,0 +1,51 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Table } from 'react-bootstrap';
+
+// using Map to preserve order
+const displayMap = new Map([
+  ['name', __('Name')],
+  ['summary', __('Summary')],
+  ['description', __('Description')],
+  ['stream', __('Stream')],
+  ['version', __('Version')],
+  ['arch', __('Arch')],
+  ['context', __('Context')],
+  ['uuid', __('UUID')],
+]);
+
+const createRows = (details, mapping) => {
+  const rows = [];
+  /* eslint-disable no-restricted-syntax, react/jsx-closing-tag-location */
+  for (const key of mapping.keys()) {
+    rows.push(<tr key={key}>
+      <td><b>{mapping.get(key)}</b></td>
+      <td>{details[key]}</td>
+    </tr>);
+  }
+  /* eslint-enable no-restricted-syntax, react/jsx-closing-tag-location */
+  return rows;
+};
+
+const ModuleStreamDetailInfo = ({ moduleStreamDetails }) => (
+  <Table>
+    <tbody>
+      {createRows(moduleStreamDetails, displayMap)}
+    </tbody>
+  </Table>
+);
+
+ModuleStreamDetailInfo.propTypes = {
+  moduleStreamDetails: PropTypes.shape({
+    name: PropTypes.string,
+    summary: PropTypes.string,
+    description: PropTypes.string,
+    stream: PropTypes.string,
+    version: PropTypes.string,
+    arch: PropTypes.string,
+    context: PropTypes.string,
+    uuid: PropTypes.string,
+  }).isRequired,
+};
+
+export default ModuleStreamDetailInfo;