foreman-tasks 9.1.0 → 9.2.0

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
+        assert_equal 1, items.count
+        assert_equal 'Tasks', items.first[:caption]
+        assert_nil items.first[:url]
       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
+        assert_equal(['Tasks', 'A task'], items.map { |i| i[:caption] })
+        assert_nil items.last[:url]
       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
+        assert_equal(['Tasks', 'A task', 'Sub tasks'], items.map { |i| i[:caption] })
+        assert_nil items.last[:url]
       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'")
+        assert_equal "Create user 'Anonymous Admin'", format_task_input(@task)
       end
 
       it 'displays the dash if task is nil' do
-        _(format_task_input(nil)).must_equal('-')
+        assert_equal '-', format_task_input(nil)
       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}")
+        assert_equal("Create #{response}", format_task_input(@task))
       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
+        assert_equal expected_id, action.input[:current_request_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
+        assert_equal expected_id, action.output[:run_result]
       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
+        assert_equal expected_id, action.output[:finalize_result]
       end
     end
   end

data/test/lib/concerns/polling_action_extensions_test.rb

@@ -11,22 +11,22 @@ module ForemanTasks
         let(:default_intervals) { [0.5, 1, 2, 4, 8, 16] }
 
         it 'is extends the polling action module' do
-          _(::Dynflow::Action::Polling.ancestors.first).must_equal ForemanTasks::Concerns::PollingActionExtensions
+          assert_equal ForemanTasks::Concerns::PollingActionExtensions, ::Dynflow::Action::Polling.ancestors.first
         end
 
         it 'does not modify polling intervals by default' do
-          _(Action.allocate.poll_intervals).must_equal default_intervals
+          assert_equal default_intervals, Action.allocate.poll_intervals
         end
 
         it 'cannot make intervals shorter than 0.5 seconds' do
           Setting.expects(:[]).with(:foreman_tasks_polling_multiplier).returns 0
-          _(Action.allocate.poll_intervals).must_equal(default_intervals.map { 0.5 })
+          assert_equal default_intervals.map { 0.5 }, Action.allocate.poll_intervals
         end
 
         it 'can be used to make the intervals longer' do
           value = 5
           Setting.expects(:[]).with(:foreman_tasks_polling_multiplier).returns value
-          _(Action.allocate.poll_intervals).must_equal(default_intervals.map { |i| i * value })
+          assert_equal default_intervals.map { |i| i * value }, Action.allocate.poll_intervals
         end
       end
     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
+    assert_equal tasks.count, ForemanTasks::Task.where(:action => label).count
     assert_match(%r{Processed #{tasks.count}/#{tasks.count} tasks}, stdout)
   end
 

data/test/unit/actions/action_with_sub_plans_test.rb

@@ -48,15 +48,15 @@ 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
+        assert_equal 1, task.sub_tasks.size
+        assert_equal ChildAction.name, task.sub_tasks.first.label
       end
 
       specify "the locks of the sub-plan don't colide with the locks of its parent" do
         child_task = task.sub_tasks.first
-        assert_not(child_task.locks.any?, "the lock is ensured by the parent")
+        assert_not child_task.locks.any?, "the lock is ensured by the parent"
         found = ForemanTasks::Link.for_resource(user).where(:task_id => child_task.id).any?
-        assert(found, "the action is linked properly")
+        assert found, "the action is linked properly"
       end
     end
   end

data/test/unit/actions/bulk_action_test.rb

@@ -37,20 +37,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
+        assert_equal targets.count, task.sub_tasks.count
         success, failed = task.sub_tasks.partition { |sub_task| sub_task.result == 'success' }
-        _(failed).must_be :empty?
-        _(success.count).must_equal 5
+        assert_empty failed
+        assert_equal 5, success.count
       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
+        assert_equal targets.count, task.sub_tasks.count
         success, failed = task.sub_tasks.partition { |sub_task| sub_task.result == 'success' }
-        _(success.count).must_equal 4
-        _(failed.count).must_equal 1
+        assert_equal 4, success.count
+        assert_equal 1, failed.count
       end
 
       specify "it handles keyword arguments as indifferent hashes when they're being flattened" do
@@ -61,8 +61,8 @@ module ForemanTasks
         task = ForemanTasks::Task.where(:external_id => triggered.id).first
         wait_for { task.reload.state == 'stopped' }
         task = task.sub_tasks.first
-        _(task.input[:kw_string]).must_equal 7
-        _(task.input[:kw_symbol]).must_equal 7
+        assert_equal 7, task.input[:kw_string]
+        assert_equal 7, task.input[:kw_symbol]
       end
 
       specify 'it allows setting concurrency limit' do
@@ -71,7 +71,7 @@ module ForemanTasks
 
         triggered = ForemanTasks.trigger(ParentAction, ChildAction, targets, concurrency_limit: 25)
         task = ForemanTasks::Task.where(:external_id => triggered.id).first
-        _(task.execution_plan.entry_action.concurrency_limit).must_equal 25
+        assert_equal 25, task.execution_plan.entry_action.concurrency_limit
       end
     end
   end

data/test/unit/actions/proxy_action_test.rb

@@ -46,17 +46,17 @@ module ForemanTasks
                   'proxy_action_name' => 'Proxy::DummyAction',
                   'callback' => { 'task_id' => Support::DummyProxyAction.proxy.uuid, 'step_id' => @run_step_id } } }
           expected_call = ['support', { @action.execution_plan_id => action_input }]
-          _(proxy_call).must_equal(expected_call)
+          assert_equal expected_call, proxy_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?
+            assert_equal 'new', task.state
+            assert_equal @action.execution_plan_id, task.execution_plan_id
+            assert_equal 'support', task.operation
+            assert_nil task.remote_task_id
           end
         end
       end
@@ -65,22 +65,22 @@ module ForemanTasks
         it "doesn't trigger the corresponding action again on the proxy" do
           action = run_action(@action)
 
-          _(action.state).must_equal :suspended
+          assert_equal :suspended, action.state
 
-          _(Support::DummyProxyAction.proxy.log[:trigger_task].size).must_equal 1
+          assert_equal 1, Support::DummyProxyAction.proxy.log[:trigger_task].size
         end
       end
 
       it 'supports skipping' do
         action = run_action(@action, ::Dynflow::Action::Skip)
-        _(action.state).must_equal :success
+        assert_equal :success, action.state
       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 [action.execution_plan_id]
-          _(action.state).must_equal :suspended
+          assert_equal [action.execution_plan_id], Support::DummyProxyAction.proxy.log[:cancel_task].first
+          assert_equal :suspended, action.state
         end
 
         it 'cancels the action immediatelly when cancel event is sent for the second time' do
@@ -91,14 +91,14 @@ module ForemanTasks
                     e
                   end
 
-          _(Support::DummyProxyAction.proxy.log[:cancel_task].size).must_equal 1
-          _(error.message).must_match 'Cancel enforced'
+          assert_equal 1, Support::DummyProxyAction.proxy.log[:cancel_task].size
+          assert_match 'Cancel enforced', error.message
         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')
+        assert_equal({ 'result' => 'success' }, action.output[:proxy_output])
       end
 
       it 'handles connection errors' do
@@ -112,12 +112,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
+        assert_equal :suspended, action.state
+        assert_equal 1, action.world.clock.pending_pings.length
+        assert_equal 1, action.output[:metadata][:failed_proxy_tasks].length
         2.times { action.output[:metadata][:failed_proxy_tasks] << {} }
-        _(proc { action = run_stubbed_action.call action }).must_raise(Errno::ECONNREFUSED)
-        _(action.state).must_equal :error
+        assert_raises(Errno::ECONNREFUSED) { run_stubbed_action.call action }
+        assert_equal :error, action.state
       end
 
       it 'hides secrets' do
@@ -127,12 +127,12 @@ module ForemanTasks
                                                        'foo' => 'bar',
                                                        'secrets' => secrets)
         task = ForemanTasks::Task.where(:external_id => triggered.id).first
