foreman-tasks 11.0.6 → 11.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ab9cdf16d7b982c8bd76f4660f35f02aea1e3033b09edc41597503370feb6e9
-  data.tar.gz: 33058b753f95df98812dedb93b8dfc8a4ae072aabfd867d9408efe2cc4dc6cde
+  metadata.gz: c64888d93b687e1d29a9b7baaeefc47dd42a8cc82383b6b42cce34e69731cbe3
+  data.tar.gz: 2166a6056f5d8553b7b61345908860d745e8dd465508bc4011251e2d2938ece2
 SHA512:
-  metadata.gz: ef63b94b770d70900b2605dd64c7c57f29b1d28512399518acccf3934be0170bcfd2327117e73189722eb36b112bae70caa0a9c4c92427a846e711b098f09ec1
-  data.tar.gz: f6ceb952e127b1f4999e1b2108f9d12c258153dfab8b48bf9430ba1794391cc12ad68e3df4f32d12cc7dcb0daec3c9a2836e6511ce2e79b63c99df275f411343
+  metadata.gz: bfce2a4d918298cec79b2954f3411fa7d6947a020f95f4b62137a12e0b81d5019dff5c317706bae0572d64728bfed5707e49a75793aa43221d2beb95f901a992
+  data.tar.gz: fc7f80734a1e145bfee7530252288a9037266c8b1da0577394a776cd3c503459b2420b35c3c4725c27ee16858978237f990b714650c32301ff7ea0a8f456716e

data/lib/foreman_tasks/version.rb

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

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

@@ -1,7 +1,11 @@
-import React from 'react';
+import React, { useState } from 'react';
 import { Grid, Row } from 'patternfly-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,13 +29,29 @@ 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} />
+      <UnlockConfirmationModal
+        onClick={unlock}
+        isOpen={unlockModalOpen}
+        setModalClosed={() => setUnlockModalOpen(false)}
+      />
+      <ForceUnlockConfirmationModal
+        onClick={forceUnlock}
+        isOpen={forceUnlockModalOpen}
+        setModalClosed={() => setForceUnlockModalOpen(false)}
+      />
       <Grid>
         <Row>
-          <TaskButtons taskReloadStart={taskReloadStart} {...props} />
+          <TaskButtons
+            taskReloadStart={taskReloadStart}
+            setUnlockModalOpen={setUnlockModalOpen}
+            setForceUnlockModalOpen={setForceUnlockModalOpen}
+            {...props}
+          />
         </Row>
         <TaskInfo {...props} />
       </Grid>
@@ -40,13 +60,21 @@ const Task = props => {
 };
 
 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,7 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import { Col, Button } from 'patternfly-react';
-import { useForemanModal } from 'foremanReact/components/ForemanModal/ForemanModalHooks';
 import { translate as __ } from 'foremanReact/common/I18n';
-import {
-  UNLOCK_MODAL,
-  FORCE_UNLOCK_MODAL,
-} from '../../TaskActions/TaskActionsConstants';
 
 export const TaskButtons = ({
   canEdit,
@@ -24,13 +19,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');
@@ -114,7 +105,9 @@ export const TaskButtons = ({
         className="unlock-button"
         bsSize="small"
         disabled={!canEdit || state !== 'paused'}
-        onClick={unlockModalActions.setModalOpen}
+        onClick={() => {
+          setUnlockModalOpen(true);
+        }}
         title={editActionsTitle}
         data-original-title={editActionsTitle}
       >
@@ -124,7 +117,7 @@ export const TaskButtons = ({
         className="force-unlock-button"
         bsSize="small"
         disabled={!canEdit || state === 'stopped'}
-        onClick={forceUnlockModalActions.setModalOpen}
+        onClick={() => setForceUnlockModalOpen(true)}
         title={editActionsTitle}
         data-original-title={editActionsTitle}
       >
@@ -134,7 +127,7 @@ export const TaskButtons = ({
   );
 };
 
-TaskButtons.propTypes = {
+export const TaskButtonspropTypes = {
   canEdit: PropTypes.bool,
   dynflowEnableConsole: PropTypes.bool,
   taskReloadStart: PropTypes.func.isRequired,
@@ -151,8 +144,7 @@ TaskButtons.propTypes = {
   cancelTaskRequest: PropTypes.func,
   resumeTaskRequest: PropTypes.func,
 };
-
-TaskButtons.defaultProps = {
+export const TaskButtonsdefaultProps = {
   canEdit: false,
   dynflowEnableConsole: false,
   taskReload: false,
@@ -166,3 +158,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,160 @@
 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');
+      expect(dynflowLink).toHaveAttribute('rel', 'noopener noreferrer');
+    });
+
+    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).toHaveClass('disabled');
+    });
+
+    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.toHaveClass('disabled');
+    });
+
+    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 +162,7 @@ describe('Task', () => {
     const id = 'some-id';
     const action = 'some-action';
     const props = {
+      ...defaultProps,
       taskReload: false,
       id,
       action,
@@ -55,41 +171,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);
     });
   });
 });

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/__snapshots__/Task.test.js.snap

@@ -2,14 +2,18 @@
 
 exports[`Task rendering render with minimal Props 1`] = `
 <Fragment>
-  <UnlockModal
+  <UnlockConfirmationModal
     id="unlockModal"
+    isOpen={false}
     onClick={[Function]}
+    setModalClosed={[Function]}
   />
-  <ForceUnlockModal
+  <ForceUnlockConfirmationModal
     id="forceUnlockModal"
+    isOpen={false}
     onClick={[Function]}
     selectedRowsLen={1}
+    setModalClosed={[Function]}
   />
   <Grid
     bsClass="container"
@@ -26,47 +30,32 @@ exports[`Task rendering render with minimal Props 1`] = `
         cancelTaskRequest={[Function]}
         cancellable={false}
         dynflowEnableConsole={false}
