katello 3.18.5 → 4.0.0.rc1

data/webpack/scenes/ContentViews/Table/tableDataGenerator.js

@@ -41,7 +41,6 @@ const buildRow = (contentView, openColumn) => {
     },
   ];
   if (openColumn) row[openColumn].props.isOpen = true;
-
   return row;
 };
 
@@ -100,7 +99,7 @@ const buildRowsAndMapping = (contentViews, newRowMapping) => {
   const rows = [];
 
   contentViews.forEach((contentView) => {
-    const { id } = contentView;
+    const { id, name } = contentView;
     const rowIndex = rows.length;
     const needsUpdate = !Object.keys(updatedRowMap).find(i => updatedRowMap[i].id === id) ||
                         !Object.keys(updatedRowMap[rowIndex] || {}).includes('expandedColumn');
@@ -109,7 +108,9 @@ const buildRowsAndMapping = (contentViews, newRowMapping) => {
     const cells = buildRow(contentView, openColumn);
     const isOpen = !!openColumn;
 
-    rows.push({ isOpen, cells });
+    rows.push({
+      cvId: id, cvName: name, isOpen, cells,
+    });
     rows.push(...buildDetailDropdowns(id, rowIndex, openColumn));
   });
 

data/webpack/scenes/ContentViews/__tests__/contentViewPage.test.js

@@ -246,4 +246,45 @@ test('No results message is shown for empty search', async (done) => {
   assertNockRequest(withSearchScope);
   assertNockRequest(searchResultScope, done);
 });
+
+test('Displays Create Content View and opens modal with Form', async () => {
+  mockAutocomplete(nockInstance, autocompleteUrl);
+
+  const noResults = {
+    total: 0,
+    subtotal: 0,
+    page: 1,
+    per_page: 20,
+    results: [],
+  };
+  nockInstance
+    .get(cvIndexPath)
+    .query(true)
+    .reply(200, noResults);
+  const {
+    getByText, queryByText, getByLabelText,
+  } = renderWithRedux(<ContentViewsPage />, renderOptions);
+  await patientlyWaitFor(() => expect(queryByText('Create content view')).toBeTruthy());
+
+  expect(queryByText('Description')).not.toBeInTheDocument();
+  expect(queryByText('Name')).not.toBeInTheDocument();
+  expect(queryByText('Label')).not.toBeInTheDocument();
+  expect(queryByText('Composite content view')).not.toBeInTheDocument();
+  expect(queryByText('Component content view')).not.toBeInTheDocument();
+  expect(queryByText('Solve Dependencies')).not.toBeInTheDocument();
+  expect(queryByText('Auto Publish')).not.toBeInTheDocument();
+  expect(queryByText('Import Only')).not.toBeInTheDocument();
+
+  getByLabelText('create_content_view').click();
+
+  expect(getByText('Description')).toBeInTheDocument();
+  expect(getByText('Name')).toBeInTheDocument();
+  expect(getByText('Label')).toBeInTheDocument();
+  expect(getByText('Composite content view')).toBeInTheDocument();
+  expect(getByText('Component content view')).toBeInTheDocument();
+  expect(getByText('Solve Dependencies')).toBeInTheDocument();
+  expect(queryByText('Auto Publish')).not.toBeInTheDocument();
+  expect(getByText('Import Only')).toBeInTheDocument();
+});
+
 /* eslint-enable no-useless-escape */

data/webpack/scenes/ContentViews/helpers.js

@@ -0,0 +1,13 @@
+import { translate as __ } from 'foremanReact/common/I18n';
+
+export const dependenciesHelpText = __('This will solve RPM and module stream dependencies on every publish of this content view. ' +
+  'Dependency solving significantly increases publish time (publishes can take over three times as long) ' +
+  'and filters will be ignored when adding packages to solve dependencies. ' +
+  'Also, certain scenarios involving errata may still cause dependency errors.');
+
+export const autoPublishHelpText = __('Automatically publish a new version of the composite content view whenever one of its content views is published. ' +
+  'Autopublish will only happen for component views that use the \'Always use latest version\' option.');
+
+export const importOnlyHelpText = __('Designate whether this content view is for importing from an upstream server. ' +
+  'Import-only content views cannot be published directly.');
+

data/webpack/scenes/SmartProxy/Content.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import SmartProxyContentTable from './SmartProxyContentTable';
+
+const Content = ({ smartProxyId }) => (
+  <SmartProxyContentTable smartProxyId={smartProxyId} />
+);
+
+Content.propTypes = {
+  smartProxyId: PropTypes.number,
+};
+
+Content.defaultProps = {
+  smartProxyId: null,
+};
+
+export default Content;

data/webpack/scenes/SmartProxy/SmartProxyContentActions.js

@@ -0,0 +1,11 @@
+import { API_OPERATIONS, get } from 'foremanReact/redux/API';
+import api, { orgId } from '../../services/api';
+import SMART_PROXY_CONTENT_KEY from './SmartProxyContentConstants';
+
+const getSmartProxyContent = ({ smartProxyId }) => get({
+  type: API_OPERATIONS.GET,
+  key: SMART_PROXY_CONTENT_KEY,
+  url: api.getApiUrl(`/capsules/${smartProxyId}/content/sync?${orgId()}`),
+});
+
+export default getSmartProxyContent;

data/webpack/scenes/SmartProxy/SmartProxyContentConstants.js

@@ -0,0 +1,3 @@
+const SMART_PROXY_CONTENT_KEY = 'SMART_PROXY_CONTENT';
+
+export default SMART_PROXY_CONTENT_KEY;

data/webpack/scenes/SmartProxy/SmartProxyContentSelectors.js

@@ -0,0 +1,16 @@
+import {
+  selectAPIStatus,
+  selectAPIError,
+  selectAPIResponse,
+} from 'foremanReact/redux/API/APISelectors';
+import { STATUS } from 'foremanReact/constants';
+import SMART_PROXY_CONTENT_KEY from './SmartProxyContentConstants';
+
+export const selectSmartProxyContent = state =>
+  selectAPIResponse(state, SMART_PROXY_CONTENT_KEY) || {};
+
+export const selectSmartProxyContentStatus = state =>
+  selectAPIStatus(state, SMART_PROXY_CONTENT_KEY) || STATUS.PENDING;
+
+export const selectSmartProxyContentError = state =>
+  selectAPIError(state, SMART_PROXY_CONTENT_KEY);

data/webpack/scenes/SmartProxy/SmartProxyContentTable.js

@@ -0,0 +1,152 @@
+import React, { useState, useEffect } from 'react';
+import PropTypes from 'prop-types';
+import { useSelector, useDispatch } from 'react-redux';
+import { wrappable } from '@patternfly/react-table';
+import { CheckCircleIcon, TimesCircleIcon } from '@patternfly/react-icons';
+import { STATUS } from 'foremanReact/constants';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { urlBuilder } from 'foremanReact/common/urlHelpers';
+import LongDateTime from 'foremanReact/components/common/dates/LongDateTime';
+import MainTable from '../../components/Table/MainTable';
+import getSmartProxyContent from './SmartProxyContentActions';
+import ContentViewIcon from '../../scenes/ContentViews/components/ContentViewIcon';
+import {
+  selectSmartProxyContent,
+  selectSmartProxyContentStatus,
+  selectSmartProxyContentError,
+} from './SmartProxyContentSelectors';
+
+const SmartProxyContentTable = ({ smartProxyId }) => {
+  const dispatch = useDispatch();
+  const [rows, setRows] = useState([]);
+  const response = useSelector(state => selectSmartProxyContent(state));
+  const status = useSelector(state => selectSmartProxyContentStatus(state));
+  const error = useSelector(state => selectSmartProxyContentError(state));
+  const columnHeaders = [
+    {
+      title: __('Environment'),
+      transforms: [wrappable],
+    },
+    {
+      title: __('Content view'),
+      transforms: [wrappable],
+    },
+    {
+      title: __('Type'),
+      transforms: [wrappable],
+    },
+    {
+      title: __('Last published'),
+      transforms: [wrappable],
+    },
+    {
+      title: __('Repositories'),
+      transforms: [wrappable],
+    },
+    {
+      title: __('Synced to smart proxy'),
+      transforms: [wrappable],
+    },
+  ];
+
+  const fetchWithParams = () => {
+    dispatch(getSmartProxyContent({ smartProxyId }));
+  };
+
+  const buildrows = (results) => {
+    const newRows = [];
+    let envCount = 0;
+    results.forEach((env) => {
+      const { name, content_views: contentViews } = env;
+      const cellEnv = {
+        isOpen: false,
+        cells: [name, null, null, null, null, null],
+      };
+      newRows.push(cellEnv);
+      contentViews.forEach((cv) => {
+        const {
+          id, name: cvName, composite, last_published: lastPublished, up_to_date: upToDate, counts,
+        } = cv;
+        const { repositories } = counts;
+        const cvType = <ContentViewIcon composite={composite} />;
+        const upToDateVal = upToDate ? <CheckCircleIcon /> : <TimesCircleIcon />;
+        const cellCv =
+          {
+            parent: envCount,
+            cells: [
+              {
+                title: null,
+                props: {
+                  colSpan: 1,
+                },
+              },
+              {
+                title: <a href={urlBuilder('content_views', '', id)}>{cvName}</a>,
+                props: {
+                  colSpan: 1,
+                },
+              },
+              {
+                title: cvType,
+                props: {
+                  colSpan: 1,
+                },
+              },
+              {
+                title: <LongDateTime date={lastPublished} showRelativeTimeTooltip />,
+                props: {
+                  colSpan: 1,
+                },
+              },
+              {
+                title: repositories,
+                props: {
+                  colSpan: 1,
+                },
+              },
+              {
+                title: upToDateVal,
+                props: {
+                  colSpan: 1,
+                },
+              },
+            ],
+          };
+        newRows.push(cellCv);
+      });
+      envCount = newRows.length;
+    });
+    return newRows;
+  };
+
+  const onCollapse = (row, setRow) => (event, rowKey, isOpen) => {
+    const newRows = [...row];
+    newRows[rowKey].isOpen = isOpen;
+    setRow(newRows);
+  };
+
+
+  useEffect(() => fetchWithParams(), []);
+
+  useEffect(() => {
+    if (status !== STATUS.PENDING && response) {
+      const { lifecycle_environments: env } = response;
+      setRows(buildrows(env));
+    }
+  }, [JSON.stringify(response), status, error]);
+
+
+  return (
+    <MainTable onCollapse={onCollapse(rows, setRows)} status={status} cells={columnHeaders} rows={rows} error={error} emptyContentTitle="No content synced" emptyContentBody="No content synced to smart proxy" emptySearchTitle="Empty" emptySearchBody="Empty" />
+  );
+};
+
+SmartProxyContentTable.propTypes = {
+  smartProxyId: PropTypes.number,
+};
+
+SmartProxyContentTable.defaultProps = {
+  smartProxyId: null,
+};
+
+export default SmartProxyContentTable;

data/webpack/scenes/SmartProxy/__tests__/SmartProxyContentResult.fixtures.json

@@ -0,0 +1,140 @@
+{
+  "last_sync_time": "2021-01-12 14:39:01 -0500",
+  "active_sync_tasks": [],
+  "last_failed_sync_tasks": [],
+  "lifecycle_environments": [
+    {
+      "library": true,
+      "id": 1,
+      "name": "Library",
+      "label": "Library",
+      "description": null,
+      "organization_id": 1,
+      "organization": {
+        "name": "Default Organization",
+        "label": "Default_Organization",
+        "id": 1
+      },
+      "syncable": false,
+      "counts": {
+        "content_hosts": 0,
+        "content_views": 2,
+        "products": 1
+      },
+      "content_views": [
+        {
+          "id": 1,
+          "label": "Default_Organization_View",
+          "name": "Default Organization View",
+          "composite": false,
+          "last_published": "2021-01-05 09:55:20 -0500",
+          "default": true,
+          "up_to_date": true,
+          "counts": {
+            "content_hosts": 0,
+            "products": 1,
+            "repositories": 2
+          }
+        },
+        {
+          "id": 2,
+          "label": "cv1",
+          "name": "cv1",
+          "composite": false,
+          "last_published": "2021-01-12 14:36:31 -0500",
+          "default": false,
+          "up_to_date": true,
+          "counts": {
+            "content_hosts": 0,
+            "products": 1,
+            "repositories": 1
+          }
+        },
+        {
+          "id": 3,
+          "label": "cv2",
+          "name": "cv2",
+          "composite": false,
+          "last_published": "2021-01-12 14:37:05 -0500",
+          "default": false,
+          "up_to_date": true,
+          "counts": {
+            "content_hosts": 0,
+            "products": 1,
+            "repositories": 1
+          }
+        }
+      ]
+    },
+    {
+      "library": false,
+      "id": 2,
+      "name": "dev",
+      "label": "dev",
+      "description": null,
+      "organization_id": 1,
+      "organization": {
+        "name": "Default Organization",
+        "label": "Default_Organization",
+        "id": 1
+      },
+      "syncable": false,
+      "counts": {
+        "content_hosts": 0,
+        "content_views": 1,
+        "products": 1
+      },
+      "content_views": [
+        {
+          "id": 2,
+          "label": "cv1",
+          "name": "cv1",
+          "composite": false,
+          "last_published": "2021-01-12 14:36:31 -0500",
+          "default": false,
+          "up_to_date": true,
+          "counts": {
+            "content_hosts": 0,
+            "products": 1,
+            "repositories": 1
+          }
+        }
+      ]
+    },
+    {
+      "library": false,
+      "id": 3,
+      "name": "test",
+      "label": "test",
+      "description": null,
+      "organization_id": 1,
+      "organization": {
+        "name": "Default Organization",
+        "label": "Default_Organization",
+        "id": 1
+      },
+      "syncable": true,
+      "counts": {
+        "content_hosts": 0,
+        "content_views": 1,
+        "products": 1
+      },
+      "content_views": [
+        {
+          "id": 2,
+          "label": "cv1",
+          "name": "cv1",
+          "composite": false,
+          "last_published": "2021-01-12 14:36:31 -0500",
+          "default": false,
+          "up_to_date": false,
+          "counts": {
+            "content_hosts": 0,
+            "products": 1,
+            "repositories": 0
+          }
+        }
+      ]
+    }
+  ]
+}

data/webpack/scenes/SmartProxy/__tests__/SmartProxyContentTest.js

@@ -0,0 +1,38 @@
+import React from 'react';
+import { renderWithRedux, patientlyWaitFor } from 'react-testing-lib-wrapper';
+
+import { nockInstance, assertNockRequest } from '../../../test-utils/nockWrapper';
+import api from '../../../services/api';
+import SmartProxyContentTable from '../SmartProxyContentTable';
+
+const smartProxyContentData = require('./SmartProxyContentResult.fixtures.json');
+
+const smartProxyContentPath = api.getApiUrl('/capsules/1/content/sync');
+
+const smartProxyContent = { ...smartProxyContentData };
+
+const contentTable = <SmartProxyContentTable smartProxyId={1} />;
+
+test('Can display Smart proxy content table', async (done) => {
+  const detailsScope = nockInstance
+    .get(smartProxyContentPath)
+    .query(true)
+    .reply(200, smartProxyContent);
+
+  const { getByText, getAllByLabelText } = renderWithRedux(contentTable);
+  await patientlyWaitFor(() => expect(getByText('Environment')).toBeInTheDocument());
+  expect(getByText('Content view')).toBeInTheDocument();
+  expect(getByText('Type')).toBeInTheDocument();
+  expect(getByText('Last published')).toBeInTheDocument();
+  expect(getByText('Repositories')).toBeInTheDocument();
+  expect(getByText('Synced to smart proxy')).toBeInTheDocument();
+  expect(getAllByLabelText('Details')[0]).toHaveAttribute('aria-expanded', 'false');
+  getAllByLabelText('Details')[0].click();
+  expect(getAllByLabelText('Details')[0]).toHaveAttribute('aria-expanded', 'true');
+  expect(getByText('Library')).toBeInTheDocument();
+  expect(getByText('Default Organization View')).toBeInTheDocument();
+  expect(getByText('dev')).toBeInTheDocument();
+
+
+  assertNockRequest(detailsScope, done);
+});

data/webpack/scenes/SmartProxy/index.js

@@ -0,0 +1,4 @@
+import { withRouter } from 'react-router-dom';
+import Content from './Content';
+
+export default withRouter(Content);

data/webpack/scenes/Subscriptions/Manifest/ManageManifestModal.js

@@ -51,11 +51,8 @@ class ManageManifestModal extends Component {
   showDeleteManifestModal = () =>
     this.props.setModalOpen({ id: DELETE_MANIFEST_MODAL_ID });
 
-  hideDeleteManifestModal = () => {
-    if (this.props.deleteManifestModalExists) {
-      this.props.setModalClosed({ id: DELETE_MANIFEST_MODAL_ID });
-    }
-  };
+  hideDeleteManifestModal = () =>
+    this.props.setModalClosed({ id: DELETE_MANIFEST_MODAL_ID });
 
   updateRepositoryUrl = (event) => {
     this.setState({ redhat_repository_url: event.target.value });
@@ -329,7 +326,6 @@ ManageManifestModal.propTypes = {
   canImportManifest: PropTypes.bool,
   canDeleteManifest: PropTypes.bool,
   isManifestImported: PropTypes.bool,
-  deleteManifestModalExists: PropTypes.bool,
   canEditOrganizations: PropTypes.bool,
   disableManifestActions: PropTypes.bool,
   disabledReason: PropTypes.string,
@@ -355,7 +351,6 @@ ManageManifestModal.defaultProps = {
   canImportManifest: false,
   canDeleteManifest: false,
   isManifestImported: false,
-  deleteManifestModalExists: false,
   canEditOrganizations: false,
   simpleContentAccess: false,
   simpleContentAccessEligible: undefined,

data/webpack/scenes/Subscriptions/Manifest/ManifestActions.js

@@ -88,7 +88,7 @@ export const checkSimpleContentAccessEligible = () => async (dispatch) => {
   dispatch({ type: SIMPLE_CONTENT_ACCESS_ELIGIBLE_REQUEST });
 
   try {
-    const { data } = await api.get(`/organizations/${orgId()}/upstream_subscriptions/simple_content_access/eligible`, {});
+    const { data } = await api.get(`/organizations/${orgId()}/simple_content_access/eligible`, {});
     return dispatch({
       type: SIMPLE_CONTENT_ACCESS_ELIGIBLE_SUCCESS,
       response: data,
@@ -106,7 +106,7 @@ export const enableSimpleContentAccess = (extendedParams = {}) => async (dispatc
   };
 
   try {
-    const { data } = await api.put(`/organizations/${orgId()}/upstream_subscriptions/simple_content_access/enable`, {}, params);
+    const { data } = await api.put(`/organizations/${orgId()}/simple_content_access/enable`, {}, params);
     return dispatch({
       type: ENABLE_SIMPLE_CONTENT_ACCESS_SUCCESS,
       response: data,
@@ -124,7 +124,7 @@ export const disableSimpleContentAccess = (extendedParams = {}) => async (dispat
   };
 
   try {
-    const { data } = await api.put(`/organizations/${orgId()}/upstream_subscriptions/simple_content_access/disable`, {}, params);
+    const { data } = await api.put(`/organizations/${orgId()}/simple_content_access/disable`, {}, params);
     return dispatch({
       type: DISABLE_SIMPLE_CONTENT_ACCESS_SUCCESS,
       response: data,

data/webpack/scenes/Subscriptions/Manifest/__tests__/ManifestActions.test.js

@@ -136,7 +136,7 @@ describe('manifest actions', () => {
 });
 
 describe('creates ENABLE_SIMPLE_CONTENT_ACCESS_REQUEST', () => {
-  const url = '/katello/api/v2/organizations/1/upstream_subscriptions/simple_content_access/enable';
+  const url = '/katello/api/v2/organizations/1/simple_content_access/enable';
 
   it('and then fails with 422', async () => {
     mockErrorRequest({
@@ -158,7 +158,7 @@ describe('creates ENABLE_SIMPLE_CONTENT_ACCESS_REQUEST', () => {
 });
 
 describe('creates DISABLE_SIMPLE_CONTENT_ACCESS_REQUEST', () => {
-  const url = '/katello/api/v2/organizations/1/upstream_subscriptions/simple_content_access/disable';
+  const url = '/katello/api/v2/organizations/1/simple_content_access/disable';
 
   it('and then fails with 422', async () => {
     mockErrorRequest({

data/webpack/scenes/Subscriptions/Manifest/__tests__/SimpleContentAccess.test.js

@@ -55,8 +55,8 @@ const initialState = {
   },
 };
 
-const enableSimpleContetAccessPath = api.getApiUrl('/organizations/1/upstream_subscriptions/simple_content_access/enable');
-const disableSimpleContetAccessPath = api.getApiUrl('/organizations/1/upstream_subscriptions/simple_content_access/disable');
+const enableSimpleContetAccessPath = api.getApiUrl('/organizations/1/simple_content_access/enable');
+const disableSimpleContetAccessPath = api.getApiUrl('/organizations/1/simple_content_access/disable');
 const manifestHistoryPath = api.getApiUrl('/organizations/1/subscriptions/manifest_history');
 
 test('Enable Simple Content Access after toggle switch value to true', async (done) => {

data/webpack/scenes/Subscriptions/Manifest/index.js

@@ -20,7 +20,6 @@ const mapStateToProps = state => ({
   simpleContentAccess: selectSimpleContentAccessEnabled(state),
   isManifestImported: selectIsManifestImported(state),
   modalOpenState: state.foremanModals.ManageManifestModal,
-  deleteManifestModalExists: !!state.foremanModals.deleteManifestModal,
   manifestActionStarted: selectManifestActionStarted(state),
   simpleContentAccessEligible: selectSimpleContentAccessEligible(state),
 });

data/webpack/test-utils/react-testing-lib-wrapper.js

@@ -8,7 +8,7 @@ import { APIMiddleware, reducers as apiReducer } from 'foremanReact/redux/API';
 import { reducers as fillReducers } from 'foremanReact/components/common/Fill';
 import { reducers as foremanModalReducer } from 'foremanReact/components/ForemanModal';
 import { STATUS } from 'foremanReact/constants';
-import { render, waitFor } from '@testing-library/react';
+import { render, waitFor, waitForElementToBeRemoved } from '@testing-library/react';
 import { createStore, applyMiddleware, combineReducers } from 'redux';
 import { Provider } from 'react-redux';
 import { MemoryRouter } from 'react-router-dom';
@@ -63,7 +63,10 @@ function renderWithRedux(
 
 // When the tests run slower, they can hit the default waitFor timeout, which is 1000ms
 // There doesn't seem to be a way to set it globally for r-t-lib, so using this wrapper function
-export const patientlyWaitFor = waitForFunc => waitFor(waitForFunc, { timeout: 5000 });
+const rtlTimeout = 5000;
+export const patientlyWaitFor = waitForFunc => waitFor(waitForFunc, { timeout: rtlTimeout });
+export const patientlyWaitForRemoval = waitForFunc =>
+  waitForElementToBeRemoved(waitForFunc, { timeout: rtlTimeout });
 
 // re-export everything, so the library can be used from this wrapper.
 export * from '@testing-library/react';

data/webpack/utils/helpers.js

@@ -96,6 +96,9 @@ export const apiError = (actionType, result, additionalData = {}) => (dispatch)
   return resultWithSuccessFlag(result);
 };
 
+export const capitalize = s => s && s[0].toUpperCase() + s.slice(1);
+
+export const truncate = (str, truncateLimit = 50) => (str.length > truncateLimit ? `${str.substring(0, truncateLimit - 3)}...` : str);
 
 export default {
   getResponseErrorMsgs,