foreman_remote_execution 12.0.5 → 13.1.0

data/test/unit/job_invocation_test.rb

@@ -11,12 +11,12 @@ 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).order('job_invocations.id DESC')
-      _(found_jobs).must_equal [job_invocation]
+      assert_equal [job_invocation], found_jobs
     end
 
     it 'is able to auto complete description' do
       expected = 'description =  "A text with \"quotes\""'
-      JobInvocation.complete_for('description = ').must_equal [expected]
+      assert_equal [expected], JobInvocation.complete_for('description = ')
     end
   end
 
@@ -40,7 +40,7 @@ class JobInvocationTest < ActiveSupport::TestCase
       job_invocation.save!
       host.destroy
       job_invocation.reload
-      _(job_invocation.template_invocations).must_be_empty
+      assert_empty job_invocation.template_invocations
     end
   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}"
+        assert_equal "#{job_invocation.job_category} - #{@input_value.value}", job_invocation.description
       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} - ''"
+        assert_equal "#{job_invocation.job_category} - ''", job_invocation.description
       end
 
       it 'truncates generated description to 255 characters' do
@@ -100,22 +100,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
+        assert_equal expected_result, job_invocation.description
       end
     end
   end
 
   context 'future execution' do
     it 'can report host count' do
-      _(job_invocation.total_hosts_count).must_equal 'N/A'
+      assert_equal 'N/A', job_invocation.total_hosts_count
       job_invocation.targeting.expects(:resolved_at).returns(Time.now.getlocal)
-      _(job_invocation.total_hosts_count).must_equal 0
+      assert_equal 0, job_invocation.total_hosts_count
     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 { assert_equal HostStatus::ExecutionStatus::QUEUED, job_invocation.status }
+    specify { assert_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::QUEUED], job_invocation.status_label }
+    specify { assert_equal 0, job_invocation.progress }
   end
 
   context 'with task' do
@@ -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 { assert_equal HostStatus::ExecutionStatus::QUEUED, job_invocation.status }
+      specify { assert job_invocation.queued? }
+      specify { assert_equal 0, job_invocation.progress }
+      specify { assert_equal progress_report_without_sub_tasks, job_invocation.progress_report }
     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
+        assert_equal progress_report_without_sub_tasks, job_invocation.progress_report
       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 { assert_equal HostStatus::ExecutionStatus::OK, job_invocation.status }
+      specify { refute job_invocation.queued? }
 
       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
+        assert_equal 100, job_invocation.progress
       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
+      assert_equal 1, invocation.failed_hosts.count
     end
 
     it 'returns failed hosts and hosts without task when #finished?' do
       invocation.stubs(:finished?).returns(true)
-      _(invocation.failed_hosts.count).must_equal 2
+      assert_equal 2, invocation.failed_hosts.count
     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
+        assert_equal 1, template_invocations.count
         template_invocation = template_invocations.first
-        _(template_invocation.run_host_job_task.result).must_equal 'error'
+        assert_equal 'error', template_invocation.run_host_job_task.result
       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
+        assert_equal 1, template_invocations.count
         template_invocation = template_invocations.first
-        _(template_invocation.run_host_job_task.result).must_equal 'success'
+        assert_equal 'success', template_invocation.run_host_job_task.result
       end
     end
   end

data/test/unit/job_template_effective_user_test.rb

@@ -19,19 +19,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
+      assert_equal user.login, effective_user.compute_value
     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'
+      assert_equal 'testuser', effective_user.compute_value
     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'
+      assert_equal 'myuser', effective_user.compute_value
     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"]'
+      assert_includes job_template.errors.full_messages.first, '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
+      assert_equal template_with_description.generate_description_format, 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}'
+      assert_equal minimal_template.generate_description_format, '%{template_name}'
       minimal_template.description_format = ''
-      _(minimal_template.generate_description_format).must_equal '%{template_name}'
+      assert_equal minimal_template.generate_description_format, '%{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
+      assert_equal template.generate_description_format, expected_result
       template.description_format = ''
-      _(template.generate_description_format).must_equal expected_result
+      assert_equal template.generate_description_format, 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
+        refute_equal duplicate, job_template
+        refute_empty duplicate.template_inputs
+        refute_equal duplicate.template_inputs.first, job_template.template_inputs.first
+        assert_equal duplicate.template_inputs.first.name, job_template.template_inputs.first.name
       end
     end
   end
