foreman-tasks 2.0.0 → 3.0.2

data/test/unit/remote_task_test.rb

@@ -24,8 +24,8 @@ module ForemanTasks
         RemoteTask.batch_trigger('a_operation', remote_tasks)
         remote_tasks.each do |remote_task|
           remote_task.reload
-          remote_task.state.must_equal 'triggered'
-          remote_task.remote_task_id.must_equal((remote_task.id + 5).to_s)
+          _(remote_task.state).must_equal 'triggered'
+          _(remote_task.remote_task_id).must_equal((remote_task.id + 5).to_s)
         end
       end
 

data/test/unit/task_groups_test.rb

@@ -55,18 +55,18 @@ module ForemanTasks
 
       it 'has the task group assigned' do
         task = spawn_task.call ChildAction
-        task.task_groups.map(&:id).must_equal [1]
+        _(task.task_groups.map(&:id)).must_equal [1]
       end
 
       it 'tasks inherit task groups correctly' do
         children_count = 3
         task = spawn_task.call ParentAction, children_count
         # Parent task has task groups of its children
-        task.task_groups.map(&:id).sort.must_equal [1, 2, 3, 4]
+        _(task.task_groups.map(&:id).sort).must_equal [1, 2, 3, 4]
         # Children have the parent's and their own, they don't have their siblings' task groups
-        task.sub_tasks.count.must_equal children_count
+        _(task.sub_tasks.count).must_equal children_count
         task.sub_tasks.each do |sub_task|
-          sub_task.task_groups.map(&:id).sort.must_equal [1, sub_task.input[:id]].sort
+          _(sub_task.task_groups.map(&:id).sort).must_equal [1, sub_task.input[:id]].sort
         end
       end
     end

data/test/unit/task_test.rb

@@ -32,8 +32,8 @@ class TasksTest < ActiveSupport::TestCase
       end
 
       test 'cannot search by arbitrary key' do
-        proc { ForemanTasks::Task.search_for('user.my_key ~ 5') }.must_raise(ScopedSearch::QueryNotSupported)
-        proc { ForemanTasks::Task.search_for('user. = 5') }.must_raise(ScopedSearch::QueryNotSupported)
+        _ { proc { ForemanTasks::Task.search_for('user.my_key ~ 5') } }.must_raise(ScopedSearch::QueryNotSupported)
+        _ { proc { ForemanTasks::Task.search_for('user. = 5') } }.must_raise(ScopedSearch::QueryNotSupported)
       end
 
       test 'can search the tasks by negated user' do
@@ -59,8 +59,8 @@ class TasksTest < ActiveSupport::TestCase
       end
 
       test 'cannot glob on user\'s id' do
-        proc { ForemanTasks::Task.search_for("user.id ~ something") }.must_raise(ScopedSearch::QueryNotSupported)
-        proc { ForemanTasks::Task.search_for("user.id ~ 5") }.must_raise(ScopedSearch::QueryNotSupported)
+        _ { proc { ForemanTasks::Task.search_for("user.id ~ something") } }.must_raise(ScopedSearch::QueryNotSupported)
+        _ { proc { ForemanTasks::Task.search_for("user.id ~ 5") } }.must_raise(ScopedSearch::QueryNotSupported)
       end
 
       test 'can search the tasks by user with wildcards' do
@@ -126,7 +126,7 @@ class TasksTest < ActiveSupport::TestCase
       end
 
       it 'raises an exception if duration is unknown' do
-        proc { ForemanTasks::Task.search_for('duration = "25 potatoes"') }.must_raise ScopedSearch::QueryNotSupported
+        _ { proc { ForemanTasks::Task.search_for('duration = "25 potatoes"') } }.must_raise ScopedSearch::QueryNotSupported
       end
     end
   end
@@ -176,13 +176,13 @@ class TasksTest < ActiveSupport::TestCase
     let(:inconsistent_task) { FactoryBot.create(:dynflow_task, :inconsistent_dynflow_task) }
 
     it 'ensures the tasks marked as running are really running in Dynflow' do
-      consistent_task.state.must_equal 'planned'
-      inconsistent_task.state.must_equal 'running'
+      _(consistent_task.state).must_equal 'planned'
+      _(inconsistent_task.state).must_equal 'running'
 
       ForemanTasks::Task::DynflowTask.consistency_check
 
