foreman_remote_execution 14.0.2 → 14.1.0

data/test/unit/actions/run_hosts_job_test.rb

@@ -1,214 +0,0 @@
-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

@@ -1,25 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-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

@@ -1,219 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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