foreman_remote_execution 14.1.0 → 14.1.1

data/test/unit/actions/run_hosts_job_test.rb

@@ -0,0 +1,214 @@
+require 'test_plugin_helper'
+require 'securerandom'
+
+module ForemanRemoteExecution
+  class RunHostsJobTest < ActiveSupport::TestCase
+    include Dynflow::Testing
+
+    # Adding run_step_id wich is needed in RunHostsJob as a quick fix
+    # it will be added to dynflow in the future see https://github.com/Dynflow/dynflow/pull/391
+    # rubocop:disable Style/ClassAndModuleChildren
+    class Dynflow::Testing::DummyPlannedAction
+      def run_step_id
+        Dynflow::Testing.get_id
+      end
+    end
+    # rubocop:enable Style/ClassAndModuleChildren
+
+    let(:host) { FactoryBot.create(:host, :with_execution) }
+    let(:proxy) { host.remote_execution_proxies('SSH')[:subnet].first }
+    let(:targeting) { FactoryBot.create(:targeting, :search_query => "name = #{host.name}", :user => User.current) }
+    let(:job_invocation) do
+      FactoryBot.build(:job_invocation, :with_template).tap do |invocation|
+        invocation.targeting = targeting
+        invocation.description = 'Some short description'
+        invocation.password = 'changeme'
+        invocation.key_passphrase = 'changemetoo'
+        invocation.effective_user_password = 'sudopassword'
+        invocation.save
+      end
+    end
+
+    let(:uuid) { SecureRandom.uuid }
+    let(:task) do
+      OpenStruct.new(:id => uuid).tap do |o|
+        o.stubs(:add_missing_task_groups)
+        o.stubs(:task_groups).returns([])
+        o.stubs(:pending?).returns(true)
+      end
+    end
+    let(:action) do
+      create_action(Actions::RemoteExecution::RunHostsJob).tap do |action|
+        action.expects(:action_subject).with(job_invocation, job_features: [])
+        ForemanTasks::Task::DynflowTask.stubs(:where).returns(mock.tap { |m| m.stubs(:first! => task) })
+      end
+    end
+    let(:planned) do
+      plan_action action, job_invocation
+    end
+
+    let(:delayed) do
+      action.delay({ :start_at => Time.now.getlocal }, job_invocation)
+      action
+    end
+
+    before do
+      ProxyAPI::ForemanDynflow::DynflowProxy.any_instance.stubs(:tasks_count).returns(0)
+      User.current = users :admin
+      action
+    end
+
+    context 'targeting resolving' do
+      it 'resolves dynamic targeting in plan' do
+        targeting.targeting_type = 'dynamic_query'
+        assert_not targeting.resolved?
+        delayed
+        assert_not targeting.resolved?
+        planned
+        assert_includes targeting.hosts, host
+      end
+
+      it 'resolves the hosts on static targeting in delay' do
+        assert_not targeting.resolved?
+        delayed
+        assert_includes targeting.hosts, host
+        # Verify Targeting#resolve_hosts! won't be hit again
+        targeting.expects(:resolve_hosts!).never
+        planned
+      end
+
+      it 'resolves the hosts on static targeting in plan phase if not resolved yet' do
+        planned
+        assert_includes targeting.hosts, host
+      end
+    end
+
+    it 'triggers the RunHostJob actions on the resolved hosts in run phase' do
+      planned.expects(:output).at_most(5).returns(:planned_count => 0)
+      planned.expects(:trigger).with { |*args| args[0] == Actions::RemoteExecution::RunHostJob }
+      planned.create_sub_plans
+    end
+
+    it 'uses the BindJobInvocation middleware' do
+      planned
+      assert_equal job_invocation.task_id, uuid
+    end
+
+    # In plan phase this is handled by #action_subject
+    #   which is expected in tests
+    it 'sets input in delay phase when delayed' do
+      job_invocation_hash = delayed.input[:job_invocation]
+      assert_equal job_invocation_hash['id'], job_invocation.id
+      assert_equal job_invocation_hash['name'], job_invocation.job_category
+      assert_equal job_invocation_hash['description'], job_invocation.description
+      planned # To make the expectations happy
+    end
+
+    describe '#proxy_batch_size' do
+      it 'defaults to Setting[foreman_tasks_proxy_batch_size]' do
+        Setting.expects(:[]).with('foreman_tasks_proxy_batch_size').returns(14)
+        planned
+        assert_equal 14, planned.proxy_batch_size
+      end
+
+      it 'gets the provider value' do
+        provider = mock('provider')
+        provider.expects(:proxy_batch_size).returns(15)
+        JobTemplate.any_instance.expects(:provider).returns(provider)
+
+        assert_equal 15, planned.proxy_batch_size
+      end
+    end
+
+    describe 'concurrency control' do
+      let(:level) { 5 }
+
+      it 'can be disabled' do
+        assert_nil planned.concurrency_limit
+      end
+
+      it 'can limit concurrency level' do
+        job_invocation.expects(:concurrency_level).twice.returns(level)
+        assert_equal level, planned.concurrency_limit
+      end
+    end
+
+    describe 'notifications' do
+      it 'creates drawer notification on succeess' do
+        blueprint = planned.job_invocation.build_notification
+        blueprint.expects(:deliver!)
+        planned.job_invocation.expects(:build_notification).returns(blueprint)
+        planned.notify_on_success(nil)
+      end
+
+      it 'creates drawer notification on failure' do
+        blueprint = planned.job_invocation.build_notification
+        blueprint.expects(:deliver!)
+        planned.job_invocation.expects(:build_notification).returns(blueprint)
+        planned.notify_on_failure(nil)
+      end
+
+      describe 'ignoring drawer notification' do
+        before do
+          blueprint = planned.job_invocation.build_notification
+          blueprint.expects(:deliver!)
+          planned.job_invocation.expects(:build_notification).returns(blueprint)
+        end
+
+        let(:mail) do
+          object = mock
+          object.stubs(:deliver_now)
+          object
+        end
+
+        describe 'for user subscribed to all' do
+          before do
+            planned.expects(:mail_notification_preference).returns(UserMailNotification.new(:interval => RexMailNotification::ALL_JOBS))
+          end
+
+          it 'sends the mail notification on success' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_success(nil)
+          end
+
+          it 'sends the mail notification on failure' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_failure(nil)
+          end
+        end
+
+        describe 'for user subscribed to failures' do
+          before do
+            planned.expects(:mail_notification_preference).returns(UserMailNotification.new(:interval => RexMailNotification::FAILED_JOBS))
+          end
+
+          it 'it does not send the mail notification on success' do
+            RexJobMailer.expects(:job_finished).never
+            planned.notify_on_success(nil)
+          end
+
+          it 'sends the mail notification on failure' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_failure(nil)
+          end
+        end
+
+        describe 'for user subscribed to successful jobs' do
+          before do
+            planned.expects(:mail_notification_preference).returns(UserMailNotification.new(:interval => RexMailNotification::SUCCEEDED_JOBS))
+          end
+
+          it 'sends the mail notification on success' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_success(nil)
+          end
+
+          it 'does not send the mail notification on failure' do
+            RexJobMailer.expects(:job_finished).never
+            planned.notify_on_failure(nil)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/api_params_test.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class ApiParamsTest < ActiveSupport::TestCase
+  describe '#format_datetime' do
+    let(:params) { JobInvocationComposer::ApiParams.allocate }
+
+    it 'leaves empty string as is' do
+      assert_equal params.send(:format_datetime, ''), ''
+    end
+
+    it 'honors explicitly supplied time zone' do
+      Time.use_zone(ActiveSupport::TimeZone['America/New_York']) do
+        assert_equal '2022-07-08 08:53', params.send(:format_datetime, '2022-07-08 12:53:20 UTC')
+      end
+    end
+
+    it 'implicitly honors current user\'s time zone' do
+      Time.use_zone(ActiveSupport::TimeZone['America/New_York']) do
+        assert_equal '2022-07-08 12:53', params.send(:format_datetime, '2022-07-08 12:53:20')
+      end
+    end
+  end
+end