@@ -120,30 +120,30 @@ class JobTemplateTest < ActiveSupport::TestCase
     end
 
     it 'sets the name' do
-      _(template.name).must_equal 'Service Restart'
+      assert_equal template.name, 'Service Restart'
     end
 
     it 'has a template' do
-      _(template.template.squish).must_equal 'service <%= input("service_name") %> restart <%# test comment %>'
+      assert_equal template.template.squish, 'service <%= input("service_name") %> restart <%# test comment %>'
     end
 
     it 'imports inputs' do
-      _(template.template_inputs.first.name).must_equal 'service_name'
+      assert_equal template.template_inputs.first.name, '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']
+      assert_equal template_with_input_sets.foreign_input_sets.first.target_template, template
+      assert_equal template_with_input_sets.template_inputs_with_foreign.map(&:name), ['service_name']
     end
 
     it 'imports feature' do
       template # let is lazy
       remote_execution_feature.reload
-      _(remote_execution_feature.job_template).must_equal template
+      assert_equal remote_execution_feature.job_template, template
     end
 
     it 'sets additional options' do
-      _(template.default).must_equal true
+      assert_equal template.default, true
     end
   end
 
@@ -226,16 +226,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'
+      assert_equal hostname.options, 'www.redhat.com'
     end
 
     it 'syncs content' do
-      _(synced_template.template).must_match(/ping -c <%= input\('count'\) %> <%= input\('hostname'\) %>/m)
+      assert_match(/ping -c <%= input\('count'\) %> <%= input\('hostname'\) %>/m, synced_template.template)
     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']
+      assert_equal synced_template.foreign_input_sets.first.target_template, included
+      assert_equal synced_template.template_inputs_with_foreign.map(&:name), ['hostname', 'count']
     end
   end
 
@@ -249,15 +249,15 @@ class JobTemplateTest < ActiveSupport::TestCase
     end
 
     it 'exports name' do