-        _(task.input[:secrets]).must_equal 'Secrets hidden'
+        assert_equal 'Secrets hidden', task.input[:secrets]
         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
+        assert_equal secrets, @action.input[: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

@@ -50,45 +50,45 @@ 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
+        assert_predicate recurring_task, :delayed?
+        assert_equal 1, recurring_logic.tasks.count
         cancelled_events = recurring_task.execution_plan.cancel
         cancelled_events.each(&:wait!)
         recurring_logic.reload
-        _(recurring_logic.tasks.count).must_equal 2
+        assert_equal 2, recurring_logic.tasks.count
         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)
+        assert_equal args, new_task.execution_plan.delay_record.args
+        assert_equal recurring_task.start_at + 1.year, new_task.start_at
       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
+        assert_equal 1, recurring_logic.tasks.count
 
         # Perform planning of the delayed plan
         task.execution_plan.delay_record.plan
 
         # Check a repetition was planned
-        _(recurring_logic.tasks.count).must_equal 2
+        assert_equal 2, recurring_logic.tasks.count
       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
+        assert_equal 1, recurring_logic.tasks.count
 
         # Perform the planning (trigger repeat)
         task.execution_plan.delay_record.plan
-        _(recurring_logic.tasks.count).must_equal 2
+        assert_equal 2, recurring_logic.tasks.count
 
         # Let it fail
         task.execution_plan.delay_record.execute.finished.wait
         task.reload
