foreman_openscap 5.0.0 → 5.1.0

data/webpack/routes/OvalContents/OvalContentsNew/__tests__/OvalContentsNew.test.js

@@ -0,0 +1,104 @@
+import React from 'react';
+
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import '@testing-library/jest-dom';
+import api from 'foremanReact/redux/API/API';
+
+import OvalContentsNew from '../OvalContentsNew';
+import { withRouter, withRedux, tick } from '../../../../testHelper';
+import { ovalContentsPath } from '../../../../helpers/pathsHelper';
+
+jest.mock('foremanReact/redux/API/API', () => ({ post: jest.fn() }));
+
+const TestComponent = withRouter(withRedux(OvalContentsNew));
+
+describe('OvalContentsNew', () => {
+  it('should create with content from URL', async () => {
+    const pushMock = jest.fn();
+    const toastMock = jest.fn();
+
+    api.post.mockImplementation(() => Promise.resolve());
+
+    render(
+      <TestComponent history={{ push: pushMock }} showToast={toastMock} />
+    );
+    expect(screen.getByText('Name')).toBeInTheDocument();
+    expect(screen.getByText('OVAL Content Source')).toBeInTheDocument();
+    expect(screen.getByText('URL')).toBeInTheDocument();
+    expect(screen.queryByText('File')).not.toBeInTheDocument();
+    expect(screen.getByText('Submit')).toBeDisabled();
+    userEvent.type(screen.getByLabelText('name'), 'test content');
+    await waitFor(tick);
+    expect(screen.getByText('Submit')).toBeDisabled();
+    userEvent.type(
+      screen.getByLabelText(/url/),
+      'http://oval-content-source.org/security/data/oval/v2/CentOS7/ansible-2.9.oval.xml.bz2'
+    );
+    await waitFor(tick);
+    expect(screen.getByText('Submit')).not.toBeDisabled();
+    userEvent.click(screen.getByText('Submit'));
+    await waitFor(tick);
+    expect(pushMock).toHaveBeenCalledWith(ovalContentsPath, {
+      refreshOvalContents: true,
+    });
+    expect(toastMock).toHaveBeenCalledWith({
+      type: 'success',
+      message: 'OVAL Content test content successfully created',
+    });
+  });
+  it('should show resource errors', async () => {
+    const pushMock = jest.fn();
+    const toastMock = jest.fn();
+    api.post.mockImplementation(() => {
+      // eslint-disable-next-line no-throw-literal
+      throw {
+        response: {
+          status: 422,
+          data: { error: { errors: { name: ['has already been taken'] } } },
+        },
+      };
+    });
+
+    render(
+      <TestComponent history={{ push: pushMock }} showToast={toastMock} />
+    );
+    userEvent.type(screen.getByLabelText('name'), 'test content');
+    userEvent.type(
+      screen.getByLabelText(/url/),
+      'http://oval-content-source.org/security/data/oval/v2/CentOS7/ansible-2.9.oval.xml.bz2'
+    );
+    await waitFor(tick);
+    userEvent.click(screen.getByText('Submit'));
+    await waitFor(tick);
+    expect(pushMock).not.toHaveBeenCalled();
+    expect(screen.getByText('has already been taken')).toBeInTheDocument();
+  });
+  it('should show error toast on unexpected error', async () => {
+    const pushMock = jest.fn();
+    const toastMock = jest.fn();
+
+    api.post.mockImplementation(() => {
+      // eslint-disable-next-line no-throw-literal
+      throw { response: { status: 500 } };
+    });
+
+    render(
+      <TestComponent history={{ push: pushMock }} showToast={toastMock} />
+    );
+    userEvent.type(screen.getByLabelText('name'), 'test content');
+    userEvent.type(
+      screen.getByLabelText(/url/),
+      'http://oval-content-source.org/security/data/oval/v2/CentOS7/ansible-2.9.oval.xml.bz2'
+    );
+    await waitFor(tick);
+    userEvent.click(screen.getByText('Submit'));
+    await waitFor(tick);
+    expect(pushMock).not.toHaveBeenCalled();
+    expect(screen.getByText('Submit')).not.toBeDisabled();
+    expect(toastMock).toHaveBeenCalledWith({
+      type: 'error',
+      message: 'Unknown error when submitting data, please try again later.',
+    });
+  });
+});