-      consistent_task.reload.state.must_equal 'planned'
-      inconsistent_task.reload.state.must_equal 'planned'
+      _(consistent_task.reload.state).must_equal 'planned'
+      _(inconsistent_task.reload.state).must_equal 'planned'
     end
   end
 
@@ -190,8 +190,8 @@ class TasksTest < ActiveSupport::TestCase
     it 'when scheduled to the future, the label and action is set properly' do
       job = Support::DummyActiveJob.set(:wait => 12.hours).perform_later
       task = ForemanTasks::Task.find_by!(:external_id => job.provider_job_id)
-      task.action.must_equal "Dummy action"
-      task.label.must_equal "Support::DummyActiveJob"
+      _(task.action).must_equal "Dummy action"
+      _(task.label).must_equal "Support::DummyActiveJob"
     end
   end
 
@@ -224,14 +224,14 @@ class TasksTest < ActiveSupport::TestCase
         :total     => 0,
         :success   => 0,
         :cancelled => 0,
-        :pending   => 0
+        :pending   => 0,
       }
     end
     let(:task) { FactoryBot.create(:dynflow_task) }
 
     describe 'without sub tasks' do
       it 'calculates the progress report correctly' do
-        task.sub_tasks_counts.must_equal result_base
+        _(task.sub_tasks_counts).must_equal result_base
       end
     end
 
@@ -242,7 +242,7 @@ class TasksTest < ActiveSupport::TestCase
 
       it 'calculate the progress report correctly' do
         expected_result = result_base.merge(:success => 1, :error => 1, :total => 2)
-        task.sub_tasks_counts.must_equal expected_result
+        _(task.sub_tasks_counts).must_equal expected_result
       end
 
       it 'calculates the progress report correctly when using batch planning' do
@@ -252,11 +252,11 @@ class TasksTest < ActiveSupport::TestCase
 
         task.state = 'stopped'
         expected_result = result_base.merge(:cancelled => 23)
-        task.sub_tasks_counts.must_equal expected_result
+        _(task.sub_tasks_counts).must_equal expected_result
 
         task.state = 'pending'
         expected_result = result_base.merge(:pending => 23)
-        task.sub_tasks_counts.must_equal expected_result
+        _(task.sub_tasks_counts).must_equal expected_result
       end
     end
   end
@@ -278,10 +278,10 @@ class TasksTest < ActiveSupport::TestCase
 
     it 'can indicate it is delayed' do
       assert_not task.delayed?
-      task.execution_type.must_equal 'Immediate'
+      _(task.execution_type).must_equal 'Immediate'
       task.start_at = Time.now.utc + 100
       assert task.delayed?
-      task.execution_type.must_equal 'Delayed'
+      _(task.execution_type).must_equal 'Delayed'
     end
   end
 

data/test/unit/triggering_test.rb

@@ -3,28 +3,28 @@ require 'foreman_tasks_test_helper'
 class TriggeringTest < ActiveSupport::TestCase
   describe 'validation' do
     it 'is valid when immediate' do
-      FactoryBot.build(:triggering).must_be :valid?
+      _(FactoryBot.build(:triggering)).must_be :valid?
     end
 
     it 'is validates future execution' do
       triggering = FactoryBot.build(:triggering, :future)
-      triggering.must_be :valid?
+      _(triggering).must_be :valid?
       triggering.start_before = triggering.start_at - 120
-      triggering.wont_be :valid?
+      _(triggering).wont_be :valid?
     end
 
     it 'is invalid when recurring logic is invalid' do
       triggering = FactoryBot.build(:triggering, :recurring)
-      triggering.must_be :valid?
+      _(triggering).must_be :valid?
       triggering.recurring_logic.stubs(:valid?).returns(false)
-      triggering.wont_be :valid?
+      _(triggering).wont_be :valid?
     end
   end
 
   it 'cannot have mode set to arbitrary value' do
     triggering = FactoryBot.build(:triggering)
-    triggering.must_be :valid?
-    proc { triggering.mode = 'bogus' }.must_raise ArgumentError
-    proc { triggering.mode = 27 }.must_raise ArgumentError
+    _(triggering).must_be :valid?
+    _ { proc { triggering.mode = 'bogus' } }.must_raise ArgumentError
+    _ { proc { triggering.mode = 27 } }.must_raise ArgumentError
   end
 end

data/test/unit/troubleshooting_help_generator_test.rb

@@ -29,8 +29,8 @@ module ForemanTasks
 
     it 'generates html from the main action troubleshooting_info' do
       generated_html = subject.generate_html
