foreman_remote_execution 16.0.3 → 16.0.5

data/lib/foreman_remote_execution/plugin.rb

@@ -0,0 +1,246 @@
+Foreman::Plugin.register :foreman_remote_execution do
+  requires_foreman '>= 3.15'
+  register_global_js_file 'global'
+  register_gettext
+
+  apipie_documented_controllers ["#{ForemanRemoteExecution::Engine.root}/app/controllers/api/v2/*.rb"]
+  ApipieDSL.configuration.dsl_classes_matchers += [
+    "#{ForemanRemoteExecution::Engine.root}/app/lib/foreman_remote_execution/renderer/**/*.rb",
+  ]
+  automatic_assets(false)
+  precompile_assets(ForemanRemoteExecution::Engine.assets_to_precompile)
+
+  # Add settings to a Remote Execution category
+  settings do
+    category :remote_execution, N_('Remote Execution') do
+      setting 'remote_execution_fallback_proxy',
+        type: :boolean,
+        description: N_('Search the host for any proxy with Remote Execution, useful when the host has no subnet or the subnet does not have an execution proxy'),
+        default: false,
+        full_name: N_('Fallback to Any Proxy')
+      setting 'remote_execution_global_proxy',
+        type: :boolean,
+        description: N_('Search for remote execution proxy outside of the proxies assigned to the host. The search will be limited to the host\'s organization and location.'),
+        default: true,
+        full_name: N_('Enable Global Proxy')
+      setting 'remote_execution_ssh_user',
+        type: :string,
+        description: N_('Default user to use for SSH.  You may override per host by setting a parameter called remote_execution_ssh_user.'),
+        default: 'root',
+        full_name: N_('SSH User')
+      setting 'remote_execution_effective_user',
+        type: :string,
+        description: N_('Default user to use for executing the script. If the user differs from the SSH user, su or sudo is used to switch the user.'),
+        default: 'root',
+        full_name: N_('Effective User')
+      setting 'remote_execution_effective_user_method',
+        type: :string,
+        description: N_('What command should be used to switch to the effective user. One of %s') % ::ScriptExecutionProvider::EFFECTIVE_USER_METHODS.inspect,
+        default: 'sudo',
+        full_name: N_('Effective User Method'),
+        collection: proc { Hash[::ScriptExecutionProvider::EFFECTIVE_USER_METHODS.map { |method| [method, method] }] }
+      setting 'remote_execution_effective_user_password',
+        type: :string,
+        description: N_('Effective user password'),
+        default: '',
+        full_name: N_('Effective user password'),
+        encrypted: true
+      setting 'remote_execution_sync_templates',
+        type: :boolean,
+        description: N_('Whether we should sync templates from disk when running db:seed.'),
+        default: true,
+        full_name: N_('Sync Job Templates')
+      setting 'remote_execution_ssh_port',
+        type: :integer,
+        description: N_('Port to use for SSH communication. Default port 22. You may override per host by setting a parameter called remote_execution_ssh_port.'),
+        default: 22,
+        full_name: N_('SSH Port')
+      setting 'remote_execution_connect_by_ip',
+        type: :boolean,
+        description: N_('Should the ip addresses on host interfaces be preferred over the fqdn? '\
+                        'It is useful when DNS not resolving the fqdns properly. You may override this per host by setting a parameter called remote_execution_connect_by_ip. '\
+                        'For dual-stacked hosts you should consider the remote_execution_connect_by_ip_prefer_ipv6 setting'),
+        default: false,
+        full_name: N_('Connect by IP')
+      setting 'remote_execution_connect_by_ip_prefer_ipv6',
+        type: :boolean,
+        description: N_('When connecting using ip address, should the IPv6 addresses be preferred? '\
+                        'If no IPv6 address is set, it falls back to IPv4 automatically. You may override this per host by setting a parameter called remote_execution_connect_by_ip_prefer_ipv6. '\
+                        'By default and for compatibility, IPv4 will be preferred over IPv6 by default'),
+        default: false,
+        full_name: N_('Prefer IPv6 over IPv4')
+      setting 'remote_execution_ssh_password',
+        type: :string,
+        description: N_('Default password to use for SSH. You may override per host by setting a parameter called remote_execution_ssh_password'),
+        default: nil,
+        full_name: N_('Default SSH password'),
+        encrypted: true
+      setting 'remote_execution_ssh_key_passphrase',
+        type: :string,
+        description: N_('Default key passphrase to use for SSH. You may override per host by setting a parameter called remote_execution_ssh_key_passphrase'),
+        default: nil,
+        full_name: N_('Default SSH key passphrase'),
+        encrypted: true
+      setting 'remote_execution_cleanup_working_dirs',
+        type: :boolean,
+        description: N_('When enabled, working directories will be removed after task completion. You may override this per host by setting a parameter called remote_execution_cleanup_working_dirs.'),
+        default: true,
+        full_name: N_('Cleanup working directories')
+      setting 'remote_execution_cockpit_url',
+        type: :string,
+        description: N_('Where to find the Cockpit instance for the Web Console button.  By default, no button is shown.'),
+        default: nil,
+        full_name: N_('Cockpit URL')
+      setting 'remote_execution_form_job_template',
+        type: :string,
+        description: N_('Choose a job template that is pre-selected in job invocation form'),
+        default: 'Run Command - Script Default',
+        full_name: N_('Form Job Template'),
+        collection: proc { Hash[JobTemplate.unscoped.map { |template| [template.name, template.name] }] }
+      setting 'remote_execution_job_invocation_report_template',
+        type: :string,
+        description: N_('Select a report template used for generating a report for a particular remote execution job'),
+        default: 'Job - Invocation Report',
+        full_name: N_('Job Invocation Report Template'),
+        collection: proc { ForemanRemoteExecution.job_invocation_report_templates_select }
+      setting 'remote_execution_time_to_pickup',
+        type: :integer,
+        description: N_('Time in seconds within which the host has to pick up a job. If the job is not picked up within this limit, the job will be cancelled. Defaults to 1 day. Applies only to pull-mqtt based jobs.'),
+        default: 24 * 60 * 60,
+        full_name: N_('Time to pickup')
+    end
+  end
+
+  # Add permissions
+  security_block :foreman_remote_execution do
+    permission :view_job_templates, { :job_templates => [:index, :show, :revision, :auto_complete_search, :auto_complete_job_category, :preview, :export],
+                                      :'api/v2/job_templates' => [:index, :show, :revision, :export],
+                                      :'api/v2/template_inputs' => [:index, :show],
+                                      :'api/v2/foreign_input_sets' => [:index, :show],
+                                      :ui_job_wizard => [:categories, :template, :resources, :job_invocation]}, :resource_type => 'JobTemplate'
+    permission :create_job_templates, { :job_templates => [:new, :create, :clone_template, :import],
+                                        :'api/v2/job_templates' => [:create, :clone, :import] }, :resource_type => 'JobTemplate'
+    permission :edit_job_templates, { :job_templates => [:edit, :update],
+                                      :'api/v2/job_templates' => [:update],
+                                      :'api/v2/template_inputs' => [:create, :update, :destroy],
+                                      :'api/v2/foreign_input_sets' => [:create, :update, :destroy]}, :resource_type => 'JobTemplate'
+    permission :view_remote_execution_features, { :remote_execution_features => [:index, :show],
+                                                  :'api/v2/remote_execution_features' => [:index, :show, :available_remote_execution_features]},
+      :resource_type => 'RemoteExecutionFeature'
+    permission :edit_remote_execution_features, { :remote_execution_features => [:update],
+                                                  :'api/v2/remote_execution_features' => [:update]}, :resource_type => 'RemoteExecutionFeature'
+    permission :destroy_job_templates, { :job_templates => [:destroy],
+                                        :'api/v2/job_templates' => [:destroy] }, :resource_type => 'JobTemplate'
+    permission :lock_job_templates, { :job_templates => [:lock, :unlock] }, :resource_type => 'JobTemplate'
+    permission :create_job_invocations, { :job_invocations => [:new, :create, :legacy_create, :refresh, :rerun, :preview_hosts],
+                                          'api/v2/job_invocations' => [:create, :rerun] }, :resource_type => 'JobInvocation'
+    permission :view_job_invocations, { :job_invocations => [:index, :chart, :show, :auto_complete_search, :preview_job_invocations_per_host, :list_jobs_hosts], :template_invocations => [:show, :show_template_invocation_by_host],
+                                        'api/v2/job_invocations' => [:index, :show, :output, :raw_output, :outputs, :hosts] }, :resource_type => 'JobInvocation'
+    permission :view_template_invocations, { :template_invocations => [:show, :template_invocation_preview, :show_template_invocation_by_host], :job_invocations => [:list_jobs_hosts],
+                                            'api/v2/template_invocations' => [:template_invocations], :ui_job_wizard => [:job_invocation] }, :resource_type => 'TemplateInvocation'
+    permission :create_template_invocations, {}, :resource_type => 'TemplateInvocation'
+    permission :execute_jobs_on_infrastructure_hosts, {}, :resource_type => 'JobInvocation'
+    permission :cancel_job_invocations, { :job_invocations => [:cancel], 'api/v2/job_invocations' => [:cancel] }, :resource_type => 'JobInvocation'
+    # this permissions grants user to get auto completion hints when setting up filters
+    permission :filter_autocompletion_for_template_invocation, { :template_invocations => [:auto_complete_search, :index] },
+      :resource_type => 'TemplateInvocation'
+    permission :cockpit_hosts, { 'cockpit' => [:redirect, :host_ssh_params] }, :resource_type => 'Host'
+  end
+
+  user_permissions = [
+    :view_job_templates,
+    :view_job_invocations,
+    :create_job_invocations,
+    :create_template_invocations,
+    :view_hosts,
+    :view_smart_proxies,
+    :view_remote_execution_features,
+  ].freeze
+  manager_permissions = user_permissions + [
+    :cancel_job_invocations,
+    :destroy_job_templates,
+    :edit_job_templates,
+    :create_job_templates,
+    :lock_job_templates,
+    :view_audit_logs,
+    :filter_autocompletion_for_template_invocation,
+    :edit_remote_execution_features,
+  ]
+
+  # Add a new role called 'Remote Execution User ' if it doesn't exist
+  role 'Remote Execution User', user_permissions, 'Role with permissions to run remote execution jobs against hosts'
+  role 'Remote Execution Manager', manager_permissions, 'Role with permissions to manage job templates, remote execution features, cancel jobs and view audit logs'
+
+  add_all_permissions_to_default_roles(except: [:execute_jobs_on_infrastructure_hosts])
+  add_permissions_to_default_roles({
+    Role::MANAGER => [:execute_jobs_on_infrastructure_hosts],
+    Role::SITE_MANAGER => user_permissions + [:execute_jobs_on_infrastructure_hosts],
+  })
+
+  # add menu entry
+  menu :top_menu, :job_templates,
+    url_hash: { controller: :job_templates, action: :index },
+    caption: N_('Job Templates'),
+    parent: :hosts_menu,
+    after: :provisioning_templates
+  menu :admin_menu, :remote_execution_features,
+    url_hash: { controller: :remote_execution_features, action: :index },
+    caption: N_('Remote Execution Features'),
+    parent: :administer_menu,
+    after: :bookmarks
+
+  menu :top_menu, :job_invocations,
+    url_hash: { controller: :job_invocations, action: :index },
+    caption: N_('Jobs'),
+    parent: :monitor_menu,
+    after: :audits
+
+  menu :labs_menu, :job_invocations_detail,
+    url_hash: { controller: :job_invocations, action: :show },
+    caption: N_('Job invocations detail'),
+    parent: :lab_features_menu,
+    url: '/experimental/job_invocations_detail/1'
+
+  register_custom_status HostStatus::ExecutionStatus
+  # add dashboard widget
+  # widget 'foreman_remote_execution_widget', name: N_('Foreman plugin template widget'), sizex: 4, sizey: 1
+  widget 'dashboard/latest-jobs', :name => N_('Latest Jobs'), :sizex => 6, :sizey => 1
+
+  parameter_filter Subnet, :remote_execution_proxies, :remote_execution_proxy_ids => []
+  parameter_filter Nic::Interface do |ctx|
+    ctx.permit :execution
+  end
+
+  register_graphql_query_field :job_invocations, '::Types::JobInvocation', :collection_field
+  register_graphql_query_field :job_invocation, '::Types::JobInvocation', :record_field
+
+  register_graphql_mutation_field :create_job_invocation, ::Mutations::JobInvocations::Create
+
+  extend_template_helpers ForemanRemoteExecution::RendererMethods
+
+  extend_rabl_template 'api/v2/smart_proxies/main', 'api/v2/smart_proxies/pubkey'
+  extend_rabl_template 'api/v2/interfaces/main', 'api/v2/interfaces/execution_flag'
+  extend_rabl_template 'api/v2/subnets/show', 'api/v2/subnets/remote_execution_proxies'
+  extend_rabl_template 'api/v2/hosts/main', 'api/v2/host/main'
+  parameter_filter ::Subnet, :remote_execution_proxy_ids
+
+  describe_host do
+    multiple_actions_provider :rex_hosts_multiple_actions
+    overview_buttons_provider :rex_host_overview_buttons
+  end
+
+  # Extend Registration module
+  extend_allowed_registration_vars :remote_execution_interface
+  extend_allowed_registration_vars :setup_remote_execution_pull
+  ForemanTasks.dynflow.eager_load_actions!
+  extend_observable_events(
+    ::Dynflow::Action.descendants.select do |klass|
+      klass <= ::Actions::ObservableAction
+    end.map(&:namespaced_event_names) +
+    RemoteExecutionFeature.all.pluck(:label).flat_map do |label|
+      [::Actions::RemoteExecution::RunHostJob, ::Actions::RemoteExecution::RunHostsJob].map do |klass|
+        klass.feature_job_event_names(label)
+      end
+    end
+  )
+end

