foreman_remote_execution 4.5.6 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f14506c337ce696f794a63b0c30b59f6d301edc4d55b9d654e2b5360215beb9
-  data.tar.gz: 0b9d86b4a422b84d507dfd977dea5dd9f2dc8b30e464b3e4383c8ea421e0615b
+  metadata.gz: 14dc89216ec220750d38149b86e0ecded26e13d99678505302a5a157b0c7c9e2
+  data.tar.gz: b2091af78be3ed0fec0d5acea056a49e601e6d1ef96954c49976fd1c0da39ecb
 SHA512:
-  metadata.gz: 250ec14568078576a42664e40e2d96b974282765e6cfcffca8ec58bdff9e72c8948f2e28e7ba5fdafe36fb45457e2f38c03bd3c39842ba0bebaa303970ea5f09
-  data.tar.gz: 4f6469e5ad8535b7996d1a8c78d266edbba4c03e1e3eb9b52e0588c653351e153b87b4d6daaf082e039d7af47207fdf5e3e6267920cde4d2a233c4e11ac5ca57
+  metadata.gz: 10d901fec16519db44d05d9b9ecb2b15923e1a2e439f1e0032778b9272ed4c48a446436b4ef7375bb5113f8067d5596035b5a7fa593a522fc37e56a472d51c31
+  data.tar.gz: cb7686bf72b55bf65bbd35cee82910925f12b9dd29ec573dc96bb340fb1cc629833a80239e96317dcef2163d17d00ba93db92f5f50a10c5a4f4363d77647f729

data/app/controllers/job_invocations_controller.rb

@@ -67,7 +67,7 @@ class JobInvocationsController < ApplicationController
   end
 
   def index
-    @job_invocations = resource_base_search_and_page.preload(:task, :targeting).order('job_invocations.id DESC')
+    @job_invocations = resource_base_search_and_page.with_task.order('job_invocations.id DESC')
   end
 
   # refreshes the form

data/app/controllers/ui_job_wizard_controller.rb

@@ -10,12 +10,9 @@ class UiJobWizardController < ::Api::V2::BaseController
 
   def template
     job_template = JobTemplate.authorized.find(params[:id])
-    advanced_template_inputs, template_inputs = map_template_inputs(job_template.template_inputs_with_foreign).partition { |x| x["advanced"] }
     render :json => {
       :job_template => job_template,
       :effective_user => job_template.effective_user,
-      :template_inputs => template_inputs,
-      :advanced_template_inputs => advanced_template_inputs,
     }
   end
 
@@ -23,10 +20,6 @@ class UiJobWizardController < ::Api::V2::BaseController
     nested_resource || 'job_template'
   end
 
-  def map_template_inputs(template_inputs_with_foreign)
-    template_inputs_with_foreign.map { |input| input.attributes.merge({:resource_type => input.resource_type&.tableize }) }
-  end
-
   def resource_class
     JobTemplate
   end

data/app/helpers/concerns/foreman_remote_execution/hosts_helper_extensions.rb

@@ -7,9 +7,7 @@ module ForemanRemoteExecution
     end
 
     def multiple_actions
-      res = super
-      res += [ [_('Schedule Remote Job'), new_job_invocation_path, false] ] if authorized_for(controller: :job_invocations, action: :new)
-      res
+      super + [ [_('Schedule Remote Job'), new_job_invocation_path, false] ]
     end
 
     def schedule_job_multi_button(*args)
@@ -23,14 +21,12 @@ module ForemanRemoteExecution
     end
 
     def rex_host_features(*args)
-      return unless authorized_for(controller: :job_invocations, action: :create)
       RemoteExecutionFeature.with_host_action_button.order(:label).map do |feature|
         link_to(_('%s') % feature.name, job_invocations_path(:host_ids => [args.first.id], :feature => feature.label), :method => :post)
       end
     end
 
     def schedule_job_button(*args)
-      return unless authorized_for(controller: :job_invocations, action: :new)
       link_to(_('Schedule Remote Job'), new_job_invocation_path(:host_ids => [args.first.id]), :id => :run_button, :class => 'btn btn-default')
     end
 

data/app/helpers/remote_execution_helper.rb

@@ -7,10 +7,6 @@ module RemoteExecutionHelper
     @job_hosts_authorizer ||= Authorizer.new(User.current, :collection => @hosts)
   end
 