-      generated_html.must_include "A paused task represents a process that has not finished properly"
-      generated_html.must_include %(See <a href="#{expected_troubleshooting_url}">troubleshooting documentation</a> for more details on how to resolve the issue)
+      _(generated_html).must_include "A paused task represents a process that has not finished properly"
+      _(generated_html).must_include %(See <a href="#{expected_troubleshooting_url}">troubleshooting documentation</a> for more details on how to resolve the issue)
     end
 
     it 'exposes link details' do
@@ -48,10 +48,10 @@ module ForemanTasks
 
       it 'includes additional description in generated html' do
         generated_html = subject.generate_html
-        generated_html.must_include 'A paused task represents a process that has not finished properly'
-        generated_html.must_match %r{See <a href=".*">troubleshooting documentation</a> for more details on how to resolve the issue}
-        generated_html.must_include 'This task requires special handling'
-        generated_html.must_include 'Investigate <a href="/additional_troubleshooting_page">custom link</a> on more details for this custom error'
+        _(generated_html).must_include 'A paused task represents a process that has not finished properly'
+        _(generated_html).must_match %r{See <a href=".*">troubleshooting documentation</a> for more details on how to resolve the issue}
+        _(generated_html).must_include 'This task requires special handling'
+        _(generated_html).must_include 'Investigate <a href="/additional_troubleshooting_page">custom link</a> on more details for this custom error'
       end
 
       it 'includes additional links' do

data/test/unit/ui_notifications_test.rb

@@ -23,11 +23,11 @@ module ForemanTasks
       it 'notifies all admins about current amount of paused tasks when some paused task occurs' do
         trigger_task
         notification = user_notifications(admin_user).first
-        notification.message.must_equal "There is 1 paused task in the system that need attention"
+        _(notification.message).must_equal "There is 1 paused task in the system that need attention"
         links = notification.actions['links']
