foreman-tasks 2.0.0 → 3.0.2

data/package.json

@@ -4,6 +4,7 @@
   "description": "Foreman Tasks =============",
   "main": "index.js",
   "scripts": {
+    "foreman-js:link": "./script/npm_link_foreman_js.sh",
     "lint": "tfm-lint --plugin -d /webpack",
     "test": "tfm-test --plugin",
     "test:watch": "tfm-test --plugin --watchAll",
@@ -27,7 +28,6 @@
   "dependencies": {
     "c3": "^0.4.11",
     "humanize-duration": "^3.20.1",
-    "react-html-parser": "^2.0.2",
     "react-intl": "^2.8.0"
   },
   "devDependencies": {

data/script/npm_link_foreman_js.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# This script replace the npm installation of `foreman-js`
+# with your local version. Usefull when developing `foreman-js`
+# Read more about foreman-js: https://github.com/theforeman/foreman-js
+#
+# This script designed to run using `npm run foreman-js:link` in foreman root
+
+set -e
+
+if [[ -z "${FOREMAN_JS_LOCATION}" ]]; then # FOREMAN_JS_LOCATION is empty
+  FOREMAN_JS_LOCATION="../foreman-js"
+  echo "FOREMAN_JS_LOCATION is not defined, using \"${FOREMAN_JS_LOCATION}\" instead"
+elif [ ! -d "${FOREMAN_JS_LOCATION}" ]; then
+  echo "Can't find folder ${FOREMAN_JS_LOCATION}"
+  exit 1
+fi
+
+FOREMAN_JS_LOCATION="../${FOREMAN_JS_LOCATION}"
+FOREMAN_JS_PACKAGES_LOCATION="${FOREMAN_JS_LOCATION}/packages"
+FOREMAN_JS_INSTALL_LOCATION="./node_modules/@theforeman"
+
+set -x
+
+rm -rf $FOREMAN_JS_INSTALL_LOCATION
+ln -s $FOREMAN_JS_PACKAGES_LOCATION $FOREMAN_JS_INSTALL_LOCATION

data/test/controllers/api/recurring_logics_controller_test.rb

@@ -44,7 +44,7 @@ module ForemanRecurringLogic
           post :cancel, params: { :id => @recurring_logic.id }
           assert_response :success
           @recurring_logic.reload
-          assert @recurring_logic.state == 'cancelled'
+          assert_equal @recurring_logic.state, 'cancelled'
         end
       end
     end

data/test/controllers/api/tasks_controller_test.rb

@@ -45,6 +45,16 @@ module ForemanTasks
         end
       end
 
+      describe 'POST /api/tasks/bulk_search' do
+        it 'searching for a task' do
+          task = FactoryBot.create(:dynflow_task, :user_create_task)
+          post :bulk_search, params: { :searches => [{ :type => "task", :task_id => task.id, :search_id => "1" }] }
+          assert_response :success
+          data = JSON.parse(response.body)
+          _(data[0]['results'][0]['id']).must_equal task.id
+        end
+      end
+
       describe 'GET /api/tasks/show' do
         it 'searches for task' do
           task = FactoryBot.create(:dynflow_task, :user_create_task)
@@ -115,7 +125,7 @@ module ForemanTasks
             assert_response :success
             response = JSON.parse(@response.body)
             assert_kind_of Array, response
-            assert response.empty?
+            assert_empty response
           end
         end
       end
@@ -135,18 +145,18 @@ module ForemanTasks
           wait_for { ForemanTasks::Task.find_by(external_id: triggered.id).state == 'running' }
 
           task = ForemanTasks::Task.where(:external_id => triggered.id).first
-          task.state.must_equal 'running'
-          task.result.must_equal 'pending'
+          _(task.state).must_equal 'running'
+          _(task.result).must_equal 'pending'
 
           callback = Support::DummyProxyAction.proxy.log[:trigger_task].first[1][:callback]
           post :callback, params: { 'callback' => callback, 'data' => { 'result' => 'success' } }
           triggered.finished.wait(5)
 
           task.reload
-          task.state.must_equal 'stopped'
-          task.result.must_equal 'success'
-          task.main_action.output['proxy_task_id'].must_equal Support::DummyProxyAction.proxy.uuid
-          task.main_action.output['proxy_output'].must_equal('result' => 'success')
+          _(task.state).must_equal 'stopped'
+          _(task.result).must_equal 'success'
+          _(task.main_action.output['proxy_task_id']).must_equal Support::DummyProxyAction.proxy.uuid
+          _(task.main_action.output['proxy_output']).must_equal('result' => 'success')
         end
       end
     end

data/test/controllers/tasks_controller_test.rb

@@ -120,30 +120,30 @@ module ForemanTasks
           @controller.stubs(:params).returns(:search => "id = #{task.id}")
           in_taxonomy_scope(organizations.first) do |_o, _l|
             results = @controller.send(:filter, ForemanTasks::Task)
-            results.map(&:id).sort.must_equal [task.id]
+            _(results.map(&:id).sort).must_equal [task.id]
           end
         end
 
         it 'does not scope by taxonomy if unset' do
           organizations
           tasks
-          @controller.send(:current_taxonomy_search).must_equal ''
+          _(@controller.send(:current_taxonomy_search)).must_equal ''
           results = @controller.send(:filter, ForemanTasks::Task)
-          results.map(&:id).sort.must_equal tasks.map(&:id).sort
+          _(results.map(&:id).sort).must_equal tasks.map(&:id).sort
         end
 
         it 'scopes by organization if set' do
           scoped, _, unscoped = tasks
           in_taxonomy_scope(organizations.first) do |o, _l|
-            @controller.send(:current_taxonomy_search).must_equal "(organization_id = #{o.id})"
+            _(@controller.send(:current_taxonomy_search)).must_equal "(organization_id = #{o.id})"
             results = @controller.send(:filter, ForemanTasks::Task)
-            results.map(&:id).sort.must_equal [scoped, unscoped].map(&:id).sort
+            _(results.map(&:id).sort).must_equal [scoped, unscoped].map(&:id).sort
           end
         end
 
         it 'scopes by org and location if set' do
           in_taxonomy_scope(organizations.first, FactoryBot.create(:location)) do |o, l|
-            @controller.send(:current_taxonomy_search).must_equal "(organization_id = #{o.id} AND location_id = #{l.id})"
+            _(@controller.send(:current_taxonomy_search)).must_equal "(organization_id = #{o.id} AND location_id = #{l.id})"
           end
         end
       end

data/test/core/unit/runner_test.rb

@@ -14,7 +14,7 @@ module ForemanTasksCore
 
         describe '#generate_updates' do
           it 'returns empty hash when there are no outputs' do
-            runner.generate_updates.must_be :empty?
+            _(runner.generate_updates).must_be :empty?
           end
 
           it 'returns a hash with outputs' do
@@ -22,10 +22,10 @@ module ForemanTasksCore
             type = 'stdout'
             runner.publish_data(message, type)
             updates = runner.generate_updates
-            updates.keys.must_equal [suspended_action]
+            _(updates.keys).must_equal [suspended_action]
             update = updates.values.first
-            update.exit_status.must_be :nil?
-            update.continuous_output.raw_outputs.count.must_equal 1
+            _(update.exit_status).must_be :nil?
+            _(update.continuous_output.raw_outputs.count).must_equal 1
           end
 
           it 'works in compatibility mode' do
@@ -34,10 +34,10 @@ module ForemanTasksCore
             type = 'stdout'
             runner.publish_data(message, type)
             updates = runner.generate_updates
-            updates.keys.must_equal [nil]
+            _(updates.keys).must_equal [nil]
             update = updates.values.first
-            update.exit_status.must_be :nil?
-            update.continuous_output.raw_outputs.count.must_equal 1
+            _(update.exit_status).must_be :nil?
+            _(update.continuous_output.raw_outputs.count).must_equal 1
           end
         end
       end
@@ -53,38 +53,38 @@ module ForemanTasksCore
         describe '#initialize_continuous_outputs' do
           it 'initializes outputs for targets and parent' do
             outputs = runner.initialize_continuous_outputs
-            outputs.keys.count.must_equal 3
-            outputs.values.each { |output| output.must_be_instance_of ContinuousOutput }
+            _(outputs.keys.count).must_equal 3
+            outputs.values.each { |output| _(output).must_be_instance_of ContinuousOutput }
           end
         end
 
         describe '#generate_updates' do
           it 'returns only updates for hosts with pending outputs' do
-            runner.generate_updates.must_equal({})
+            _(runner.generate_updates).must_equal({})
             runner.publish_data_for('foo', 'something', 'something')
             updates = runner.generate_updates
-            updates.keys.count.must_equal 1
+            _(updates.keys.count).must_equal 1
           end
 
           it 'works in compatibility mode' do
             runner = Parent.new targets
-            runner.generate_updates.must_equal({})
+            _(runner.generate_updates).must_equal({})
             runner.broadcast_data('something', 'stdout')
             updates = runner.generate_updates
-            updates.keys.count.must_equal 3
+            _(updates.keys.count).must_equal 3
             # One of the keys is nil in compatibility mode
-            updates.keys.compact.count.must_equal 2
+            _(updates.keys.compact.count).must_equal 2
             updates.keys.compact.each do |key|
-              key.must_be_instance_of ::Dynflow::Action::Suspended
+              _(key).must_be_instance_of ::Dynflow::Action::Suspended
             end
           end
 
           it 'works without compatibility mode' do
             runner.broadcast_data('something', 'stdout')
             updates = runner.generate_updates
-            updates.keys.count.must_equal 3
+            _(updates.keys.count).must_equal 3
             updates.keys.each do |key|
-              key.must_be_instance_of ::Dynflow::Action::Suspended
+              _(key).must_be_instance_of ::Dynflow::Action::Suspended
             end
           end
         end
@@ -92,14 +92,14 @@ module ForemanTasksCore
         describe '#publish_data_for' do
           it 'publishes data for a single host' do
             runner.publish_data_for('foo', 'message', 'stdout')
-            runner.generate_updates.keys.count.must_equal 1
+            _(runner.generate_updates.keys.count).must_equal 1
           end
         end
 
         describe '#broadcast_data' do
           it 'publishes data for all hosts' do
             runner.broadcast_data('message', 'stdout')
-            runner.generate_updates.keys.count.must_equal 3
+            _(runner.generate_updates.keys.count).must_equal 3
           end
         end
 
@@ -115,7 +115,7 @@ module ForemanTasksCore
           it 'broadcasts the exception to all targets' do
             runner.expects(:publish_exit_status).never
             runner.publish_exception('general failure', exception, false)
-            runner.generate_updates.keys.count.must_equal 3
+            _(runner.generate_updates.keys.count).must_equal 3
           end
 
           it 'publishes exit status if fatal' do

data/test/core/unit/task_launcher_test.rb

@@ -17,15 +17,15 @@ module ForemanTasksCore
 
           it 'triggers an action' do
             Support::DummyDynflowAction.any_instance.expects(:plan).with do |arg|
-              arg.must_equal(expected_result)
+              _(arg).must_equal(expected_result)
             end
             launcher.launch!(launcher_input)
           end
 
           it 'provides results' do
             plan = launcher.launch!(launcher_input).finished.value!
-            launcher.results[:result].must_equal 'success'
-            plan.result.must_equal :success
+            _(launcher.results[:result]).must_equal 'success'
+            _(plan.result).must_equal :success
           end
         end
 
@@ -36,17 +36,17 @@ module ForemanTasksCore
             Support::DummyDynflowAction.any_instance.expects(:plan).with { |arg| arg == expected_result }.twice
             parent = launcher.launch!('foo' => launcher_input, 'bar' => launcher_input)
             plan = parent.finished.value!
-            plan.result.must_equal :success
-            plan.sub_plans.count.must_equal 2
+            _(plan.result).must_equal :success
+            _(plan.sub_plans.count).must_equal 2
           end
 
           it 'provides results' do
             launcher.launch!('foo' => launcher_input, 'bar' => launcher_input)
-            launcher.results.keys.must_equal %w[foo bar]
+            _(launcher.results.keys).must_equal %w[foo bar]
             launcher.results.values.each do |result|
               plan = ForemanTasks.dynflow.world.persistence.load_execution_plan(result[:task_id])
-              result[:result].must_equal 'success'
-              plan.result.must_equal :success
+              _(result[:result]).must_equal 'success'
+              _(plan.result).must_equal :success
             end
           end
         end

data/test/helpers/foreman_tasks/foreman_tasks_helper_test.rb

@@ -10,9 +10,9 @@ module ForemanTasks
       it 'prepares items for index correctly' do
         stubs(:action_name).returns('index')
         items = breadcrumb_items
-        items.count.must_equal 1
-        items.first[:caption].must_equal 'Tasks'
-        items.first[:url].must_be_nil
+        _(items.count).must_equal 1
+        _(items.first[:caption]).must_equal 'Tasks'
+        _(items.first[:url]).must_be_nil
       end
 
       it 'prepares items for show correctly' do
@@ -20,8 +20,8 @@ module ForemanTasks
         @task.action = 'A task'
         stubs(:action_name).returns('show')
         items = breadcrumb_items
-        items.map { |i| i[:caption] }.must_equal ['Tasks', 'A task']
-        items.last[:url].must_be_nil
+        _(items.map { |i| i[:caption] }).must_equal ['Tasks', 'A task']
+        _(items.last[:url]).must_be_nil
       end
 
       it 'prepares items for sub tasks correctly' do
@@ -31,8 +31,8 @@ module ForemanTasks
         @task.action = 'A task'
         stubs(:action_name).returns('sub_tasks')
         items = breadcrumb_items
-        items.map { |i| i[:caption] }.must_equal ['Tasks', 'A task', 'Sub tasks']
-        items.last[:url].must_be_nil
+        _(items.map { |i| i[:caption] }).must_equal ['Tasks', 'A task', 'Sub tasks']
+        _(items.last[:url]).must_be_nil
       end
     end
   end

data/test/helpers/foreman_tasks/tasks_helper_test.rb

@@ -12,11 +12,11 @@ module ForemanTasks
       end
 
       it 'formats the task input properly' do
-        format_task_input(@task).must_equal("Create user 'Anonymous Admin'")
+        _(format_task_input(@task)).must_equal("Create user 'Anonymous Admin'")
       end
 
       it 'displays the dash if task is nil' do
-        format_task_input(nil).must_equal('-')
+        _(format_task_input(nil)).must_equal('-')
       end
     end
 
@@ -37,7 +37,7 @@ module ForemanTasks
 
       it 'formats the task input properly' do
         response = "product 'product-2'; organization 'test-0'"
-        format_task_input(@task).must_equal("Create #{response}")
+        _(format_task_input(@task)).must_equal("Create #{response}")
       end
     end
   end

data/test/lib/actions/middleware/keep_current_request_id_test.rb

@@ -29,21 +29,21 @@ module ForemanTasks
       it 'stores the id on planning' do
         ::Logging.mdc['request'] = expected_id
         action = create_and_plan_action(DummyAction)
-        action.input[:current_request_id].must_equal expected_id
+        _(action.input[:current_request_id]).must_equal expected_id
       end
 
       it 'restores the id for run' do
         ::Logging.mdc['request'] = expected_id
         action = create_and_plan_action(DummyAction, true)
         action = run_action action
-        action.output[:run_result].must_equal expected_id
+        _(action.output[:run_result]).must_equal expected_id
       end
 
       it 'restores the id for finalize' do
         ::Logging.mdc['request'] = expected_id
         action = create_and_plan_action(DummyAction, true)
         action = finalize_action(run_action(action))
-        action.output[:finalize_result].must_equal expected_id
+        _(action.output[:finalize_result]).must_equal expected_id
       end
     end
   end

data/test/support/history_tasks_builder.rb

@@ -5,7 +5,7 @@ class HistoryTasksBuilder
                      by_result: {
                        'success' => { recent: 2, total: 4 },
                        'warning' => { recent: 1, total: 2 },
-                       'error' => { recent: 0, total: 1 }
+                       'error' => { recent: 0, total: 1 },
                      } } }
   end
 