-  def host_tasks_authorizer
-    @host_tasks_authorizer ||= Authorizer.new(User.current, :collection => @job_invocation.sub_tasks)
-  end
-
   def host_counter(label, count)
     content_tag(:div, :class => 'host_counter') do
       content_tag(:div, label, :class => 'header') + content_tag(:div, count.to_s, :class => 'count')
@@ -40,7 +36,7 @@ module RemoteExecutionHelper
                   'data-method': 'get', id: "#{host.name}-actions-rerun" } }
     end
 
-    if host_task.present? && authorized_for(hash_for_foreman_tasks_task_path(host_task).merge(auth_object: host_task, permission: :view_foreman_tasks, authorizer: host_tasks_authorizer))
+    if host_task.present? && authorized_for(hash_for_foreman_tasks_task_path(host_task).merge(auth_object: host_task, permission: :view_foreman_tasks))
       links << { title: _('Host task'),
         action: { href: foreman_tasks_task_path(host_task),
                   'data-method': 'get', id: "#{host.name}-actions-task" } }
@@ -113,14 +109,12 @@ module RemoteExecutionHelper
         :class => 'btn btn-danger',
         :title => _('Try to cancel the job on a host'),
         :disabled => !task.cancellable?,
-        :method => :post,
-        :remote => true)
+        :method => :post)
       buttons << link_to(_('Abort Job'), abort_foreman_tasks_task_path(task),
         :class => 'btn btn-danger',
         :title => _('Try to abort the job on a host without waiting for its result'),
         :disabled => !task.cancellable?,
-        :method => :post,
-        :remote => true)
+        :method => :post)
     end
     buttons
   end

data/app/lib/actions/remote_execution/run_host_job.rb

@@ -47,16 +47,12 @@ module Actions
         script = renderer.render
         raise _('Failed rendering template: %s') % renderer.error_message unless script
 
-        first_execution = host.executed_through_proxies.where(:id => proxy.id).none?
-        host.executed_through_proxies << proxy if first_execution
-
         additional_options = { :hostname => provider.find_ip_or_hostname(host),
                                :script => script,
                                :execution_timeout_interval => job_invocation.execution_timeout_interval,
                                :secrets => secrets(host, job_invocation, provider),
                                :use_batch_triggering => true,
-                               :use_concurrency_control => options[:use_concurrency_control],
-                               :first_execution => first_execution }
+                               :use_concurrency_control => options[:use_concurrency_control]}
         action_options = provider.proxy_command_options(template_invocation, host)
                                  .merge(additional_options)
 

data/app/lib/actions/remote_execution/run_hosts_job.rb

@@ -72,7 +72,7 @@ module Actions
 
       def total_count
         # For compatibility with already existing tasks
-        return output[:total_count] || hosts.count unless output.has_key?(:host_count) || task.pending?
+        return output[:total_count] unless output.has_key?(:host_count) || task.pending?
 
         output[:host_count] || hosts.count
       end

data/app/models/concerns/foreman_remote_execution/host_extensions.rb

@@ -6,8 +6,6 @@ module ForemanRemoteExecution
         has_many :template_invocations, :dependent => :destroy, :foreign_key => 'host_id'
         has_one :execution_status_object, :class_name => 'HostStatus::ExecutionStatus', :foreign_key => 'host_id', :dependent => :destroy
         has_many :run_host_job_tasks, :through => :template_invocations
-        has_many :host_proxy_invocations, :foreign_key => 'host_id', :dependent => :destroy
-        has_many :executed_through_proxies, :through => :host_proxy_invocations, :source => 'smart_proxy'
 
         scoped_search :relation => :run_host_job_tasks, :on => :result, :rename => 'job_invocation.result',
           :ext_method => :search_by_job_invocation,

data/app/models/concerns/foreman_remote_execution/orchestration/ssh.rb

