foreman-tasks 2.0.0 → 3.0.2

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

data/test/unit/dashboard_table_filter_test.rb

@@ -24,7 +24,7 @@ class DashboardTableFilterTest < ActiveSupport::TestCase
       let(:params) { { result: 'warning' } }
 
       it 'filters' do
-        filtered_scope.count.must_equal @tasks_builder.distribution['stopped'][:by_result]['warning'][:total]
+        _(filtered_scope.count).must_equal @tasks_builder.distribution['stopped'][:by_result]['warning'][:total]
       end
     end
 
@@ -32,7 +32,7 @@ class DashboardTableFilterTest < ActiveSupport::TestCase
       let(:params) { { state: 'running' } }
 
       it 'filters' do
-        filtered_scope.count.must_equal @tasks_builder.distribution['running'][:total]
+        _(filtered_scope.count).must_equal @tasks_builder.distribution['running'][:total]
       end
     end
 
@@ -44,7 +44,7 @@ class DashboardTableFilterTest < ActiveSupport::TestCase
       end
 
       it 'filters' do
-        filtered_scope.count.must_equal @tasks_builder.distribution['running'][:recent]
+        _(filtered_scope.count).must_equal @tasks_builder.distribution['running'][:recent]
       end
     end
 
@@ -56,7 +56,7 @@ class DashboardTableFilterTest < ActiveSupport::TestCase
       end
 
       it 'filters' do
-        filtered_scope.count.must_equal @tasks_builder.distribution['running'][:recent]
+        _(filtered_scope.count).must_equal @tasks_builder.distribution['running'][:recent]
       end
     end
 
@@ -70,7 +70,7 @@ class DashboardTableFilterTest < ActiveSupport::TestCase
       it 'filters' do
         old_tasks_count = @tasks_builder.distribution['running'][:total] -
                           @tasks_builder.distribution['running'][:recent]
-        filtered_scope.count.must_equal old_tasks_count
+        _(filtered_scope.count).must_equal old_tasks_count
       end
     end
   end

data/test/unit/otp_manager_test.rb

@@ -28,7 +28,7 @@ module ForemanTasksCore
     it 'generates OTPs using SecureRandom.hex and converts them to strings' do
       otp = 4
       SecureRandom.stubs(:hex).returns(otp)
-      TestOtpManager.generate_otp(username).must_equal otp.to_s
+      _(TestOtpManager.generate_otp(username)).must_equal otp.to_s
     end
 
     it 'provides #drop_otp method that removes OTP only when correct username and password is provided' do
@@ -64,7 +64,7 @@ module ForemanTasksCore
     end
 
     it 'creates token from username and password correctly' do
-      TestOtpManager.tokenize(username, password).must_equal base64
+      _(TestOtpManager.tokenize(username, password)).must_equal base64
     end
 
     it 'overwrites old OTP when generating a new one for the same username' do

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
+      _(available.count).must_equal count
+      _(available.uniq.count).must_equal count - 1
+      _(proxy_selector.offline.count).must_equal 1
     end
 
     it 'returns nil for if no proxy is available' do
-      proxy_selector.select_by_jobs_count([]).must_be_nil
+      _(proxy_selector.select_by_jobs_count([])).must_be_nil
     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
+      _(proxy_selector.determine_proxy).must_equal :not_defined
       proxy_selector.stubs(:available_proxies => { :global => [] })
-      proxy_selector.determine_proxy.must_equal :not_defined
+      _(proxy_selector.determine_proxy).must_equal :not_defined
     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
+      _(proxy_selector.determine_proxy).must_equal :not_available
     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
+      _(ForemanTasks::ProxySelector.new.determine_proxy).must_equal fallback_proxy
       ProxyAPI::ForemanDynflow::DynflowProxy.any_instance.expects(:tasks_count).raises.then.returns(0)
-      ForemanTasks::ProxySelector.new.determine_proxy.must_equal global_proxy
+      _(ForemanTasks::ProxySelector.new.determine_proxy).must_equal global_proxy
     end
   end
 end

data/test/unit/recurring_logic_test.rb

@@ -4,17 +4,17 @@ class RecurringLogicsTest < ActiveSupport::TestCase
   describe 'generating times' do
     it 'assembles cronline' do
       hash = {}
-      ForemanTasks::RecurringLogic.assemble_cronline(hash).must_equal '* * * * *'
+      _(ForemanTasks::RecurringLogic.assemble_cronline(hash)).must_equal '* * * * *'
       hash.update :minutes => '*'
