foreman_ansible 6.4.1 → 7.0.0

data/webpack/components/AnsibleHostDetail/components/JobsTab/PreviousJobsTable.js

@@ -0,0 +1,103 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { usePaginationOptions } from 'foremanReact/components/Pagination/PaginationHooks';
+
+import RelativeDateTime from 'foremanReact/components/common/dates/RelativeDateTime';
+
+import {
+  TableComposable,
+  Thead,
+  Tbody,
+  Tr,
+  Th,
+  Td,
+} from '@patternfly/react-table';
+import { Flex, FlexItem, Pagination } from '@patternfly/react-core';
+
+import { decodeId } from '../../../../globalIdHelper';
+import withLoading from '../../../withLoading';
+import {
+  preparePerPageOptions,
+  refreshPage,
+} from '../../../../helpers/paginationHelper';
+
+const PreviousJobsTable = ({ history, totalCount, jobs, pagination }) => {
+  const columns = [
+    __('Description'),
+    __('Result'),
+    __('State'),
+    __('Executed at'),
+    __('Schedule'),
+  ];
+
+  const handlePerPageSelected = (event, perPage) => {
+    refreshPage(history, { page: 1, perPage });
+  };
+
+  const handlePageSelected = (event, page) => {
+    refreshPage(history, { ...pagination, page });
+  };
+
+  const perPageOptions = preparePerPageOptions(usePaginationOptions());
+
+  return (
+    <React.Fragment>
+      <h3>{__('Previously executed jobs')}</h3>
+      <Flex className="pf-u-pt-md">
+        <FlexItem align={{ default: 'alignRight' }}>
+          <Pagination
+            itemCount={totalCount}
+            page={pagination.page}
+            perPage={pagination.perPage}
+            onSetPage={handlePageSelected}
+            onPerPageSelect={handlePerPageSelected}
+            perPageOptions={perPageOptions}
+            variant="top"
+          />
+        </FlexItem>
+      </Flex>
+      <TableComposable variant="compact">
+        <Thead>
+          <Tr>
+            {columns.map(col => (
+              <Th key={col}>{col}</Th>
+            ))}
+          </Tr>
+        </Thead>
+        <Tbody>
+          {jobs.map(job => (
+            <Tr key={job.id}>
+              <Td>
+                <a
+                  onClick={() =>
+                    window.tfm.nav.pushUrl(
+                      `/job_invocations/${decodeId(job.id)}`
+                    )
+                  }
+                >
+                  {job.description}
+                </a>
+              </Td>
+              <Td>{job.task.result}</Td>
+              <Td>{job.task.state}</Td>
+              <Td>
+                <RelativeDateTime date={job.startAt} />
+              </Td>
+              <Td>{job.recurringLogic.cronLine}</Td>
+            </Tr>
+          ))}
+        </Tbody>
+      </TableComposable>
+    </React.Fragment>
+  );
+};
+
+PreviousJobsTable.propTypes = {
+  jobs: PropTypes.array.isRequired,
+  history: PropTypes.object.isRequired,
+  totalCount: PropTypes.number.isRequired,
+  pagination: PropTypes.object.isRequired,
+};
+
+export default withLoading(PreviousJobsTable);

data/webpack/components/AnsibleHostDetail/components/JobsTab/RecurringJobsTable.js