@@ -0,0 +1,70 @@
+module ForemanRemoteExecution
+  module Orchestration::SSH
+    extend ActiveSupport::Concern
+
+    included do
+      before_destroy :ssh_destroy
+      after_validation :queue_ssh_destroy
+      register_rebuild(:queue_ssh_destroy, N_("SSH_#{self.to_s.split('::').first}"))
+    end
+
+    def drop_from_known_hosts(proxy_id)
+      _, _, target = host_kind_target
+      return true if target.nil?
+
+      proxy = ::SmartProxy.find(proxy_id)
+      begin
+        proxy.drop_host_from_known_hosts(target)
+      rescue ::ProxyAPI::ProxyException => e
+        if e.wrapped_exception.is_a?(RestClient::NotFound)
+          # ignore 404 when known_hosts entry is missing or the module was not enabled
+          Foreman::Logging.exception "Proxy failed to delete SSH known_hosts for #{name}, #{ip}", e, :level => :error
+        else
+          raise e
+        end
+      rescue => e
+        Rails.logger.warn e.message
+        return false
+      end
+      true
+    end
+
+    def ssh_destroy
+      logger.debug "Scheduling SSH known_hosts cleanup"
+
+      host, _kind, _target = host_kind_target
+      # #remote_execution_proxies may not be defined on the host object in some case
+      # for example Host::Discovered does not have it defined, even though these hosts
+      # have Nic::Managed interfaces associated with them
+      proxies = (host.try(:remote_execution_proxies, 'SSH') || {}).values
+      proxies.flatten.uniq.each do |proxy|
+        queue.create(id: queue_id(proxy.id), name: _("Remove SSH known hosts for %s") % self,
+          priority: 200, action: [self, :drop_from_known_hosts, proxy.id])
+      end
+    end
+
+    def queue_ssh_destroy
+      should_drop_from_known_hosts? && ssh_destroy
+    end
+
+    def should_drop_from_known_hosts?
+      host, = host_kind_target
+      host && !host.new_record? && host.build && host.changes.key?('build')
+    end
+
+    private
+
+    def host_kind_target
+      if self.is_a?(::Host::Base)
+        [self, 'host', name]
+      else
+        [self.host, 'interface', ip]
+      end
+    end
+
+    def queue_id(proxy_id)
+      _, kind, id = host_kind_target
+      "ssh_remove_known_hosts_#{kind}_#{id}_#{proxy_id}"
+    end
+  end
+end

data/app/models/concerns/foreman_remote_execution/smart_proxy_extensions.rb

@@ -1,11 +1,5 @@
 module ForemanRemoteExecution
   module SmartProxyExtensions
-    def self.prepended(base)
-      base.instance_eval do
-        has_many :host_proxy_invocations, :dependent => :destroy
-      end
-    end
-
     def pubkey
       self[:pubkey] || update_pubkey
     end

data/app/models/host_status/execution_status.rb

@@ -64,11 +64,11 @@ class HostStatus::ExecutionStatus < HostStatus::Status
 
       case status
         when OK
-          [ "foreman_tasks_tasks.state = 'stopped' AND foreman_tasks_tasks.result = 'success'" ]
+          [ "foreman_tasks_tasks.state = 'stopped' AND result = 'success'" ]
         when CANCELLED
-          [ "foreman_tasks_tasks.state = 'stopped' AND foreman_tasks_tasks.result = 'cancelled'" ]
+          [ "foreman_tasks_tasks.state = 'stopped' AND result = 'cancelled'" ]
         when ERROR
-          [ "foreman_tasks_tasks.state = 'stopped' AND (foreman_tasks_tasks.result = 'error' OR foreman_tasks_tasks.result = 'warning')" ]
+          [ "foreman_tasks_tasks.state = 'stopped' AND (result = 'error' OR result = 'warning')" ]
         when QUEUED
           [ "foreman_tasks_tasks.state = 'scheduled' OR foreman_tasks_tasks.state IS NULL" ]
         when RUNNING

data/app/models/job_invocation.rb

@@ -65,6 +65,8 @@ class JobInvocation < ApplicationRecord
   scoped_search :on => 'pattern_template_name', :rename => 'pattern_template_name', :operators => ['= '],
     :complete_value => false, :only_explicit => true, :ext_method => :search_by_pattern_template
 
+  scope :with_task, -> { references(:task) }
+
   scoped_search :relation => :recurring_logic, :on => 'id', :rename => 'recurring_logic.id'
 
   scoped_search :relation => :recurring_logic, :on => 'id', :rename => 'recurring',
@@ -97,7 +99,7 @@ class JobInvocation < ApplicationRecord
   def self.search_by_status(key, operator, value)
     conditions = HostStatus::ExecutionStatus::ExecutionTaskStatusMapper.sql_conditions_for(value)
     conditions[0] = "NOT (#{conditions[0]})" if operator == '<>'
-    { :conditions => sanitize_sql_for_conditions(conditions), :joins => :task }
+    { :conditions => sanitize_sql_for_conditions(conditions), :include => :task }
   end
 
   def self.search_by_recurring_logic(key, operator, value)
