foreman-tasks 1.1.3 → 3.0.0

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

@@ -0,0 +1,60 @@
+import { testActionSnapshotWithFixtures } from '@theforeman/test';
+import { API } from 'foremanReact/redux/API';
+import {
+  cancelTaskRequest,
+  resumeTaskRequest,
+  forceCancelTaskRequest,
+  unlockTaskRequest,
+} from './';
+
+jest.mock('foremanReact/components/common/table', () => ({
+  getTableItemsAction: jest.fn(controller => controller),
+}));
+
+jest.mock('foremanReact/redux/API');
+
+const task = ['some-id', '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);
+  },
+
+  '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);
+});

data/webpack/ForemanTasks/Components/{TasksTable/TasksTableActionHelpers.js → TaskActions/TaskActionHelpers.js}

@@ -2,6 +2,11 @@ import { translate as __, sprintf } from 'foremanReact/common/I18n';
 import { addToast } from 'foremanReact/redux/actions/toasts';
 import { TASKS_DASHBOARD_JS_QUERY_MODES } from '../TasksDashboard/TasksDashboardConstants';
 import { timeToHoursNumber } from '../TasksDashboard/TasksDashboardHelper';
+import {
+  successToastData,
+  errorToastData,
+  warningToastData,
+} from '../common/ToastsHelpers';
 
 export const convertDashboardQuery = query => {
   const {
@@ -29,14 +34,24 @@ export const convertDashboardQuery = query => {
 };
 
 export const resumeToastInfo = {
-  resumed: { type: 'success', text: __('was resumed') },
-  failed: { type: 'error', text: __('could not be resumed') },
-  skipped: { type: 'warning', text: __('task has to be resumable') },
+  resumed: successToastData(__('was resumed')),
+  failed: errorToastData(__('could not be resumed')),
+  skipped: warningToastData(__('task has to be resumable')),
 };
 
 export const cancelToastInfo = {
-  cancelled: { type: 'success', text: __('was cancelled') },
-  skipped: { type: 'warning', text: __('task has to be cancellable') },
+  cancelled: successToastData(__('was cancelled')),
+  skipped: warningToastData(__('task has to be cancellable')),
+};
+
+export const forceCancelToastInfo = {
+  forceCancelled: successToastData(__('resources were unlocked with force.')),
+  failed: warningToastData(__('cannot be cancelled with force at the moment.')),
+};
+
+export const unlockToastInfo = {
+  unlocked: successToastData(__('resources were unlocked ')),
+  failed: warningToastData(__('resources cannot be unlocked at the moment.')),
 };
 
 export const toastDispatch = ({ type, name, toastInfo, dispatch }) => {
@@ -45,7 +60,7 @@ export const toastDispatch = ({ type, name, toastInfo, dispatch }) => {
       type: toastInfo[type].type,
       message: sprintf('%(name)s Task execution %(type)s', {
         name,
-        type: toastInfo[type].text,
+        type: toastInfo[type].message,
       }),
     })
   );

data/webpack/ForemanTasks/Components/{TasksTable/__tests__/TasksTableActionHelpers.test.js → TaskActions/TaskActionHelpers.test.js}

@@ -1,8 +1,8 @@
-import { convertDashboardQuery } from '../TasksTableActionHelpers';
+import { convertDashboardQuery } from './TaskActionHelpers';
 import {
   TASKS_DASHBOARD_JS_QUERY_MODES,
   TASKS_DASHBOARD_AVAILABLE_TIMES,
-} from '../../TasksDashboard/TasksDashboardConstants';
+} from '../TasksDashboard/TasksDashboardConstants';
 
 let realDate;
 

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

@@ -0,0 +1,16 @@
+export const UNLOCK_MODAL = 'unlockModal';
+export const FORCE_UNLOCK_MODAL = 'forceUnlockModal';
+
+export const TASKS_RESUME_REQUEST = 'TASKS_RESUME_REQUEST';
+export const TASKS_RESUME_SUCCESS = 'TASKS_RESUME_SUCCESS';
+export const TASKS_RESUME_FAILURE = 'TASKS_RESUME_FAILURE';
+export const TASKS_CANCEL_REQUEST = 'TASKS_CANCEL_REQUEST';
+export const TASKS_CANCEL_SUCCESS = 'TASKS_CANCEL_SUCCESS';
+export const TASKS_CANCEL_FAILURE = 'TASKS_CANCEL_FAILURE';
+
+export const TASKS_FORCE_CANCEL_REQUEST = 'TASKS_FORCE_CANCEL_REQUEST';
+export const TASKS_FORCE_CANCEL_SUCCESS = 'TASKS_FORCE_CANCEL_SUCCESS';
+export const TASKS_FORCE_CANCEL_FAILURE = 'TASKS_FORCE_CANCEL_FAILURE';
+export const TASKS_UNLOCK_REQUEST = 'TASKS_UNLOCK_REQUEST';
+export const TASKS_UNLOCK_SUCCESS = 'TASKS_UNLOCK_SUCCESS';
+export const TASKS_UNLOCK_FAILURE = 'TASKS_UNLOCK_FAILURE';

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

@@ -0,0 +1,60 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import { ClickConfirmation } from '../common/ClickConfirmation';
+import { UNLOCK_MODAL, FORCE_UNLOCK_MODAL } from './TaskActionsConstants';
+
+const confirmationMessage = __(
+  'I understand that this may cause harm and have working database backups of all backend services.'
+);
+
+export const UnlockModal = ({ onClick, id }) => (
+  <ClickConfirmation
+    id={id}
+    title={__('Unlock')}
+    body={__(
+      "This will unlock the resources that the task is running against. Please note that this might lead to inconsistent state and should be used with caution, after making sure that the task can't be resumed."
+    )}
+    confirmationMessage={confirmationMessage}
+    confirmAction={__('Unlock')}
+    onClick={onClick}
+    confirmType="warning"
+  />
+);
+
+export const ForceUnlockModal = ({ onClick, id, selectedRowsLen }) => (
+  <ClickConfirmation
+    id={id}
+    title={__('Force Unlock')}
+    body={sprintf(
+      __(
+        `Resources for %s task(s) will be unlocked and will not prevent other tasks from being run. As the task(s) might be still running, it should be avoided to use this unless you are really sure the task(s) got stuck.`
+      ),
+      selectedRowsLen
+    )}
+    confirmationMessage={confirmationMessage}
+    confirmAction={__('Force Unlock')}
+    onClick={onClick}
+    confirmType="danger"
+  />
+);
+
+UnlockModal.propTypes = {
+  onClick: PropTypes.func.isRequired,
+  id: PropTypes.string,
+};
+
+ForceUnlockModal.propTypes = {
+  onClick: PropTypes.func.isRequired,
+  id: PropTypes.string,
+  selectedRowsLen: PropTypes.number,
+};
+
+UnlockModal.defaultProps = {
+  id: UNLOCK_MODAL,
+};
+
+ForceUnlockModal.defaultProps = {
+  id: FORCE_UNLOCK_MODAL,
+  selectedRowsLen: 1,
+};