foreman_remote_execution 12.0.5 → 13.0.0

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

data/test/unit/renderer_scope_input_test.rb

@@ -13,15 +13,15 @@ class RendererScopeInputTest < ActiveSupport::TestCase
     it 'caches the value under given key' do
       i = 1
       result = input.cached('some_key') { i }
-      _(result).must_equal 1
+      assert_equal 1, result
 
       i += 1
       result = input.cached('some_key') { i }
-      _(result).must_equal 1
+      assert_equal 1, result
 
       i += 1
       result = input.cached('different_key') { i }
-      _(result).must_equal 3
+      assert_equal 3, result
     end
   end
 
@@ -35,15 +35,15 @@ class RendererScopeInputTest < ActiveSupport::TestCase
     it 'does not cache the value' do
       i = 1
       result = input.cached('some_key') { i }
-      _(result).must_equal 1
+      assert_equal 1, result
 
       i += 1
       result = input.cached('some_key') { i }
-      _(result).must_equal 2
+      assert_equal 2, result
 
       i += 1
       result = input.cached('different_key') { i }
-      _(result).must_equal 3
+      assert_equal 3, result
     end
   end
 end

data/test/unit/targeting_test.rb

@@ -51,7 +51,7 @@ class TargetingTest < ActiveSupport::TestCase
       targeting.resolve_hosts!
     end
 
-    it { _(targeting.hosts).must_include(host) }
+    it { assert_includes targeting.hosts, host }
   end
 
   context 'can delete a user' do
@@ -63,7 +63,7 @@ class TargetingTest < ActiveSupport::TestCase
 
     it { assert_nil targeting.reload.user }
     it do
-      -> { targeting.resolve_hosts! }.must_raise(Foreman::Exception)
+      assert_raises(Foreman::Exception) { targeting.resolve_hosts! }
     end
   end
 
@@ -74,7 +74,7 @@ class TargetingTest < ActiveSupport::TestCase
       host.destroy
     end
 
-    it { _(targeting.reload.hosts).must_be_empty }
+    it { assert_empty targeting.reload.hosts }
   end
 
   describe '#resolve_hosts!' do
@@ -100,9 +100,9 @@ class TargetingTest < ActiveSupport::TestCase
         targeting.user = User.current
         targeting.resolve_hosts!
 
-        targeting.hosts.must_include host
-        targeting.hosts.must_include second_host
-        targeting.hosts.must_include infra_host
+        assert_includes targeting.hosts, host
+        assert_includes targeting.hosts, second_host
+        assert_includes targeting.hosts, infra_host
       end
     end
 
@@ -115,9 +115,9 @@ class TargetingTest < ActiveSupport::TestCase
         targeting.user = User.current
         targeting.resolve_hosts!
 
-        targeting.hosts.must_include host
-        targeting.hosts.must_include second_host
-        targeting.hosts.wont_include infra_host
+        assert_includes targeting.hosts, host
+        assert_includes targeting.hosts, second_host
+        refute_includes targeting.hosts, infra_host
       end
     end
   end
@@ -136,14 +136,14 @@ class TargetingTest < ActiveSupport::TestCase
       let(:query) { Targeting.build_query_from_hosts([ host.id, second_host.id, infra_host.id ]) }
 
       it 'builds query using host names joining inside ^' do
-        _(query).must_include host.name
-        _(query).must_include second_host.name
-        _(query).must_include infra_host.name
-        _(query).must_include 'name ^'
-
-        Host.search_for(query).must_include host
-        Host.search_for(query).must_include second_host
-        Host.search_for(query).must_include infra_host
+        assert_includes query, host.name
+        assert_includes query, second_host.name
+        assert_includes query, infra_host.name
+        assert_includes query, 'name ^'
+
+        assert_includes Host.search_for(query), host
+        assert_includes Host.search_for(query), second_host
+        assert_includes Host.search_for(query), infra_host
       end
     end
 
@@ -151,10 +151,10 @@ class TargetingTest < ActiveSupport::TestCase
       let(:query) { Targeting.build_query_from_hosts([ host.id ]) }
 
       it 'builds query using host name' do
-        _(query).must_equal "name ^ (#{host.name})"
-        Host.search_for(query).must_include host
-        Host.search_for(query).wont_include second_host
-        Host.search_for(query).wont_include infra_host
+        assert_equal "name ^ (#{host.name})", query
+        assert_includes Host.search_for(query), host
+        refute_includes Host.search_for(query), second_host
+        refute_includes Host.search_for(query), infra_host
       end
     end
 
@@ -162,9 +162,9 @@ class TargetingTest < ActiveSupport::TestCase
       let(:query) { Targeting.build_query_from_hosts([]) }
 
       it 'builds query to find all hosts' do
-        Host.search_for(query).must_include host
-        Host.search_for(query).must_include second_host
-        Host.search_for(query).must_include infra_host
+        assert_includes Host.search_for(query), host
+        assert_includes Host.search_for(query), second_host
+        assert_includes Host.search_for(query), infra_host
       end
     end
 
@@ -173,14 +173,14 @@ class TargetingTest < ActiveSupport::TestCase
 
       it 'ignores the infrastructure host' do
         query = Targeting.build_query_from_hosts([host.id, second_host.id, infra_host.id])
-        _(query).must_include host.name
-        _(query).must_include second_host.name
-        _(query).wont_include infra_host.name
-        _(query).must_include 'name ^'
-
-        Host.search_for(query).must_include host
-        Host.search_for(query).must_include second_host
-        Host.search_for(query).wont_include infra_host
+        assert_includes query, host.name
+        assert_includes query, second_host.name
+        refute_includes query, infra_host.name
+        assert_includes query, 'name ^'
+
+        assert_includes Host.search_for(query), host
+        assert_includes Host.search_for(query), second_host
+        refute_includes Host.search_for(query), infra_host
       end
     end
   end

data/webpack/JobWizard/JobWizardConstants.js

@@ -5,6 +5,10 @@ export const JOB_TEMPLATES = 'JOB_TEMPLATES';
 export const JOB_CATEGORIES = 'JOB_CATEGORIES';
 export const JOB_TEMPLATE = 'JOB_TEMPLATE';
 export const JOB_INVOCATION = 'JOB_INVOCATION';
+export const CURRENT_PERMISSIONS = 'CURRENT_PERMISSIONS';
+export const currentPermissionsUrl = foremanUrl(
+  '/api/v2/permissions/current_permissions'
+);
 export const templatesUrl = foremanUrl('/api/v2/job_templates');
 
 export const repeatTypes = {