foreman_openscap 4.3.2 → 5.2.0

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

@@ -1,12 +1,19 @@
 import React from 'react';
 import PropTypes from 'prop-types';
+import { Button } from '@patternfly/react-core';
+
 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';
+import {
+  ovalPoliciesPath,
+  modelPath,
+  ovalPoliciesNewPath,
+} from '../../../helpers/pathsHelper';
 
 const OvalPoliciesTable = props => {
   const columns = [{ title: __('Name') }, { title: __('OVAL Content') }];
@@ -19,17 +26,39 @@ 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;
+  };
+
+  const createBtn = (
+    <Button
+      onClick={() => props.history.push(ovalPoliciesNewPath)}
+      variant="primary"
+      aria-label="create_oval_policy"
+    >
+      {__('Create OVAL Policy')}
+    </Button>
+  );
 
   return (
     <IndexTable
       columns={columns}
       rows={rows}
-      actions={actions}
+      actionResolver={actionResolver}
       pagination={props.pagination}
       totalCount={props.totalCount}
       history={props.history}
       ariaTableLabel={__('OVAL Policies Table')}
+      toolbarBtns={createBtn}
     />
   );
 };
@@ -39,6 +68,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();
+  });
+});

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

@@ -1,6 +1,11 @@
 import policiesQuery from '../../../../graphql/queries/ovalPolicies.gql';
 import { ovalPoliciesPath } from '../../../../helpers/pathsHelper';
-import { mockFactory } from '../../../../testHelper';
+import {
+  mockFactory,
+  admin,
+  intruder,
+  userFactory,
+} from '../../../../testHelper';
 
 const policiesMockFactory = mockFactory('ovalPolicies', policiesQuery);
 
@@ -14,23 +19,37 @@ export const pageParamsHistoryMock = {
   push: pushMock,
 };
 
+const viewer = userFactory('viewer', [
+  {
+    __typename: 'Permission',
+    id: 'MDE6UGVybWlzc2lvbi0yOTY=',
+    name: 'view_oval_policies',
+  },
+]);
+
+const firstPolicy = (meta = { canDestroy: true }) => ({
+  __typename: 'ForemanOpenscap::OvalPolicy',
+  id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTE=',
+  name: 'first policy',
+  meta,
+  ovalContent: { name: 'first content' },
+});
+const secondPolicy = (meta = { canDestroy: true }) => ({
+  __typename: 'ForemanOpenscap::OvalPolicy',
+  id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTQw',
+  name: 'second policy',
+  meta,
+  ovalContent: { name: 'second content' },
+});
+const policiesData = {
+  totalCount: 2,
+  nodes: [firstPolicy(), secondPolicy()],
+};
+
 export const mocks = policiesMockFactory(
   { first: 20, last: 20 },
-  {
-    totalCount: 2,
-    nodes: [
-      {
-        id: 'abc',
-        name: 'first policy',
-        ovalContent: { name: 'first content' },
-      },
-      {
-        id: 'xyz',
-        name: 'second policy',
-        ovalContent: { name: 'second content' },
-      },
-    ],
-  }
+  policiesData,
+  { currentUser: admin }
 );
 export const pageParamsMocks = policiesMockFactory(
   { first: 10, last: 5 },
@@ -38,24 +57,55 @@ export const pageParamsMocks = policiesMockFactory(
     totalCount: 7,
     nodes: [
       {
-        id: 'xyz',
+        __typename: 'ForemanOpenscap::OvalPolicy',
+        id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTQx',
         name: 'sixth policy',
+        meta: { canDestroy: true },
         ovalContent: { name: 'sixth content' },
       },
       {
-        id: 'abc',
+        __typename: 'ForemanOpenscap::OvalPolicy',
+        id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTQy',
         name: 'seventh policy',
+        meta: { canDestroy: true },
         ovalContent: { name: 'seventh content' },
       },
     ],
-  }
+  },
+  { currentUser: admin }
 );