-      _(erb).must_match(/^name: #{exportable_template.name}$/)
+      assert_match(/^name: #{exportable_template.name}$/, erb)
     end
 
     it 'includes template inputs' do
-      _(erb).must_match(/^template_inputs:$/)
+      assert_match(/^template_inputs:$/, erb)
     end
 
     it 'includes template contents' do
-      _(erb).must_include exportable_template.template
+      assert_includes erb, exportable_template.template
     end
 
     it 'is importable' do
@@ -266,8 +266,8 @@ class JobTemplateTest < ActiveSupport::TestCase
       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
+      assert_equal imported.name, old_name
+      assert_equal imported.template_inputs.first.to_export, exportable_template.template_inputs.first.to_export
     end
 
     it 'has taxonomies in metadata' do
@@ -282,7 +282,7 @@ class JobTemplateTest < ActiveSupport::TestCase
 
     describe 'job template deletion' do
       it 'succeeds' do
-        _(job_template.pattern_template_invocations).wont_be_empty
+        refute_empty job_template.pattern_template_invocations
         assert job_template.destroy
       end
     end
@@ -310,7 +310,7 @@ class JobTemplateTest < ActiveSupport::TestCase
         template_invocation.host,
         template_invocation
       result = renderer.render
-      _(result).must_equal "<wrap>#{inner.template}</wrap>"
+      assert_equal result, "<wrap>#{inner.template}</wrap>"
     end
   end
 end

data/test/unit/remote_execution_feature_test.rb

@@ -31,16 +31,16 @@ class RemoteExecutionFeatureTest < ActiveSupport::TestCase
     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
+      assert_equal 1, composer.pattern_template_invocations.size
       template_invocation = composer.pattern_template_invocations.first
-      _(template_invocation.template).must_equal package_template
-      _(template_invocation.input_values.size).must_equal 1
+      assert_equal package_template, template_invocation.template
+      assert_equal 1, template_invocation.input_values.size
 
       input_value = template_invocation.input_values.first
-      _(input_value.value).must_equal 'zsh'
-      _(input_value.template_input.name).must_equal 'package'
+      assert_equal 'zsh', input_value.value
+      assert_equal 'package', input_value.template_input.name
 
-      _(composer.targeting.search_query).must_equal "name ^ (#{host.name})"
+      assert_equal "name ^ (#{host.name})", composer.targeting.search_query
     end
 
     it 'updates the feature when attributes change' do
@@ -48,24 +48,24 @@ class RemoteExecutionFeatureTest < ActiveSupport::TestCase
         :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']
+      assert_equal install_feature.id, updated_feature.id
+      assert_equal 'New description', updated_feature.description
+      assert_equal ['package', 'force'], updated_feature.provided_input_names
     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'
+      assert_predicate feature, :persisted?
+      assert_equal 'new_feature_that_does_not_exist', feature.label
+      assert_equal 'name', feature.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?
+      assert_predicate feature, :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?
+      assert_predicate feature, :persisted?
       existing.reload
       assert existing.host_action_button
     end

data/test/unit/remote_execution_provider_test.rb

@@ -3,39 +3,39 @@ require 'test_plugin_helper'
 class RemoteExecutionProviderTest < ActiveSupport::TestCase
   describe '.providers' do
     let(:providers) { RemoteExecutionProvider.providers }
-    it { _(providers).must_be_kind_of HashWithIndifferentAccess }
+    it { assert_kind_of HashWithIndifferentAccess, providers }
     it 'makes providers accessible using symbol' do
-      _(providers[:SSH]).must_equal SSHExecutionProvider
-      _(providers[:script]).must_equal ScriptExecutionProvider
+      assert_equal SSHExecutionProvider, providers[:SSH]
+      assert_equal ScriptExecutionProvider, providers[:script]
     end
     it 'makes providers accessible using string' do
-      _(providers['SSH']).must_equal SSHExecutionProvider
-      _(providers['script']).must_equal ScriptExecutionProvider
+      assert_equal SSHExecutionProvider, providers['SSH']
+      assert_equal ScriptExecutionProvider, providers['script']
     end
   end
 
   describe '.register_provider' do
     before { RemoteExecutionProvider.providers.delete(:new) }
     let(:new_provider) { RemoteExecutionProvider.providers[:new] }
-    it { _(new_provider).must_be_nil }
+    it { assert_nil new_provider }
 
     context 'registers a provider under key :new' do
       before { RemoteExecutionProvider.register(:new, String) }
-      it { _(new_provider).must_equal String }
+      it { assert_equal String, new_provider }
     end
   end
 
   describe '.provider_for' do
     it 'accepts symbols' do
-      RemoteExecutionProvider.provider_for(:SSH).must_equal SSHExecutionProvider
+      assert_equal SSHExecutionProvider, RemoteExecutionProvider.provider_for(:SSH)
     end
 
     it 'accepts strings' do
-      RemoteExecutionProvider.provider_for('SSH').must_equal SSHExecutionProvider
+      assert_equal SSHExecutionProvider, RemoteExecutionProvider.provider_for('SSH')
     end
 
     it 'returns a default one if unknown value is provided' do
-      RemoteExecutionProvider.provider_for('WinRM').must_equal ScriptExecutionProvider
+      assert_equal ScriptExecutionProvider, RemoteExecutionProvider.provider_for('WinRM')
     end
   end
 
@@ -44,15 +44,15 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
 
     it 'returns only strings' do
       provider_names.each do |name|
-        _(name).must_be_kind_of String
+        assert_kind_of String, name
       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 { assert_includes provider_names, 'SSH' }
+      it { assert_includes provider_names, 'Custom' }
     end
   end
 
@@ -71,7 +71,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
       ::RemoteExecutionProvider.register('custom', CustomProvider)
 
       feature = CustomProvider.proxy_feature
-      _(feature).must_equal 'custom'
+      assert_equal 'custom', feature
     ensure
       ::RemoteExecutionProvider = old
     end
@@ -86,8 +86,8 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
       )
 
       features = RemoteExecutionProvider.provider_proxy_features
-      _(features).must_include 'SSH'
-      _(features).must_include 'Script'
+      assert_includes features, 'SSH'
+      assert_includes features, 'Script'
       RemoteExecutionProvider.unstub(:providers)
     end
 
@@ -95,7 +95,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
       provider = OpenStruct.new(proxy_feature: 'Testing')
       RemoteExecutionProvider.stubs(:providers).returns(:testing => provider)
       features = RemoteExecutionProvider.provider_proxy_features
-      _(features).must_include 'Testing'
+      assert_includes features, 'Testing'
       RemoteExecutionProvider.unstub(:providers)
     end
   end
@@ -125,14 +125,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'
+        assert_equal 'my user', proxy_options[:effective_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'
+        assert_equal 'my user', proxy_options[:ssh_user]
       end
     end
 
@@ -140,8 +140,8 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
       it 'uses the remote_execution_effective_user_password on the host param' do
         host.params['remote_execution_effective_user_password'] = 'mypassword'
         host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_effective_user_password', :value => 'mypassword')
-        assert_not proxy_options.key?(:effective_user_password)
-        _(secrets[:effective_user_password]).must_equal 'mypassword'
+        assert_nil proxy_options[:effective_user_password]
+        assert_equal 'mypassword', secrets[:effective_user_password]
       end
     end
 
@@ -150,15 +150,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'
+        assert_equal 'sudo', proxy_options[:effective_user_method]
         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'
+        assert_equal 'su', proxy_options[:effective_user_method]
         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'
+        assert_equal 'dzdo', proxy_options[:effective_user_method]
       end
     end
 
@@ -168,8 +168,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
+        assert_kind_of Integer, proxy_options[:ssh_port]
+        assert_equal 66, proxy_options[:ssh_port]
       end
     end
 
@@ -178,8 +178,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
+        assert_kind_of Integer, proxy_options[:ssh_port]
+        assert_equal 30, proxy_options[:ssh_port]
       end
     end
 
@@ -189,7 +189,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
       end
 
       it 'updates the value via settings' do
-        _(proxy_options[:cleanup_working_dirs]).must_equal false
+        refute proxy_options[:cleanup_working_dirs]
       end
     end
 
@@ -198,7 +198,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
+        refute proxy_options[:cleanup_working_dirs]
       end
     end
 
@@ -219,7 +219,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
 
       it 'gets fqdn from flagged interfaces if not preferring ips' do
         # falling to primary interface
-        SSHExecutionProvider.find_ip_or_hostname(host).must_equal 'somehost.somedomain.org'
+        assert_equal 'somehost.somedomain.org', SSHExecutionProvider.find_ip_or_hostname(host)
 
         # execution wins if present
         execution_interface = FactoryBot.build(:nic_managed,
@@ -228,13 +228,13 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.primary_interface.update(:execution => false)
         host.interfaces.each(&:save)
         host.reload
-        SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.fqdn
+        assert_equal execution_interface.fqdn, SSHExecutionProvider.find_ip_or_hostname(host)
       end
 
       it 'gets ip from flagged interfaces' do
         host.host_params['remote_execution_connect_by_ip'] = true
         # no ip address set on relevant interface - fallback to fqdn
-        SSHExecutionProvider.find_ip_or_hostname(host).must_equal 'somehost.somedomain.org'
+        assert_equal 'somehost.somedomain.org', SSHExecutionProvider.find_ip_or_hostname(host)
 
         # provision interface with ip while primary without
         provision_interface = FactoryBot.build(:nic_managed,
@@ -243,12 +243,12 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.primary_interface.update(:provision => false)
         host.interfaces.each(&:save)
         host.reload
-        SSHExecutionProvider.find_ip_or_hostname(host).must_equal provision_interface.ip
+        assert_equal provision_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
 
         # both primary and provision interface have IPs: the primary wins
         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
+        assert_equal host.primary_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
 
         # there is an execution interface with IP: it wins
         execution_interface = FactoryBot.build(:nic_managed,
@@ -257,7 +257,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.primary_interface.update(:execution => false)
         host.interfaces.each(&:save)
         host.reload
-        SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip
+        assert_equal execution_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
 
         # there is an execution interface with both IPv6 and IPv4: IPv4 is being preferred over IPv6 by default
         execution_interface = FactoryBot.build(:nic_managed,
@@ -265,7 +265,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.interfaces = [execution_interface]
         host.interfaces.each(&:save)
         host.reload
-        SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip
+        assert_equal execution_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
       end
 
       it 'gets ipv6 from flagged interfaces with IPv6 preference' do
@@ -278,7 +278,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.interfaces = [execution_interface]
         host.interfaces.each(&:save)
         host.reload
-        SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip6
+        assert_equal execution_interface.ip6, SSHExecutionProvider.find_ip_or_hostname(host)
       end
 
       it 'gets ipv6 from flagged interfaces with IPv4 preference but without IPv4 address' do
@@ -291,7 +291,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.interfaces = [execution_interface]
         host.interfaces.each(&:save)
         host.reload
-        SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip6
+        assert_equal execution_interface.ip6, SSHExecutionProvider.find_ip_or_hostname(host)
       end
     end
   end