data/lib/foreman_remote_execution/version.rb

@@ -1,3 +1,3 @@
 module ForemanRemoteExecution
-  VERSION = '16.0.3'.freeze
+  VERSION = '16.0.5'.freeze
 end

data/test/functional/api/v2/job_invocations_controller_test.rb

@@ -91,7 +91,7 @@ module Api
         end
 
         test 'should create with schedule' do
-          @attrs[:scheduling] = { start_at: Time.now.to_s }
+          @attrs[:scheduling] = { start_at: (Time.now + 1.hour).to_s }
           post :create, params: { job_invocation: @attrs }
           invocation = ActiveSupport::JSON.decode(@response.body)
           assert_equal invocation['mode'], 'future'

data/test/functional/api/v2/job_templates_controller_test.rb

@@ -90,6 +90,35 @@ module Api
         assert_response :unprocessable_entity
       end
 
+      test 'should clone locked template' do
+        @template.locked = true
+        @template.save!
+        post :clone, params: { :id => @template.to_param, :job_template => {:name => 'MyClone'} }
+        assert_response :success
+
+        template = ActiveSupport::JSON.decode(@response.body)
+        assert_equal(template['locked'], false)
+      end
+
+      test 'should clone template with associations' do
+        template2 = FactoryBot.create(:job_template)
+        @template.organizations << FactoryBot.create(:organization)
+        @template.locations << FactoryBot.create(:location)
+        @template.foreign_input_sets << FactoryBot.build(:foreign_input_set).tap { |fis| fis.target_template_id = template2.id }
+        @template.effective_user.value = 'toor'
+        @template.save!
+
+        post :clone, params: { :id => @template.to_param, :job_template => {:name => 'MyClone'} }
+        template = ActiveSupport::JSON.decode(@response.body)
+
+        clone = JobTemplate.unscoped.find(template['id'])
+        assert_equal(clone.organizations.sort, @template.organizations.sort)
+        assert_equal(clone.locations.sort, @template.locations.sort)
+        assert_equal(clone.foreign_input_sets.map(&:target_template_id), [template2.id])
+        assert_equal(clone.effective_user.value, 'toor')
+        assert_equal(clone.cloned_from.id, @template.id)
+      end
+
       test 'should export template' do
         get :export, params: { :id => @template.to_param }
         User.current = users(:admin)