data/test/unit/concerns/foreman_tasks_cleaner_extensions_test.rb

@@ -0,0 +1,29 @@
+require 'test_plugin_helper'
+
+class ForemanRemoteExecutionForemanTasksCleanerExtensionsTest < ActiveSupport::TestCase
+  # Apply the same stubbing as in foreman-tasks
+  before do
+    # To stop dynflow from backing up actions, execution_plans and steps
+    ForemanTasks.dynflow.world.persistence.adapter.stubs(:backup_to_csv)
+    ForemanTasks::Cleaner.any_instance.stubs(:say) # Make the tests silent
+    # Hack to make the tests pass due to ActiveRecord shenanigans
+    ForemanTasks::Cleaner.any_instance.stubs(:delete_orphaned_dynflow_tasks)
+  end
+
+  it 'tries to delete associated job invocations' do
+    job = FactoryBot.create(:job_invocation, :with_task)
+    ForemanTasks::Cleaner.new(:filter => "id = #{job.task.id}").delete
+    assert_empty JobInvocation.where(:id => job.id)
+  end
+
+  it 'removes orphaned job invocations' do
+    job = FactoryBot.create(:job_invocation, :with_task)
+    assert_equal 1, JobInvocation.where(:id => job.id).count
+    job.task.delete
+    job.reload
+    assert_nil job.task
+    refute_nil job.task_id
+    ForemanTasks::Cleaner.new(:filter => '').delete
+    assert_empty JobInvocation.where(:id => job.id)
+  end
+end

