foreman-tasks 2.0.3 → 3.0.0

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
@@ -148,12 +148,6 @@ class RecurringLogicsTest < ActiveSupport::TestCase
         assert ForemanTasks.dynflow.world.persistence.load_delayed_plan(task.execution_plan.id).frozen
       end
 
-      it 'handles if the task has been deleted' do
-        logic.tasks.find_by(:state => 'scheduled').destroy
-        logic.update!(:enabled => false)
-        assert_equal 'disabled', logic.state
-      end
-
       it 'properly re-enables on disable' do
         logic.update!(:enabled => false)
         logic.update!(:enabled => true)
@@ -170,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

data/test/unit/remote_task_test.rb

@@ -24,8 +24,8 @@ module ForemanTasks
         RemoteTask.batch_trigger('a_operation', remote_tasks)
         remote_tasks.each do |remote_task|
           remote_task.reload
-          remote_task.state.must_equal 'triggered'
-          remote_task.remote_task_id.must_equal((remote_task.id + 5).to_s)
+          _(remote_task.state).must_equal 'triggered'
+          _(remote_task.remote_task_id).must_equal((remote_task.id + 5).to_s)
         end
       end
 

data/test/unit/task_groups_test.rb

@@ -55,18 +55,18 @@ module ForemanTasks
 
       it 'has the task group assigned' do
         task = spawn_task.call ChildAction
-        task.task_groups.map(&:id).must_equal [1]
+        _(task.task_groups.map(&:id)).must_equal [1]
       end
 
       it 'tasks inherit task groups correctly' do
         children_count = 3
         task = spawn_task.call ParentAction, children_count
         # Parent task has task groups of its children
-        task.task_groups.map(&:id).sort.must_equal [1, 2, 3, 4]
+        _(task.task_groups.map(&:id).sort).must_equal [1, 2, 3, 4]
         # Children have the parent's and their own, they don't have their siblings' task groups
-        task.sub_tasks.count.must_equal children_count
+        _(task.sub_tasks.count).must_equal children_count
         task.sub_tasks.each do |sub_task|
-          sub_task.task_groups.map(&:id).sort.must_equal [1, sub_task.input[:id]].sort
+          _(sub_task.task_groups.map(&:id).sort).must_equal [1, sub_task.input[:id]].sort
         end
       end
     end

data/test/unit/task_test.rb

@@ -32,8 +32,8 @@ class TasksTest < ActiveSupport::TestCase
       end
 
       test 'cannot search by arbitrary key' do
-        proc { ForemanTasks::Task.search_for('user.my_key ~ 5') }.must_raise(ScopedSearch::QueryNotSupported)
-        proc { ForemanTasks::Task.search_for('user. = 5') }.must_raise(ScopedSearch::QueryNotSupported)
+        _ { proc { ForemanTasks::Task.search_for('user.my_key ~ 5') } }.must_raise(ScopedSearch::QueryNotSupported)
+        _ { proc { ForemanTasks::Task.search_for('user. = 5') } }.must_raise(ScopedSearch::QueryNotSupported)
       end
 
       test 'can search the tasks by negated user' do
@@ -59,8 +59,8 @@ class TasksTest < ActiveSupport::TestCase
       end
 
       test 'cannot glob on user\'s id' do
-        proc { ForemanTasks::Task.search_for("user.id ~ something") }.must_raise(ScopedSearch::QueryNotSupported)
-        proc { ForemanTasks::Task.search_for("user.id ~ 5") }.must_raise(ScopedSearch::QueryNotSupported)
+        _ { proc { ForemanTasks::Task.search_for("user.id ~ something") } }.must_raise(ScopedSearch::QueryNotSupported)
+        _ { proc { ForemanTasks::Task.search_for("user.id ~ 5") } }.must_raise(ScopedSearch::QueryNotSupported)
       end
 
       test 'can search the tasks by user with wildcards' do
@@ -126,7 +126,7 @@ class TasksTest < ActiveSupport::TestCase
       end
 
       it 'raises an exception if duration is unknown' do
-        proc { ForemanTasks::Task.search_for('duration = "25 potatoes"') }.must_raise ScopedSearch::QueryNotSupported
+        _ { proc { ForemanTasks::Task.search_for('duration = "25 potatoes"') } }.must_raise ScopedSearch::QueryNotSupported
       end
     end
   end
@@ -176,13 +176,13 @@ class TasksTest < ActiveSupport::TestCase
     let(:inconsistent_task) { FactoryBot.create(:dynflow_task, :inconsistent_dynflow_task) }
 
     it 'ensures the tasks marked as running are really running in Dynflow' do
