foreman_remote_execution 3.0.3 → 3.1.0

data/test/unit/job_invocation_test.rb

@@ -11,7 +11,7 @@ class JobInvocationTest < ActiveSupport::TestCase
 
     it 'is able to perform search through job invocations' do
       found_jobs = JobInvocation.search_for(%{job_category = "#{job_invocation.job_category}"}).paginate(:page => 1).with_task.order('job_invocations.id DESC')
-      found_jobs.must_equal [job_invocation]
+      _(found_jobs).must_equal [job_invocation]
     end
 
     it 'is able to auto complete description' do
@@ -40,7 +40,7 @@ class JobInvocationTest < ActiveSupport::TestCase
       job_invocation.save!
       host.destroy
       job_invocation.reload
-      job_invocation.template_invocations.must_be_empty
+      _(job_invocation.template_invocations).must_be_empty
     end
   end
 
@@ -51,11 +51,11 @@ class JobInvocationTest < ActiveSupport::TestCase
       input = job_invocation.pattern_template_invocations.first.template.template_inputs.create!(:name => 'foo', :required => true, :input_type => 'user')
       input2 = job_invocation.pattern_template_invocations.first.template.template_inputs.create!(:name => 'bar', :required => true, :input_type => 'user')
       FactoryBot.create(:template_invocation_input_value,
-                        :template_invocation => job_invocation.pattern_template_invocations.first,
-                        :template_input => input2)
+        :template_invocation => job_invocation.pattern_template_invocations.first,
+        :template_input => input2)
       @input_value = FactoryBot.create(:template_invocation_input_value,
-                                       :template_invocation => job_invocation.pattern_template_invocations.first,
-                                       :template_input => input)
+        :template_invocation => job_invocation.pattern_template_invocations.first,
+        :template_input => input)
       job_invocation.reload
       job_invocation.pattern_template_invocations.first.reload
     end
@@ -85,13 +85,13 @@ class JobInvocationTest < ActiveSupport::TestCase
       it 'generates description from input values' do
         job_invocation.description_format = '%{job_category} - %{foo}'
         job_invocation.generate_description
-        job_invocation.description.must_equal "#{job_invocation.job_category} - #{@input_value.value}"
+        _(job_invocation.description).must_equal "#{job_invocation.job_category} - #{@input_value.value}"
       end
 
       it 'handles missing keys correctly' do
         job_invocation.description_format = '%{job_category} - %{missing_key}'
         job_invocation.generate_description
-        job_invocation.description.must_equal "#{job_invocation.job_category} - %{missing_key}"
+        _(job_invocation.description).must_equal "#{job_invocation.job_category} - ''"
       end
 
       it 'truncates generated description to 255 characters' do
@@ -101,22 +101,22 @@ class JobInvocationTest < ActiveSupport::TestCase
         job_invocation.description_format = '%{job_category}'
         job_invocation.job_category = 'a' * 1000
         job_invocation.generate_description
-        job_invocation.description.must_equal expected_result
+        _(job_invocation.description).must_equal expected_result
       end
     end
   end
 
   context 'future execution' do
     it 'can report host count' do
-      job_invocation.total_hosts_count.must_equal 'N/A'
+      _(job_invocation.total_hosts_count).must_equal 'N/A'
       job_invocation.targeting.expects(:resolved_at).returns(Time.now.getlocal)
-      job_invocation.total_hosts_count.must_equal 0
+      _(job_invocation.total_hosts_count).must_equal 0
     end
 
     # task does not exist
-    specify { job_invocation.status.must_equal HostStatus::ExecutionStatus::QUEUED }
-    specify { job_invocation.status_label.must_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::QUEUED] }
-    specify { job_invocation.progress.must_equal 0 }
+    specify { _(job_invocation.status).must_equal HostStatus::ExecutionStatus::QUEUED }
+    specify { _(job_invocation.status_label).must_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::QUEUED] }
+    specify { _(job_invocation.progress).must_equal 0 }
   end
 
   context 'with task' do
@@ -130,7 +130,7 @@ class JobInvocationTest < ActiveSupport::TestCase
         :cancelled => 0,
         :failed    => 0,
         :pending   => 0,
-        :progress  => 0
+        :progress  => 0,
       }
     end
     before { job_invocation.task = task }
@@ -138,10 +138,10 @@ class JobInvocationTest < ActiveSupport::TestCase
     context 'which is scheduled' do
       before { task.state = 'scheduled' }
 