data/test/unit/concerns/host_extensions_test.rb

@@ -0,0 +1,219 @@
+require 'test_plugin_helper'
+
+class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
+  let(:provider) { 'SSH' }
+
+  before { User.current = FactoryBot.build(:user, :admin) }
+  after { User.current = nil }
+
+  describe 'ssh specific params' do
+    let(:host) { FactoryBot.create(:host, :with_execution) }
+    let(:sshkey) { 'ssh-rsa AAAAB3NzaC1yc2EAAAABJQ foo@example.com' }
+
+    before do
+      SmartProxy.any_instance.stubs(:pubkey).returns(sshkey)
+      Setting[:remote_execution_ssh_user] = 'root'
+      Setting[:remote_execution_effective_user_method] = 'sudo'
+    end
+
+    it 'has ssh user in the parameters' do
+      assert_equal Setting[:remote_execution_ssh_user], host.host_param('remote_execution_ssh_user')
+    end
+
+    it 'can override ssh user' do
+      host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_ssh_user', :value => 'amy')
+      assert_equal 'amy', host.host_param('remote_execution_ssh_user')
+    end
+
+    it 'has effective user method in the parameters' do
+      assert_equal Setting[:remote_execution_effective_user_method], host.host_param('remote_execution_effective_user_method')
+    end
+
+    it 'can override effective user method' do
+      host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_effective_user_method', :value => 'su')
+      assert_equal 'su', host.host_param('remote_execution_effective_user_method')
+    end
+
+    it 'has ssh keys in the parameters' do
+      assert_includes host.remote_execution_ssh_keys, sshkey
+    end
+
+    it 'merges ssh keys from host parameters and proxies' do
+      key = 'ssh-rsa not-even-a-key something@somewhere.com'
+      host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_ssh_keys', :value => [key])
+      assert_includes host.host_param('remote_execution_ssh_keys'), key
+      assert_includes host.host_param('remote_execution_ssh_keys'), sshkey
+    end
+
+    it 'merges ssh key as a string from host parameters and proxies' do
+      key = 'ssh-rsa not-even-a-key something@somewhere.com'
+      host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_ssh_keys', :value => key)
+      assert_includes host.host_param('remote_execution_ssh_keys'), key
+      assert_includes host.host_param('remote_execution_ssh_keys'), sshkey
+    end
+
+    it 'has ssh keys in the parameters even when no user specified' do
+      # this is a case, when using the helper in provisioning templates
+      FactoryBot.create(:smart_proxy, :ssh)
+      host.interfaces.first.subnet.remote_execution_proxies.clear
+      User.current = nil
+      assert_includes host.remote_execution_ssh_keys, sshkey
+    end
+  end
+
+  context 'host has multiple nics' do
+    let(:host) { FactoryBot.build(:host, :with_execution) }
+
+    it 'should only have one execution interface' do
+      host.interfaces << FactoryBot.build(:nic_managed)
+      host.interfaces.each { |interface| interface.execution = true }
+      assert_predicate host, :valid?
+      assert_equal 1, host.interfaces.count(&:execution?)
+    end
+
+    it 'returns the execution interface' do
+      assert_kind_of Nic::Managed, host.execution_interface
+    end
+  end
+
+  context 'scoped search' do
+    let(:job) do
+      job = FactoryBot.create(:job_invocation, :with_task)
+      job.template_invocations << FactoryBot.create(:template_invocation, :with_host, :with_failed_task)
+      job
+    end
+
+    let(:job2) do
+      job = FactoryBot.create(:job_invocation, :with_task)
+      job.template_invocations << FactoryBot.create(:template_invocation, :with_host, :with_failed_task)
+      job
+    end
+
+    it 'finds hosts for job_invocation.id' do
+      found_ids = Host.search_for("job_invocation.id = #{job.id}").map(&:id).sort
+      assert_equal job.template_invocations_host_ids.sort, found_ids
+    end
+
+    it 'finds hosts by job_invocation.result' do
+      success, failed = job.template_invocations
+                           .partition { |template| template.run_host_job_task.result == 'success' }
+      found_ids = Host.search_for('job_invocation.result = success').map(&:id)
+      assert_equal success.map(&:host_id), found_ids
+      found_ids = Host.search_for('job_invocation.result = failed').map(&:id)
+      assert_equal failed.map(&:host_id), found_ids
+    end
+
+    it 'finds hosts by job_invocation.id and job_invocation.result' do
+      # Force evaluation of the jobs
+      job
+      job2
+
+      assert_equal 2, Host.search_for("job_invocation.id = #{job.id}").count
+      assert_equal 2, Host.search_for("job_invocation.id = #{job2.id}").count
+      assert_equal 2, Host.search_for('job_invocation.result = success').count
+      assert_equal 2, Host.search_for('job_invocation.result = failed').count
+
+      success, failed = job.template_invocations
+                           .partition { |template| template.run_host_job_task.result == 'success' }
+      found_ids = Host.search_for("job_invocation.id = #{job.id} AND job_invocation.result = success").map(&:id)
+      assert_equal success.map(&:host_id), found_ids
+      found_ids = Host.search_for("job_invocation.id = #{job.id} AND job_invocation.result = failed").map(&:id)
+      assert_equal failed.map(&:host_id), found_ids
+    end
+  end
+
+  describe 'proxy determination strategies' do
+    context 'subnet strategy' do
+      let(:host) { FactoryBot.build(:host, :with_execution) }
+      it { assert_includes host.remote_execution_proxies(provider)[:subnet], host.subnet.remote_execution_proxies.first }
+    end
+
+    context 'fallback strategy' do
+      let(:host) { FactoryBot.build(:host, :with_tftp_subnet) }
+
+      context 'enabled' do
+        before do
+          Setting[:remote_execution_fallback_proxy] = true
+          host.subnet.tftp.features << FactoryBot.create(:feature, :ssh)
+        end
+
+        it 'returns a fallback proxy' do
+          assert_includes host.remote_execution_proxies(provider)[:fallback], host.subnet.tftp
+        end
+      end
+
+      context 'disabled' do
+        before do
+          Setting[:remote_execution_fallback_proxy] = false
+          host.subnet.tftp.features << FactoryBot.create(:feature, :ssh)
+        end
+
+        it 'returns no proxy' do
+          assert_empty host.remote_execution_proxies(provider)[:fallback]
+        end
+      end
+    end
+
+    context 'global strategy' do
+      let(:tax_organization) { FactoryBot.build(:organization) }
+      let(:tax_location) { FactoryBot.build(:location) }
+      let(:host) { FactoryBot.build(:host, :organization => tax_organization, :location => tax_location) }
+      let(:proxy_in_taxonomies) { FactoryBot.create(:smart_proxy, :ssh, :organizations => [tax_organization], :locations => [tax_location]) }
+      let(:proxy_no_taxonomies) { FactoryBot.create(:smart_proxy, :ssh) }
+
+      context 'enabled' do
+        before { Setting[:remote_execution_global_proxy] = true }
+
+        it 'returns correct proxies confined by taxonomies' do
+          proxy_in_taxonomies
+          proxy_no_taxonomies
+          assert_includes host.remote_execution_proxies(provider)[:global], proxy_in_taxonomies
+          refute_includes host.remote_execution_proxies(provider)[:global], proxy_no_taxonomies
+        end
+      end
+
+      context 'disabled' do
+        before { Setting[:remote_execution_global_proxy] = false }
+        it 'returns no proxy' do
+          assert_empty host.remote_execution_proxies(provider)[:global]
+        end
+      end
+    end
+  end
+
+  describe '#execution_scope' do
+    let(:host) { FactoryBot.create(:host) }
+    let(:infra_host) { FactoryBot.create(:host, :with_infrastructure_facet) }
+
+    before do
+      host
+      infra_host
+    end
+
+    context 'without infrastructure host permission' do
+      it 'omits the infrastructure host' do
+        setup_user('view', 'hosts')
+
+        hosts = ::Host::Managed.execution_scope
+        assert_includes hosts, host
+        refute_includes hosts, infra_host
+      end
+    end
+
+    context 'with infrastructure host permission' do
+      it 'finds the host as admin' do
+        assert User.current.admin?
+        hosts = ::Host::Managed.execution_scope
+        assert_includes hosts, host
+        assert_includes hosts, infra_host
+      end
+
+      it 'finds the host as user with needed permissions' do
+        setup_user('execute_jobs_on', 'infrastructure_hosts')
+        hosts = ::Host::Managed.execution_scope
+        assert_includes hosts, host
+        assert_includes hosts, infra_host
+      end
+    end
+  end
+end