data/webpack/routes/OvalContents/OvalContentsNew/index.js

@@ -0,0 +1,13 @@
+import React from 'react';
+import { useDispatch } from 'react-redux';
+import { showToast } from '../../../helpers/toastHelper';
+
+import OvalContentsNew from './OvalContentsNew';
+
+const WrappedOvalContentsNew = props => {
+  const dispatch = useDispatch();
+
+  return <OvalContentsNew {...props} showToast={showToast(dispatch)} />;
+};
+
+export default WrappedOvalContentsNew;

data/webpack/routes/OvalContents/OvalContentsShow/OvalContentsShow.js

@@ -0,0 +1,62 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Helmet } from 'react-helmet';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import {
+  Grid,
+  GridItem,
+  TextContent,
+  Text,
+  TextVariants,
+} from '@patternfly/react-core';
+
+import withLoading from '../../../components/withLoading';
+
+const OvalContentsShow = ({ ovalContent }) => {
+  let contentSource;
+  if (ovalContent.url) {
+    contentSource = (
+      <React.Fragment>
+        <Text component={TextVariants.h3}>{__('URL')}</Text>
+        <Text component={TextVariants.p}>{ovalContent.url || ''}</Text>
+      </React.Fragment>
+    );
+  } else {
+    contentSource = (
+      <React.Fragment>
+        <Text component={TextVariants.h3}>{__('File')}</Text>
+        <Text component={TextVariants.p}>
+          {ovalContent.originalFilename || ''}
+        </Text>
+      </React.Fragment>
+    );
+  }
+
+  return (
+    <React.Fragment>
+      <Helmet>
+        <title>{`${ovalContent.name} | ${__('OVAL Content')}`}</title>
+      </Helmet>
+      <Grid className="scap-page-grid">
+        <GridItem span={10}>
+          <Text component={TextVariants.h1}>{ovalContent.name}</Text>
+        </GridItem>
+        <GridItem span={2} />
+        <GridItem span={12}>
+          <TextContent className="pf-u-pt-md">
+            <Text component={TextVariants.h3}>{__('Name')}</Text>
+            <Text component={TextVariants.p}>{ovalContent.name}</Text>
+            {contentSource}
+          </TextContent>
+        </GridItem>
+      </Grid>
+    </React.Fragment>
+  );
+};
+
+OvalContentsShow.propTypes = {
+  ovalContent: PropTypes.object.isRequired,
+};
+
+export default withLoading(OvalContentsShow);

data/webpack/routes/OvalContents/OvalContentsShow/OvalContentsShow.test.js

@@ -0,0 +1,45 @@
+import React from 'react';
+import '@testing-library/jest-dom';
+import { render, screen, waitFor } from '@testing-library/react';
+
+import { withMockedProvider, tick } from '../../../testHelper';
+import ovalContentQuery from '../../../graphql/queries/ovalContent.gql';
+import OvalContentsShow from './';
+
+const TestComponent = withMockedProvider(OvalContentsShow);
+
+const matchMock = { params: { id: 4 } };
+const name = 'dotnet OVAL content';
+const url =
+  'http://oval-content-source/security/data/oval/dotnet-2.2.oval.xml.bz2';
+const id = 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsQ29udGVudC00';
+
+const mocks = [
+  {
+    request: {
+      query: ovalContentQuery,
+      variables: { id },
+    },
+    result: {
+      data: {
+        ovalContent: {
+          id,
+          name,
+          url,
+          originalFilename: '',
+        },
+      },
+    },
+  },
+];
+
+describe('OVAL Contents show page', () => {
+  it('should show OVAL Content', async () => {
+    render(<TestComponent match={matchMock} mocks={mocks} />);
+    expect(screen.getByText('Loading')).toBeInTheDocument();
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(screen.getAllByText(name).length === 2).toBeTruthy();
+    expect(screen.getByText(url)).toBeInTheDocument();
+  });
+});