data/test/unit/actions/run_host_job_test.rb

@@ -10,7 +10,7 @@ module ForemanRemoteExecution
       let(:job_invocation) { FactoryBot.create(:job_invocation, :with_task) }
       let(:host) { job_invocation.template_invocations.first.host }
       let(:provider) do
-        provider = ::SSHExecutionProvider
+        provider = ::ScriptExecutionProvider
         provider.expects(:ssh_password).with(host).returns('sshpass')
         provider.expects(:effective_user_password).with(host).returns('sudopass')
         provider.expects(:ssh_key_passphrase).with(host).returns('keypass')

data/test/unit/job_invocation_report_template_test.rb

@@ -28,9 +28,9 @@ class JobReportTemplateTest < ActiveSupport::TestCase
     describe 'task reporting' do
       let(:fake_outputs) do
         [
-          { 'output_type' => 'stderr', 'output' => "error" },
-          { 'output_type' => 'stdout', 'output' => "output" },
-          { 'output_type' => 'debug', 'output' => "debug" },
+          { 'output_type' => 'stderr', 'output' => "error\n" },
+          { 'output_type' => 'stdout', 'output' => "output\n" },
+          { 'output_type' => 'debug', 'output' => "debug\n" },
         ]
       end
       let(:fake_task) { FakeTask.new(result: 'success', action_continuous_output: fake_outputs, :ended_at => Time.new(2020, 12, 1, 0, 0, 0).utc) }