-      ForemanTasks::RecurringLogic.assemble_cronline(hash).must_equal '* * * * *'
+      _(ForemanTasks::RecurringLogic.assemble_cronline(hash)).must_equal '* * * * *'
       hash.update :hours => '0,12'
-      ForemanTasks::RecurringLogic.assemble_cronline(hash).must_equal '* 0,12 * * *'
+      _(ForemanTasks::RecurringLogic.assemble_cronline(hash)).must_equal '* 0,12 * * *'
       hash.update :days => '*/2'
-      ForemanTasks::RecurringLogic.assemble_cronline(hash).must_equal '* 0,12 */2 * *'
+      _(ForemanTasks::RecurringLogic.assemble_cronline(hash)).must_equal '* 0,12 */2 * *'
       hash.update :months => '12'
-      ForemanTasks::RecurringLogic.assemble_cronline(hash).must_equal '* 0,12 */2 12 *'
+      _(ForemanTasks::RecurringLogic.assemble_cronline(hash)).must_equal '* 0,12 */2 12 *'
       hash.update :days_of_week => '1,2,3,4,5,6,7'
-      ForemanTasks::RecurringLogic.assemble_cronline(hash).must_equal '* 0,12 */2 12 1,2,3,4,5,6,7'
+      _(ForemanTasks::RecurringLogic.assemble_cronline(hash)).must_equal '* 0,12 */2 12 1,2,3,4,5,6,7'
     end
 
     it 'generates correct times' do
@@ -25,17 +25,17 @@ class RecurringLogicsTest < ActiveSupport::TestCase
       minute = 0
       reference_time = Time.utc(year, month, day, hour, minute)
       parser = ForemanTasks::RecurringLogic.new_from_cronline('* * * * *')
-      parser.next_occurrence_time(reference_time).must_equal Time.utc(year, month, day, hour, minute)
+      _(parser.next_occurrence_time(reference_time)).must_equal Time.utc(year, month, day, hour, minute)
       parser = ForemanTasks::RecurringLogic.new_from_cronline('*/2 * * * *')
-      parser.next_occurrence_time(reference_time).must_equal Time.utc(year, month, day, hour, minute)
+      _(parser.next_occurrence_time(reference_time)).must_equal Time.utc(year, month, day, hour, minute)
       parser = ForemanTasks::RecurringLogic.new_from_cronline('*/2 18,19 * * *')
-      parser.next_occurrence_time(reference_time).must_equal Time.utc(year, month, day, 18)
+      _(parser.next_occurrence_time(reference_time)).must_equal Time.utc(year, month, day, 18)
       parser = ForemanTasks::RecurringLogic.new_from_cronline('*/2 18,19 10 * *')
-      parser.next_occurrence_time(reference_time).must_equal Time.utc(year, month + 1, 10, 18, minute)
+      _(parser.next_occurrence_time(reference_time)).must_equal Time.utc(year, month + 1, 10, 18, minute)
       parser = ForemanTasks::RecurringLogic.new_from_cronline('*/2 18,19 10 11,12 *')
-      parser.next_occurrence_time(reference_time).must_equal Time.utc(year, 11, 10, 18, 0)
+      _(parser.next_occurrence_time(reference_time)).must_equal Time.utc(year, 11, 10, 18, 0)
       parser = ForemanTasks::RecurringLogic.new_from_cronline('* * * * 1')
-      parser.next_occurrence_time(reference_time).must_equal Time.utc(year, month + 1, 5)
+      _(parser.next_occurrence_time(reference_time)).must_equal Time.utc(year, month + 1, 5)
     end
 
     it 'creates correct cronline hash' do
@@ -48,27 +48,27 @@ class RecurringLogicsTest < ActiveSupport::TestCase
       expected_result_daily = { :minutes => minutes, :hours => hours }
       expected_result_weekly = { :minutes => minutes, :hours => hours, :days_of_week => '1,4,6' }
       expected_result_monthly = { :minutes => minutes, :hours => hours, :days => days }