data/webpack/routes/OvalContents/OvalContentsShow/index.js

@@ -0,0 +1,35 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { useQuery } from '@apollo/client';
+
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import OvalContentsShow from './OvalContentsShow';
+import { encodeId } from '../../../helpers/globalIdHelper';
+
+import ovalContent from '../../../graphql/queries/ovalContent.gql';
+
+const WrappedOvalContentsShow = props => {
+  const id = encodeId('ForemanOpenscap::OvalContent', props.match.params.id);
+
+  const useFetchFn = componentProps =>
+    useQuery(ovalContent, { variables: { id } });
+
+  const renameData = data => ({ ovalContent: data.ovalContent });
+
+  return (
+    <OvalContentsShow
+      {...props}
+      fetchFn={useFetchFn}
+      renameData={renameData}
+      resultPath="ovalContent"
+      emptyStateTitle={__('No OVAL Content found')}
+    />
+  );
+};
+
+WrappedOvalContentsShow.propTypes = {
+  match: PropTypes.object.isRequired,
+};
+
+export default WrappedOvalContentsShow;

data/webpack/routes/OvalPolicies/OvalPoliciesIndex/OvalPoliciesIndex.js

@@ -4,6 +4,8 @@ import { useQuery } from '@apollo/client';
 import { translate as __ } from 'foremanReact/common/I18n';
 
 import OvalPoliciesTable from './OvalPoliciesTable';