@@ -191,16 +193,11 @@ class JobInvocation < ApplicationRecord
   end
 
   def total_hosts_count
-    count = _('N/A')
-
     if targeting.resolved?
-      count = if task&.main_action.respond_to?(:total_count)
-                task.main_action.total_count
-              else
-                targeting.hosts.count
-              end
+      task&.main_action&.total_count || targeting.hosts.count
+    else
+      _('N/A')
     end
-    count
   end
 
   def pattern_template_invocation_for_host(host)

data/app/models/job_invocation_composer.rb

@@ -209,7 +209,7 @@ class JobInvocationComposer
     def format_datetime(datetime)
       return datetime if datetime.blank?
 
-      Time.parse(datetime).utc.strftime('%Y-%m-%d %H:%M')
+      Time.parse(datetime).strftime('%Y-%m-%d %H:%M')
     end
   end
 
@@ -296,7 +296,7 @@ class JobInvocationComposer
     attr_reader :feature_label, :feature, :provided_inputs
 
     def initialize(feature_label, hosts, provided_inputs = {})
-      @feature = RemoteExecutionFeature.feature!(feature_label)
+      @feature = RemoteExecutionFeature.feature(feature_label)
       @provided_inputs = provided_inputs
       translator = HostIdsTranslator.new(hosts)
       @host_bookmark = translator.bookmark
@@ -405,7 +405,7 @@ class JobInvocationComposer
     job_invocation.effective_user_password = params[:effective_user_password]
 
     if @reruns && job_invocation.targeting.static?
-      job_invocation.targeting.assign_host_ids(JobInvocation.find(@reruns).targeting.host_ids)
+      job_invocation.targeting.host_ids = JobInvocation.find(@reruns).targeting.host_ids
       job_invocation.targeting.mark_resolved!
     end
 
@@ -636,7 +636,7 @@ class JobInvocationComposer
     setting_value = Setting['remote_execution_form_job_template']
     return default_value unless setting_value
 
-    form_template = JobTemplate.authorized(:view_job_templates).find_by :name => setting_value
+    form_template = JobTemplate.find_by :name => setting_value
     return default_value unless form_template
 
     if block_given?

data/app/models/remote_execution_feature.rb

@@ -20,11 +20,7 @@ class RemoteExecutionFeature < ApplicationRecord
   end
 
   def self.feature(label)
-    self.find_by(label: label)
-  end
-
-  def self.feature!(label)
-    feature(label) || raise(::Foreman::Exception.new(N_('Unknown remote execution feature %s'), label))
+    self.find_by(label: label) || raise(::Foreman::Exception.new(N_('Unknown remote execution feature %s'), label))
   end
 
   def self.register(label, name, options = {})

data/app/models/remote_execution_provider.rb

@@ -89,8 +89,7 @@ class RemoteExecutionProvider
     end
 
     def host_setting(host, setting)
-      param_value = host.host_param(setting.to_s)
-      param_value.nil? ? Setting[setting] : param_value
+      host.host_param(setting.to_s) || Setting[setting]
     end
 
     def ssh_password(_host)
@@ -112,7 +111,7 @@ class RemoteExecutionProvider
     end
 
     def proxy_action_class
-      'ForemanRemoteExecutionCore::Actions::RunScript'
+      'Proxy::RemoteExecution::Ssh::Actions::RunScript'
     end
 
     # Return a specific proxy selector to use for running a given template

data/app/models/setting/remote_execution.rb

@@ -70,13 +70,13 @@ class Setting::RemoteExecution < Setting
       self.set('remote_execution_form_job_template',
         N_('Choose a job template that is pre-selected in job invocation form'),
         'Run Command - SSH Default',
-        N_('Form Job Template'),
+        _('Form Job Template'),
         nil,
         { :collection => proc { Hash[JobTemplate.unscoped.map { |template| [template.name, template.name] }] } }),
       self.set('remote_execution_job_invocation_report_template',
         N_('Select a report template used for generating a report for a particular remote execution job'),
         'Jobs - Invocation report template',
-        N_('Job Invocation Report Template'),
+        _('Job Invocation Report Template'),
         nil,
         { :collection => proc { self.job_invocation_report_templates_select } }),
     ]

data/app/models/targeting.rb

