foreman-tasks 12.2.3 → 12.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 200260a81901f7159c565c8188aa71de7b80bc0583b7cf3bf6432a2541130567
-  data.tar.gz: 3cb1afe2a7706fe328155ac0b32da0864155dfcb9e97a7b026283ba020f41489
+  metadata.gz: 23f5d844abe59e29a92b15f62c0770e4c3c1b577a1315232c422d976fa77a07e
+  data.tar.gz: 5d6316649f6cb75894b966301e5d8abefa579d472ddb33052d06e9d32210b869
 SHA512:
-  metadata.gz: 26157491f3be0ce0e7386008c492476db1e49d28d28934f1139daec25771626d3e7813c3e858b501020f719930ad4fee3fcf6a54850bb661d4104b0628676993
-  data.tar.gz: d295b0470a35efb6a20801431614256612fdb16fb9f85f6c2c79ffdfaf0bd384656986d82f9d1bf0072b68366420884fbb552638152ccf9ca397f4c8a20a14c8
+  metadata.gz: 7b16c2a1cd40296f38805bddb2a96879ed09d4288e7dc03c8061ba6b561333c96f9e9aa213b583349bce844580b85cc24833ca49f617e67730d3e6b28edf4773
+  data.tar.gz: 2b147d1a8a95389cb7c6a12c4fefea577cdec04f8c0ca66315b4411e62f968b1255b4a82438c014300bfd8d67eb0b9a0bea6fcaf277f1eb2d7058a8feaf5375f

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '12.2.3'.freeze
+  VERSION = '12.2.4'.freeze
 end

data/webpack/ForemanTasks/Components/TaskActions/TaskAction.test.js

