foreman_remote_execution 14.1.4 → 15.0.0

data/webpack/JobInvocationDetail/TemplateInvocationComponents/TemplateActionButtons.js

@@ -0,0 +1,224 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { useDispatch, useSelector } from 'react-redux';
+import { Flex, FlexItem, Button } from '@patternfly/react-core';
+import { ActionsColumn } from '@patternfly/react-table';
+import { APIActions } from 'foremanReact/redux/API';
+import { addToast } from 'foremanReact/components/ToastsList';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { selectTemplateInvocation } from '../JobInvocationSelectors';
+
+const actions = ({
+  taskID,
+  jobID,
+  hostID,
+  taskCancellable,
+  permissions,
+  dispatch,
+}) => ({
+  rerun: {
+    name: 'template-invocation-rerun-job',
+    href: `/job_invocations/${jobID}/rerun?host_ids[]=${hostID}`,
+    component: 'a',
+    text: __('Rerun'),
+    permission: permissions.execute_jobs,
+  },
+  details: {
+    name: 'template-invocation-task-details',
+    href: `/foreman_tasks/tasks/${taskID}`,
+    component: 'a',
+    text: __('Task Details'),
+    permission: permissions.view_foreman_tasks,
+  },
+  cancel: {
+    name: 'template-invocation-cancel-job',
+    text: __('Cancel Task'),
+    permission: permissions.cancel_job_invocations,
+    onClick: () => {
+      dispatch(
+        addToast({
+          key: `cancel-job-info`,
+          type: 'info',
+          message: __('Trying to cancel the task for the host'),
+        })
+      );
+      dispatch(
+        APIActions.post({
+          url: `/foreman_tasks/tasks/${taskID}/cancel`,
+          key: 'CANCEL_TASK',
+          errorToast: ({ response }) => response.data.message,
+          successToast: () => __('Task for the host cancelled succesfully'),
+        })
+      );
+    },
+    isDisabled: !taskCancellable,
+  },
+  abort: {
+    name: 'template-invocation-abort-job',
+    text: __('Abort task'),
+    permission: permissions.cancel_job_invocations,
+    onClick: () => {
+      dispatch(
+        addToast({
+          key: `abort-job-info`,
+          type: 'info',
+          message: __('Trying to abort the task for the host'),
+        })
+      );
+      dispatch(
+        APIActions.post({
+          url: `/foreman_tasks/tasks/${taskID}/abort`,
+          key: 'ABORT_TASK',
+          errorToast: ({ response }) => response.data.message,
+          successToast: () => __('task aborted succesfully'),
+        })
+      );
+    },
+    isDisabled: !taskCancellable,
+  },
+});
+
+export const RowActions = ({ hostID, jobID }) => {
+  const dispatch = useDispatch();
+  const response = useSelector(selectTemplateInvocation);
+  if (!response?.permissions) return null;
+  const {
+    task_id: taskID,
+    task_cancellable: taskCancellable,
+    permissions,
+  } = response;
+
+  const getActions = actions({
+    taskID,
+    jobID,
+    hostID,
+    taskCancellable,
+    permissions,
+    dispatch,
+  });
+  const rowActions = Object.values(getActions)
+    .map(({ text, onClick, href, permission, isDisabled }) =>
+      permission
+        ? {
+            title: href ? (
+              <a href={href} target="_blank" rel="noreferrer">
+                {text}
+              </a>
+            ) : (
+              text
+            ),
+            onClick,
+            isDisabled,
+          }
+        : null
+    )
+    .filter(Boolean);
+
+  return <ActionsColumn items={rowActions} />;
+};
+
+export const TemplateActionButtons = ({
+  taskID,
+  jobID,
+  hostID,
+  taskCancellable,
+  permissions,
+}) => {
+  const dispatch = useDispatch();
+  const { rerun, details, cancel, abort } = actions({
+    taskID,
+    jobID,
+    hostID,
+    taskCancellable,
+    permissions,
+    dispatch,
+  });
+  return (
+    <Flex align={{ default: 'alignRight' }}>
+      {rerun.permission && (
+        <FlexItem spacer={{ default: 'spacerXs' }}>
+          <Button
+            isSmall
+            variant="secondary"
+            isInline
+            ouiaId={rerun.name}
+            href={rerun.href}
+            component="a"
+            target="_blank"
+          >
+            {rerun.text}
+          </Button>
+        </FlexItem>
+      )}
+      {details.permission && (
+        <FlexItem spacer={{ default: 'spacerXs' }}>
+          <Button
+            isSmall
+            variant="secondary"
+            isInline
+            ouiaId={details.name}
+            href={details.href}
+            component="a"
+            target="_blank"
+          >
+            {details.text}
+          </Button>
+        </FlexItem>
+      )}
+      {cancel.permission && (
+        <FlexItem spacer={{ default: 'spacerXs' }}>
+          <Button
+            isSmall
+            variant="danger"
+            isInline
+            ouiaId={cancel.name}
+            onClick={cancel.onClick}
+            isDisabled={cancel.isDisabled}
+          >
+            {cancel.text}
+          </Button>
+        </FlexItem>
+      )}
+      {abort.permission && (
+        <FlexItem spacer={{ default: 'spacerXs' }}>
+          <Button
+            isSmall
+            variant="danger"
+            isInline
+            ouiaId={abort.name}
+            onClick={abort.onClick}
+            isDisabled={abort.isDisabled}
+          >
+            {abort.text}
+          </Button>
+        </FlexItem>
+      )}
+    </Flex>
+  );
+};
+TemplateActionButtons.propTypes = {
+  taskID: PropTypes.string,
+  jobID: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
+  hostID: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
+  taskCancellable: PropTypes.bool,
+  permissions: PropTypes.shape({
+    view_foreman_tasks: PropTypes.bool,
+    cancel_job_invocations: PropTypes.bool,
+    execute_jobs: PropTypes.bool,
+  }),
+};
+
+TemplateActionButtons.defaultProps = {
+  taskID: null,
+  taskCancellable: false,
+  permissions: {
+    view_foreman_tasks: false,
+    cancel_job_invocations: false,
+    execute_jobs: false,
+  },
+};
+
+RowActions.propTypes = {
+  hostID: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
+  jobID: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
+};

