foreman-tasks 9.1.0 → 9.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 959e8a5bbb07d3d1b6b0d1f0b57f502b4397d5797ccc3037b1e9f77a8229b06a
-  data.tar.gz: f0bef4b1aca4d471a2616e6b41751f1da2165eb23d9da65be87bf055bc4fab05
+  metadata.gz: 5280ef80f012ccdd9210e1dadd08a201a20cecba8158d78e6c4820cb367c007e
+  data.tar.gz: bba5cbfeadb51c5bd8f998a3f3439e53d52775d86703535c6359b808149ef24f
 SHA512:
-  metadata.gz: 2740338c22e5f0371358d037212a2964d4a46119dd2d2275dc290b91742be20bdd2b74ef8b9b036f60e975b4e798424b20776eabfeaa9f49049f24a2389d48c7
-  data.tar.gz: 43ae242cf9b8d2e7e873ab9fa99b5be157d1f9467e931d163ccf0e831d1e1969cd81ceb0391d1397f1d6606ee159b62e88e97202ddeac112579a34cc74f3d698
+  metadata.gz: 2226e22a486c65df96a9dd672b1a360a727482b5038a47d6405ff10fc23849b12077978d898c92467e8c911a79558be1be1004685d7abe99d311d9100677ca56
+  data.tar.gz: 9c3d1498b4aa19d45242ebfc333ccad9d4d2b4b09f1b8d466c9f5dfda9ad09b4ff3d45decd083617a5719ca738ada5f2992915f74a96b8c79a14347997d5afc4

data/app/models/foreman_tasks/remote_task.rb

@@ -42,6 +42,9 @@ module ForemanTasks
     end
 
     def update_from_batch_trigger(data, parent = {})
+      # The ID might get overwritten later, but it is a sane default in case of async
+      # triggering where we only get an id of a remote parent
+      self.remote_task_id = execution_plan_id
       if data['result'] == 'success'
         self.remote_task_id = data['task_id']
         self.state = 'triggered'

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '9.1.0'.freeze
+  VERSION = '9.1.1'.freeze
 end

data/test/controllers/api/tasks_controller_test.rb

@@ -17,14 +17,14 @@ module ForemanTasks
           get :index
           assert_response :success
           data = JSON.parse(response.body)
-          _(data['results'].count).must_equal 5
+          assert_equal 5, data['results'].count
         end
 
         it 'supports searching' do
           get :index, params: { :search => 'label = Actions::User::Create' }
           assert_response :success
           data = JSON.parse(response.body)
-          _(data['results'].count).must_equal 5
+          assert_equal 5, data['results'].count
         end
 
         it 'renders task ids when searching by resource id' do
@@ -33,15 +33,15 @@ module ForemanTasks
           get :index, params: { :search => "label = Actions::Katello::Product::Create and resource_id = 1" }
           assert_response :success
           data = JSON.parse(response.body)
-          _(data['results'].first["id"]).must_equal task.id
+          assert_equal task.id, data['results'].first["id"]
         end
 
         it 'supports ordering by duration' do
           get :index, params: { :sort_by => 'duration' }
           assert_response :success
           data = JSON.parse(response.body)
-          _(data.dig('sort', 'by')).must_equal 'duration'
-          _(data['results'].count).must_equal 5
+          assert_equal 'duration', data.dig('sort', 'by')
+          assert_equal 5, data['results'].count
         end
 
         context 'with current taxonomies' do
@@ -53,9 +53,9 @@ module ForemanTasks
             get :index, params: { organization_id: org1.id }
             assert_response :success
             results = JSON.parse(response.body)['results']
-            _(results.count).must_equal 6
-            _(results.map { |r| r['id'] }).must_include org1_task.id
-            _(results.map { |r| r['id'] }).wont_include org2_task.id
+            assert_equal 6, results.count
+            assert_includes results.map { |r| r['id'] }, org1_task.id
+            assert_not_includes results.map { |r| r['id'] }, org2_task.id
           end
         end
       end
@@ -66,7 +66,7 @@ module ForemanTasks
           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
+          assert_equal task.id, data[0]['results'][0]['id']
         end
 
         it 'can search for a specific resource' do
@@ -77,7 +77,7 @@ module ForemanTasks
 
           assert_response :success
           data = JSON.parse(response.body)
-          _(data[0]['results'][0]['id']).must_equal task.id
+          assert_equal task.id, data[0]['results'][0]['id']
         end
       end
 
@@ -108,7 +108,7 @@ module ForemanTasks
           get :show, params: { id: task.id }, session: set_session_user
           assert_response :success
           data = JSON.parse(response.body)
-          _(data['duration']).must_equal task.duration.in_seconds.to_s
+          assert_equal task.duration.in_seconds.to_s, data['duration']
         end
       end
 
@@ -118,7 +118,7 @@ module ForemanTasks
           get :index, session: set_session_user
           assert_response :success
           data = JSON.parse(response.body)
-          _(data['results'][0]['duration']).must_equal task.duration.in_seconds.to_s
+          assert_equal task.duration.in_seconds.to_s, data['results'][0]['duration']
         end
       end
 
@@ -189,17 +189,17 @@ 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'
+          assert_equal 'running', task.state
+          assert_equal 'pending', task.result
 
           callback = Support::DummyProxyAction.proxy.log[:trigger_task].first[1].first[1][:action_input][: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_output']).must_equal('result' => 'success')
+          assert_equal 'stopped', task.state
+          assert_equal 'success', task.result
+          assert_equal({ 'result' => 'success' }, task.main_action.output['proxy_output'])
         end
       end
     end

data/test/controllers/tasks_controller_test.rb

@@ -141,30 +141,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]
+            assert_equal [task.id], results.map(&:id).sort
           end
         end
 
         it 'does not scope by taxonomy if unset' do
           organizations
           tasks
-          _(@controller.send(:current_taxonomy_search)).must_equal ''
+          assert_equal '', @controller.send(:current_taxonomy_search)
           results = @controller.send(:filter, ForemanTasks::Task)
-          _(results.map(&:id).sort).must_equal tasks.map(&:id).sort
+          assert_equal tasks.map(&:id).sort, results.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})"
+            assert_equal "(organization_id = #{o.id})", @controller.send(:current_taxonomy_search)
             results = @controller.send(:filter, ForemanTasks::Task)
-            _(results.map(&:id).sort).must_equal [scoped, unscoped].map(&:id).sort
+            assert_equal [scoped, unscoped].map(&:id).sort, results.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})"
+            assert_equal "(organization_id = #{o.id} AND location_id = #{l.id})", @controller.send(:current_taxonomy_search)
           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
+        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