-      consistent_task.state.must_equal 'planned'
-      inconsistent_task.state.must_equal 'running'
+      _(consistent_task.state).must_equal 'planned'
+      _(inconsistent_task.state).must_equal 'running'
 
       ForemanTasks::Task::DynflowTask.consistency_check
 
-      consistent_task.reload.state.must_equal 'planned'
-      inconsistent_task.reload.state.must_equal 'planned'
+      _(consistent_task.reload.state).must_equal 'planned'
+      _(inconsistent_task.reload.state).must_equal 'planned'
     end
   end
 
@@ -190,8 +190,8 @@ class TasksTest < ActiveSupport::TestCase
     it 'when scheduled to the future, the label and action is set properly' do
       job = Support::DummyActiveJob.set(:wait => 12.hours).perform_later
       task = ForemanTasks::Task.find_by!(:external_id => job.provider_job_id)
-      task.action.must_equal "Dummy action"
-      task.label.must_equal "Support::DummyActiveJob"
+      _(task.action).must_equal "Dummy action"
+      _(task.label).must_equal "Support::DummyActiveJob"
     end
   end
 
@@ -224,14 +224,14 @@ class TasksTest < ActiveSupport::TestCase
         :total     => 0,
         :success   => 0,
         :cancelled => 0,
-        :pending   => 0
+        :pending   => 0,
       }
     end
     let(:task) { FactoryBot.create(:dynflow_task) }
 
     describe 'without sub tasks' do
       it 'calculates the progress report correctly' do
-        task.sub_tasks_counts.must_equal result_base
+        _(task.sub_tasks_counts).must_equal result_base
       end
     end
 
@@ -242,7 +242,7 @@ class TasksTest < ActiveSupport::TestCase
 
       it 'calculate the progress report correctly' do
         expected_result = result_base.merge(:success => 1, :error => 1, :total => 2)
-        task.sub_tasks_counts.must_equal expected_result
+        _(task.sub_tasks_counts).must_equal expected_result
       end
 
       it 'calculates the progress report correctly when using batch planning' do
@@ -252,11 +252,11 @@ class TasksTest < ActiveSupport::TestCase
 
         task.state = 'stopped'
         expected_result = result_base.merge(:cancelled => 23)
-        task.sub_tasks_counts.must_equal expected_result
+        _(task.sub_tasks_counts).must_equal expected_result
 
         task.state = 'pending'
         expected_result = result_base.merge(:pending => 23)
-        task.sub_tasks_counts.must_equal expected_result
+        _(task.sub_tasks_counts).must_equal expected_result
       end
     end
   end
@@ -278,10 +278,10 @@ class TasksTest < ActiveSupport::TestCase
 
     it 'can indicate it is delayed' do
       assert_not task.delayed?
-      task.execution_type.must_equal 'Immediate'
+      _(task.execution_type).must_equal 'Immediate'
       task.start_at = Time.now.utc + 100
       assert task.delayed?
-      task.execution_type.must_equal 'Delayed'
+      _(task.execution_type).must_equal 'Delayed'
     end
   end
 

data/test/unit/triggering_test.rb

@@ -3,28 +3,28 @@ require 'foreman_tasks_test_helper'
 class TriggeringTest < ActiveSupport::TestCase
   describe 'validation' do
     it 'is valid when immediate' do
-      FactoryBot.build(:triggering).must_be :valid?
+      _(FactoryBot.build(:triggering)).must_be :valid?
     end
 
     it 'is validates future execution' do
       triggering = FactoryBot.build(:triggering, :future)
-      triggering.must_be :valid?
+      _(triggering).must_be :valid?
       triggering.start_before = triggering.start_at - 120
-      triggering.wont_be :valid?
+      _(triggering).wont_be :valid?
     end
 
     it 'is invalid when recurring logic is invalid' do
       triggering = FactoryBot.build(:triggering, :recurring)
-      triggering.must_be :valid?
+      _(triggering).must_be :valid?
       triggering.recurring_logic.stubs(:valid?).returns(false)
-      triggering.wont_be :valid?
+      _(triggering).wont_be :valid?
     end
   end
 
   it 'cannot have mode set to arbitrary value' do
     triggering = FactoryBot.build(:triggering)
-    triggering.must_be :valid?
-    proc { triggering.mode = 'bogus' }.must_raise ArgumentError
-    proc { triggering.mode = 27 }.must_raise ArgumentError
+    _(triggering).must_be :valid?
+    _ { proc { triggering.mode = 'bogus' } }.must_raise ArgumentError
+    _ { proc { triggering.mode = 27 } }.must_raise ArgumentError
   end
 end