@@ -46,13 +46,9 @@ class Targeting < ApplicationRecord
     #   pluck(:id) returns duplicate results for HostCollections
     host_ids = User.as(user.login) { Host.authorized(RESOLVE_PERMISSION, Host).search_for(search_query).order(:name, :id).pluck(:id).uniq }
     host_ids.shuffle!(random: Random.new) if randomized_ordering
-    self.assign_host_ids(host_ids)
-    self.save(:validate => false)
-  end
-
-  def assign_host_ids(host_ids)
     # this can be optimized even more, by introducing bulk insert
     self.targeting_hosts.build(host_ids.map { |id| { :host_id => id } })
+    self.save(:validate => false)
   end
 
   def dynamic?

data/app/views/job_invocations/index.html.erb

@@ -21,7 +21,7 @@
     <% @job_invocations.each do |invocation| %>
       <tr>
         <td class="text_warp"><%= link_to_if_authorized invocation_description(invocation), hash_for_job_invocation_path(invocation).merge(:auth_object => invocation, :permission => :view_job_invocations, :authorizer => authorizer) %></td>
-        <td><%= trunc_with_tooltip(invocation.targeting.search_query, 15) %></td>
+        <td><%= trunc_with_tooltip(invocation&.targeting&.search_query, 15) %></td>
         <td><%= link_to_invocation_task_if_authorized(invocation) %></td>
         <td><%= invocation_result(invocation, :success_count) %></td>
         <td><%= invocation_result(invocation, :failed_count) %></td>

data/app/views/templates/ssh/module_action.erb

@@ -29,7 +29,6 @@ template_inputs:
   input_type: user
   required: false
   advanced: true
-feature: katello_module_stream_action
 %>
 
 <%

data/app/views/templates/ssh/power_action.erb

@@ -13,8 +13,6 @@ template_inputs:
   required: true
 %>
 
-PATH="$PATH:/usr/sbin:/sbin"
-
 echo <%= input('action') %> host && sleep 3
 <%= case input('action')
       when 'restart'

data/app/views/templates/ssh/puppet_run_once.erb

@@ -10,7 +10,6 @@ template_inputs:
   description: Additional options to pass to puppet
   input_type: user
   required: false
-feature: puppet_run_host
 %>
 <% if @host.operatingsystem.family == 'Debian' -%>
 export PATH=/opt/puppetlabs/bin:$PATH

data/foreman_remote_execution.gemspec

@@ -25,7 +25,6 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'deface'
   s.add_dependency 'dynflow', '>= 1.0.2', '< 2.0.0'
-  s.add_dependency 'foreman_remote_execution_core'
   s.add_dependency 'foreman-tasks', '>= 4.1.0'
 
   s.add_development_dependency 'factory_bot_rails', '~> 4.8.0'

data/lib/foreman_remote_execution/engine.rb

@@ -201,10 +201,12 @@ module ForemanRemoteExecution
 
       Host::Managed.prepend ForemanRemoteExecution::HostExtensions
       Host::Managed.include ForemanTasks::Concerns::HostActionSubject
+      Host::Managed.include ForemanRemoteExecution::Orchestration::SSH
 
       (Nic::Base.descendants + [Nic::Base]).each do |klass|
         klass.send(:include, ForemanRemoteExecution::NicExtensions)
       end
+      Nic::Managed.include ForemanRemoteExecution::Orchestration::SSH
 
       Bookmark.include ForemanRemoteExecution::BookmarkExtensions
       HostsHelper.prepend ForemanRemoteExecution::HostsHelperExtensions

data/lib/foreman_remote_execution/version.rb

@@ -1,3 +1,3 @@
 module ForemanRemoteExecution
-  VERSION = '4.5.6'.freeze
+  VERSION = '4.6.0'.freeze
 end

data/test/models/orchestration/ssh_test.rb