+
 export const emptyMocks = policiesMockFactory(
   { first: 20, last: 20 },
-  { totalCount: 0, nodes: [] }
+  { totalCount: 0, nodes: [] },
+  { currentUser: admin }
 );
 export const errorMocks = policiesMockFactory(
   { first: 20, last: 20 },
   { totalCount: 0, nodes: [] },
-  [{ message: 'Something very bad happened.' }]
+  {
+    errors: [{ message: 'Something very bad happened.', path: 'base' }],
+    currentUser: admin,
+  }
+);
+export const viewerMocks = policiesMockFactory(
+  { first: 20, last: 20 },
+  policiesData,
+  { currentUser: viewer }
+);
+export const unauthorizedMocks = policiesMockFactory(
+  { first: 20, last: 20 },
+  policiesData,
+  { currentUser: intruder }
+);
+export const noDeleteMocks = policiesMockFactory(
+  { first: 20, last: 20 },
+  {
+    totalCount: 2,
+    nodes: [
+      firstPolicy({ canDestroy: false }),
+      secondPolicy({ canDestroy: false }),
+    ],
+  },
+  { currentUser: admin }
 );

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

@@ -7,6 +7,7 @@ import '@testing-library/jest-dom';
 import {
   withMockedProvider,
   withRouter,
+  withRedux,
   tick,
   historyMock,
 } from '../../../../testHelper';
@@ -18,12 +19,16 @@ import {
   pageParamsHistoryMock,
   emptyMocks,
   errorMocks,
+  viewerMocks,
+  unauthorizedMocks,
 } from './OvalPoliciesIndex.fixtures';
 
-import OvalPoliciesIndex from '../OvalPoliciesIndex';
+import OvalPoliciesIndex from '../index';
 import { ovalPoliciesPath } from '../../../../helpers/pathsHelper';
 