@@ -0,0 +1,96 @@
+import React from 'react';
+import { useDispatch } from 'react-redux';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+import RelativeDateTime from 'foremanReact/components/common/dates/RelativeDateTime';
+import { openConfirmModal } from 'foremanReact/components/ConfirmModal';
+
+import {
+  TableComposable,
+  Thead,
+  Tbody,
+  Tr,
+  Th,
+  Td,
+} from '@patternfly/react-table';
+
+import { useCancelMutation } from './JobsTabHelper';
+import withLoading from '../../../withLoading';
+import { decodeId } from '../../../../globalIdHelper';
+
+const RecurringJobsTable = ({ jobs, resourceName, resourceId }) => {
+  const columns = [__('Description'), __('Schedule'), __('Next Run')];
+  const dispatch = useDispatch();
+
+  const [callMutation] = useCancelMutation(resourceName, resourceId);
+
+  const onJobCancel = rlId => () => {
+    dispatch(
+      openConfirmModal({
+        title: __('Cancel Ansible config job'),
+        message: __('Are you sure you want to cancel Ansible config job?'),
+        isWarning: true,
+        onConfirm: () => callMutation({ variables: { id: rlId } }),
+      })
+    );
+  };
+
+  const actionItems = job => {
+    const items = [];
+    if (job.recurringLogic.meta.canEdit) {
+      items.push({
+        title: __('Cancel'),
+        onClick: onJobCancel(job.recurringLogic.id),
+        key: 'cancel',
+      });
+    }
+
+    return { items };
+  };
+
+  return (
+    <React.Fragment>
+      <h3>{__('Scheduled recurring jobs')}</h3>
+      <TableComposable variant="compact">
+        <Thead>
+          <Tr>
+            {columns.map(col => (
+              <Th key={col}>{col}</Th>
+            ))}
+            <Th />
+          </Tr>
+        </Thead>
+        <Tbody>
+          {jobs.map(job => (
+            <Tr key={job.id}>
+              <Td>
+                <a
+                  onClick={() =>
+                    window.tfm.nav.pushUrl(
+                      `/job_invocations/${decodeId(job.id)}`
+                    )
+                  }
+                >
+                  {job.description}
+                </a>
+              </Td>
+              <Td>{job.recurringLogic.cronLine}</Td>
+              <Td>
+                <RelativeDateTime date={job.startAt} />
+              </Td>
+              <Td actions={actionItems(job)} />
+            </Tr>
+          ))}
+        </Tbody>
+      </TableComposable>
+    </React.Fragment>
+  );
+};
+
+RecurringJobsTable.propTypes = {
+  jobs: PropTypes.array.isRequired,
+  resourceId: PropTypes.number.isRequired,
+  resourceName: PropTypes.string.isRequired,
+};
+
+export default withLoading(RecurringJobsTable);

data/webpack/components/AnsibleHostDetail/components/JobsTab/__test__/JobsTab.fixtures.js