-        _(task.result).must_equal 'error'
+        assert_equal 'error', task.result
 
         # Check no new repetitions were planned
-        _(recurring_logic.tasks.count).must_equal 2
+        assert_equal 2, recurring_logic.tasks.count
       end
 
       specify 'it resets the request id on repetition' do
@@ -99,13 +99,13 @@ module ForemanTasks
 
         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
+        assert_equal expected_id, task.input[:current_request_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
+        assert_equal new_id, repetition.input[:current_request_id]
       ensure
         ::Logging.mdc['request'] = old_id
       end
@@ -114,11 +114,11 @@ module ForemanTasks
         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
+        assert_equal 1, past_recurring_logic.tasks.count
 
         task.execution_plan.delay_record.plan
         # Post planning, a new task should be scheduled
-        _(past_recurring_logic.tasks.count).must_equal 2
+        assert_equal 2, past_recurring_logic.tasks.count
         # 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/actions/trigger_proxy_batch_test.rb

@@ -13,8 +13,8 @@ module ForemanTasks
       describe 'triggering' do
         it 'doesnt run anything on trigger' do
           Actions::TriggerProxyBatch.any_instance.expects(:trigger_remote_tasks_batch).never
-          _(triggered.state).must_equal :suspended
-          _(triggered.output[:planned_count]).must_equal 0
+          assert_equal :suspended, triggered.state
+          assert_equal 0, triggered.output[:planned_count]
         end
 
         it 'triggers remote tasks on TriggerNextBatch' do
@@ -37,7 +37,7 @@ module ForemanTasks
           Actions::TriggerProxyBatch.any_instance.expects(:trigger_remote_tasks_batch).once
           triggered.output[:planned_count] = 0
           action = run_action(triggered, Actions::TriggerProxyBatch::TriggerLastBatch)
-          _(action.state).must_equal :success
+          assert_equal :success, action.state
         end
       end
 
@@ -57,7 +57,7 @@ module ForemanTasks
           ForemanTasks::RemoteTask.expects(:batch_trigger).with(proxy_operation_name, grouped_remote_batch)
 
           triggered.trigger_remote_tasks_batch
-          _(triggered.output[:planned_count]).must_equal(batch_size)
+          assert_equal batch_size, triggered.output[:planned_count]
         end
       end
     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
+      assert_empty ForemanTasks::Task.where(id: tasks_to_delete)
+      assert_equal tasks_to_keep.map(&:id).sort, ForemanTasks::Task.where(id: tasks_to_keep).order(:id).map(&:id)
 
-      _(ForemanTasks.dynflow.world.persistence
-                  .find_execution_plans(filters: { 'uuid' => tasks_to_delete.map(&:external_id) }).size).must_equal 0
+      assert_equal 0, ForemanTasks.dynflow.world.persistence
+                                  .find_execution_plans(filters: { 'uuid' => tasks_to_delete.map(&:external_id) }).size
 
-      _(ForemanTasks.dynflow.world.persistence
-                  .find_execution_plans(filters: { 'uuid' => tasks_to_keep.map(&:external_id) }).size).must_equal tasks_to_keep.size
+      assert_equal tasks_to_keep.size, ForemanTasks.dynflow.world.persistence
+                                                   .find_execution_plans(filters: { 'uuid' => tasks_to_keep.map(&:external_id) }).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
+      assert_empty ForemanTasks::Task.where(id: tasks_to_delete)
+      assert_equal tasks_to_keep, ForemanTasks::Task.where(id: tasks_to_keep)
 
-      _(ForemanTasks::Link.find_by(id: link_to_delete.id)).must_be_nil
-      _(ForemanTasks::Link.find_by(id: link_to_keep.id)).wont_be_nil
+      assert_nil ForemanTasks::Link.find_by(id: link_to_delete.id)
+      assert_not_nil ForemanTasks::Link.find_by(id: link_to_keep.id)
     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
+      assert_empty ForemanTasks::Task.where(id: tasks_to_delete)
+      assert_equal tasks_to_keep, ForemanTasks::Task.where(id: 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]
+      assert_empty ForemanTasks::Task.where(id: tasks_to_delete)
+      assert_equal [task_to_keep], ForemanTasks::Task.where(id: 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(',')
+      assert_equal ForemanTasks::Task.attribute_names.join(','), header
       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
+      assert_equal expected_lines.count, data.count
+      expected_lines.each { |line| assert_includes data, line }
+      assert_empty ForemanTasks::Task.where(id: tasks_to_delete)
     end
 
     class ActionWithCleanup < Actions::Base
@@ -135,7 +135,7 @@ class TasksTest < ActiveSupport::TestCase
         ForemanTasks::Cleaner.stubs(:cleanup_settings => {})
         actions = ForemanTasks::Cleaner.actions_with_default_cleanup
         example = actions.find { |rule| rule.klass == ActionWithCleanup }
-        _(example.after).must_equal '15d'
+        assert_equal '15d', example.after
       end
 
       it 'searches for the actions that have the cleanup_after defined' do
@@ -143,7 +143,7 @@ class TasksTest < ActiveSupport::TestCase
                                      { :actions => [{ :name => ActionWithCleanup.name, :after => '5d' }] })
         actions = ForemanTasks::Cleaner.actions_with_default_cleanup
         example = actions.find { |rule| rule.klass == ActionWithCleanup }
-        _(example.after).must_equal '5d'
+        assert_equal '5d', example.after
       end
 
       it 'generates filters from rules properly' do
@@ -157,10 +157,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 '(NOT ((label ^ (action1, action2)))) AND (label = something)'
-        _(r1[:states]).must_equal %w[stopped paused]
-        _(r2[:filter]).must_equal '(label = something_else)'
-        _(r2[:states]).must_equal []
+        assert_equal '(NOT ((label ^ (action1, action2)))) AND (label = something)', r1[:filter]
+        assert_equal %w[stopped paused], r1[:states]
+        assert_equal '(label = something_else)', r2[:filter]
+        assert_equal [], r2[:states]
       end
     end
   end

data/test/unit/locking_test.rb

@@ -32,14 +32,14 @@ module ForemanTasks
 
         it 'can lock a resource for a single task only once' do
           Lock.lock!(resource, task1)
-          _(Lock.for_resource(resource).count).must_equal 1
+          assert_equal 1, Lock.for_resource(resource).count
           Lock.lock!(resource, task1)
-          _(Lock.for_resource(resource).count).must_equal 1
+          assert_equal 1, Lock.for_resource(resource).count
         end
 
         it 'cannot lock a resource for multiple tasks' do
           lock = Lock.lock!(resource, task1)
-          _(Lock.colliding_locks(resource, task2)).must_equal [lock]
+          assert_equal [lock], Lock.colliding_locks(resource, task2)
           assert_raises Lock::LockConflict do
             Lock.lock!(resource, task2)
           end
@@ -52,13 +52,13 @@ module ForemanTasks
           exception = assert_raises Lock::LockConflict do
             Lock.lock!(resource, task2)
           end
-          _(exception.message).must_match(/#{lock.task_id}/)
+          assert_match(/#{lock.task_id}/, exception.message)
         end
 
         it 'creates a link when creating a lock for a resource' do
           Lock.lock!(resource, task1)
           link = Link.for_resource(resource).first
-          _(link.task_id).must_equal task1.id
+          assert_equal task1.id, link.task_id
         end
       end
 
@@ -69,15 +69,15 @@ module ForemanTasks
 
         it 'can link a resource for a single task only once' do
           Link.link!(resource, task1)
-          _(Link.for_resource(resource).count).must_equal 1
+          assert_equal 1, Link.for_resource(resource).count
           Link.link!(resource, task1)
-          _(Link.for_resource(resource).count).must_equal 1
+          assert_equal 1, Link.for_resource(resource).count
         end
 
         it 'can link a resource to multiple tasks' do
           Link.link!(resource, task1)
           Link.link!(resource, task2)
-          _(Link.for_resource(resource).count).must_equal 2
+          assert_equal 2, Link.for_resource(resource).count
         end
       end
     end

data/test/unit/proxy_selector_test.rb

@@ -18,22 +18,22 @@ describe ForemanTasks::ProxySelector do
         found << proxy_selector.select_by_jobs_count(proxies)
       end
 
-      _(available.count).must_equal count
-      _(available.uniq.count).must_equal count - 1
-      _(proxy_selector.offline.count).must_equal 1
+      assert_equal count, available.count
+      assert_equal count - 1, available.uniq.count
+      assert_equal 1, proxy_selector.offline.count
     end
 
     it 'returns nil for if no proxy is available' do
-      _(proxy_selector.select_by_jobs_count([])).must_be_nil
+      assert_nil proxy_selector.select_by_jobs_count([])
     end
   end
 
   describe '#determine_proxy' do
     it 'returns :not_defined when avialable proxies returns empty hash' do
       proxy_selector.stubs(:available_proxies => [])
-      _(proxy_selector.determine_proxy).must_equal :not_defined
+      assert_equal :not_defined, proxy_selector.determine_proxy
       proxy_selector.stubs(:available_proxies => { :global => [] })
-      _(proxy_selector.determine_proxy).must_equal :not_defined
+      assert_equal :not_defined, proxy_selector.determine_proxy
     end
 
     it 'returns :not_available when proxies are set but offline' do
@@ -41,7 +41,7 @@ describe ForemanTasks::ProxySelector do
       ProxyAPI::ForemanDynflow::DynflowProxy.any_instance.expects(:tasks_count).times(count).raises
       proxy_selector.stubs(:available_proxies =>
                            { :global => FactoryBot.create_list(:smart_proxy, count) })
-      _(proxy_selector.determine_proxy).must_equal :not_available
+      assert_equal :not_available, proxy_selector.determine_proxy
     end
 
     it 'returns first available proxy, prioritizing by strategy' do
@@ -51,9 +51,9 @@ describe ForemanTasks::ProxySelector do
       ForemanTasks::ProxySelector.any_instance.stubs(:available_proxies =>
                                                      { :fallback => [fallback_proxy],
                                                        :global => [global_proxy] })
-      _(ForemanTasks::ProxySelector.new.determine_proxy).must_equal fallback_proxy
+      assert_equal fallback_proxy, ForemanTasks::ProxySelector.new.determine_proxy
       ProxyAPI::ForemanDynflow::DynflowProxy.any_instance.expects(:tasks_count).raises.then.returns(0)
-      _(ForemanTasks::ProxySelector.new.determine_proxy).must_equal global_proxy
+      assert_equal global_proxy, ForemanTasks::ProxySelector.new.determine_proxy
     end
   end
 end