data/webpack/JobInvocationDetail/TemplateInvocationPage.js

@@ -0,0 +1,53 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { useSelector } from 'react-redux';
+import PageLayout from 'foremanReact/routes/common/PageLayout/PageLayout';
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import { TemplateInvocation } from './TemplateInvocation';
+import { selectTemplateInvocation } from './JobInvocationSelectors';
+import { jobInvocationDetailsUrl } from './JobInvocationConstants';
+
+const TemplateInvocationPage = ({
+  match: {
+    params: { hostID, jobID },
+  },
+}) => {
+  const {
+    job_invocation_description: jobDescription,
+    host_name: hostName,
+  } = useSelector(selectTemplateInvocation);
+  const description = sprintf(__('Template Invocation for %s'), hostName);
+  const breadcrumbOptions = {
+    breadcrumbItems: [
+      { caption: __('Jobs'), url: `/job_invocations` },
+      { caption: jobDescription, url: jobInvocationDetailsUrl(jobID) },
+      { caption: hostName },
+    ],
+    isPf4: true,
+  };
+  return (
+    <PageLayout
+      header={description}
+      breadcrumbOptions={breadcrumbOptions}
+      searchable={false}
+    >
+      <TemplateInvocation
+        hostID={hostID}
+        jobID={jobID}
+        isInTableView={false}
+        hostName={hostName}
+      />
+    </PageLayout>
+  );
+};
+
+TemplateInvocationPage.propTypes = {
+  match: PropTypes.shape({
+    params: PropTypes.shape({
+      jobID: PropTypes.string.isRequired,
+      hostID: PropTypes.string.isRequired,
+    }).isRequired,
+  }).isRequired,
+};
+
+export default TemplateInvocationPage;

data/webpack/JobInvocationDetail/__tests__/MainInformation.test.js