-      specify { job_invocation.status.must_equal HostStatus::ExecutionStatus::QUEUED }
-      specify { job_invocation.queued?.must_equal true }
-      specify { job_invocation.progress.must_equal 0 }
-      specify { job_invocation.progress_report.must_equal progress_report_without_sub_tasks }
+      specify { _(job_invocation.status).must_equal HostStatus::ExecutionStatus::QUEUED }
+      specify { _(job_invocation.queued?).must_equal true }
+      specify { _(job_invocation.progress).must_equal 0 }
+      specify { _(job_invocation.progress_report).must_equal progress_report_without_sub_tasks }
     end
 
     context 'with cancelled task' do
@@ -153,7 +153,7 @@ class JobInvocationTest < ActiveSupport::TestCase
       it 'calculates the progress correctly' do
         job_invocation.targeting.stubs(:resolved?).returns(true)
         task.expects(:sub_tasks_counts).never
-        job_invocation.progress_report.must_equal progress_report_without_sub_tasks
+        _(job_invocation.progress_report).must_equal progress_report_without_sub_tasks
       end
     end
 
@@ -163,8 +163,8 @@ class JobInvocationTest < ActiveSupport::TestCase
         task.result = 'success'
       end
 
-      specify { job_invocation.status.must_equal HostStatus::ExecutionStatus::OK }
-      specify { job_invocation.queued?.must_equal false }
+      specify { _(job_invocation.status).must_equal HostStatus::ExecutionStatus::OK }
+      specify { _(job_invocation.queued?).must_equal false }
 
       it 'calculates the progress correctly' do
         sub_tasks = [ForemanTasks::Task.new]
@@ -173,7 +173,7 @@ class JobInvocationTest < ActiveSupport::TestCase
         sub_tasks.expects(:where).with(:result => %w(success warning error)).returns(sub_tasks)
         job_invocation.stubs(:sub_tasks).returns(sub_tasks)
 
-        job_invocation.progress.must_equal 100
+        _(job_invocation.progress).must_equal 100
       end
     end
   end
@@ -203,29 +203,29 @@ class JobInvocationTest < ActiveSupport::TestCase
 
     it 'returns only failed hosts when not #finished?' do
       invocation.stubs(:finished?).returns(false)
-      invocation.failed_hosts.count.must_equal 1
+      _(invocation.failed_hosts.count).must_equal 1
     end
 
     it 'returns failed hosts and hosts without task when #finished?' do
       invocation.stubs(:finished?).returns(true)
-      invocation.failed_hosts.count.must_equal 2
+      _(invocation.failed_hosts.count).must_equal 2
     end
 
     describe '#failed_template_invocations' do
       it 'finds only failed template invocations' do
         template_invocations = invocation.send(:failed_template_invocations)
-        template_invocations.count.must_equal 1
+        _(template_invocations.count).must_equal 1
         template_invocation = template_invocations.first
-        template_invocation.run_host_job_task.result.must_equal 'error'
+        _(template_invocation.run_host_job_task.result).must_equal 'error'
       end
     end
 
     describe '#not_failed_template_invocations' do
       it 'finds only non-failed template invocations' do
         template_invocations = invocation.send(:not_failed_template_invocations)
-        template_invocations.count.must_equal 1
+        _(template_invocations.count).must_equal 1
         template_invocation = template_invocations.first
-        template_invocation.run_host_job_task.result.must_equal 'success'
+        _(template_invocation.run_host_job_task.result).must_equal 'success'
       end
     end
   end

data/test/unit/job_template_effective_user_test.rb

@@ -23,19 +23,19 @@ class JobTemplateEffectiveUserTest < ActiveSupport::TestCase
       user = FactoryBot.create(:user)
       User.current = user
       effective_user.current_user = true
-      effective_user.compute_value.must_equal user.login
+      _(effective_user.compute_value).must_equal user.login
     end
 
     it 'returns the value when not current user is set to true' do
       effective_user.current_user = false
       effective_user.value = 'testuser'
-      effective_user.compute_value.must_equal 'testuser'
+      _(effective_user.compute_value).must_equal 'testuser'
     end
 
     it 'returns a default value when no value is specified for the user' do
       effective_user.value = ''
       Setting[:remote_execution_effective_user] = 'myuser'
-      effective_user.compute_value.must_equal 'myuser'
+      _(effective_user.compute_value).must_equal 'myuser'
     end
   end
 end

data/test/unit/job_template_test.rb

@@ -30,7 +30,7 @@ class JobTemplateTest < ActiveSupport::TestCase
       job_template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => template_with_inputs)
       job_template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => template_with_inputs)
       assert_not job_template.valid?
