foreman-tasks 12.2.3 → 13.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 200260a81901f7159c565c8188aa71de7b80bc0583b7cf3bf6432a2541130567
-  data.tar.gz: 3cb1afe2a7706fe328155ac0b32da0864155dfcb9e97a7b026283ba020f41489
+  metadata.gz: 9fa716da28a9b6bf38240aa02e47f9ab4a4ab6ba82f98c5d26f7d6066f3149e4
+  data.tar.gz: eb7ec125870236abf803a65c132b042fd4360f4de5d7d9a5b2bc718ba8672235
 SHA512:
-  metadata.gz: 26157491f3be0ce0e7386008c492476db1e49d28d28934f1139daec25771626d3e7813c3e858b501020f719930ad4fee3fcf6a54850bb661d4104b0628676993
-  data.tar.gz: d295b0470a35efb6a20801431614256612fdb16fb9f85f6c2c79ffdfaf0bd384656986d82f9d1bf0072b68366420884fbb552638152ccf9ca397f4c8a20a14c8
+  metadata.gz: 0547b82e39eabef4f7205100733272e5bdb7b619721ea1a9b94259403c1be370a4ee34564825ccbca83ed16767e72634dd2a070f288ceed28627c3c58671d726
+  data.tar.gz: c27122956334571f9b1cc287e8ec6cf322f5f2931be69780539cc58a7f37cbf7f7c4c81800807fc81a79ca8213d1510c127552492ee942c21a1067eb09258a9e

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -6,11 +6,6 @@ module ForemanTasks
 
     before_action :find_dynflow_task, only: [:unlock, :force_unlock, :cancel, :abort, :cancel_step, :resume]
 
-    def show
-      @task = resource_base.find(params[:id])
-      render :layout => !request.xhr?
-    end
-
     def index
       params[:order] ||= 'started_at DESC'
       respond_with_tasks resource_base

data/config/routes.rb

@@ -12,7 +12,7 @@ Foreman::Application.routes.draw do
       end
     end
 
-    resources :tasks, :only => [:show] do
+    resources :tasks, :only => [] do
       collection do
         get 'auto_complete_search'
         get '/summary/:recent_timeframe', action: 'summary'
@@ -27,7 +27,7 @@ Foreman::Application.routes.draw do
         post :cancel_step
       end
     end
-    resources :tasks, :only => [:show], constraints: ->(req) { req.format == :csv } do
+    resources :tasks, :only => [], constraints: ->(req) { req.format == :csv } do
       member do
         get :sub_tasks
       end
@@ -35,6 +35,7 @@ Foreman::Application.routes.draw do
     resources :tasks, :only => [:index], constraints: ->(req) { req.format == :csv }
 
     match '/tasks', to: '/react#index', via: :get
+    match '/tasks/:id', to: '/react#index', via: :get, :as => :task
     match '/tasks/:id/sub_tasks', to: '/react#index', via: :get
 
     namespace :api do

data/lib/foreman_tasks/engine.rb

@@ -20,7 +20,7 @@ module ForemanTasks
       require 'foreman/cron'
 
       Foreman::Plugin.register :"foreman-tasks" do
-        requires_foreman '>= 3.19'
+        requires_foreman '>= 5.0'
         register_global_js_file 'global'
         divider :top_menu, :parent => :monitor_menu, :last => true, :caption => N_('Foreman Tasks')
         menu :top_menu, :tasks,
@@ -36,7 +36,7 @@ module ForemanTasks
              :last     => true
 
         security_block :foreman_tasks do |_map|
-          permission :view_foreman_tasks, { :'foreman_tasks/tasks' => [:auto_complete_search, :sub_tasks, :index, :summary, :summary_sub_tasks, :show],
+          permission :view_foreman_tasks, { :'foreman_tasks/tasks' => [:auto_complete_search, :sub_tasks, :index, :summary, :summary_sub_tasks],
                                             :'foreman_tasks/api/tasks' => [:bulk_search, :show, :index, :summary, :summary_sub_tasks, :details, :sub_tasks] }, :resource_type => 'ForemanTasks::Task'
           permission :edit_foreman_tasks, { :'foreman_tasks/tasks' => [:resume, :unlock, :force_unlock, :cancel_step, :cancel, :abort],
                                             :'foreman_tasks/api/tasks' => [:bulk_resume, :bulk_cancel, :bulk_stop] }, :resource_type => 'ForemanTasks::Task'

data/lib/foreman_tasks/version.rb

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

data/test/controllers/tasks_controller_test.rb

@@ -82,15 +82,6 @@ module ForemanTasks
         assert_include response.body.lines[1], 'Some action'
       end
 
-      describe 'show' do
-        it 'does not allow user without permissions to see task details' do
-          setup_user('view', 'foreman_tasks', 'owner.id = current_user')
-          get :show, params: { id: FactoryBot.create(:some_task).id },
-                     session: set_session_user(User.current)
-          assert_response :not_found
-        end
-      end
-
       describe 'index' do
         it 'shows duration column' do
           task = ForemanTasks::Task.select_duration.find(FactoryBot.create(:some_task).id)

data/test/foreman_tasks_test_helper.rb

@@ -9,8 +9,8 @@ require_relative './support/history_tasks_builder'
 require 'dynflow/testing'
 require 'foreman_tasks/test_helpers'
 
-FactoryBot.definition_file_paths = ["#{ForemanTasks::Engine.root}/test/factories"]
-FactoryBot.find_definitions
+FactoryBot.definition_file_paths << "#{ForemanTasks::Engine.root}/test/factories"
+FactoryBot.reload
 
 ForemanTasks.dynflow.require!
 ForemanTasks.dynflow.config.disable_active_record_actions = true

data/test/integration/tasks_test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../test_plugin_helper'
+require 'integration_test_helper'
+
+class TasksIntegrationTest < IntegrationTestWithJavascript
+  test 'does not allow user without permissions to see task details' do
+    setup_user('view', 'foreman_tasks', 'owner.id = current_user')
+    task = FactoryBot.create(:some_task)
+    set_request_user(User.current)
+
+    visit "/foreman_tasks/tasks/#{task.id}"
+
+    assert_selector 'h5', text: /Unable to load task/i
+    assert_no_selector '#task-details-tabs'
+  end
+end

data/test/test_plugin_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This calls the main test_helper in Foreman-core
+require 'test_helper'
+
+# Add plugin to FactoryBot's paths
+FactoryBot.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
+FactoryBot.reload

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'
+        )
+      );
+    });
+  });
 });