@@ -105,7 +105,7 @@ describe('JobInvocationDetailPage', () => {
     expect(screen.getByText('Succeeded: 2')).toBeInTheDocument();
     expect(screen.getByText('Failed: 4')).toBeInTheDocument();
     expect(screen.getByText('In Progress: 0')).toBeInTheDocument();
-    expect(screen.getByText('Canceled: 0')).toBeInTheDocument();
+    expect(screen.getByText('Cancelled: 0')).toBeInTheDocument();
 
     const informationToCheck = {
       'Effective user:': jobInvocationData.effective_user,

data/webpack/JobInvocationDetail/__tests__/OpenAlInvocations.test.js

@@ -0,0 +1,110 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom/extend-expect';
+import { OpenAlInvocations, PopupAlert } from '../OpenAlInvocations';
+import { templateInvocationPageUrl } from '../JobInvocationConstants';
+
+// Mock the templateInvocationPageUrl function
+jest.mock('../JobInvocationConstants', () => ({
+  ...jest.requireActual('../JobInvocationConstants'),
+  templateInvocationPageUrl: jest.fn((resultId, id) => `url/${resultId}/${id}`),
+}));
+
+describe('OpenAlInvocations', () => {
+  const mockResults = [{ id: 1 }, { id: 2 }, { id: 3 }];
+  const mockSetShowAlert = jest.fn();
+  let windowSpy;
+  const windowOpen = window.open;
+
+  beforeAll(() => {
+    window.open = () => {};
+  });
+  afterAll(() => {
+    windowSpy.mockRestore();
+    jest.clearAllMocks();
+    window.open = windowOpen;
+  });
+
+  test('renders without crashing', () => {
+    render(
+      <OpenAlInvocations
+        results={mockResults}
+        id="test-id"
+        setShowAlert={mockSetShowAlert}
+      />
+    );
+  });
+
+  test('opens links when results length is less than or equal to 3', () => {
+    render(
+      <OpenAlInvocations
+        results={mockResults}
+        id="test-id"
+        setShowAlert={mockSetShowAlert}
+      />
+    );
+
+    const button = screen.getByRole('button', { name: /open all/i });
+    fireEvent.click(button);
+
+    expect(templateInvocationPageUrl).toHaveBeenCalledTimes(mockResults.length);
+    mockResults.forEach(result => {
+      expect(templateInvocationPageUrl).toHaveBeenCalledWith(
+        result.id,
+        'test-id'
+      );
+    });
+  });
+
+  test('shows modal when results length is greater than 3', () => {
+    const largeResults = [...mockResults, { id: 4 }];
+    render(
+      <OpenAlInvocations
+        results={largeResults}
+        id="test-id"
+        setShowAlert={mockSetShowAlert}
+      />
+    );
+
+    const button = screen.getByRole('button', { name: /open all/i });
+    fireEvent.click(button);
+
+    expect(
+      screen.getAllByText(/open all invocations in new tabs/i)
+    ).toHaveLength(2);
+  });
+
+  test('shows alert when popups are blocked', () => {
+    window.open = jest.fn().mockReturnValueOnce(null);
+
+    render(
+      <OpenAlInvocations
+        results={mockResults}
+        id="test-id"
+        setShowAlert={mockSetShowAlert}
+      />
+    );
+
+    const button = screen.getByRole('button', { name: /open all/i });
+    fireEvent.click(button);
+
+    expect(mockSetShowAlert).toHaveBeenCalledWith(true);
+  });
+});
+
+describe('PopupAlert', () => {
+  const mockSetShowAlert = jest.fn();
+
+  test('renders without crashing', () => {
+    render(<PopupAlert setShowAlert={mockSetShowAlert} />);
+  });
+
+  test('closes alert when close button is clicked', () => {
+    render(<PopupAlert setShowAlert={mockSetShowAlert} />);
+
+    const closeButton = screen.getByRole('button', { name: /close/i });
+    fireEvent.click(closeButton);
+
+    expect(mockSetShowAlert).toHaveBeenCalledWith(false);
+  });
+});

data/webpack/JobInvocationDetail/__tests__/OutputCodeBlock.test.js

@@ -0,0 +1,69 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom/extend-expect';
+import { OutputCodeBlock } from '../TemplateInvocationComponents/OutputCodeBlock';
+import { jobInvocationOutput } from './fixtures';
+
+const mockShowOutputType = {
+  stdout: true,
+  stderr: true,
+  debug: true,
+};
+
+describe('OutputCodeBlock', () => {
+  beforeAll(() => {
+    Element.prototype.scrollTo = () => {};
+  });
+  afterAll(() => {
+    delete Element.prototype.scrollTo;
+  });
+  test('displays the correct output', () => {
+    render(
+      <OutputCodeBlock
+        code={jobInvocationOutput}
+        showOutputType={mockShowOutputType}
+        scrollElement="body"
+      />
+    );
+
+    expect(screen.getByText('3:')).toBeInTheDocument();
+    expect(screen.getByText('This is red text')).toHaveStyle('color: red');
+    expect(screen.getByText('This is green text')).toHaveStyle(
+      'color: lightgreen'
+    );
+  });
+
+  test('displays no output message when filtered', () => {
+    render(
+      <OutputCodeBlock
+        code={jobInvocationOutput}
+        showOutputType={{ stdout: false, stderr: false, debug: false }}
+        scrollElement="body"
+      />
+    );
+
+    expect(
+      screen.getByText('No output for the selected filters')
+    ).toBeInTheDocument();
+  });
+
+  test('scrolls to top and bottom', async () => {
+    render(
+      <div className="template-invocation">
+        <div className="invocation-output" style={{ overflow: 'auto' }}>
+          <OutputCodeBlock
+            code={jobInvocationOutput}
+            showOutputType={mockShowOutputType}
+            scrollElement=".invocation-output"
+          />
+        </div>
+      </div>
+    );
+
+    const scrollToTopButton = screen.getByText('Scroll to top');
+    const scrollToBottomButton = screen.getByText('Scroll to bottom');
+
+    fireEvent.click(scrollToTopButton);
+    fireEvent.click(scrollToBottomButton);
+  });
+});

data/webpack/JobInvocationDetail/__tests__/TemplateInvocation.test.js

@@ -0,0 +1,131 @@
+import React from 'react';
+import configureMockStore from 'redux-mock-store';
+import { Provider } from 'react-redux';
+import { render, screen, act, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom/extend-expect';
+import * as APIHooks from 'foremanReact/common/hooks/API/APIHooks';
+import * as api from 'foremanReact/redux/API';
+import { TemplateInvocation } from '../TemplateInvocation';
+import { mockTemplateInvocationResponse } from './fixtures';
+
+jest.spyOn(api, 'get');
+jest.mock('foremanReact/common/hooks/API/APIHooks');
+APIHooks.useAPI.mockImplementation(() => ({
+  response: mockTemplateInvocationResponse,
+  status: 'RESOLVED',
+}));
+
+const mockStore = configureMockStore([]);
+const store = mockStore({
+  HOSTS_API: {
+    response: {
+      subtotal: 3,
+    },
+  },
+});
+describe('TemplateInvocation', () => {
+  test('render', async () => {
+    render(
+      <Provider store={store}>
+        <TemplateInvocation
+          hostID="1"
+          jobID="1"
+          isInTableView={false}
+          hostName="example-host"
+        />
+      </Provider>
+    );
+
+    expect(screen.getByText('Target:')).toBeInTheDocument();
+    expect(screen.getByText('example-host')).toBeInTheDocument();
+
+    expect(screen.getByText('This is red text')).toBeInTheDocument();
+    expect(screen.getByText('This is default text')).toBeInTheDocument();
+  });
+  test('filtering toggles', () => {
+    render(
+      <Provider store={store}>
+        <TemplateInvocation
+          hostID="1"
+          jobID="1"
+          isInTableView={false}
+          hostName="example-host"
+        />
+      </Provider>
+    );
+
+    act(() => {
+      fireEvent.click(screen.getByText('STDOUT'));
+      fireEvent.click(screen.getByText('DEBUG'));
+      fireEvent.click(screen.getByText('STDERR'));
+    });
+    expect(
+      screen.queryAllByText('No output for the selected filters')
+    ).toHaveLength(1);
+    expect(screen.queryAllByText('Exit status: 1')).toHaveLength(0);
+    expect(
+      screen.queryAllByText('StandardError: Job execution failed')
+    ).toHaveLength(0);
+
+    act(() => {
+      fireEvent.click(screen.getByText('STDOUT'));
+    });
+    expect(
+      screen.queryAllByText('No output for the selected filters')
+    ).toHaveLength(0);
+    expect(screen.queryAllByText('Exit status: 1')).toHaveLength(1);
+    expect(
+      screen.queryAllByText('StandardError: Job execution failed')
+    ).toHaveLength(0);
+
+    act(() => {
+      fireEvent.click(screen.getByText('DEBUG'));
+    });
+    expect(
+      screen.queryAllByText('No output for the selected filters')
+    ).toHaveLength(0);
+    expect(screen.queryAllByText('Exit status: 1')).toHaveLength(1);
+    expect(
+      screen.queryAllByText('StandardError: Job execution failed')
+    ).toHaveLength(1);
+  });
+  test('displays an error alert when there is an error', async () => {
+    APIHooks.useAPI.mockImplementation(() => ({
+      response: { response: { data: { error: 'Error message' } } },
+      status: 'ERROR',
+    }));
+
+    render(
+      <TemplateInvocation
+        hostID="1"
+        jobID="1"
+        isInTableView={false}
+        hostName="example-host"
+      />
+    );
+
+    expect(
+      screen.getByText(
+        'An error occurred while fetching the template invocation details.'
+      )
+    ).toBeInTheDocument();
+    expect(screen.getByText('Error message')).toBeInTheDocument();
+  });
+
+  test('displays a skeleton while loading', async () => {
+    APIHooks.useAPI.mockImplementation(() => ({
+      response: {},
+      status: 'PENDING',
+    }));
+    render(
+      <TemplateInvocation
+        hostID="1"
+        jobID="1"
+        isInTableView={false}
+        hostName="example-host"
+      />
+    );
+
+    expect(document.querySelectorAll('.pf-c-skeleton')).toHaveLength(1);
+  });
+});