-      ForemanTasks::RecurringLogic.cronline_hash(:hourly,  time_hash, days, days_of_week).must_equal expected_result_hourly
-      ForemanTasks::RecurringLogic.cronline_hash(:daily,   time_hash, days, days_of_week).must_equal expected_result_daily
-      ForemanTasks::RecurringLogic.cronline_hash(:weekly,  time_hash, days, days_of_week).must_equal expected_result_weekly
-      ForemanTasks::RecurringLogic.cronline_hash(:monthly, time_hash, days, days_of_week).must_equal expected_result_monthly
+      _(ForemanTasks::RecurringLogic.cronline_hash(:hourly,  time_hash, days, days_of_week)).must_equal expected_result_hourly
+      _(ForemanTasks::RecurringLogic.cronline_hash(:daily,   time_hash, days, days_of_week)).must_equal expected_result_daily
+      _(ForemanTasks::RecurringLogic.cronline_hash(:weekly,  time_hash, days, days_of_week)).must_equal expected_result_weekly
+      _(ForemanTasks::RecurringLogic.cronline_hash(:monthly, time_hash, days, days_of_week)).must_equal expected_result_monthly
     end
 
     it 'can have limited number of repeats' do
       parser = ForemanTasks::RecurringLogic.new_from_cronline('* * * * *')
       parser.state = 'active'
-      parser.must_be :can_continue?
+      _(parser).must_be :can_continue?
       parser.max_iteration = 5
       parser.expects(:iteration).twice.returns(5)
-      parser.wont_be :can_continue?
+      _(parser).wont_be :can_continue?
       parser.max_iteration = nil
       time = Time.utc(2015, 9, 29, 15, 0)
       parser.end_time = time
-      parser.wont_be :can_continue?, time
+      _(parser).wont_be :can_continue?, time
       parser.end_time = time + 120
-      parser.must_be :can_continue?, time
+      _(parser).must_be :can_continue?, time
       parser.max_iteration = 5
-      parser.wont_be :can_continue?, time
+      _(parser).wont_be :can_continue?, time
     end
 
     it 'generates delay options' do
@@ -76,9 +76,9 @@ class RecurringLogicsTest < ActiveSupport::TestCase
       parser.stubs(:id).returns(1)
       reference_time = Time.utc(2015, 9, 29, 15)
       expected_hash = { :start_at => reference_time, :start_before => nil, :recurring_logic_id => parser.id, :frozen => false }
-      parser.generate_delay_options(reference_time).must_equal expected_hash
-      parser.generate_delay_options(reference_time, 'start_before' => reference_time + 3600)
-            .must_equal expected_hash.merge(:start_before => reference_time + 3600)
+      _(parser.generate_delay_options(reference_time)).must_equal expected_hash
+      _(parser.generate_delay_options(reference_time, 'start_before' => reference_time + 3600))
+        .must_equal expected_hash.merge(:start_before => reference_time + 3600)
     end
 
     it 'can start' do
@@ -108,19 +108,19 @@ class RecurringLogicsTest < ActiveSupport::TestCase
     it 'has a task group associated to all tasks that were created as part of the recurring logic' do
       recurring_logic = ForemanTasks::RecurringLogic.new_from_cronline('* * * * *')
       recurring_logic.save
-      recurring_logic.task_group.must_be_kind_of ForemanTasks::TaskGroups::RecurringLogicTaskGroup
+      _(recurring_logic.task_group).must_be_kind_of ForemanTasks::TaskGroups::RecurringLogicTaskGroup
       task = FactoryBot.build(:dynflow_task, :user_create_task)
       task.task_groups << Support::DummyTaskGroup.new
       task.save!
       recurring_logic.task_group.tasks << task
-      recurring_logic.task_groups.must_include(*task.task_groups)
+      _(recurring_logic.task_groups).must_include(*task.task_groups)
     end
 
     it 'can be created from triggering' do
       triggering = FactoryBot.build(:triggering, :recurring, :end_time_limited)
       logic = ForemanTasks::RecurringLogic.new_from_triggering(triggering)
       # Mysql coerces the times a bit
-      logic.end_time.must_be_close_to(triggering.end_time, 1.second)
+      _(logic.end_time).must_be_close_to(triggering.end_time, 1.second)
     end
 
     it 'cannot trigger tasks when cancelled' do
@@ -164,24 +164,24 @@ class RecurringLogicsTest < ActiveSupport::TestCase
       let(:logic) { FactoryBot.build(:recurring_logic) }
 
       it 'is valid by default' do
-        logic.must_be :valid?
+        _(logic).must_be :valid?
       end
 
       it 'is invalid when end time in past' do
         logic.end_time = (Time.zone.now - 120)
-        logic.wont_be :valid?
+        _(logic).wont_be :valid?
       end
 
       it 'is invalid when iteration limit < 1' do
         logic.max_iteration = 0
-        logic.wont_be :valid?
+        _(logic).wont_be :valid?
       end
 
       it 'is valid when in active state' do
         logic.end_time = (Time.zone.now - 120)
-        logic.wont_be :valid?
+        _(logic).wont_be :valid?
         logic.state = 'active'
-        logic.must_be :valid?
+        _(logic).must_be :valid?
       end
     end
   end