foreman-tasks 11.0.6 → 11.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ab9cdf16d7b982c8bd76f4660f35f02aea1e3033b09edc41597503370feb6e9
-  data.tar.gz: 33058b753f95df98812dedb93b8dfc8a4ae072aabfd867d9408efe2cc4dc6cde
+  metadata.gz: 6323c04ba353b2c7db536b30690adf3e03648858e9883ba31276a217acedaaa5
+  data.tar.gz: 521d94f6dfc0d3fba10057376aeafa6b71dc5605b19dd9ed07d08e7505b982c2
 SHA512:
-  metadata.gz: ef63b94b770d70900b2605dd64c7c57f29b1d28512399518acccf3934be0170bcfd2327117e73189722eb36b112bae70caa0a9c4c92427a846e711b098f09ec1
-  data.tar.gz: f6ceb952e127b1f4999e1b2108f9d12c258153dfab8b48bf9430ba1794391cc12ad68e3df4f32d12cc7dcb0daec3c9a2836e6511ce2e79b63c99df275f411343
+  metadata.gz: ef93f73cb3325aa63c06b392ec9abb20825d27a71388667a29eddc242365407d3be292cabcba7bb6340329140f14d28eee4bb2c66219cf109e11f8f5af0c7a2a
+  data.tar.gz: 4a30e8776e8938bc75f1a3b88093d7d6707324abd41942c0e9e92efc39c2c85da6d322e7424b71b389f2c4e617fd4d4bdfa1aea587aa4bc72d918bf9c0a02148

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '11.0.6'.freeze
+  VERSION = '11.1.0'.freeze
 end

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

@@ -1,7 +1,10 @@
-import React from 'react';
-import { Grid, Row } from 'patternfly-react';
+import React, { useState } from 'react';
+import PropTypes from 'prop-types';
 import TaskInfo from './TaskInfo';
-import { ForceUnlockModal, UnlockModal } from '../../TaskActions/UnlockModals';
+import {
+  ForceUnlockConfirmationModal,
+  UnlockConfirmationModal,
+} from '../../common/ClickConfirmation';
 import { TaskButtons } from './TaskButtons';
 
 const Task = props => {
@@ -25,28 +28,48 @@ const Task = props => {
     }
     unlockTaskRequest(id, action);
   };
+  const [unlockModalOpen, setUnlockModalOpen] = useState(false);
+  const [forceUnlockModalOpen, setForceUnlockModalOpen] = useState(false);
+
   return (
     <React.Fragment>
-      <UnlockModal onClick={unlock} />
-      <ForceUnlockModal onClick={forceUnlock} />
-      <Grid>
-        <Row>
-          <TaskButtons taskReloadStart={taskReloadStart} {...props} />
-        </Row>
-        <TaskInfo {...props} />
-      </Grid>
+      <UnlockConfirmationModal
+        onClick={unlock}
+        isOpen={unlockModalOpen}
+        setModalClosed={() => setUnlockModalOpen(false)}
+      />
+      <ForceUnlockConfirmationModal
+        onClick={forceUnlock}
+        isOpen={forceUnlockModalOpen}
+        setModalClosed={() => setForceUnlockModalOpen(false)}
+      />
+      <TaskButtons
+        taskReloadStart={taskReloadStart}
+        setUnlockModalOpen={setUnlockModalOpen}
+        setForceUnlockModalOpen={setForceUnlockModalOpen}
+        {...props}
+      />
+      <TaskInfo {...props} />
     </React.Fragment>
   );
 };
 
 Task.propTypes = {
-  ...TaskInfo.PropTypes,
-  ...TaskButtons.PropTypes,
+  taskReload: PropTypes.bool,
+  id: PropTypes.string,
+  forceCancelTaskRequest: PropTypes.func,
+  unlockTaskRequest: PropTypes.func,
+  action: PropTypes.string,
+  taskReloadStart: PropTypes.func,
 };
 
 Task.defaultProps = {
-  ...TaskInfo.defaultProps,
-  ...TaskButtons.defaultProps,
+  taskReload: false,
+  id: '',
+  forceCancelTaskRequest: () => null,
+  unlockTaskRequest: () => null,
+  action: '',
+  taskReloadStart: () => null,
 };
 
 export default Task;

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