+import { submitDelete, prepareMutation } from '../../../helpers/mutationHelper';
+
 import IndexLayout from '../../../components/IndexLayout';
 
 import {
@@ -11,10 +13,9 @@ import {
   useCurrentPagination,
 } from '../../../helpers/pageParamsHelper';
 import policiesQuery from '../../../graphql/queries/ovalPolicies.gql';
+import deleteOvalPolicyMutation from '../../../graphql/mutations/deleteOvalPolicy.gql';
 
 const OvalPoliciesIndex = props => {
-  const pagination = useCurrentPagination(props.history);
-
   const useFetchFn = componentProps =>
     useQuery(policiesQuery, {
       variables: useParamsToVars(componentProps.history),
@@ -25,6 +26,8 @@ const OvalPoliciesIndex = props => {
     totalCount: data.ovalPolicies.totalCount,
   });
 
+  const pagination = useCurrentPagination(props.history);
+
   return (
     <IndexLayout pageTitle={__('OVAL Policies')}>
       <OvalPoliciesTable
@@ -35,6 +38,17 @@ const OvalPoliciesIndex = props => {
         pagination={pagination}
         emptyStateTitle={__('No OVAL Policies found')}
         permissions={['view_oval_policies']}
+        confirmDeleteTitle={__('Delete OVAL Policy')}
+        submitDelete={submitDelete}
+        prepareMutation={prepareMutation(
+          props.history,
+          props.showToast,
+          policiesQuery,
+          'deleteOvalPolicy',
+          __('OVAL policy was successfully deleted.'),
+          deleteOvalPolicyMutation,
+          __('OVAL policy')
+        )}
       />
     </IndexLayout>
   );
@@ -42,6 +56,7 @@ const OvalPoliciesIndex = props => {
 
 OvalPoliciesIndex.propTypes = {
   history: PropTypes.object.isRequired,
+  showToast: PropTypes.func.isRequired,
 };
 
 export default OvalPoliciesIndex;

data/webpack/routes/OvalPolicies/OvalPoliciesIndex/OvalPoliciesTable.js

@@ -4,6 +4,7 @@ import { translate as __ } from 'foremanReact/common/I18n';
 
 import IndexTable from '../../../components/IndexTable';
 import withLoading from '../../../components/withLoading';
+import withDeleteModal from '../../../components/withDeleteModal';
 
 import { linkCell } from '../../../helpers/tableHelper';
 import { ovalPoliciesPath, modelPath } from '../../../helpers/pathsHelper';
@@ -19,13 +20,24 @@ const OvalPoliciesTable = props => {
     policy,
   }));
 
-  const actions = [];
+  const actionResolver = (rowData, rest) => {
+    const actions = [];
+    if (rowData.policy.meta.canDestroy) {
+      actions.push({
+        title: __('Delete OVAL Policy'),
+        onClick: (event, rowId, rData, extra) => {
+          props.toggleModal(rData.policy);
+        },
+      });
+    }
+    return actions;
+  };
 
   return (
     <IndexTable
       columns={columns}
       rows={rows}
-      actions={actions}
+      actionResolver={actionResolver}
       pagination={props.pagination}
       totalCount={props.totalCount}
       history={props.history}
@@ -39,6 +51,7 @@ OvalPoliciesTable.propTypes = {
   pagination: PropTypes.object.isRequired,
   totalCount: PropTypes.number.isRequired,
   history: PropTypes.object.isRequired,
+  toggleModal: PropTypes.func.isRequired,
 };
 
-export default withLoading(OvalPoliciesTable);
+export default withLoading(withDeleteModal(OvalPoliciesTable));

data/webpack/routes/OvalPolicies/OvalPoliciesIndex/__tests__/OvalPoliciesDestroy.fixtures.js

@@ -0,0 +1,101 @@
+import policiesQuery from '../../../../graphql/queries/ovalPolicies.gql';
+import deleteOvalPolicy from '../../../../graphql/mutations/deleteOvalPolicy.gql';
+
+import { admin } from '../../../../testHelper';
+
+export const firstCall = {
+  data: {
+    ovalPolicies: {
+      totalCount: 5,
+      nodes: [
+        {
+          __typename: 'ForemanOpenscap::OvalPolicy',
+          id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTQz',
+          name: 'first policy',
+          meta: { canDestroy: true },
+          ovalContent: { name: 'foo' },
+        },
+        {
+          __typename: 'ForemanOpenscap::OvalPolicy',
+          id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTQ0',
+          name: 'second policy',
+          meta: { canDestroy: true },
+          ovalContent: { name: 'foo' },
+        },
+      ],
+    },
+    currentUser: admin,
+  },
+};
+
+export const secondCall = {
+  data: {
+    ovalPolicies: {
+      totalCount: 4,
+      nodes: [
+        {
+          id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTQ0',
+          name: 'second policy',
+          meta: { canDestroy: true },
+          ovalContent: { name: 'foo' },
+        },
+        {
+          id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTQ1',
+          name: 'third policy',
+          meta: { canDestroy: true },
+          ovalContent: { name: 'foo' },
+        },
+      ],
+    },
+    currentUser: admin,
+  },
+};
+
+export const deleteMockFactory = (first, second, errors = null) => {
+  let called = false;
+
+  const deleteMocks = [
+    {
+      request: {
+        query: deleteOvalPolicy,
+        variables: {
+          id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTQz',
+        },
+      },
+      result: {
+        data: {
+          deleteOvalPolicy: {
+            __typename: 'ForemanOpenscap::OvalPolicy',
+            id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTQz',
+            errors,
+          },
+        },
+      },
+    },
+    {
+      request: {
+        query: policiesQuery,
+        variables: {
+          first: 2,
+          last: 2,
+        },
+      },
+      newData: () => {
+        if (called && !errors) {
+          return second;
+        } else if (called && errors) {
+          return first;
+        }
+        called = true;
+        return first;
+      },
+    },
+  ];
+  return deleteMocks;
+};
+
+export const pageParamsHistoryMock = {
+  location: {
+    search: '?page=1&perPage=2',
+  },
+};

data/webpack/routes/OvalPolicies/OvalPoliciesIndex/__tests__/OvalPoliciesDestroy.test.js

@@ -0,0 +1,117 @@
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import userEvent from '@testing-library/user-event';
+
+import OvalPoliciesIndex from '../OvalPoliciesIndex';
+import {
+  withRouter,
+  withRedux,
+  withMockedProvider,
+  tick,
+  historyMock,
+} from '../../../../testHelper';
+import { mocks, noDeleteMocks } from './OvalPoliciesIndex.fixtures';
+import {
+  firstCall,
+  secondCall,
+  deleteMockFactory,
+  pageParamsHistoryMock,
+} from './OvalPoliciesDestroy.fixtures';
+
+const TestComponent = withRouter(
+  withRedux(withMockedProvider(OvalPoliciesIndex))
+);
+
+describe('OvalPoliciesIndex', () => {
+  it('should open and close delete modal', async () => {
+    render(
+      <TestComponent
+        history={historyMock}
+        mocks={mocks}
+        showToast={jest.fn()}
+      />
+    );
+    await waitFor(tick);
+    expect(screen.getByText('first policy')).toBeInTheDocument();
+    userEvent.click(screen.getAllByRole('button', { name: 'Actions' })[0]);
+    userEvent.click(screen.getByText('Delete OVAL Policy'));
+    await waitFor(tick);
+    expect(
+      screen.getByText('Are you sure you want to delete first policy?')
+    ).toBeInTheDocument();
+    userEvent.click(screen.getByText('Cancel'));
+    await waitFor(tick);
+    expect(
+      screen.queryByText('Are you sure you want to delete first policy?')
+    ).not.toBeInTheDocument();
+    expect(screen.getByText('first policy')).toBeInTheDocument();
+  });
+  it('should delete OVAL policy', async () => {
+    const showToast = jest.fn();
+    render(
+      <TestComponent
+        history={pageParamsHistoryMock}
+        mocks={deleteMockFactory(firstCall, secondCall)}
+        showToast={showToast}
+      />
+    );
+    await waitFor(tick);
+    expect(screen.getByText('first policy')).toBeInTheDocument();
+    expect(screen.queryByText('third policy')).not.toBeInTheDocument();
+    userEvent.click(screen.getAllByRole('button', { name: 'Actions' })[0]);
+    userEvent.click(screen.getByText('Delete OVAL Policy'));
+    await waitFor(tick);
+    userEvent.click(screen.getByText('Confirm'));
+    await waitFor(tick);
+    expect(showToast).toHaveBeenCalledWith({
+      type: 'success',
+      message: 'OVAL policy was successfully deleted.',
+    });
+    await waitFor(tick);
+    expect(screen.queryByText('first policy')).not.toBeInTheDocument();
+    expect(screen.getByText('third policy')).toBeInTheDocument();
+  });
+  it('should show error when deleting OVAL policy fails', async () => {
+    const showToast = jest.fn();
+    render(
+      <TestComponent
+        history={pageParamsHistoryMock}
+        mocks={deleteMockFactory(firstCall, secondCall, [
+          { message: 'cannot do it', path: 'base' },
+          { message: 'will not do it', path: 'base' },
+        ])}
+        showToast={showToast}
+      />
+    );
+    await waitFor(tick);
+    expect(screen.getByText('first policy')).toBeInTheDocument();
+    expect(screen.queryByText('third policy')).not.toBeInTheDocument();
+    userEvent.click(screen.getAllByRole('button', { name: 'Actions' })[0]);
+    userEvent.click(screen.getByText('Delete OVAL Policy'));
+    await waitFor(tick);
+    userEvent.click(screen.getByText('Confirm'));
+    await waitFor(tick);
+    expect(showToast).toHaveBeenCalledWith({
+      type: 'error',
+      message:
+        'There was a following error when deleting OVAL policy: cannot do it, will not do it',
+    });
+    expect(screen.getByText('first policy')).toBeInTheDocument();
+    expect(screen.queryByText('third policy')).not.toBeInTheDocument();
+  });
+  it('should not show delete button when user does not have delete permissions', async () => {
+    render(
+      <TestComponent
+        history={historyMock}
+        mocks={noDeleteMocks}
+        showToast={jest.fn()}
+      />
+    );
+    await waitFor(tick);
+    expect(screen.getByText('first policy')).toBeInTheDocument();
+    expect(
+      screen.queryByRole('button', { name: 'Actions' })
+    ).not.toBeInTheDocument();
+  });
+});