-        links.must_include('href' => '/foreman_tasks/tasks?search=state%3Dpaused',
+        _(links).must_include('href' => '/foreman_tasks/tasks?search=state%3Dpaused',
                            'title' => 'List of tasks')
-        links.must_include('name' => 'troubleshooting',
+        _(links).must_include('name' => 'troubleshooting',
                            'title' => 'Troubleshooting Documentation',
                            'description' => 'See %{link} for more details on how to resolve the issue',
                            'href' => "https://theforeman.org/manuals/#{SETTINGS[:version].short}/tasks_troubleshooting.html#",
@@ -37,19 +37,19 @@ module ForemanTasks
       it 'aggregates the notification when multiple tasks get paused' do
         trigger_task
         recipient1 = NotificationRecipient.find_by(user_id: admin_user)
-        recipient1.notification.message.must_match(/1 paused task/)
+        _(recipient1.notification.message).must_match(/1 paused task/)
 
         new_admin_user = FactoryBot.create(:user, :admin)
 
         trigger_task
 
-        NotificationRecipient.find_by(id: recipient1.id).must_be_nil
-        Notification.find_by(id: recipient1.notification.id).must_be_nil
+        _(NotificationRecipient.find_by(id: recipient1.id)).must_be_nil
+        _(Notification.find_by(id: recipient1.notification.id)).must_be_nil
         recipient2 = NotificationRecipient.find_by(user_id: admin_user)
-        recipient2.notification.message.must_match(/2 paused tasks/)
+        _(recipient2.notification.message).must_match(/2 paused tasks/)
 
         new_recipient = NotificationRecipient.find_by(user_id: new_admin_user)
-        new_recipient.notification.must_equal recipient2.notification
+        _(new_recipient.notification).must_equal recipient2.notification
       end
     end
 
@@ -59,11 +59,11 @@ module ForemanTasks
         notifications = user_notifications(task_owner)
         assert_equal 1, notifications.size, 'Only notification for the main action should be triggered'
         notification = notifications.first
-        notification.message.must_equal "The task 'Dummy pause action' got paused"
+        _(notification.message).must_equal "The task 'Dummy pause action' got paused"
         links = notification.actions['links']
-        links.must_include("href" => "/foreman_tasks/tasks/#{task.id}",
+        _(links).must_include("href" => "/foreman_tasks/tasks/#{task.id}",
                            "title" => "Task Details")
-        links.must_include('name' => 'troubleshooting',
+        _(links).must_include('name' => 'troubleshooting',
                            'title' => 'Troubleshooting Documentation',
                            'description' => 'See %{link} for more details on how to resolve the issue',
                            'href' => "https://theforeman.org/manuals/#{SETTINGS[:version].short}/tasks_troubleshooting.html#Support::DummyPauseAction",

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

@@ -1,5 +1,5 @@
 import { testActionSnapshotWithFixtures } from '@theforeman/test';
-import API from 'foremanReact/API';
+import { API } from 'foremanReact/redux/API';
 import {
   cancelTaskRequest,
   resumeTaskRequest,
@@ -11,7 +11,7 @@ jest.mock('foremanReact/components/common/table', () => ({
   getTableItemsAction: jest.fn(controller => controller),
 }));
 
-jest.mock('foremanReact/API');
+jest.mock('foremanReact/redux/API');
 
 const task = ['some-id', 'some-name'];
 

data/webpack/ForemanTasks/Components/TaskActions/index.js

@@ -1,5 +1,5 @@
 import { sprintf } from 'foremanReact/common/I18n';
-import API from 'foremanReact/API';
+import { API } from 'foremanReact/redux/API';
 import { addToast } from 'foremanReact/redux/actions/toasts';
 import {
   TASKS_RESUME_REQUEST,

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

@@ -3,7 +3,13 @@ import PropTypes from 'prop-types';
 import { Alert, Button } from 'patternfly-react';
 import { translate as __ } from 'foremanReact/common/I18n';
 
-const RunningSteps = ({ runningSteps }) => {
+const RunningSteps = ({
+  runningSteps,
+  id,
+  cancelStep,
+  taskReload,
+  taskReloadStart,
+}) => {
   if (!runningSteps.length) return <span>{__('No running steps')}</span>;
   return (
     <div>
@@ -13,8 +19,12 @@ const RunningSteps = ({ runningSteps }) => {
             <p>
               <Button
                 bsSize="small"
-                data-method="post"
-                href={`/foreman_tasks/tasks/${step.id}/cancel_step`}
+                onClick={() => {
+                  if (!taskReload) {
+                    taskReloadStart(id);
+                  }
+                  cancelStep(id, step.id);
+                }}
               >
                 {__('Cancel')}
               </Button>
@@ -46,6 +56,10 @@ const RunningSteps = ({ runningSteps }) => {
 
 RunningSteps.propTypes = {
   runningSteps: PropTypes.array,
+  id: PropTypes.string.isRequired,
+  cancelStep: PropTypes.func.isRequired,
+  taskReload: PropTypes.bool.isRequired,
+  taskReloadStart: PropTypes.func.isRequired,
 };
 
 RunningSteps.defaultProps = {

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

@@ -1,64 +1,27 @@
 import React from 'react';
-import PropTypes from 'prop-types';
-import { Grid, Row, Col, Button } from 'patternfly-react';
-import { translate as __ } from 'foremanReact/common/I18n';
-import { useForemanModal } from 'foremanReact/components/ForemanModal/ForemanModalHooks';
+import { Grid, Row } from 'patternfly-react';
 import TaskInfo from './TaskInfo';
-import {
-  UNLOCK_MODAL,
-  FORCE_UNLOCK_MODAL,
-} from '../../TaskActions/TaskActionsConstants';
 import { ForceUnlockModal, UnlockModal } from '../../TaskActions/UnlockModals';
+import { TaskButtons } from './TaskButtons';
 
 const Task = props => {
-  const taskProgressToggle = () => {
-    const {
-      timeoutId,
-      refetchTaskDetails,
-      id,
-      loading,
-      taskReloadStop,
-      taskReloadStart,
-    } = props;
-    if (timeoutId) {
-      taskReloadStop(timeoutId);
-    } else {
-      taskReloadStart(timeoutId, refetchTaskDetails, id, loading);
-    }
-  };
-
-  const unlockModalActions = useForemanModal({
-    id: UNLOCK_MODAL,
-  });
-  const forceUnlockModalActions = useForemanModal({
-    id: FORCE_UNLOCK_MODAL,
-  });
-
   const {
     taskReload,
-    externalId,
     id,
-    state,
-    resumable,
-    cancellable,
-    hasSubTasks,
-    parentTask,
-    cancelTaskRequest,
-    resumeTaskRequest,
     forceCancelTaskRequest,
     unlockTaskRequest,
     action,
-    dynflowEnableConsole,
+    taskReloadStart,
   } = props;
   const forceUnlock = () => {
     if (!taskReload) {
-      taskProgressToggle();
+      taskReloadStart(id);
     }
     forceCancelTaskRequest(id, action);
   };
   const unlock = () => {
     if (!taskReload) {
-      taskProgressToggle();
+      taskReloadStart(id);
     }
     unlockTaskRequest(id, action);
   };
@@ -68,88 +31,7 @@ const Task = props => {
       <ForceUnlockModal onClick={forceUnlock} />
       <Grid>
         <Row>
-          <Col xs={12}>
-            <Button
-              className="reload-button"
-              bsSize="small"
-              onClick={taskProgressToggle}
-            >
-              <span
-                className={`glyphicon glyphicon-refresh ${
-                  taskReload ? 'spin' : ''
-                }`}
-              />
-              {__(`${taskReload ? 'Stop' : 'Start'}  auto-reloading`)}
-            </Button>
-            <Button
-              className="dynflow-button"
-              bsSize="small"
-              href={`/foreman_tasks/dynflow/${externalId}`}
-              disabled={!dynflowEnableConsole}
-            >
-              {__('Dynflow console')}
-            </Button>
-            <Button
-              className="resume-button"
-              bsSize="small"
-              disabled={!resumable}
-              onClick={() => {
-                if (!taskReload) {
-                  taskProgressToggle();
-                }
-                resumeTaskRequest(id, action);
-              }}
-            >
-              {__('Resume')}
-            </Button>
-            <Button
-              className="cancel-button"
-              bsSize="small"
-              disabled={!cancellable}
-              onClick={() => {
-                if (!taskReload) {
-                  taskProgressToggle();
-                }
-                cancelTaskRequest(id, action);
-              }}
-            >
-              {__('Cancel')}
-            </Button>
-            {parentTask && (
-              <Button
-                className="parent-button"
-                bsSize="small"
-                href={`/foreman_tasks/tasks/${parentTask}`}
-              >
-                {__('Parent task')}
-              </Button>
-            )}
-            {hasSubTasks && (
-              <Button
-                className="subtask-button"
-                bsSize="small"
-                href={`/foreman_tasks/tasks/${id}/sub_tasks`}
-              >
-                {__('Sub tasks')}
-              </Button>
-            )}
-            <Button
-              className="unlock-button"
-              bsSize="small"
-              disabled={state !== 'paused'}
-              onClick={unlockModalActions.setModalOpen}
-            >
-              {__('Unlock')}
-            </Button>
-            <Button
-              className="force-unlock-button"
-              bsSize="small"
-              disabled={state === 'stopped'}
-              onClick={forceUnlockModalActions.setModalOpen}
-            >
-              {__('Force Unlock')}
-            </Button>
-          </Col>
+          <TaskButtons taskReloadStart={taskReloadStart} {...props} />
         </Row>
         <TaskInfo {...props} />
       </Grid>
@@ -159,39 +41,12 @@ const Task = props => {
 
 Task.propTypes = {
   ...TaskInfo.PropTypes,
-  state: PropTypes.string,
-  resumable: PropTypes.bool,
-  cancellable: PropTypes.bool,
-  refetchTaskDetails: PropTypes.func,
-  hasSubTasks: PropTypes.bool,
-  parentTask: PropTypes.string,
-  taskReload: PropTypes.bool,
-  taskReloadStop: PropTypes.func,
-  taskReloadStart: PropTypes.func,
-  timeoutId: PropTypes.number,
-  externalId: PropTypes.string,
-  id: PropTypes.string.isRequired,
-  cancelTaskRequest: PropTypes.func,
-  resumeTaskRequest: PropTypes.func,
-  dynflowEnableConsole: PropTypes.bool,
+  ...TaskButtons.PropTypes,
 };
 
 Task.defaultProps = {
   ...TaskInfo.defaultProps,
-  state: '',
-  resumable: false,
-  cancellable: false,
-  refetchTaskDetails: () => null,
-  hasSubTasks: false,
-  parentTask: '',
-  taskReload: false,
-  taskReloadStop: () => null,
-  taskReloadStart: () => null,
-  timeoutId: null,
-  externalId: '',
-  cancelTaskRequest: () => null,
-  resumeTaskRequest: () => null,
-  dynflowEnableConsole: false,
+  ...TaskButtons.defaultProps,
 };
 
 export default Task;