@@ -50,9 +50,9 @@ class JobReportTemplateTest < ActiveSupport::TestCase
         row = rows.first
         assert_equal host.name, row['Host']
         assert_equal 'success', row['Result']
-        assert_equal 'error', row['stderr']
-        assert_equal 'output', row['stdout']
-        assert_equal 'debug', row['debug']
+        assert_equal "error\n", row['stderr']
+        assert_equal "output\n", row['stdout']
+        assert_equal "debug\n", row['debug']
         assert_kind_of Time, Time.zone.parse(row['Finished']), 'Parsing of time column failed'
       end
     end

data/test/unit/remote_execution_provider_test.rb

@@ -5,11 +5,11 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
     let(:providers) { RemoteExecutionProvider.providers }
     it { assert_kind_of HashWithIndifferentAccess, providers }
     it 'makes providers accessible using symbol' do
-      assert_equal SSHExecutionProvider, providers[:SSH]
+      assert_equal ScriptExecutionProvider, providers[:SSH]
       assert_equal ScriptExecutionProvider, providers[:script]
     end
     it 'makes providers accessible using string' do
-      assert_equal SSHExecutionProvider, providers['SSH']
+      assert_equal ScriptExecutionProvider, providers['SSH']
       assert_equal ScriptExecutionProvider, providers['script']
     end
   end