-      job_template.errors.full_messages.first.must_include 'Duplicated inputs detected: ["command"]'
+      _(job_template.errors.full_messages.first).must_include 'Duplicated inputs detected: ["command"]'
     end
   end
 
@@ -40,21 +40,21 @@ class JobTemplateTest < ActiveSupport::TestCase
     let(:minimal_template) { FactoryBot.build(:job_template) }
 
     it 'uses the description_format attribute if set' do
-      template_with_description.generate_description_format.must_equal template_with_description.description_format
+      _(template_with_description.generate_description_format).must_equal template_with_description.description_format
     end
 
     it 'uses the job name as description_format if not set or blank and has no inputs' do
-      minimal_template.generate_description_format.must_equal '%{template_name}'
+      _(minimal_template.generate_description_format).must_equal '%{template_name}'
       minimal_template.description_format = ''
-      minimal_template.generate_description_format.must_equal '%{template_name}'
+      _(minimal_template.generate_description_format).must_equal '%{template_name}'
     end
 
     it 'generates the description_format if not set or blank and has inputs' do
       input_name = template.template_inputs.first.name
       expected_result = %(%{template_name} with inputs #{input_name}="%{#{input_name}}")
-      template.generate_description_format.must_equal expected_result
+      _(template.generate_description_format).must_equal expected_result
       template.description_format = ''
-      template.generate_description_format.must_equal expected_result
+      _(template.generate_description_format).must_equal expected_result
     end
   end
 
@@ -64,10 +64,10 @@ class JobTemplateTest < ActiveSupport::TestCase
     describe '#dup' do
       it 'duplicates also template inputs' do
         duplicate = job_template.dup
-        duplicate.wont_equal job_template
-        duplicate.template_inputs.wont_be_empty
-        duplicate.template_inputs.first.wont_equal job_template.template_inputs.first
-        duplicate.template_inputs.first.name.must_equal job_template.template_inputs.first.name
+        _(duplicate).wont_equal job_template
+        _(duplicate.template_inputs).wont_be_empty
+        _(duplicate.template_inputs.first).wont_equal job_template.template_inputs.first
+        _(duplicate.template_inputs.first.name).must_equal job_template.template_inputs.first.name
       end
     end
   end
@@ -118,30 +118,30 @@ class JobTemplateTest < ActiveSupport::TestCase
     end
 
     it 'sets the name' do
-      template.name.must_equal 'Service Restart'
+      _(template.name).must_equal 'Service Restart'
     end
 
     it 'has a template' do
-      template.template.squish.must_equal 'service <%= input("service_name") %> restart'
+      _(template.template.squish).must_equal 'service <%= input("service_name") %> restart'
     end
 
     it 'imports inputs' do
-      template.template_inputs.first.name.must_equal 'service_name'
+      _(template.template_inputs.first.name).must_equal 'service_name'
     end
 
     it 'imports input sets' do
-      template_with_input_sets.foreign_input_sets.first.target_template.must_equal template
-      template_with_input_sets.template_inputs_with_foreign.map(&:name).must_equal ['service_name']
+      _(template_with_input_sets.foreign_input_sets.first.target_template).must_equal template
+      _(template_with_input_sets.template_inputs_with_foreign.map(&:name)).must_equal ['service_name']
     end
 
     it 'imports feature' do
       template # let is lazy
       remote_execution_feature.reload
-      remote_execution_feature.job_template.must_equal template
+      _(remote_execution_feature.job_template).must_equal template
     end
 
     it 'sets additional options' do
-      template.default.must_equal true
+      _(template.default).must_equal true
     end
   end
 
@@ -224,16 +224,16 @@ class JobTemplateTest < ActiveSupport::TestCase
 
     it 'syncs inputs' do
       hostname = synced_template.template_inputs.find { |input| input.name == 'hostname' }
-      hostname.options.must_equal 'www.redhat.com'
+      _(hostname.options).must_equal 'www.redhat.com'
     end
 
     it 'syncs content' do
-      synced_template.template.must_match(/ping -c <%= input\('count'\) %> <%= input\('hostname'\) %>/m)
+      _(synced_template.template).must_match(/ping -c <%= input\('count'\) %> <%= input\('hostname'\) %>/m)
     end
 
     it 'syncs input sets' do
-      synced_template.foreign_input_sets.first.target_template.must_equal included
-      synced_template.template_inputs_with_foreign.map(&:name).must_equal ['hostname', 'count']
+      _(synced_template.foreign_input_sets.first.target_template).must_equal included
+      _(synced_template.template_inputs_with_foreign.map(&:name)).must_equal ['hostname', 'count']
     end
   end
 
@@ -247,25 +247,25 @@ class JobTemplateTest < ActiveSupport::TestCase
     end
 
     it 'exports name' do
-      erb.must_match(/^name: #{exportable_template.name}$/)
+      _(erb).must_match(/^name: #{exportable_template.name}$/)
     end
 
     it 'includes template inputs' do
-      erb.must_match(/^template_inputs:$/)
+      _(erb).must_match(/^template_inputs:$/)
     end
 
     it 'includes template contents' do
-      erb.must_include exportable_template.template
+      _(erb).must_include exportable_template.template
     end
 
     it 'is importable' do
       erb
       old_name = exportable_template.name
-      exportable_template.update_attributes(:name => "#{old_name}_renamed")
+      exportable_template.update(:name => "#{old_name}_renamed")
 
       imported = JobTemplate.import_raw!(erb)
-      imported.name.must_equal old_name
-      imported.template_inputs.first.to_export.must_equal exportable_template.template_inputs.first.to_export
+      _(imported.name).must_equal old_name
+      _(imported.template_inputs.first.to_export).must_equal exportable_template.template_inputs.first.to_export
     end
 
     it 'has taxonomies in metadata' do
@@ -280,7 +280,7 @@ class JobTemplateTest < ActiveSupport::TestCase
 
     describe 'job template deletion' do
       it 'succeeds' do
-        job_template.pattern_template_invocations.wont_be_empty
+        _(job_template.pattern_template_invocations).wont_be_empty
         assert job_template.destroy
       end
     end
@@ -305,10 +305,10 @@ class JobTemplateTest < ActiveSupport::TestCase
 
       setup_user('view', 'job_templates')
       renderer = InputTemplateRenderer.new template_invocation.template,
-                                           template_invocation.host,
-                                           template_invocation
+        template_invocation.host,
+        template_invocation
       result = renderer.render
-      result.must_equal "<wrap>#{inner.template}</wrap>"
+      _(result).must_equal "<wrap>#{inner.template}</wrap>"
     end
   end
 end

data/test/unit/remote_execution_feature_test.rb

@@ -8,8 +8,8 @@ class RemoteExecutionFeatureTest < ActiveSupport::TestCase
 
   let(:install_feature) do
     RemoteExecutionFeature.register(:katello_install_package, N_('Katello: Install package'),
-                                    :description => 'Install package via Katello user interface',
-                                    :provided_inputs => ['package'])
+      :description => 'Install package via Katello user interface',
+      :provided_inputs => ['package'])
   end
 
   let(:package_template) do
@@ -24,48 +24,48 @@ class RemoteExecutionFeatureTest < ActiveSupport::TestCase
 
   before do
     User.current = users :admin
-    install_feature.update_attributes!(:job_template_id => package_template.id)
+    install_feature.update!(:job_template_id => package_template.id)
   end
 
   describe 'composer' do
     it 'prepares composer for given feature based on the mapping' do
       composer = JobInvocationComposer.for_feature(:katello_install_package, host, :package => 'zsh')
       assert composer.valid?
-      composer.pattern_template_invocations.size.must_equal 1
+      _(composer.pattern_template_invocations.size).must_equal 1
       template_invocation = composer.pattern_template_invocations.first
-      template_invocation.template.must_equal package_template
-      template_invocation.input_values.size.must_equal 1
+      _(template_invocation.template).must_equal package_template
+      _(template_invocation.input_values.size).must_equal 1
 
       input_value = template_invocation.input_values.first
-      input_value.value.must_equal 'zsh'
-      input_value.template_input.name.must_equal 'package'
+      _(input_value.value).must_equal 'zsh'
+      _(input_value.template_input.name).must_equal 'package'
 
-      composer.targeting.search_query.must_equal "name ^ (#{host.name})"
+      _(composer.targeting.search_query).must_equal "name ^ (#{host.name})"
     end
 
     it 'updates the feature when attributes change' do
       updated_feature = RemoteExecutionFeature.register(install_feature.label, N_('Katello: Install package'),
-                                                        :description => 'New description',
-                                                        :provided_inputs => ['package', 'force'])
+        :description => 'New description',
+        :provided_inputs => ['package', 'force'])
       updated_feature.reload
-      updated_feature.id.must_equal(install_feature.id)
-      updated_feature.description.must_equal 'New description'
-      updated_feature.provided_input_names.must_equal ['package', 'force']
+      _(updated_feature.id).must_equal(install_feature.id)
+      _(updated_feature.description).must_equal 'New description'
+      _(updated_feature.provided_input_names).must_equal ['package', 'force']
     end
   end
 
   describe '.register' do
     it "creates a feature if it's missing" do
       feature = RemoteExecutionFeature.register('new_feature_that_does_not_exist', 'name')
-      feature.must_be :persisted?
-      feature.label.must_equal 'new_feature_that_does_not_exist'
-      feature.name.must_equal 'name'
+      _(feature).must_be :persisted?
+      _(feature.label).must_equal 'new_feature_that_does_not_exist'
+      _(feature.name).must_equal 'name'
       assert_not feature.host_action_button
     end
 
     it 'creates a feature with host action flag' do
       feature = RemoteExecutionFeature.register('new_feature_that_does_not_exist_button', 'name', :host_action_button => true)
-      feature.must_be :persisted?
+      _(feature).must_be :persisted?
       assert feature.host_action_button
     end
 
@@ -78,7 +78,7 @@ class RemoteExecutionFeatureTest < ActiveSupport::TestCase
     it 'updates a feature if it exists' do
       existing = FactoryBot.create(:remote_execution_feature, :name => 'existing_feature_withou_action_button')
       feature = RemoteExecutionFeature.register(existing.label, existing.name, :host_action_button => true)
-      feature.must_be :persisted?
+      _(feature).must_be :persisted?
       existing.reload
       assert existing.host_action_button
     end

data/test/unit/remote_execution_provider_test.rb

@@ -3,23 +3,23 @@ require 'test_plugin_helper'
 class RemoteExecutionProviderTest < ActiveSupport::TestCase
   describe '.providers' do
     let(:providers) { RemoteExecutionProvider.providers }
-    it { providers.must_be_kind_of HashWithIndifferentAccess }
+    it { _(providers).must_be_kind_of HashWithIndifferentAccess }
     it 'makes providers accessible using symbol' do
-      providers[:SSH].must_equal SSHExecutionProvider
+      _(providers[:SSH]).must_equal SSHExecutionProvider
     end
     it 'makes providers accessible using string' do
-      providers['SSH'].must_equal SSHExecutionProvider
+      _(providers['SSH']).must_equal SSHExecutionProvider
     end
   end
 
   describe '.register_provider' do
     before { RemoteExecutionProvider.providers.delete(:new) }
     let(:new_provider) { RemoteExecutionProvider.providers[:new] }
-    it { new_provider.must_be_nil }
+    it { _(new_provider).must_be_nil }
 
     context 'registers a provider under key :new' do
       before { RemoteExecutionProvider.register(:new, String) }
-      it { new_provider.must_equal String }
+      it { _(new_provider).must_equal String }
     end
   end
 
@@ -38,15 +38,15 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
 
     it 'returns only strings' do
       provider_names.each do |name|
-        name.must_be_kind_of String
+        _(name).must_be_kind_of String
       end
     end
 
     context 'provider is registetered under :custom symbol' do
       before { RemoteExecutionProvider.register(:Custom, String) }
 
-      it { provider_names.must_include 'SSH' }
-      it { provider_names.must_include 'Custom' }
+      it { _(provider_names).must_include 'SSH' }
+      it { _(provider_names).must_include 'Custom' }
     end
   end
 
@@ -67,14 +67,14 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
     describe 'effective user' do
       it 'takes the effective user from value from the template invocation' do
         template_invocation.effective_user = 'my user'
-        proxy_options[:effective_user].must_equal 'my user'
+        _(proxy_options[:effective_user]).must_equal 'my user'
       end
     end
 
     describe 'ssh user' do
       it 'uses the remote_execution_ssh_user on the host param' do
         host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_ssh_user', :value => 'my user')
-        proxy_options[:ssh_user].must_equal 'my user'
+        _(proxy_options[:ssh_user]).must_equal 'my user'
       end
     end
 
@@ -83,7 +83,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.params['remote_execution_sudo_password'] = 'mypassword'
         host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_sudo_password', :value => 'mypassword')
         assert_not proxy_options.key?(:sudo_password)
-        secrets[:sudo_password].must_equal 'mypassword'
+        _(secrets[:sudo_password]).must_equal 'mypassword'
       end
     end
 
@@ -92,15 +92,15 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.params['remote_execution_effective_user_method'] = 'sudo'
         method_param = FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_effective_user_method', :value => 'sudo')
         host.host_parameters << method_param
-        proxy_options[:effective_user_method].must_equal 'sudo'
-        method_param.update_attributes!(:value => 'su')
+        _(proxy_options[:effective_user_method]).must_equal 'sudo'
+        method_param.update!(:value => 'su')
         host.clear_host_parameters_cache!
         proxy_options = SSHExecutionProvider.proxy_command_options(template_invocation, host)
-        proxy_options[:effective_user_method].must_equal 'su'
-        method_param.update_attributes!(:value => 'dzdo')
+        _(proxy_options[:effective_user_method]).must_equal 'su'
+        method_param.update!(:value => 'dzdo')
         host.clear_host_parameters_cache!
         proxy_options = SSHExecutionProvider.proxy_command_options(template_invocation, host)
-        proxy_options[:effective_user_method].must_equal 'dzdo'
+        _(proxy_options[:effective_user_method]).must_equal 'dzdo'
       end
     end
 
@@ -110,8 +110,8 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
       end
 
       it 'has ssh port changed in settings and check return type' do
-        proxy_options[:ssh_port].must_be_kind_of Integer
-        proxy_options[:ssh_port].must_equal 66
+        _(proxy_options[:ssh_port]).must_be_kind_of Integer
+        _(proxy_options[:ssh_port]).must_equal 66
       end
     end
 
@@ -120,8 +120,8 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.params['remote_execution_ssh_port'] = '30'
         host.host_parameters << FactoryBot.build(:host_parameter, :name => 'remote_execution_ssh_port', :value => '30')
         host.clear_host_parameters_cache!
-        proxy_options[:ssh_port].must_be_kind_of Integer
-        proxy_options[:ssh_port].must_equal 30
+        _(proxy_options[:ssh_port]).must_be_kind_of Integer
+        _(proxy_options[:ssh_port]).must_equal 30
       end
     end
 
@@ -131,7 +131,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
       end
 
       it 'updates the value via settings' do
-        proxy_options[:cleanup_working_dirs].must_equal false
+        _(proxy_options[:cleanup_working_dirs]).must_equal false
       end
     end
 
@@ -140,7 +140,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.params['remote_execution_cleanup_working_dirs'] = 'false'
         host.host_parameters << FactoryBot.build(:host_parameter, :name => 'remote_execution_cleanup_working_dirs', :value => 'false')
         host.clear_host_parameters_cache!
-        proxy_options[:cleanup_working_dirs].must_equal false
+        _(proxy_options[:cleanup_working_dirs]).must_equal false
       end
     end
 
@@ -162,9 +162,9 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
 
         # execution wins if present
         execution_interface = FactoryBot.build(:nic_managed,
-                                               flags.merge(:execution => true, :name => 'special.somedomain.org'))
+          flags.merge(:execution => true, :name => 'special.somedomain.org'))
         host.interfaces << execution_interface