-        endedAt=""
-        errors={Array []}
         externalId=""
+        forceCancelTaskRequest={[Function]}
         hasSubTasks={false}
-        help=""
         id="test"
-        output=""
         parentTask=""
-        progress={0}
-        result="error"
         resumable={false}
         resumeTaskRequest={[Function]}
-        startAt=""
-        startBefore=""
-        startedAt=""
+        setForceUnlockModalOpen={[Function]}
+        setUnlockModalOpen={[Function]}
         state=""
         taskProgressToggle={[MockFunction]}
         taskReload={false}
         taskReloadStart={[MockFunction]}
-        username=""
-        usernamePath=""
+        unlockTaskRequest={[Function]}
       />
     </Row>
     <TaskInfo
       action=""
-      canEdit={false}
-      cancelTaskRequest={[Function]}
-      cancellable={false}
-      dynflowEnableConsole={false}
       endedAt=""
       errors={Array []}
-      externalId=""
-      hasSubTasks={false}
+      forceCancelTaskRequest={[Function]}
       help=""
       id="test"
       output=""
-      parentTask=""
       progress={0}
       result="error"
-      resumable={false}
-      resumeTaskRequest={[Function]}
       startAt=""
       startBefore=""
       startedAt=""
@@ -74,6 +63,7 @@ exports[`Task rendering render with minimal Props 1`] = `
       taskProgressToggle={[MockFunction]}
       taskReload={false}
       taskReloadStart={[MockFunction]}
+      unlockTaskRequest={[Function]}
       username=""
       usernamePath=""
     />
@@ -83,14 +73,18 @@ exports[`Task rendering render with minimal Props 1`] = `
 
 exports[`Task rendering render with some Props 1`] = `
 <Fragment>
-  <UnlockModal
+  <UnlockConfirmationModal
     id="unlockModal"
+    isOpen={false}
     onClick={[Function]}
+    setModalClosed={[Function]}
   />
-  <ForceUnlockModal
+  <ForceUnlockConfirmationModal
     id="forceUnlockModal"
+    isOpen={false}
     onClick={[Function]}
     selectedRowsLen={1}
+    setModalClosed={[Function]}
   />
   <Grid
     bsClass="container"
@@ -107,39 +101,30 @@ exports[`Task rendering render with some Props 1`] = `
         cancelTaskRequest={[Function]}
         cancellable={false}
         dynflowEnableConsole={true}
-        endedAt=""
-        errors={Array []}
         externalId=""
+        forceCancelTaskRequest={[Function]}
         hasSubTasks={true}
-        help=""
         id="test"
-        output=""
         parentTask="parent-id"
-        progress={0}
-        result="error"
         resumable={false}
         resumeTaskRequest={[Function]}
-        startAt=""
-        startBefore=""
-        startedAt=""
+        setForceUnlockModalOpen={[Function]}
+        setUnlockModalOpen={[Function]}
         state="paused"
         status="RESOLVED"
         taskProgressToggle={[MockFunction]}
         taskReload={true}
         taskReloadStart={[MockFunction]}
-        username=""
-        usernamePath=""
+        unlockTaskRequest={[Function]}
       />
     </Row>
     <TaskInfo
       action=""
       canEdit={true}
-      cancelTaskRequest={[Function]}
-      cancellable={false}
       dynflowEnableConsole={true}
       endedAt=""
       errors={Array []}
-      externalId=""
+      forceCancelTaskRequest={[Function]}
       hasSubTasks={true}
       help=""
       id="test"
@@ -147,8 +132,6 @@ exports[`Task rendering render with some Props 1`] = `
       parentTask="parent-id"
       progress={0}
       result="error"
-      resumable={false}
-      resumeTaskRequest={[Function]}
       startAt=""
       startBefore=""
       startedAt=""
@@ -157,6 +140,7 @@ exports[`Task rendering render with some Props 1`] = `
       taskProgressToggle={[MockFunction]}
       taskReload={true}
       taskReloadStart={[MockFunction]}
+      unlockTaskRequest={[Function]}
       username=""
       usernamePath=""
     />

data/webpack/ForemanTasks/Components/TaskDetails/__tests__/__snapshots__/TaskDetails.test.js.snap

@@ -89,34 +89,20 @@ exports[`TaskDetails rendering render with min Props 1`] = `
     >
       <Task
         action=""
-        canEdit={false}
-        cancelTaskRequest={[Function]}
-        cancellable={false}
-        dynflowEnableConsole={false}
         endedAt=""
-        errors={Array []}
         externalId=""
-        hasSubTasks={false}
-        help=""
+        forceCancelTaskRequest={[Function]}
         id="a15dd820-32f1-4ced-9ab7-c0fab8234c47"
         input={Array []}
         label=""
         output={Object {}}
-        parentTask=""
-        progress={0}
-        result="error"
         resumable={false}
-        resumeTaskRequest={[Function]}
-        startAt=""
-        startBefore=""
         startedAt=""
-        state=""
         status="RESOLVED"
         taskProgressToggle={[Function]}
         taskReload={false}
         taskReloadStart={[MockFunction]}
-        username=""
-        usernamePath=""
+        unlockTaskRequest={[Function]}
       />
     </Tab>
     <Tab