@@ -1,12 +1,8 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import { Col, Button } from 'patternfly-react';
-import { useForemanModal } from 'foremanReact/components/ForemanModal/ForemanModalHooks';
+import { Button, Icon } from '@patternfly/react-core';
+import { SyncAltIcon } from '@patternfly/react-icons';
 import { translate as __ } from 'foremanReact/common/I18n';
-import {
-  UNLOCK_MODAL,
-  FORCE_UNLOCK_MODAL,
-} from '../../TaskActions/TaskActionsConstants';
 
 export const TaskButtons = ({
   canEdit,
@@ -24,13 +20,9 @@ export const TaskButtons = ({
   parentTask,
   cancelTaskRequest,
   resumeTaskRequest,
+  setUnlockModalOpen,
+  setForceUnlockModalOpen,
 }) => {
-  const unlockModalActions = useForemanModal({
-    id: UNLOCK_MODAL,
-  });
-  const forceUnlockModalActions = useForemanModal({
-    id: FORCE_UNLOCK_MODAL,
-  });
   const editActionsTitle = canEdit
     ? undefined
     : __('You do not have permission');
@@ -39,35 +31,42 @@ export const TaskButtons = ({
     : `dynflow_enable_console ${__('Setting is off')}`;
 
   return (
-    <Col xs={12}>
+    <>
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-reload-button"
         className="reload-button"
-        bsSize="small"
+        size="sm"
         onClick={taskProgressToggle}
       >
-        <span
-          className={`glyphicon glyphicon-refresh ${taskReload ? 'spin' : ''}`}
-        />
+        <Icon className={taskReload ? 'spin' : ''}>
+          <SyncAltIcon />
+        </Icon>
         {taskReload ? __('Stop auto-reloading') : __('Start auto-reloading')}
       </Button>
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-dynflow-button"
         className="dynflow-button"
-        bsSize="small"
+        size="sm"
+        component="a"
         href={`/foreman_tasks/dynflow/${externalId}`}
-        disabled={!dynflowEnableConsole}
-        rel="noopener noreferrer"
+        isDisabled={!dynflowEnableConsole}
         target="_blank"
+        rel="noopener noreferrer"
       >
         <span title={dynflowTitle} data-original-title={dynflowTitle}>
           {__('Dynflow console')}
         </span>
       </Button>
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-resume-button"
         className="resume-button"
-        bsSize="small"
+        size="sm"
         title={editActionsTitle}
         data-original-title={editActionsTitle}
-        disabled={!canEdit || !resumable}
+        isDisabled={!canEdit || !resumable}
         onClick={() => {
           if (!taskReload) {
             taskReloadStart(id);
@@ -78,11 +77,13 @@ export const TaskButtons = ({
         {__('Resume')}
       </Button>
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-cancel-button"
         className="cancel-button"
-        bsSize="small"
+        size="sm"
         title={editActionsTitle}
         data-original-title={editActionsTitle}
-        disabled={!canEdit || !cancellable}
+        isDisabled={!canEdit || !cancellable}
         onClick={() => {
           if (!taskReload) {
             taskReloadStart(id);
@@ -94,47 +95,59 @@ export const TaskButtons = ({
       </Button>
       {parentTask && (
         <Button
+          variant="secondary"
+          ouiaId="task-buttons-parent-button"
           className="parent-button"
-          bsSize="small"
+          size="sm"
           href={`/foreman_tasks/tasks/${parentTask}`}
+          component="a"
         >
           {__('Parent task')}
         </Button>
       )}
       {hasSubTasks && (
         <Button
+          variant="secondary"
+          ouiaId="task-buttons-subtask-button"
           className="subtask-button"
-          bsSize="small"
+          size="sm"
           href={`/foreman_tasks/tasks/${id}/sub_tasks`}
+          component="a"
         >
           {__('Sub tasks')}
         </Button>
       )}
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-unlock-button"
         className="unlock-button"
-        bsSize="small"
-        disabled={!canEdit || state !== 'paused'}
-        onClick={unlockModalActions.setModalOpen}
+        size="sm"
+        isDisabled={!canEdit || state !== 'paused'}
+        onClick={() => {
+          setUnlockModalOpen(true);
+        }}
         title={editActionsTitle}
         data-original-title={editActionsTitle}
       >
         {__('Unlock')}
       </Button>
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-force-unlock-button"
         className="force-unlock-button"
-        bsSize="small"
-        disabled={!canEdit || state === 'stopped'}
-        onClick={forceUnlockModalActions.setModalOpen}
+        size="sm"
+        isDisabled={!canEdit || state === 'stopped'}
+        onClick={() => setForceUnlockModalOpen(true)}
         title={editActionsTitle}
         data-original-title={editActionsTitle}
       >
         {__('Force Unlock')}
       </Button>
-    </Col>
+    </>
   );
 };
 
-TaskButtons.propTypes = {
+export const TaskButtonspropTypes = {
   canEdit: PropTypes.bool,
   dynflowEnableConsole: PropTypes.bool,
   taskReloadStart: PropTypes.func.isRequired,
@@ -151,8 +164,7 @@ TaskButtons.propTypes = {
   cancelTaskRequest: PropTypes.func,
   resumeTaskRequest: PropTypes.func,
 };
-
-TaskButtons.defaultProps = {
+export const TaskButtonsdefaultProps = {
   canEdit: false,
   dynflowEnableConsole: false,
   taskReload: false,
@@ -166,3 +178,14 @@ TaskButtons.defaultProps = {
   cancelTaskRequest: () => null,
   resumeTaskRequest: () => null,
 };
+
+TaskButtons.propTypes = {
+  ...TaskButtonspropTypes,
+  setUnlockModalOpen: PropTypes.func,
+  setForceUnlockModalOpen: PropTypes.func,
+};
+TaskButtons.defaultProps = {
+  setUnlockModalOpen: () => null,
+  setForceUnlockModalOpen: () => null,
+  ...TaskButtonsdefaultProps,
+};

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/TaskButtons.test.js

@@ -1,45 +1,159 @@
 import React from 'react';
-import {
-  testComponentSnapshotsWithFixtures,
-  mount,
-  shallow,
-} from '@theforeman/test';
-import { useForemanModal } from 'foremanReact/components/ForemanModal/ForemanModalHooks';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
 import { STATUS } from 'foremanReact/constants';
 import { TaskButtons } from '../TaskButtons';
-import {
-  UNLOCK_MODAL,
-  FORCE_UNLOCK_MODAL,
-} from '../../../TaskActions/TaskActionsConstants';
-
-const fixtures = {
-  'render with minimal Props': {
-    id: 'test',
-    taskReloadStart: jest.fn(),
-    taskProgressToggle: jest.fn(),
-  },
-  'render with some Props': {
-    id: 'test',
-    state: 'paused',
-    hasSubTasks: true,
-    dynflowEnableConsole: true,
-    parentTask: 'parent-id',
-    taskReload: true,
-    canEdit: true,
-    status: STATUS.RESOLVED,
-    taskReloadStart: jest.fn(),
-    taskProgressToggle: jest.fn(),
-  },
+
+const setUnlockModalOpen = jest.fn();
+const setForceUnlockModalOpen = jest.fn();
+
+const defaultProps = {
+  id: 'test',
+  taskReloadStart: jest.fn(),
+  taskProgressToggle: jest.fn(),
+  cancelTaskRequest: jest.fn(),
+  resumeTaskRequest: jest.fn(),
+  setUnlockModalOpen,
+  setForceUnlockModalOpen,
 };
 
-describe('Task', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(TaskButtons, fixtures));
-  describe('click test', () => {
-    const setModalOpen = jest.fn();
-    useForemanModal.mockImplementation(id => ({
-      setModalOpen: () => setModalOpen(id),
-    }));
+describe('TaskButtons', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('rendering', () => {
+    it('renders reload button with correct text when taskReload is false', () => {
+      render(<TaskButtons {...defaultProps} taskReload={false} />);
+      expect(
+        screen.getByRole('button', { name: /start auto-reloading/i })
+      ).toBeInTheDocument();
+      expect(
+        screen.queryByRole('button', { name: /stop auto-reloading/i })
+      ).not.toBeInTheDocument();
+    });
+
+    it('renders reload button with correct text when taskReload is true', () => {
+      render(<TaskButtons {...defaultProps} taskReload />);
+      expect(
+        screen.getByRole('button', { name: /stop auto-reloading/i })
+      ).toBeInTheDocument();
+      expect(
+        screen.queryByRole('button', { name: /start auto-reloading/i })
+      ).not.toBeInTheDocument();
+    });
+
+    it('renders dynflow console link with correct href when externalId is provided', () => {
+      render(<TaskButtons {...defaultProps} externalId="external-123" />);
+      const dynflowLink = screen.getByRole('link', {
+        name: /dynflow console/i,
+      });
+      expect(dynflowLink).toHaveAttribute(
+        'href',
+        '/foreman_tasks/dynflow/external-123'
+      );
+      expect(dynflowLink).toHaveAttribute('target', '_blank');
+    });
+
+    it('disables dynflow console link when dynflowEnableConsole is false', () => {
+      render(<TaskButtons {...defaultProps} dynflowEnableConsole={false} />);
+      const dynflowLink = screen.getByRole('link', {
+        name: /dynflow console/i,
+      });
+      expect(dynflowLink).not.toBeDisabled();
+    });
+
+    it('enables dynflow console link when dynflowEnableConsole is true', () => {
+      render(
+        <TaskButtons
+          {...defaultProps}
+          dynflowEnableConsole
+          externalId="external-123"
+        />
+      );
+      const dynflowLink = screen.getByRole('link', {
+        name: /dynflow console/i,
+      });
+      expect(dynflowLink).not.toBeDisabled();
+    });
+
+    it('disables resume and cancel buttons when canEdit is false', () => {
+      render(<TaskButtons {...defaultProps} canEdit={false} />);
+      expect(screen.getByRole('button', { name: /resume/i })).toBeDisabled();
+      expect(screen.getByRole('button', { name: /cancel/i })).toBeDisabled();
+    });
+
+    it('disables resume button when resumable is false', () => {
+      render(<TaskButtons {...defaultProps} canEdit resumable={false} />);
+      expect(screen.getByRole('button', { name: /resume/i })).toBeDisabled();
+    });
+
+    it('disables cancel button when cancellable is false', () => {
+      render(<TaskButtons {...defaultProps} canEdit cancellable={false} />);
+      expect(screen.getByRole('button', { name: /cancel/i })).toBeDisabled();
+    });
+
+    it('disables unlock button when state is not paused', () => {
+      render(<TaskButtons {...defaultProps} canEdit state="running" />);
+      expect(screen.getByRole('button', { name: /^unlock$/i })).toBeDisabled();
+    });
+
+    it('enables unlock button when state is paused and canEdit is true', () => {
+      render(<TaskButtons {...defaultProps} canEdit state="paused" />);
+      expect(
+        screen.getByRole('button', { name: /^unlock$/i })
+      ).not.toBeDisabled();
+    });
+
+    it('disables force unlock button when state is stopped', () => {
+      render(<TaskButtons {...defaultProps} canEdit state="stopped" />);
+      expect(
+        screen.getByRole('button', { name: /force unlock/i })
+      ).toBeDisabled();
+    });
+
+    it('enables force unlock button when state is not stopped and canEdit is true', () => {
+      render(<TaskButtons {...defaultProps} canEdit state="running" />);
+      expect(
+        screen.getByRole('button', { name: /force unlock/i })
+      ).not.toBeDisabled();
+    });
+
+    it('renders parent task button when parentTask is provided', () => {
+      render(<TaskButtons {...defaultProps} parentTask="parent-123" />);
+      const parentButton = screen.getByRole('link', { name: /parent task/i });
+      expect(parentButton).toBeInTheDocument();
+      expect(parentButton).toHaveAttribute(
+        'href',
+        '/foreman_tasks/tasks/parent-123'
+      );
+    });
+
+    it('does not render parent task button when parentTask is not provided', () => {
+      render(<TaskButtons {...defaultProps} />);
+      expect(
+        screen.queryByRole('link', { name: /parent task/i })
+      ).not.toBeInTheDocument();
+    });
+
+    it('renders sub tasks button when hasSubTasks is true', () => {
+      render(<TaskButtons {...defaultProps} hasSubTasks id="task-123" />);
+      const subTasksButton = screen.getByRole('link', { name: /sub tasks/i });
+      expect(subTasksButton).toBeInTheDocument();
+      expect(subTasksButton).toHaveAttribute(
+        'href',
+        '/foreman_tasks/tasks/task-123/sub_tasks'
+      );
+    });
+
+    it('does not render sub tasks button when hasSubTasks is false', () => {
+      render(<TaskButtons {...defaultProps} hasSubTasks={false} />);
+      expect(
+        screen.queryByRole('link', { name: /sub tasks/i })
+      ).not.toBeInTheDocument();
+    });
+  });
+  describe('user interactions', () => {
     const cancelTaskRequest = jest.fn();
     const resumeTaskRequest = jest.fn();
     const taskProgressToggle = jest.fn();
@@ -47,6 +161,7 @@ describe('Task', () => {
     const id = 'some-id';
     const action = 'some-action';
     const props = {
+      ...defaultProps,
       taskReload: false,
       id,
       action,
@@ -55,41 +170,51 @@ describe('Task', () => {
       taskProgressToggle,
       taskReloadStart,
       status: STATUS.RESOLVED,
+      canEdit: true,
+      resumable: true,
+      cancellable: true,
+      state: 'paused',
     };
-    afterEach(() => {
-      jest.clearAllMocks();
-    });
-    it('reload', () => {
-      const component = mount(<TaskButtons {...props} />);
-      const reloadButton = component.find('.reload-button').at(0);
-      reloadButton.simulate('click');
-      expect(taskProgressToggle).toBeCalled();
-    });
-    it('resume', () => {
-      const component = shallow(<TaskButtons {...props} />);
-      const resumeButton = component.find('.resume-button').at(0);
-      resumeButton.props().onClick();
-      expect(taskReloadStart).toBeCalled();
-      expect(resumeTaskRequest).toBeCalledWith(id, action);
-    });
-    it('cancel', () => {
-      const component = shallow(<TaskButtons {...props} />);
-      const cancelButton = component.find('.cancel-button').at(0);
-      cancelButton.props().onClick();
-      expect(taskReloadStart).toBeCalled();
-      expect(cancelTaskRequest).toBeCalledWith(id, action);
-    });
-    it('unlock', () => {
-      const component = shallow(<TaskButtons {...props} />);
-      const unlockButton = component.find('.unlock-button').at(0);
-      unlockButton.props().onClick();
-      expect(setModalOpen).toBeCalledWith({ id: UNLOCK_MODAL });
-    });
-    it('focrce unlock', () => {
-      const component = shallow(<TaskButtons {...props} />);
-      const forceUnlockButton = component.find('.force-unlock-button').at(0);
-      forceUnlockButton.props().onClick();
-      expect(setModalOpen).toBeCalledWith({ id: FORCE_UNLOCK_MODAL });
+
+    it('calls taskProgressToggle when reload button is clicked', () => {
+      render(<TaskButtons {...props} />);
+      const reloadButton = screen.getByRole('button', {
+        name: /start auto-reloading/i,
+      });
+      fireEvent.click(reloadButton);
+      expect(taskProgressToggle).toHaveBeenCalled();
+    });
+
+    it('calls taskReloadStart and resumeTaskRequest when resume button is clicked', () => {
+      render(<TaskButtons {...props} />);
+      const resumeButton = screen.getByRole('button', { name: /resume/i });
+      fireEvent.click(resumeButton);
+      expect(taskReloadStart).toHaveBeenCalledWith(id);
+      expect(resumeTaskRequest).toHaveBeenCalledWith(id, action);
+    });
+
+    it('calls taskReloadStart and cancelTaskRequest when cancel button is clicked', () => {
+      render(<TaskButtons {...props} />);
+      const cancelButton = screen.getByRole('button', { name: /cancel/i });
+      fireEvent.click(cancelButton);
+      expect(taskReloadStart).toHaveBeenCalledWith(id);
+      expect(cancelTaskRequest).toHaveBeenCalledWith(id, action);
+    });
+
+    it('calls setUnlockModalOpen when unlock button is clicked', () => {
+      render(<TaskButtons {...props} />);
+      const unlockButton = screen.getByRole('button', { name: /^unlock$/i });
+      fireEvent.click(unlockButton);
+      expect(setUnlockModalOpen).toHaveBeenCalledWith(true);
+    });
+
+    it('calls setForceUnlockModalOpen when force unlock button is clicked', () => {
+      render(<TaskButtons {...props} />);
+      const forceUnlockButton = screen.getByRole('button', {
+        name: /force unlock/i,
+      });
+      fireEvent.click(forceUnlockButton);
+      expect(setForceUnlockModalOpen).toHaveBeenCalledWith(true);
     });
   });
 });