@@ -1,4 +1,3 @@
-import { testActionSnapshotWithFixtures } from '@theforeman/test';
 import { API } from 'foremanReact/redux/API';
 import {
   cancelTaskRequest,
@@ -6,6 +5,20 @@ import {
   forceCancelTaskRequest,
   unlockTaskRequest,
 } from './';
+import {
+  TASKS_CANCEL_REQUEST,
+  TASKS_CANCEL_SUCCESS,
+  TASKS_CANCEL_FAILURE,
+  TASKS_RESUME_REQUEST,
+  TASKS_RESUME_SUCCESS,
+  TASKS_RESUME_FAILURE,
+  TASKS_FORCE_CANCEL_REQUEST,
+  TASKS_FORCE_CANCEL_SUCCESS,
+  TASKS_FORCE_CANCEL_FAILURE,
+  TASKS_UNLOCK_REQUEST,
+  TASKS_UNLOCK_SUCCESS,
+  TASKS_UNLOCK_FAILURE,
+} from './TaskActionsConstants';
 
 jest.mock('foremanReact/components/common/table', () => ({
   getTableItemsAction: jest.fn(controller => controller),
@@ -21,48 +34,205 @@ jest.mock('foremanReact/components/ToastsList', () => ({
   }),
 }));
 
-const task = ['some-id', 'some-name'];
+const taskId = 'some-id';
+const taskName = 'some-name';
 
-const fixtures = {
-  'should cancelTaskRequest and succeed': () => cancelTaskRequest(...task),
-  'should cancelTaskRequest and fail': () => {
-    API.post.mockImplementation(() =>
-      Promise.reject(new Error('Network Error'))
-    );
-    return cancelTaskRequest(...task);
+const toastAction = (message, type) => ({
+  type: 'TOASTS_ADD',
+  payload: {
+    message: {
+      message,
+      type,
+    },
   },
+});
 
-  'should resumeTaskRequest and succeed': () => {
-    API.post.mockImplementation(() => ({ data: 'some-data' }));
-    return resumeTaskRequest(...task);
-  },
-  'should resumeTaskRequest and fail': () => {
-    API.post.mockImplementation(() =>
-      Promise.reject(new Error('Network Error'))
-    );
-    return resumeTaskRequest(...task);
-  },
-  'should forceCancelTaskRequest and succeed': () => {
-    API.post.mockImplementation(() => ({ data: 'some-data' }));
-    return forceCancelTaskRequest(...task);
-  },
-  'should forceCancelTaskRequest and fail': () => {
-    API.post.mockImplementation(() =>
-      Promise.reject(new Error('Network Error'))
-    );
-    return forceCancelTaskRequest(...task);
-  },
-  'should unlockTaskRequest and succeed': () => {
-    API.post.mockImplementation(() => ({ data: 'some-data' }));
-    return unlockTaskRequest(...task);
-  },
-  'should unlockTaskRequest and fail': () => {
-    API.post.mockImplementation(() =>
-      Promise.reject(new Error('Network Error'))
-    );
-    return forceCancelTaskRequest(...task);
-  },
-};
-describe('Tasks actions', () => {
-  testActionSnapshotWithFixtures(fixtures);
+describe('Task actions', () => {
+  beforeEach(() => {
+    API.post.mockReset();
+    API.post.mockResolvedValue({ data: 'some-data' });
+  });
+
+  describe('cancelTaskRequest', () => {
+    it('dispatches success actions and toasts when cancel succeeds', async () => {
+      const dispatch = jest.fn();
+
+      await cancelTaskRequest(taskId, taskName)(dispatch);
+
+      expect(API.post).toHaveBeenCalledWith(
+        `/foreman_tasks/tasks/${taskId}/cancel`
+      );
+      expect(dispatch).toHaveBeenCalledTimes(4);
+      expect(dispatch.mock.calls[0][0]).toEqual(
+        toastAction('Trying to cancel some-name task', 'info')
+      );
+      expect(dispatch.mock.calls[1][0]).toEqual({
+        type: TASKS_CANCEL_REQUEST,
+      });
+      expect(dispatch.mock.calls[2][0]).toEqual({
+        type: TASKS_CANCEL_SUCCESS,
+      });
+      expect(dispatch.mock.calls[3][0]).toEqual(
+        toastAction('some-name Task execution was cancelled', 'success')
+      );
+    });
+
+    it('dispatches failure actions and warning toast when cancel fails', async () => {
+      API.post.mockRejectedValue(new Error('Network Error'));
+      const dispatch = jest.fn();
+
+      await cancelTaskRequest(taskId, taskName)(dispatch);
+
+      expect(dispatch).toHaveBeenCalledTimes(4);
+      expect(dispatch.mock.calls[0][0]).toEqual(
+        toastAction('Trying to cancel some-name task', 'info')
+      );
+      expect(dispatch.mock.calls[1][0]).toEqual({
+        type: TASKS_CANCEL_REQUEST,
+      });
+      expect(dispatch.mock.calls[2][0]).toEqual({
+        type: TASKS_CANCEL_FAILURE,
+        payload: expect.any(Error),
+      });
+      expect(dispatch.mock.calls[3][0]).toEqual(
+        toastAction(
+          'some-name Task execution task has to be cancellable',
+          'warning'
+        )
+      );
+    });
+  });
+
+  describe('resumeTaskRequest', () => {
+    it('dispatches success actions and toast when resume succeeds', async () => {
+      const dispatch = jest.fn();
+
+      await resumeTaskRequest(taskId, taskName)(dispatch);
+
+      expect(API.post).toHaveBeenCalledWith(
+        `/foreman_tasks/tasks/${taskId}/resume`
+      );
+      expect(dispatch).toHaveBeenCalledTimes(3);
+      expect(dispatch.mock.calls[0][0]).toEqual({
+        type: TASKS_RESUME_REQUEST,
+      });
+      expect(dispatch.mock.calls[1][0]).toEqual({
+        type: TASKS_RESUME_SUCCESS,
+      });
+      expect(dispatch.mock.calls[2][0]).toEqual(
+        toastAction('some-name Task execution was resumed', 'success')
+      );
+    });
+
+    it('dispatches failure actions and error toast when resume fails', async () => {
+      API.post.mockRejectedValue(new Error('Network Error'));
+      const dispatch = jest.fn();
+
+      await resumeTaskRequest(taskId, taskName)(dispatch);
+
+      expect(dispatch).toHaveBeenCalledTimes(3);
+      expect(dispatch.mock.calls[0][0]).toEqual({
+        type: TASKS_RESUME_REQUEST,
+      });
+      expect(dispatch.mock.calls[1][0]).toEqual({
+        type: TASKS_RESUME_FAILURE,
+        payload: expect.any(Error),
+      });
+      expect(dispatch.mock.calls[2][0]).toEqual(
+        toastAction('some-name Task execution could not be resumed', 'error')
+      );
+    });
+  });
+
+  describe('forceCancelTaskRequest', () => {
+    it('dispatches success actions and toast when force cancel succeeds', async () => {
+      const dispatch = jest.fn();
+
+      await forceCancelTaskRequest(taskId, taskName)(dispatch);
+
+      expect(API.post).toHaveBeenCalledWith(
+        `/foreman_tasks/tasks/${taskId}/force_unlock`
+      );
+      expect(dispatch).toHaveBeenCalledTimes(3);
+      expect(dispatch.mock.calls[0][0]).toEqual({
+        type: TASKS_FORCE_CANCEL_REQUEST,
+      });
+      expect(dispatch.mock.calls[1][0]).toEqual({
+        type: TASKS_FORCE_CANCEL_SUCCESS,
+      });
+      expect(dispatch.mock.calls[2][0]).toEqual(
+        toastAction(
+          'some-name Task execution resources were unlocked with force.',
+          'success'
+        )
+      );
+    });
+
+    it('dispatches failure actions and warning toast when force cancel fails', async () => {
+      API.post.mockRejectedValue(new Error('Network Error'));
+      const dispatch = jest.fn();
+
+      await forceCancelTaskRequest(taskId, taskName)(dispatch);
+
+      expect(dispatch).toHaveBeenCalledTimes(3);
+      expect(dispatch.mock.calls[0][0]).toEqual({
+        type: TASKS_FORCE_CANCEL_REQUEST,
+      });
+      expect(dispatch.mock.calls[1][0]).toEqual({
+        type: TASKS_FORCE_CANCEL_FAILURE,
+      });
+      expect(dispatch.mock.calls[2][0]).toEqual(
+        toastAction(
+          'some-name Task execution cannot be cancelled with force at the moment.',
+          'warning'
+        )
+      );
+    });
+  });
+
+  describe('unlockTaskRequest', () => {
+    it('dispatches success actions and toast when unlock succeeds', async () => {
+      const dispatch = jest.fn();
+
+      await unlockTaskRequest(taskId, taskName)(dispatch);
+
+      expect(API.post).toHaveBeenCalledWith(
+        `/foreman_tasks/tasks/${taskId}/unlock`
+      );
+      expect(dispatch).toHaveBeenCalledTimes(3);
+      expect(dispatch.mock.calls[0][0]).toEqual({
+        type: TASKS_UNLOCK_REQUEST,
+      });
+      expect(dispatch.mock.calls[1][0]).toEqual({
+        type: TASKS_UNLOCK_SUCCESS,
+      });
+      expect(dispatch.mock.calls[2][0]).toEqual(
+        toastAction(
+          'some-name Task execution resources were unlocked ',
+          'success'
+        )
+      );
+    });
+
+    it('dispatches failure actions and warning toast when unlock fails', async () => {
+      API.post.mockRejectedValue(new Error('Network Error'));
+      const dispatch = jest.fn();
+
+      await unlockTaskRequest(taskId, taskName)(dispatch);
+
+      expect(dispatch).toHaveBeenCalledTimes(3);
+      expect(dispatch.mock.calls[0][0]).toEqual({
+        type: TASKS_UNLOCK_REQUEST,
+      });
+      expect(dispatch.mock.calls[1][0]).toEqual({
+        type: TASKS_UNLOCK_FAILURE,
+      });
+      expect(dispatch.mock.calls[2][0]).toEqual(
+        toastAction(
+          'some-name Task execution resources cannot be unlocked at the moment.',
+          'warning'
+        )
+      );
+    });
+  });
 });

data/webpack/ForemanTasks/Components/TaskDetails/Components/Errors.js

@@ -1,69 +1,238 @@
-import React from 'react';
+import React, { useState, useEffect } from 'react';
 import PropTypes from 'prop-types';
-import { Alert } from '@patternfly/react-core';
+import classNames from 'classnames';
+import {
+  Alert,
+  AlertVariant,
+  CodeBlock,
+  CodeBlockCode,
+  EmptyState,
+  EmptyStateBody,
+  EmptyStateHeader,
+  Icon,
+  EmptyStateVariant,
+  Flex,
+  FlexItem,
+  Grid,
+  GridItem,
+  Split,
+  SplitItem,
+  Stack,
+  StackItem,
+  Tab,
+  Tabs,
+  TabTitleIcon,
+  TabTitleText,
+} from '@patternfly/react-core';
+import {
+  CheckCircleIcon,
+  ExclamationCircleIcon,
+} from '@patternfly/react-icons';
 import { translate as __ } from 'foremanReact/common/I18n';
 
-const Errors = ({ ...props }) => {
-  const { failedSteps, executionPlan } = props;
-  if (!executionPlan)
+import './Errors.scss';
+
+const isStoppedStep = step =>
+  ['skipped', 'skipping'].includes(String(step.state ?? ''));
+
+const STEP_SUMMARY_MAX_LENGTH = 120;
+
+const getStepSummary = step =>
+  step.error?.message || step.action_class || __('Unknown error');
+
+const truncateStepSummary = summary => {
+  if (summary.length <= STEP_SUMMARY_MAX_LENGTH) {
+    return summary;
+  }
+
+  return `${summary.slice(0, STEP_SUMMARY_MAX_LENGTH - 3)}...`;
+};
+
+const getStepStatus = step => (isStoppedStep(step) ? 'warning' : 'danger');
+
+const ErrorTabTitle = ({ step }) => {
+  const status = getStepStatus(step);
+
+  return (
+    <>
+      <TabTitleIcon>
+        <Icon status={status}>
+          <ExclamationCircleIcon />
+        </Icon>
+      </TabTitleIcon>
+      <TabTitleText
+        className={classNames(
+          'task-errors-tab-title',
+          `task-errors-tab-title--${status}`
+        )}
+      >
+        {truncateStepSummary(getStepSummary(step))}
+      </TabTitleText>
+    </>
+  );
+};
+
+ErrorTabTitle.propTypes = {
+  step: PropTypes.shape({
+    action_class: PropTypes.string,
+    state: PropTypes.string,
+    error: PropTypes.shape({
+      message: PropTypes.string,
+    }),
+  }).isRequired,
+};
+
+const ErrorDetailSection = ({ label, children }) => (
+  <StackItem className="task-errors-detail-section">
+    <Flex
+      direction={{ default: 'column' }}
+      spaceItems={{ default: 'spaceItemsXs' }}
+    >
+      <FlexItem className="task-errors-detail-label">
+        <strong>{label}</strong>
+      </FlexItem>
+      <FlexItem>
+        <CodeBlock className="task-errors-codeblock">
+          <CodeBlockCode className="task-errors-codeblock-code">
+            {children}
+          </CodeBlockCode>
+        </CodeBlock>
+      </FlexItem>
+    </Flex>
+  </StackItem>
+);
+
+ErrorDetailSection.propTypes = {
+  label: PropTypes.node.isRequired,
+  children: PropTypes.node.isRequired,
+};
+
+const ErrorDetailsPane = ({ step }) => {
+  if (!step) {
+    return null;
+  }
+
+  return (
+    <Stack>
+      {step.error && (
+        <>
+          <ErrorDetailSection label={`${__('Exception')}:`}>
+            {step.error.exception_class}: {step.error.message}
+          </ErrorDetailSection>
+          <ErrorDetailSection label={__('Backtrace')}>
+            {(step.error.backtrace || []).join('\n')}
+          </ErrorDetailSection>
+        </>
+      )}
+      <ErrorDetailSection label={__('Input')}>{step.input}</ErrorDetailSection>
+      <ErrorDetailSection label={__('Output')}>
+        {step.output}
+      </ErrorDetailSection>
+    </Stack>
+  );
+};
+
+ErrorDetailsPane.propTypes = {
+  step: PropTypes.shape({
+    input: PropTypes.node,
+    output: PropTypes.node,
+    error: PropTypes.shape({
+      exception_class: PropTypes.string,
+      message: PropTypes.string,
+      backtrace: PropTypes.array,
+    }),
+  }),
+};
+
+ErrorDetailsPane.defaultProps = {
+  step: null,
+};
+
+const Errors = ({ executionPlan, failedSteps }) => {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+
+  useEffect(() => {
+    setSelectedIndex(idx => {
+      if (idx >= failedSteps.length) {
+        return Math.max(0, failedSteps.length - 1);
+      }
+
+      return idx;
+    });
+  }, [failedSteps.length]);
+
+  if (!executionPlan) {
     return (
       <Alert
-        variant="danger"
-        isInline
+        title={__('Execution plan data not available ')}
+        variant={AlertVariant.danger}
         ouiaId="task-errors-plan-missing"
-        title={__('Execution plan unavailable')}
-      >
-        {__('Execution plan data not available ')}
-      </Alert>
+      />
     );
-  if (!failedSteps.length)
+  }
+
+  if (!failedSteps.length) {
     return (
-      <Alert
-        variant="success"
-        isInline
-        ouiaId="task-errors-none"
-        title={__('No errors')}
-      />
+      <Grid>
+        <GridItem span={12}>
+          <Flex
+            direction={{ default: 'column' }}
+            alignItems={{ default: 'alignItemsCenter' }}
+            justifyContent={{ default: 'justifyContentCenter' }}
+            fullWidth={{ default: 'fullWidth' }}
+          >
+            <FlexItem>
+              <EmptyState variant={EmptyStateVariant.full}>
+                <EmptyStateHeader
+                  titleText={__('No errors found')}
+                  headingLevel="h2"
+                  icon={
+                    <Icon size="xl" status="success">
+                      <CheckCircleIcon />
+                    </Icon>
+                  }
+                />
+                <EmptyStateBody>
+                  {__('The task finished with no errors or warnings.')}
+                </EmptyStateBody>
+              </EmptyState>
+            </FlexItem>
+          </Flex>
+        </GridItem>
+      </Grid>
     );
+  }
+
+  const selectedStep = failedSteps[selectedIndex];
+
   return (
-    <div>
-      {failedSteps.map((step, i) => (
-        <Alert
-          variant="danger"
-          isInline
-          key={i}
-          ouiaId={`task-error-${i}`}
-          title={__('Step error')}
+    <Split hasGutter>
+      <SplitItem className="task-errors-tabs-split">
+        <Tabs
+          id="task-errors-tabs"
+          ouiaId="task-errors-tabs"
+          activeKey={selectedIndex}
+          className="task-errors-tabs"
+          onSelect={(_event, tabIndex) => setSelectedIndex(Number(tabIndex))}
+          isVertical
+          isBox
+          aria-label={__('Failed task errors')}
         >
-          <span>{__('Action')}:</span>
-          <span>
-            <pre>{step.action_class}</pre>
-          </span>
-          <span>{__('Input')}:</span>
-          <span>
-            <pre>{step.input}</pre>
-          </span>
-          <span>{__('Output')}:</span>
-          <span>
-            <pre>{step.output}</pre>
-          </span>
-          {step.error && (
-            <React.Fragment>
-              <span>{__('Exception')}:</span>
-              <span>
-                <pre>
-                  {step.error.exception_class}: {step.error.message}
-                </pre>
-              </span>
-              <span>{__('Backtrace')}:</span>
-              <span>
-                <pre>{(step.error.backtrace || []).join('\n')}</pre>
-              </span>
-            </React.Fragment>
-          )}
-        </Alert>
-      ))}
-    </div>
+          {failedSteps.map((step, i) => (
+            <Tab
+              key={`${step.action_class}-${i}`}
+              eventKey={i}
+              ouiaId={`task-error-${i}`}
+              title={<ErrorTabTitle step={step} />}
+              aria-label={getStepSummary(step)}
+            />
+          ))}
+        </Tabs>
+      </SplitItem>
+      <SplitItem isFilled>
+        <ErrorDetailsPane step={selectedStep} />
+      </SplitItem>
+    </Split>
   );
 };
 

data/webpack/ForemanTasks/Components/TaskDetails/Components/Errors.scss

@@ -0,0 +1,41 @@
+.task-details-react {
+  .task-errors-detail-section {
+    margin-top: 1rem;
+    margin-left: 1.5rem;
+  }
+
+  .task-errors-detail-label {
+    padding-bottom: 0.25rem;
+  }
+
+  .task-errors-tabs-split {
+    flex: 0 0 min(33%, 20rem);
+  }
+
+
+  .task-errors-codeblock {
+    background-color: transparent;
+  }
+
+  .task-errors-codeblock-code {
+    margin: -1rem;
+    background-color: transparent;
+  }
+
+  .task-errors-tab-title {
+    word-break: break-all;
+    font-weight: var(--pf-v5-global--FontWeight--bold);
+
+    &--danger {
+      color: var(--pf-v5-global--danger-color--200);
+    }
+
+    &--warning {
+      color: var(--pf-v5-global--warning-color--200);
+    }
+  }
+
+  .task-errors-tabs {
+    --pf-v5-c-tabs--m-vertical--MaxWidth: 100%;
+  }
+}