data/test/unit/concerns/nic_extensions_test.rb

@@ -0,0 +1,9 @@
+require 'test_plugin_helper'
+
+class ForemanRemoteExecutionNicExtensionsTest < ActiveSupport::TestCase
+  let(:host) { FactoryBot.create(:host) }
+
+  it 'sets the first primary interface as the execution interface' do
+    assert_equal host.interfaces.first, host.execution_interface
+  end
+end

data/test/unit/execution_task_status_mapper_test.rb

@@ -0,0 +1,92 @@
+require 'test_plugin_helper'
+
+class ExecutionTaskStatusMapperTest < ActiveSupport::TestCase
+  describe '.sql_conditions_for(status)' do
+    let(:subject) { HostStatus::ExecutionStatus::ExecutionTaskStatusMapper }
+
+    it 'accepts status number as well as string representation' do
+      assert_equal subject.sql_conditions_for('failed'), subject.sql_conditions_for(HostStatus::ExecutionStatus::ERROR)
+    end
+
+    it 'does not find any task for unknown state' do
+      assert_equal [ '1 = 0' ], subject.sql_conditions_for(-1)
+    end
+  end
+
+  let(:task) { ForemanTasks::Task.new }
+  let(:mapper) { HostStatus::ExecutionStatus::ExecutionTaskStatusMapper.new(task) }
+
+  describe '#status' do
+    let(:subject) { mapper }
+
+    describe 'is queued' do
+      context 'when there is no task' do
+        before { subject.task = nil }
+        specify { assert_equal HostStatus::ExecutionStatus::QUEUED, subject.status }
+      end
+
+      context 'when the task is scheduled in future' do
+        before { subject.task.state = 'scheduled' }
+        specify { assert_equal HostStatus::ExecutionStatus::QUEUED, subject.status }
+      end
+    end
+
+    context 'when task is stopped' do
+      before { subject.task.state = 'stopped' }
+
+      describe 'is succeeded' do
+        context 'without error' do
+          before { subject.task.result = 'success' }
+          specify { assert_equal HostStatus::ExecutionStatus::OK, subject.status }
+        end
+      end
+
+      describe 'is failed' do
+        context 'with error' do
+          before { subject.task.result = 'error' }
+          specify { assert_equal HostStatus::ExecutionStatus::ERROR, subject.status }
+        end
+
+        context 'without error but just with warning (sub task failed)' do
+          before { subject.task.result = 'warning' }
+          specify { assert_equal HostStatus::ExecutionStatus::ERROR, subject.status }
+        end
+      end
+    end
+
+    context 'when task is pending' do
+      before { subject.task.state = 'running' }
+
+      describe 'is pending' do
+        specify { assert_equal HostStatus::ExecutionStatus::RUNNING, subject.status }
+      end
+    end
+  end
+
+  describe '#status_label' do
+    let(:subject) { mapper.status_label }
+
+    context 'status is OK' do
+      before do
+        mapper.task.state = 'stopped'
+        mapper.task.result = 'success'
+      end
+
+      it 'returns ok label' do
+        assert_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::OK], subject
+      end
+    end
+
+    context 'status is ERROR' do
+      before do
+        mapper.task.state = 'stopped'
+        mapper.task.result = 'error'
+      end
+
+      it 'returns failed label' do
+        assert_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::ERROR], subject
+      end
+    end
+  end
+
+end