data/test/tasks/generate_task_actions_test.rb

@@ -26,7 +26,7 @@ class GenerateTaskActionsTest < ActiveSupport::TestCase
     end
 
     assert_match(%r{Generating action for #{tasks.count} tasks}, stdout)
-    ForemanTasks::Task.where(:action => label).count.must_equal tasks.count
+    _(ForemanTasks::Task.where(:action => label).count).must_equal tasks.count
     assert_match(%r{Processed #{tasks.count}/#{tasks.count} tasks}, stdout)
   end
 

data/test/unit/actions/action_with_sub_plans_test.rb

@@ -43,8 +43,8 @@ module ForemanTasks
       end
 
       specify 'the sub-plan stores the information about its parent' do
-        task.sub_tasks.size.must_equal 1
-        task.sub_tasks.first.label.must_equal ChildAction.name
+        _(task.sub_tasks.size).must_equal 1
+        _(task.sub_tasks.first.label).must_equal ChildAction.name
       end
 
       specify "the locks of the sub-plan don't colide with the locks of its parent" do

data/test/unit/actions/bulk_action_test.rb

@@ -31,20 +31,20 @@ module ForemanTasks
         Target.expects(:unscoped).returns(Target)
         Target.expects(:where).with(:id => targets.map(&:id)).returns(targets)
 
-        task.sub_tasks.count.must_equal targets.count
+        _(task.sub_tasks.count).must_equal targets.count
         success, failed = task.sub_tasks.partition { |sub_task| sub_task.result == 'success' }
-        failed.must_be :empty?
-        success.count.must_equal 5
+        _(failed).must_be :empty?
+        _(success.count).must_equal 5
       end
 
       specify 'it plans a task for each target even if target cannot be found' do
         Target.expects(:unscoped).returns(Target)
         Target.expects(:where).with(:id => targets.map(&:id)).returns(targets.take(4))
 
-        task.sub_tasks.count.must_equal targets.count
+        _(task.sub_tasks.count).must_equal targets.count
         success, failed = task.sub_tasks.partition { |sub_task| sub_task.result == 'success' }
-        success.count.must_equal 4
-        failed.count.must_equal 1
+        _(success.count).must_equal 4
+        _(failed.count).must_equal 1
       end
     end
   end

data/test/unit/actions/proxy_action_test.rb

@@ -37,17 +37,17 @@ module ForemanTasks
                              'proxy_action_name' => 'Proxy::DummyAction',
                              "proxy_version" => { "major" => 1, "minor" => 21, "patch" => 0 },
                              'callback' => { 'task_id' => Support::DummyProxyAction.proxy.uuid, 'step_id' => @action.run_step_id } }]
-          proxy_call.must_equal(expected_call)
+          _(proxy_call).must_equal(expected_call)
         end
 
         describe 'with batch triggering' do
           let(:batch_triggering) { true }
           it 'create remote tasks for batch triggering' do
             task = RemoteTask.first
-            task.state.must_equal 'new'
-            task.execution_plan_id.must_equal @action.execution_plan_id
-            task.operation.must_equal 'support'
-            task.remote_task_id.must_be :nil?
+            _(task.state).must_equal 'new'
+            _(task.execution_plan_id).must_equal @action.execution_plan_id
+            _(task.operation).must_equal 'support'
+            _(task.remote_task_id).must_be :nil?
           end
         end
       end
@@ -56,22 +56,22 @@ module ForemanTasks
         it "doesn't trigger the corresponding action again on the proxy" do
           action = run_action(@action)
 
-          action.state.must_equal :suspended
+          _(action.state).must_equal :suspended
 
-          Support::DummyProxyAction.proxy.log[:trigger_task].size.must_equal 1
+          _(Support::DummyProxyAction.proxy.log[:trigger_task].size).must_equal 1
         end
       end
 
       it 'supports skipping' do
         action = run_action(@action, ::Dynflow::Action::Skip)
-        action.state.must_equal :success
+        _(action.state).must_equal :success
       end
 
       describe 'cancel' do
         it 'sends the cancel event to the proxy when the cancel event is sent for the first time' do
           action = run_action(@action, ::Dynflow::Action::Cancellable::Cancel)
-          Support::DummyProxyAction.proxy.log[:cancel_task].first.must_equal [Support::DummyProxyAction.proxy.uuid]
-          action.state.must_equal :suspended
+          _(Support::DummyProxyAction.proxy.log[:cancel_task].first).must_equal [Support::DummyProxyAction.proxy.uuid]
+          _(action.state).must_equal :suspended
         end
 
         it 'cancels the action immediatelly when cancel event is sent for the second time' do
@@ -82,14 +82,14 @@ module ForemanTasks
                     e
                   end
 
-          Support::DummyProxyAction.proxy.log[:cancel_task].size.must_equal 1
-          error.message.must_match 'Cancel enforced'
+          _(Support::DummyProxyAction.proxy.log[:cancel_task].size).must_equal 1
+          _(error.message).must_match 'Cancel enforced'
         end
       end
 
       it 'saves the data comming from the proxy to the output and finishes' do
         action = run_action(@action, ::Actions::ProxyAction::CallbackData.new('result' => 'success'))
-        action.output[:proxy_output].must_equal('result' => 'success')
+        _(action.output[:proxy_output]).must_equal('result' => 'success')
       end
 
       it 'handles connection errors' do
@@ -103,12 +103,12 @@ module ForemanTasks
           end
         end
         action = run_stubbed_action.call action
-        action.state.must_equal :suspended
-        action.world.clock.pending_pings.length.must_equal 1
-        action.output[:metadata][:failed_proxy_tasks].length.must_equal 1
+        _(action.state).must_equal :suspended
+        _(action.world.clock.pending_pings.length).must_equal 1
+        _(action.output[:metadata][:failed_proxy_tasks].length).must_equal 1
         2.times { action.output[:metadata][:failed_proxy_tasks] << {} }
-        proc { action = run_stubbed_action.call action }.must_raise(Errno::ECONNREFUSED)
-        action.state.must_equal :error
+        _ { proc { action = run_stubbed_action.call action } }.must_raise(Errno::ECONNREFUSED)
+        _(action.state).must_equal :error
       end
 
       it 'hides secrets' do
@@ -118,12 +118,12 @@ module ForemanTasks
                                                        'foo' => 'bar',
                                                        'secrets' => secrets)
         task = ForemanTasks::Task.where(:external_id => triggered.id).first
-        task.input[:secrets].must_equal 'Secrets hidden'
+        _(task.input[:secrets]).must_equal 'Secrets hidden'
         triggered.future.wait # Wait for the task to get triggered before leaving the test
       end
 
       it 'wipes secrets' do
-        @action.input[:secrets].must_equal secrets
+        _(@action.input[:secrets]).must_equal secrets
         action = run_action(@action, ::Actions::ProxyAction::CallbackData.new('result' => 'success'))
 
         # #wipe_secrets! gets called as a hook, hooks are not triggered when using action testing helpers