-        host.primary_interface.update_attributes(:execution => false)
+        host.primary_interface.update(:execution => false)
         host.interfaces.each(&:save)
         host.reload
         SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.fqdn
@@ -177,23 +177,23 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
 
         # provision interface with ip while primary without
         provision_interface = FactoryBot.build(:nic_managed,
-                                               flags.merge(:provision => true, :ip => '10.0.0.1'))
+          flags.merge(:provision => true, :ip => '10.0.0.1'))
         host.interfaces << provision_interface
-        host.primary_interface.update_attributes(:provision => false)
+        host.primary_interface.update(:provision => false)
         host.interfaces.each(&:save)
         host.reload
         SSHExecutionProvider.find_ip_or_hostname(host).must_equal provision_interface.ip
 
         # both primary and provision interface have IPs: the primary wins
-        host.primary_interface.update_attributes(:ip => '10.0.0.2', :execution => false)
+        host.primary_interface.update(:ip => '10.0.0.2', :execution => false)
         host.reload
         SSHExecutionProvider.find_ip_or_hostname(host).must_equal host.primary_interface.ip
 
         # there is an execution interface with IP: it wins
         execution_interface = FactoryBot.build(:nic_managed,
-                                               flags.merge(:execution => true, :ip => '10.0.0.3'))
+          flags.merge(:execution => true, :ip => '10.0.0.3'))
         host.interfaces << execution_interface
-        host.primary_interface.update_attributes(:execution => false)
+        host.primary_interface.update(:execution => false)
         host.interfaces.each(&:save)
         host.reload
         SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip