foreman-tasks 2.0.3 → 3.0.0

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

data/test/unit/actions/recurring_action_test.rb

@@ -22,7 +22,7 @@ module ForemanTasks
           :minutes => 0,
           :hours => 12,
           :days => 1,
-          :months => ((Time.zone.now.month + 1) % 12) + 1
+          :months => ((Time.zone.now.month + 1) % 12) + 1,
         }
       end
 
@@ -50,77 +50,75 @@ module ForemanTasks
       end
 
       specify 'it triggers the repeat when task is cancelled' do
-        recurring_task.must_be :delayed?
-        recurring_logic.tasks.count.must_equal 1
+        _(recurring_task).must_be :delayed?
+        _(recurring_logic.tasks.count).must_equal 1
         cancelled_events = recurring_task.execution_plan.cancel
         cancelled_events.each(&:wait!)
         recurring_logic.reload
-        recurring_logic.tasks.count.must_equal 2
+        _(recurring_logic.tasks.count).must_equal 2
         new_task = recurring_logic.tasks.find { |task| task.id != recurring_task.id }
-        new_task.execution_plan.delay_record.args.must_equal args
-        new_task.start_at.must_equal(recurring_task.start_at + 1.year)
+        _(new_task.execution_plan.delay_record.args).must_equal args
+        _(new_task.start_at).must_equal(recurring_task.start_at + 1.year)
       end
 
       specify 'it triggers the repeat when the task goes into planned state' do
         delay_options = recurring_logic.generate_delay_options
         task = ForemanTasks.delay HookedAction, delay_options, *args
-        recurring_logic.tasks.count.must_equal 1
+        _(recurring_logic.tasks.count).must_equal 1
 
         # Perform planning of the delayed plan
         task.execution_plan.delay_record.plan
 
         # Check a repetition was planned
-        recurring_logic.tasks.count.must_equal 2
+        _(recurring_logic.tasks.count).must_equal 2
       end
 
       specify 'it does not trigger repeat when failing in run' do
         delay_options = recurring_logic.generate_delay_options
         task = ForemanTasks.delay HookedAction, delay_options, true, args.last
-        recurring_logic.tasks.count.must_equal 1
+        _(recurring_logic.tasks.count).must_equal 1
 
         # Perform the planning (trigger repeat)
         task.execution_plan.delay_record.plan
-        recurring_logic.tasks.count.must_equal 2
+        _(recurring_logic.tasks.count).must_equal 2
 
         # Let it fail
         task.execution_plan.delay_record.execute.finished.wait
         task.reload
-        task.result.must_equal 'error'
+        _(task.result).must_equal 'error'
 
         # Check no new repetitions were planned
-        recurring_logic.tasks.count.must_equal 2
+        _(recurring_logic.tasks.count).must_equal 2
       end
 
       specify 'it resets the request id on repetition' do
-        begin
-          expected_id = 'an_id'
-          new_id = SecureRandom.uuid
-          old_id = ::Logging.mdc['request']
-          ::Logging.mdc['request'] = expected_id
-
-          delay_options = recurring_logic.generate_delay_options
-          task = ForemanTasks.delay HookedAction, delay_options, true, args.last
-          task.input[:current_request_id].must_equal expected_id
-
-          SecureRandom.stubs(:uuid).returns(new_id)
-          # Perform the planning (trigger repeat)
-          task.execution_plan.delay_record.plan
-          repetition = recurring_logic.tasks.find { |t| t.id != task.id }
-          repetition.input[:current_request_id].must_equal new_id
-        ensure
-          ::Logging.mdc['request'] = old_id
-        end
+        expected_id = 'an_id'
+        new_id = SecureRandom.uuid
+        old_id = ::Logging.mdc['request']
+        ::Logging.mdc['request'] = expected_id
+
+        delay_options = recurring_logic.generate_delay_options
+        task = ForemanTasks.delay HookedAction, delay_options, true, args.last
+        _(task.input[:current_request_id]).must_equal expected_id
+
+        SecureRandom.stubs(:uuid).returns(new_id)
+        # Perform the planning (trigger repeat)
+        task.execution_plan.delay_record.plan
+        repetition = recurring_logic.tasks.find { |t| t.id != task.id }
+        _(repetition.input[:current_request_id]).must_equal new_id
+      ensure
+        ::Logging.mdc['request'] = old_id
       end
 
       specify 'it does not trigger tasks in the past' do
         delay_options = past_recurring_logic.generate_delay_options
         delay_options[:start_at] = Time.zone.now - 1.week
         task = ForemanTasks.delay HookedAction, delay_options, *args
-        past_recurring_logic.tasks.count.must_equal 1
+        _(past_recurring_logic.tasks.count).must_equal 1
 
         task.execution_plan.delay_record.plan
         # Post planning, a new task should be scheduled
-        past_recurring_logic.tasks.count.must_equal 2
+        _(past_recurring_logic.tasks.count).must_equal 2
         # The scheduled task should have the start date according to cron in future.
         assert_equal (Time.zone.now + 1.minute).change(:sec => 0), past_recurring_logic.tasks.where(:state => "scheduled").first.start_at
       end

data/test/unit/cleaner_test.rb

@@ -22,14 +22,14 @@ class TasksTest < ActiveSupport::TestCase
                          FactoryBot.create(:dynflow_task, :product_create_task)]
       cleaner.expects(:tasks_to_csv)
       cleaner.delete
-      ForemanTasks::Task.where(id: tasks_to_delete).must_be_empty
-      ForemanTasks::Task.where(id: tasks_to_keep).order(:id).map(&:id).must_equal tasks_to_keep.map(&:id).sort
+      _(ForemanTasks::Task.where(id: tasks_to_delete)).must_be_empty
+      _(ForemanTasks::Task.where(id: tasks_to_keep).order(:id).map(&:id)).must_equal tasks_to_keep.map(&:id).sort
 
-      ForemanTasks.dynflow.world.persistence
-                  .find_execution_plans(filters: { 'uuid' => tasks_to_delete.map(&:external_id) }).size.must_equal 0
+      _(ForemanTasks.dynflow.world.persistence
+                  .find_execution_plans(filters: { 'uuid' => tasks_to_delete.map(&:external_id) }).size).must_equal 0
 
-      ForemanTasks.dynflow.world.persistence
-                  .find_execution_plans(filters: { 'uuid' => tasks_to_keep.map(&:external_id) }).size.must_equal tasks_to_keep.size
+      _(ForemanTasks.dynflow.world.persistence
+                  .find_execution_plans(filters: { 'uuid' => tasks_to_keep.map(&:external_id) }).size).must_equal tasks_to_keep.size
     end
 
     describe "#orphaned_dynflow_tasks" do
@@ -67,11 +67,11 @@ class TasksTest < ActiveSupport::TestCase
 
       cleaner.expects(:tasks_to_csv)
       cleaner.delete
-      ForemanTasks::Task.where(id: tasks_to_delete).must_be_empty
-      ForemanTasks::Task.where(id: tasks_to_keep).must_equal tasks_to_keep
+      _(ForemanTasks::Task.where(id: tasks_to_delete)).must_be_empty
+      _(ForemanTasks::Task.where(id: tasks_to_keep)).must_equal tasks_to_keep
 
-      ForemanTasks::Lock.find_by(id: lock_to_delete.id).must_be_nil
-      ForemanTasks::Lock.find_by(id: lock_to_keep.id).wont_be_nil
+      _(ForemanTasks::Lock.find_by(id: lock_to_delete.id)).must_be_nil
+      _(ForemanTasks::Lock.find_by(id: lock_to_keep.id)).wont_be_nil
     end
 
     it 'supports passing empty filter (just delete all)' do
@@ -85,8 +85,8 @@ class TasksTest < ActiveSupport::TestCase
                        end]
       cleaner.expects(:tasks_to_csv)
       cleaner.delete
-      ForemanTasks::Task.where(id: tasks_to_delete).must_be_empty
-      ForemanTasks::Task.where(id: tasks_to_keep).must_equal tasks_to_keep
+      _(ForemanTasks::Task.where(id: tasks_to_delete)).must_be_empty
+      _(ForemanTasks::Task.where(id: tasks_to_keep)).must_equal tasks_to_keep
     end
 
     it 'matches tasks with compound filters properly' do
@@ -100,8 +100,8 @@ class TasksTest < ActiveSupport::TestCase
       task_to_keep.update!(:result => 'pending', :state => 'planned')
       cleaner.expects(:tasks_to_csv)
       cleaner.delete
-      ForemanTasks::Task.where(id: tasks_to_delete).must_be_empty
-      ForemanTasks::Task.where(id: task_to_keep).must_equal [task_to_keep]
+      _(ForemanTasks::Task.where(id: tasks_to_delete)).must_be_empty
+      _(ForemanTasks::Task.where(id: task_to_keep)).must_equal [task_to_keep]
     end
 
     it 'backs tasks up before deleting' do
@@ -117,11 +117,11 @@ class TasksTest < ActiveSupport::TestCase
       cleaner.delete
       w.close
       header, *data = r.readlines.map(&:chomp)
-      header.must_equal ForemanTasks::Task.attribute_names.join(',')
+      _(header).must_equal ForemanTasks::Task.attribute_names.join(',')
       expected_lines = tasks_to_delete.map { |task| task.attributes.values.to_csv.chomp }
-      data.count.must_equal expected_lines.count
-      expected_lines.each { |line| data.must_include line }
-      ForemanTasks::Task.where(id: tasks_to_delete).must_be_empty
+      _(data.count).must_equal expected_lines.count
+      expected_lines.each { |line| _(data).must_include line }
+      _(ForemanTasks::Task.where(id: tasks_to_delete)).must_be_empty
     end
 
     class ActionWithCleanup < Actions::Base
@@ -133,13 +133,13 @@ class TasksTest < ActiveSupport::TestCase
     describe 'default behaviour' do
       it 'searches for the actions that have the cleanup_after defined' do
         ForemanTasks::Cleaner.stubs(:cleanup_settings => {})
-        ForemanTasks::Cleaner.actions_with_default_cleanup[ActionWithCleanup].must_equal '15d'
+        _(ForemanTasks::Cleaner.actions_with_default_cleanup[ActionWithCleanup]).must_equal '15d'
       end
 
       it 'searches for the actions that have the cleanup_after defined' do
         ForemanTasks::Cleaner.stubs(:cleanup_settings =>
                                      { :actions => [{ :name => ActionWithCleanup.name, :after => '5d' }] })
-        ForemanTasks::Cleaner.actions_with_default_cleanup[ActionWithCleanup].must_equal '5d'
+        _(ForemanTasks::Cleaner.actions_with_default_cleanup[ActionWithCleanup]).must_equal '5d'
       end
 
       it 'deprecates the usage of :after' do
@@ -159,10 +159,10 @@ class TasksTest < ActiveSupport::TestCase
                    :override_actions => true, :states => 'all' }]
         ForemanTasks::Cleaner.stubs(:cleanup_settings).returns(:rules => rules)
         r1, r2 = ForemanTasks::Cleaner.actions_by_rules actions_with_default
-        r1[:filter].must_equal '(label !^ (action1, action2)) AND (label = something)'
-        r1[:states].must_equal %w[stopped paused]
-        r2[:filter].must_equal '(label = something_else)'
-        r2[:states].must_equal []
+        _(r1[:filter]).must_equal '(label !^ (action1, action2)) AND (label = something)'
+        _(r1[:states]).must_equal %w[stopped paused]
+        _(r2[:filter]).must_equal '(label = something_else)'
+        _(r2[:states]).must_equal []
       end
     end
   end