-const TestComponent = withRouter(withMockedProvider(OvalPoliciesIndex));
+const TestComponent = withRouter(
+  withRedux(withMockedProvider(OvalPoliciesIndex))
+);
 
 describe('OvalPoliciesIndex', () => {
   it('should load page', async () => {
@@ -40,6 +45,15 @@ describe('OvalPoliciesIndex', () => {
     expect(within(pageItems).getByText(/1 - 2/)).toBeInTheDocument();
     expect(within(pageItems).getByText('of')).toBeInTheDocument();
     expect(within(pageItems).getByText('2')).toBeInTheDocument();
+
+    expect(screen.getByText('first policy').closest('a')).toHaveAttribute(
+      'href',
+      '/experimental/compliance/oval_policies/1'
+    );
+    expect(screen.getByText('second policy').closest('a')).toHaveAttribute(
+      'href',
+      '/experimental/compliance/oval_policies/40'
+    );
   });
   it('should load page with page params', async () => {
     const { container } = render(
@@ -75,4 +89,22 @@ describe('OvalPoliciesIndex', () => {
     ).toBeInTheDocument();
     expect(screen.getByText('Error!')).toBeInTheDocument();
   });
+  it('should load page for user with permissions', async () => {
+    render(<TestComponent history={historyMock} mocks={viewerMocks} />);
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(screen.getByText('first policy')).toBeInTheDocument();
+  });
+  it('should not load page for user without permissions', async () => {
+    render(<TestComponent history={historyMock} mocks={unauthorizedMocks} />);
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(screen.queryByText('first policy')).not.toBeInTheDocument();
+    expect(
+      screen.getByText(
+        'You are not authorized to view the page. Request the following permissions from administrator: view_oval_policies.'
+      )
+    ).toBeInTheDocument();
+    expect(screen.getByText('Permission denied')).toBeInTheDocument();
+  });
 });

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

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

data/webpack/routes/OvalPolicies/OvalPoliciesNew/HostgroupSelect.js

@@ -0,0 +1,135 @@
+import React, { useState } from 'react';
+import PropTypes from 'prop-types';
+import { useLazyQuery } from '@apollo/client';
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import {
+  Select,
+  SelectOption,
+  SelectVariant,
+  FormGroup,
+} from '@patternfly/react-core';
+import { ExclamationCircleIcon } from '@patternfly/react-icons';
+import hostgroupsQuery from '../../../graphql/queries/hostgroups.gql';
+
+const HostgroupSelect = ({
+  selected,
+  setSelected,
+  hgsError,
+  showError,
+  setShowError,
+}) => {
+  const [isOpen, setIsOpen] = useState(false);
+
+  const [typingTimeout, setTypingTimeout] = useState(null);
+
+  const [fetchHostgroups, { loading, data, error }] = useLazyQuery(
+    hostgroupsQuery
+  );
+  const results = data?.hostgroups?.nodes ? data.hostgroups.nodes : [];
+
+  const onSelect = (event, selection) => {
+    if (selected.find(item => item.name === selection)) {
+      setSelected(selected.filter(item => item.name !== selection));
+    } else {
+      const hg = results.find(item => item.name === selection);
+      setSelected([...selected, hg]);
+    }
+  };
+
+  const onClear = () => {
+    if (showError) {
+      setShowError(false);
+    }
+    setSelected([]);
+  };
+
+  const onInputChange = value => {
+    if (showError) {
+      setShowError(false);
+    }
+    if (typingTimeout) {
+      clearTimeout(typingTimeout);
+    }
+    const variables = { search: `name ~ ${value}` };
+    setTypingTimeout(setTimeout(() => fetchHostgroups({ variables }), 500));
+  };
+
+  const shouldValidate = (err, shouldShowError) => {
+    if (shouldShowError) {
+      return err ? 'error' : 'success';
+    }
+    return 'noval';
+  };
+
+  const prepareOptions = fetchedResults => {
+    if (loading) {
+      return [
+        <SelectOption isDisabled key={0}>
+          {__('Loading...')}
+        </SelectOption>,
+      ];
+    }
+
+    if (error) {
+      return [
+        <SelectOption isDisabled key={0}>
+          {sprintf('Failed to fetch hostgroups, cause: %s', error.message)}
+        </SelectOption>,
+      ];
+    }
+
+    if (fetchedResults.length > 20) {
+      return [
+        <SelectOption isDisabled key={0}>
+          {sprintf(
+            'You have %s hostgroups to display. Please refine your search.',
+            fetchedResults.length
+          )}
+        </SelectOption>,
+      ];
+    }
+
+    return fetchedResults.map((hg, idx) => (
+      <SelectOption key={hg.id} value={hg.name} />
+    ));
+  };
+
+  return (
+    <FormGroup
+      label={__('Hostgroups')}
+      helperTextInvalidIcon={<ExclamationCircleIcon />}
+      helperTextInvalid={showError && hgsError}
+      validated={shouldValidate(hgsError, showError)}
+    >
+      <Select
+        variant={SelectVariant.typeaheadMulti}
+        typeAheadAriaLabel="Select a hostgroup"
+        placeholderText="Type a hostroup name..."
+        onToggle={() => setIsOpen(!isOpen)}
+        onSelect={onSelect}
+        onClear={onClear}
+        selections={selected.map(item => item.name)}
+        isOpen={isOpen}
+        onTypeaheadInputChanged={onInputChange}
+        validated={shouldValidate(hgsError, showError)}
+      >
+        {prepareOptions(results)}
+      </Select>
+    </FormGroup>
+  );
+};
+
+HostgroupSelect.propTypes = {
+  selected: PropTypes.array,
+  setSelected: PropTypes.func.isRequired,
+  hgsError: PropTypes.string,
+  showError: PropTypes.bool.isRequired,
+  setShowError: PropTypes.func.isRequired,
+};
+
+HostgroupSelect.defaultProps = {
+  selected: [],
+  hgsError: '',
+};
+
+export default HostgroupSelect;