@@ -27,11 +27,11 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
 
   describe '.provider_for' do
     it 'accepts symbols' do
-      assert_equal SSHExecutionProvider, RemoteExecutionProvider.provider_for(:SSH)
+      assert_equal ScriptExecutionProvider, RemoteExecutionProvider.provider_for(:SSH)
     end
 
     it 'accepts strings' do
-      assert_equal SSHExecutionProvider, RemoteExecutionProvider.provider_for('SSH')
+      assert_equal ScriptExecutionProvider, RemoteExecutionProvider.provider_for('SSH')
     end
 
     it 'returns a default one if unknown value is provided' do
@@ -81,7 +81,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
   describe '.provider_proxy_features' do
     it 'returns correct values' do
       RemoteExecutionProvider.stubs(:providers).returns(
-        :SSH => SSHExecutionProvider,
+        :SSH => ScriptExecutionProvider,
         :script => ScriptExecutionProvider
       )
 
@@ -112,15 +112,15 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
     end
   end
 
-  describe SSHExecutionProvider do
+  describe ScriptExecutionProvider do
     before { User.current = FactoryBot.build(:user, :admin) }
     after { User.current = nil }
 
     let(:job_invocation) { FactoryBot.create(:job_invocation, :with_template) }
     let(:template_invocation) { job_invocation.pattern_template_invocations.first }
     let(:host) { FactoryBot.create(:host) }
-    let(:proxy_options) { SSHExecutionProvider.proxy_command_options(template_invocation, host) }
-    let(:secrets) { SSHExecutionProvider.secrets(host) }
+    let(:proxy_options) { ScriptExecutionProvider.proxy_command_options(template_invocation, host) }
+    let(:secrets) { ScriptExecutionProvider.secrets(host) }
 
     describe 'effective user' do
       it 'takes the effective user from value from the template invocation' do
@@ -153,11 +153,11 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         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 = ScriptExecutionProvider.proxy_command_options(template_invocation, host)
         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 = ScriptExecutionProvider.proxy_command_options(template_invocation, host)
         assert_equal 'dzdo', proxy_options[:effective_user_method]
       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
-        assert_equal 'somehost.somedomain.org', SSHExecutionProvider.find_ip_or_hostname(host)
+        assert_equal 'somehost.somedomain.org', ScriptExecutionProvider.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
-        assert_equal execution_interface.fqdn, SSHExecutionProvider.find_ip_or_hostname(host)
+        assert_equal execution_interface.fqdn, ScriptExecutionProvider.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
-        assert_equal 'somehost.somedomain.org', SSHExecutionProvider.find_ip_or_hostname(host)
+        assert_equal 'somehost.somedomain.org', ScriptExecutionProvider.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
-        assert_equal provision_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
+        assert_equal provision_interface.ip, ScriptExecutionProvider.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
-        assert_equal host.primary_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
+        assert_equal host.primary_interface.ip, ScriptExecutionProvider.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
-        assert_equal execution_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
+        assert_equal execution_interface.ip, ScriptExecutionProvider.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
-        assert_equal execution_interface.ip, SSHExecutionProvider.find_ip_or_hostname(host)
+        assert_equal execution_interface.ip, ScriptExecutionProvider.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
-        assert_equal execution_interface.ip6, SSHExecutionProvider.find_ip_or_hostname(host)
+        assert_equal execution_interface.ip6, ScriptExecutionProvider.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
-        assert_equal execution_interface.ip6, SSHExecutionProvider.find_ip_or_hostname(host)
+        assert_equal execution_interface.ip6, ScriptExecutionProvider.find_ip_or_hostname(host)
       end
     end
   end