@@ -0,0 +1,184 @@
+import { scheduledJobsSearch, previousJobsSearch } from '../JobsTabHelper';
+import { admin, mockFactory, userFactory } from '../../../../../testHelper';
+
+import recurringJobsQuery from '.../../../../graphql/queries/recurringJobs.gql';
+import createJobMutation from '../../../../../graphql/mutations/createJobInvocation.gql';
+import cancelRecurringLogicMutation from '../../../../../graphql/mutations/cancelRecurringLogic.gql';
+
+import { toVars, toCron } from '../NewRecurringJobHelper';
+
+export const hostId = 3;
+
+const today = new Date();
+const futureDate = new Date(today.setDate(today.getDate() + 3));
+futureDate.setMilliseconds(0);
+futureDate.setSeconds(0);
+export { futureDate };
+
+const viewer = userFactory('viewer', [
+  { id: 'MDE6UGVybWlzc2lvbi0zMjE=', name: 'view_recurring_logics' },
+  { id: 'MDE6UGVybWlzc2lvbi0yNTg=', name: 'view_job_invocations' },
+  { id: 'MDE6UGVybWlzc2lvbi0xNzg=', name: 'view_foreman_tasks' },
+]);
+
+const firstRecurringLogicGlobalId =
+  'MDE6Rm9yZW1hblRhc2tzOjpSZWN1cnJpbmdMb2dpYy0x';
+const firstRecurringLogic = {
+  __typename: 'ForemanTasks::RecurringLogic',
+  id: firstRecurringLogicGlobalId,
+  cronLine: toCron(futureDate, 'weekly'),
+  meta: {
+    canEdit: true,
+  },
+};
+
+const secondRecurringLogic = {
+  ...firstRecurringLogic,
+  id: 'MDE6Rm9yZW1hblRhc2tzOjpSZWN1cnJpbmdMb2dpYy03NQ==',
+  meta: {
+    canEdit: false,
+  },
+};
+
+export const firstJob = {
+  __typename: 'JobInvocation',
+  id: 'MDE6Sm9iSW52b2NhdGlvbi0yNTY=',
+  description: 'Run Ansible roles',
+  startAt: futureDate.toISOString(),
+  statusLabel: 'queued',
+  recurringLogic: firstRecurringLogic,
+  task: {
+    __typename: 'ForemanTasks::Task',
+    id:
+      'MDE6Rm9yZW1hblRhc2tzOjpUYXNrLTg2OGE5NjRlLWZmMzctNGUxZS1iMzVkLTA5NzdkY2JkOTZhMw==',
+    state: 'scheduled',
+    result: 'pending',
+  },
+};
+
+export const secondJob = {
+  __typename: 'JobInvocation',
+  id: 'MDE6Sm9iSW52b2NhdGlvbi0yNzE=',
+  description: 'Run Ansible roles',
+  startAt: '2021-06-31T13:37:00+02:00',
+  statusLabel: 'succeeded',
+  recurringLogic: {
+    __typename: 'ForemanTasks::RecurringLogic',
+    id: 'MDE6Rm9yZW1hblRhc2tzOjpSZWN1cnJpbmdMb2dpYy0yMw==',
+    cronLine: '54 10 15 * *',
+    meta: {
+      canEdit: true,
+    },
+  },
+  task: {
+    __typename: 'ForemanTasks::Task',
+    id:
+      'MDE6Rm9yZW1hblRhc2tzOjpUYXNrLWY4ZDJkZTU4LWQ3YmMtNGQ5OS05NDZkLTI4NDNlZWRhYzUwZQ==',
+    state: 'stopped',
+    result: 'success',
+  },
+};
+
+export const thirdJob = {
+  ...firstJob,
+  id: 'MDE6Sm9iSW52b2NhdGlvbi00NDg=',
+  recurringLogic: secondRecurringLogic,
+};
+
+export const jobInvocationsMockFactory = mockFactory(
+  'jobInvocations',
+  recurringJobsQuery
+);
+export const jobCreateMockFactory = mockFactory(
+  'createJobInvocation',
+  createJobMutation
+);
+
+const jobCancelMockFactory = mockFactory(
+  'cancelRecurringLogic',
+  cancelRecurringLogicMutation
+);
+
+const emptyScheduledJobsMock = jobInvocationsMockFactory(
+  { search: scheduledJobsSearch('host', hostId) },
+  { nodes: [], totalCount: 0 },
+  { currentUser: admin }
+);
+const emptyScheduledViewerMock = jobInvocationsMockFactory(
+  { search: scheduledJobsSearch('host', hostId) },
+  { nodes: [], totalCount: 0 },
+  { currentUser: viewer }
+);
+const scheduledViewerMock = jobInvocationsMockFactory(
+  { search: scheduledJobsSearch('host', hostId) },
+  { nodes: [thirdJob], totalCount: 1 },
+  { currentUser: viewer }
+);
+const emptyScheduledJobsRefetchMock = jobInvocationsMockFactory(
+  { search: scheduledJobsSearch('host', hostId) },
+  { nodes: [], totalCount: 0 },
+  { refetchData: { nodes: [firstJob], totalCount: 1 }, currentUser: admin }
+);
+const emptyPreviousJobsMock = jobInvocationsMockFactory(
+  { search: previousJobsSearch('host', hostId), first: 20, last: 20 },
+  { nodes: [], totalCount: 0 },
+  { currentUser: admin }
+);
+const emptyPreviousViewerMock = jobInvocationsMockFactory(
+  { search: previousJobsSearch('host', hostId) },
+  { nodes: [], totalCount: 0 },
+  { currentUser: viewer }
+);
+const scheduledJobsMocks = jobInvocationsMockFactory(
+  { search: scheduledJobsSearch('host', hostId) },
+  { nodes: [firstJob], totalCount: 1 },
+  { currentUser: admin }
+);
+const previousJobsMocks = jobInvocationsMockFactory(
+  { search: previousJobsSearch('host', hostId), first: 20, last: 20 },
+  { nodes: [secondJob], totalCount: 1 },
+  { currentUser: admin }
+);
+
+export const emptyMocks = emptyScheduledJobsMock.concat(emptyPreviousJobsMock);
+export const emptyViewerMocks = emptyScheduledViewerMock.concat(
+  emptyPreviousViewerMock
+);
+
+export const scheduledAndPreviousMocks = scheduledJobsMocks.concat(
+  previousJobsMocks
+);
+
+const createJobMock = jobCreateMockFactory(
+  toVars('host', hostId, futureDate, 'weekly').variables,
+  { jobInvocation: { id: 'MDE6Sm9iSW52b2NhdGlvbi00MTU=' }, errors: [] }
+);
+
+export const createMocks = emptyScheduledJobsRefetchMock
+  .concat(emptyPreviousJobsMock)
+  .concat(createJobMock);
+
+const scheduledWithRefetch = jobInvocationsMockFactory(
+  { search: scheduledJobsSearch('host', hostId) },
+  { nodes: [firstJob], totalCount: 1 },
+  { refetchData: { nodes: [], totalCount: 0 }, currentUser: admin }
+);
+
+const previousWithRefetch = jobInvocationsMockFactory(
+  { search: previousJobsSearch('host', hostId), first: 20, last: 20 },
+  { nodes: [], totalCount: 0 },
+  { refetchData: { nodes: [firstJob], totalCount: 1 }, currentUser: admin }
+);
+
+const cancelJobMock = jobCancelMockFactory(
+  { id: firstRecurringLogicGlobalId },
+  { recurringLogic: firstRecurringLogic, errors: [] }
+);
+
+export const cancelMocks = scheduledWithRefetch
+  .concat(previousWithRefetch)
+  .concat(cancelJobMock);
+
+export const cancelViewerMocks = scheduledViewerMock.concat(
+  emptyPreviousViewerMock
+);

data/webpack/components/AnsibleHostDetail/components/JobsTab/__test__/JobsTab.test.js

@@ -0,0 +1,195 @@
+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 { i18nProviderWrapperFactory } from 'foremanReact/common/i18nProviderWrapperFactory';
+import JobsTab from '../';
+import {
+  emptyMocks,
+  emptyViewerMocks,
+  scheduledAndPreviousMocks,
+  cancelMocks,
+  cancelViewerMocks,
+  createMocks,
+  hostId,
+  futureDate,
+} from './JobsTab.fixtures';
+import * as toasts from '../../../../../toastHelper';
+
+import { toCron } from '../NewRecurringJobHelper';
+
+import {
+  tick,
+  withRouter,
+  withMockedProvider,
+  withRedux,
+  historyMock,
+} from '../../../../../testHelper';
+
+const TestComponent = withRedux(withRouter(withMockedProvider(JobsTab)));
+
+const now = new Date('2021-08-28 00:00:00 -1100');
+const ComponentWithIntl = i18nProviderWrapperFactory(now, 'UTC')(TestComponent);
+
+describe('JobsTab', () => {
+  it('should load the page', async () => {
+    render(
+      <ComponentWithIntl
+        resourceName="host"
+        resourceId={hostId}
+        mocks={scheduledAndPreviousMocks}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    await waitFor(tick);
+    screen
+      .getAllByText('Run Ansible roles')
+      .map(element => expect(element).toBeInTheDocument());
+    expect(screen.getByText('Scheduled recurring jobs')).toBeInTheDocument();
+    expect(screen.getByText('Previously executed jobs')).toBeInTheDocument();
+    expect(screen.getByText(toCron(futureDate, 'weekly'))).toBeInTheDocument();
+    expect(screen.getByText('54 10 15 * *')).toBeInTheDocument();
+  });
+  it('should show empty state', async () => {
+    render(
+      <ComponentWithIntl
+        resourceName="host"
+        resourceId={hostId}
+        mocks={emptyMocks}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    await waitFor(tick);
+    expect(
+      screen.getByText('No config job for Ansible roles scheduled')
+    ).toBeInTheDocument();
+    expect(screen.getByText('Schedule recurring job')).toBeInTheDocument();
+  });
+  it('should not show create button for viewer', async () => {
+    render(
+      <ComponentWithIntl
+        resourceName="host"
+        resourceId={hostId}
+        mocks={emptyViewerMocks}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    await waitFor(tick);
+    expect(
+      screen.getByText('No config job for Ansible roles scheduled')
+    ).toBeInTheDocument();
+    expect(
+      screen.queryByText('Schedule recurring job')
+    ).not.toBeInTheDocument();
+  });
+  it('should create new recurring job', async () => {
+    const showToast = jest.fn();
+    jest.spyOn(toasts, 'showToast').mockImplementation(showToast);
+
+    render(
+      <ComponentWithIntl
+        resourceName="host"
+        resourceId={hostId}
+        mocks={createMocks}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    userEvent.click(
+      screen.getByRole('button', { name: 'schedule recurring job' })
+    );
+    await waitFor(tick);
+    userEvent.selectOptions(screen.getByLabelText(/repeat/), 'weekly');
+    userEvent.type(
+      screen.getByLabelText(/startTime/),
+      futureDate
+        .toISOString()
+        .split('T')[1]
+        .slice(0, 5)
+    );
+    userEvent.type(
+      screen.getByLabelText(/startDate/),
+      futureDate.toISOString().split('T')[0]
+    );
+    expect(
+      screen.getByRole('button', { name: 'submit creating job' })
+    ).not.toBeDisabled();
+    userEvent.click(
+      screen.getByRole('button', { name: 'submit creating job' })
+    );
+    await waitFor(tick);
+    await waitFor(tick);
+    await waitFor(tick);
+    expect(showToast).toHaveBeenCalledWith({
+      type: 'success',
+      message: 'Ansible job was successfully created.',
+    });
+    await waitFor(tick);
+    expect(screen.getByText(toCron(futureDate, 'weekly'))).toBeInTheDocument();
+    expect(screen.getByText('in 3 days')).toBeInTheDocument();
+    expect(
+      screen.queryByText('No config job for Ansible roles scheduled')
+    ).not.toBeInTheDocument();
+  });
+  it('should cancel existing recurring job', async () => {
+    const showToast = jest.fn();
+    jest.spyOn(toasts, 'showToast').mockImplementation(showToast);
+    render(
+      <ComponentWithIntl
+        resourceId={hostId}
+        resourceName="host"
+        history={historyMock}
+        mocks={cancelMocks}
+      />
+    );
+    await waitFor(tick);
+    await waitFor(tick);
+    expect(
+      screen.queryByText('No config job for Ansible roles scheduled')
+    ).not.toBeInTheDocument();
+    userEvent.click(screen.getAllByRole('button', { name: 'Actions' })[0]);
+    userEvent.click(screen.getByText('Cancel'));
+    await waitFor(tick);
+    expect(
+      screen.getByText('Are you sure you want to cancel Ansible config job?')
+    ).toBeInTheDocument();
+    userEvent.click(screen.getByText('Confirm'));
+    await waitFor(tick);
+    await waitFor(tick);
+    expect(showToast).toHaveBeenCalledWith({
+      type: 'success',
+      message: 'Ansible job was successfully canceled.',
+    });
+    expect(
+      screen.queryByText('Are you sure you want to cancel Ansible config job?')
+    ).not.toBeInTheDocument();
+    await waitFor(tick);
+    await waitFor(tick);
+    await waitFor(tick);
+    expect(
+      screen.getByText('No config job for Ansible roles scheduled')
+    ).toBeInTheDocument();
+  });
+  it('should not show cancel button if user is not allowed to cancel', async () => {
+    render(
+      <ComponentWithIntl
+        resourceId={hostId}
+        resourceName="host"
+        history={historyMock}
+        mocks={cancelViewerMocks}
+      />
+    );
+    await waitFor(tick);
+    await waitFor(tick);
+    expect(
+      screen.queryByText('No config job for Ansible roles scheduled')
+    ).not.toBeInTheDocument();
+    expect(screen.queryAllByRole('button', { name: 'Actions' })).toHaveLength(
+      0
+    );
+  });
+});

data/webpack/components/AnsibleHostDetail/components/JobsTab/index.js

@@ -0,0 +1,88 @@
+import React, { useState } from 'react';
+import PropTypes from 'prop-types';
+
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import { Grid, GridItem, Button } from '@patternfly/react-core';
+
+import { fetchRecurringFn, fetchPreviousFn, renameData } from './JobsTabHelper';
+import {
+  useParamsToVars,
+  useCurrentPagination,
+} from '../../../../helpers/pageParamsHelper';
+
+import RecurringJobsTable from './RecurringJobsTable';
+import PreviousJobsTable from './PreviousJobsTable';
+import NewRecurringJobModal from './NewRecurringJobModal';
+
+const JobsTab = ({ resourceName, resourceId, history }) => {
+  const [modalOpen, setModalOpen] = useState(false);
+  const toggleModal = () => setModalOpen(!modalOpen);
+
+  const permissions = [
+    'view_job_invocations',
+    'view_recurring_logics',
+    'view_foreman_tasks',
+  ];
+
+  const pagination = useCurrentPagination(history);
+
+  const primaryActionPermissions = [
+    'create_job_invocations',
+    'create_recurring_logics',
+  ];
+
+  const scheduleBtn = (
+    <Button aria-label="schedule recurring job" onClick={toggleModal}>
+      {__('Schedule recurring job')}
+    </Button>
+  );
+
+  return (
+    <Grid>
+      <GridItem span={12}>
+        <RecurringJobsTable
+          resourceId={resourceId}
+          resourceName={resourceName}
+          fetchFn={fetchRecurringFn}
+          renameData={renameData}
+          renamedDataPath="jobs"
+          emptyStateProps={{
+            header: __('No config job for Ansible roles scheduled'),
+            action: scheduleBtn,
+          }}
+          permissions={permissions}
+          primaryActionPermissions={primaryActionPermissions}
+        />
+      </GridItem>
+      <GridItem span={12}>
+        <PreviousJobsTable
+          resourceId={resourceId}
+          resourceName={resourceName}
+          fetchFn={fetchPreviousFn(useParamsToVars(history))}
+          renameData={renameData}
+          emptyWrapper={() => null}
+          renamedDataPath="jobs"
+          emptyStateProps={{ header: __('No previous job executions found') }}
+          permissions={permissions}
+          pagination={pagination}
+          history={history}
+        />
+      </GridItem>
+      <NewRecurringJobModal
+        isOpen={modalOpen}
+        onClose={toggleModal}
+        resourceId={resourceId}
+        resourceName={resourceName}
+      />
+    </Grid>
+  );
+};
+
+JobsTab.propTypes = {
+  resourceName: PropTypes.string.isRequired,
+  resourceId: PropTypes.number.isRequired,
+  history: PropTypes.object.isRequired,
+};
+
+export default JobsTab;