@@ -0,0 +1,56 @@
+require 'test_plugin_helper'
+
+class SSHOrchestrationTest < ActiveSupport::TestCase
+  let(:host) { FactoryBot.create(:host, :managed, :with_subnet) }
+  let(:proxy) { FactoryBot.create(:smart_proxy, :ssh) }
+  let(:interface) { host.interfaces.first }
+
+  before { interface.subnet.remote_execution_proxies = [proxy] }
+
+  it 'attempts to drop IP address and hostname from smart proxies on destroy' do
+    host.stubs(:skip_orchestration?).returns false
+    SmartProxy.any_instance.expects(:drop_host_from_known_hosts).with(interface.ip)
+    SmartProxy.any_instance.expects(:drop_host_from_known_hosts).with(host.name)
+    host.destroy
+  end
+
+  it 'attempts to drop IP address and hostname from smart proxies on rebuild' do
+    host.stubs(:skip_orchestration?).returns false
+    SmartProxy.any_instance.expects(:drop_host_from_known_hosts).with(interface.ip)
+    SmartProxy.any_instance.expects(:drop_host_from_known_hosts).with(host.name)
+
+    host.build = true
+    host.save!
+
+    ids = ["ssh_remove_known_hosts_interface_#{interface.ip}_#{proxy.id}",
+           "ssh_remove_known_hosts_host_#{host.name}_#{proxy.id}"]
+    _(host.queue.task_ids).must_equal ids
+    _(host.queue.items.map(&:status)).must_equal %w(completed completed)
+  end
+
+  it 'does not fail on 404 from the smart proxy' do
+    host.stubs(:skip_orchestration?).returns false
+    ::ProxyAPI::RemoteExecutionSSH.any_instance.expects(:delete).raises(RestClient::ResourceNotFound).twice
+    host.build = true
+    host.save!
+    ids = ["ssh_remove_known_hosts_interface_#{interface.ip}_#{proxy.id}",
+           "ssh_remove_known_hosts_host_#{host.name}_#{proxy.id}"]
+    _(host.queue.task_ids).must_equal ids
+    _(host.queue.items.map(&:status)).must_equal %w(completed completed)
+  end
+
+  it 'does not trigger the removal when creating a new host' do
+    SmartProxy.any_instance.expects(:drop_host_from_known_hosts).never
+    host = Host::Managed.new(:name => 'test', :ip => '127.0.0.1')
+    host.stubs(:skip_orchestration?).returns false
+    _(host.queue.task_ids).must_equal []
+  end
+
+  it 'does not call to the proxy when target is nil' do
+    host.stubs(:skip_orchestration?).returns false
+    SmartProxy.any_instance.expects(:drop_host_from_known_hosts).with(host.name)
+    host.interfaces.first.stubs(:ip)
+    host.destroy
+    _(host.queue.items.map(&:status)).must_equal %w(completed completed)
+  end
+end

data/test/unit/job_invocation_composer_test.rb

@@ -864,9 +864,7 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
     it 'marks targeting as resolved if static' do
       created = JobInvocationComposer.from_job_invocation(job_invocation).job_invocation
       assert created.targeting.resolved?
-      created.targeting.save
-      created.targeting.reload
-      assert_equal job_invocation.template_invocations_host_ids, created.targeting.targeting_hosts.pluck(:host_id)
+      assert_equal job_invocation.template_invocations_host_ids, created.targeting.host_ids
     end
 
     it 'takes randomized_ordering from the original job invocation when rerunning failed' do
@@ -876,17 +874,6 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
       composer = JobInvocationComposer.from_job_invocation(job_invocation, :host_ids => host_ids)
       assert composer.job_invocation.targeting.randomized_ordering
     end
-
-    it 'works with invalid hosts' do
-      host = job_invocation.targeting.hosts.first
-      ::Host::Managed.any_instance.stubs(:valid?).returns(false)
-      composer = JobInvocationComposer.from_job_invocation(job_invocation, {})
-      targeting = composer.compose.job_invocation.targeting
-      targeting.save!
-      targeting.reload
-      assert targeting.valid?
-      assert_equal targeting.hosts.pluck(:id), [host.id]
-    end
   end
 
   describe '.for_feature' do

data/test/unit/job_invocation_test.rb

@@ -10,7 +10,7 @@ class JobInvocationTest < ActiveSupport::TestCase
     end
 
     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 = 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]
     end
 

data/test/unit/remote_execution_provider_test.rb

@@ -50,18 +50,6 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
     end
   end
 
-  describe '.host_setting' do
-    let(:host) { FactoryBot.create(:host) }
-
-    it 'honors falsey values set as a host parameter' do
-      key = 'remote_execution_connect_by_ip'
-      Setting[key] = true
-      host.parameters << HostParameter.new(name: key, value: false)
-
-      refute RemoteExecutionProvider.host_setting(host, key)
-    end
-  end
-
   describe SSHExecutionProvider do
     before { User.current = FactoryBot.build(:user, :admin) }
     after { User.current = nil }