foreman_remote_execution 14.1.0 → 14.1.2

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+module Api
+  module V2
+    class TemplateInvocationsControllerTest < ActionController::TestCase
+      setup do
+        @job = FactoryBot.create(:job_invocation, :with_template, :with_task)
+        @template_invocation = @job.template_invocations.first
+      end
+
+      test 'should get template invocations belonging to job invocation' do
+        get :template_invocations, params: { :id => @job.id }
+        invocations = ActiveSupport::JSON.decode(@response.body)
+        assert_equal @job.template_invocations.count, invocations['results'].count
+        assert_equal @job.template_invocations.count, invocations['total']
+
+        expected_result = {
+          'id'                   => @template_invocation.id,
+          'host_id'              => @template_invocation.host_id,
+          'host_name'            => @template_invocation.host.name,
+          'template_id'          => @template_invocation.template_id,
+          'effective_user'       => @template_invocation.effective_user,
+          'job_invocation_id'    => @job.id,
+          'run_host_job_task_id' => @template_invocation.run_host_job_task_id,
+        }
+        assert_equal [expected_result], invocations['results']
+        assert_response :success
+      end
+    end
+  end
+end

data/test/functional/cockpit_controller_test.rb

@@ -0,0 +1,16 @@
+require 'test_plugin_helper'
+
+class CockpitControllerTest < ActionController::TestCase
+  def setup
+    as_admin do
+      @host = FactoryBot.create(:host)
+    end
+  end
+
+  test "should get host_ssh_params" do
+    get :host_ssh_params, params: { id: @host.id }, session: set_session_user
+    assert_response :success
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert response.key?('ssh_user'), 'ssh_params response must include ssh_user'
+  end
+end

data/test/functional/job_invocations_controller_test.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+require_relative '../support/remote_execution_helper'
+
+class JobInvocationsControllerTest < ActionController::TestCase
+  test 'should parse inputs coming from the URL params' do
+    template = FactoryBot.create(:job_template, :with_input)
+    feature = FactoryBot.create(:remote_execution_feature,
+      :job_template => template)
+    params = {
+      feature: feature.label,
+      inputs: { template.template_inputs.first.name => 'foobar' },
+    }
+
+    get :new, params: params, session: set_session_user
+    template_invocation_params = [
+      {
+        'input_values' =>
+        [
+          {
+            'value' => 'foobar',
+            'template_input_id' => template.template_inputs.first.id,
+          },
+        ],
+        'template_id' => template.id,
+      },
+    ]
+    assert_equal(template_invocation_params,
+      assigns(:composer).params['template_invocations'])
+  end
+
+  test 'should allow no inputs' do
+    template = FactoryBot.create(:job_template)
+    feature = FactoryBot.create(:remote_execution_feature,
+      :job_template => template)
+    params = {
+      feature: feature.label,
+    }
+    get :new, params: params, session: set_session_user
+    template_invocation_params = [
+      {
+        'template_id' => template.id,
+        'input_values' => {},
+      },
+    ]
+    assert_equal(template_invocation_params,
+      assigns(:composer).params['template_invocations'])
+  end
+
+  test 'new via GET and POST' do
+    template = FactoryBot.create(:job_template, :with_input)
+    feature = FactoryBot.create(:remote_execution_feature, job_template: template)
+    params = { feature: feature.label, inputs: { template.template_inputs.first.name => 'foobar' } }
+
+    get :new, params: params, session: set_session_user
+    assert_response :success
+
+    post :new, params: params, session: set_session_user
+    assert_response :success
+  end
+
+  context 'restricted access' do
+    setup do
+      @admin = users(:admin)
+      @user = FactoryBot.create(:user, mail: 'test23@test.foreman.com', admin: false)
+      @invocation = FactoryBot.create(:job_invocation, :with_template, :with_task)
+      @invocation2 = FactoryBot.create(:job_invocation, :with_template, :with_task)
+
+      @invocation.task.update(user: @admin)
+      @invocation2.task.update(user: @user)
+
+      setup_user 'view', 'hosts', nil, @user
+      setup_user 'view', 'job_invocations', 'user = current_user', @user
+      setup_user 'create', 'job_invocations', 'user = current_user', @user
+      setup_user 'cancel', 'job_invocations', 'user = current_user', @user
+    end
+
+    context 'without user filter' do
+      test '#index' do
+        get :index, session: prepare_user(@admin)
+        assert_response :success
+        assert 2, assigns(:job_invocations).size
+      end
+
+      test '#show' do
+        get :show, params: { id: @invocation2.id }, session: prepare_user(@admin)
+        assert_response :success
+      end
+
+      test '#rerun' do
+        get :rerun, params: { id: @invocation2.id }, session: prepare_user(@admin)
+        assert_response :success
+      end
+
+      test '#cancel' do
+        ForemanTasks::Task.any_instance.expects(:cancel).returns(true)
+        post :cancel, params: { id: @invocation2.id }, session: prepare_user(@admin)
+        assert_response :redirect
+      end
+    end
+
+    context 'with user filter' do
+      test '#index' do
+        get :index, session: prepare_user(@user)
+        assert_response :success
+        assert_equal 1, assigns(:job_invocations).size
+        assert_equal @invocation2, assigns(:job_invocations)[0]
+      end
+
+      test '#show' do
+        get :show, params: { id: @invocation.id }, session: prepare_user(@user)
+        assert_response :not_found
+      end
+
+      test '#rerun' do
+        get :rerun, params: { id: @invocation.id }, session: prepare_user(@user)
+        assert_response :not_found
+      end
+
+      test 'cancel' do
+        post :cancel, params: { id: @invocation.id }, session: prepare_user(@user)
+        assert_response :not_found
+      end
+    end
+  end
+
+  def prepare_user(user)
+    User.current = user
+    set_session_user(user)
+  end
+end

data/test/functional/job_templates_controller_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class JobTemplatesControllerTest < ActionController::TestCase
+  context '#preview' do
+    let(:template) { FactoryBot.create(:job_template) }
+    let(:host) { FactoryBot.create(:host, :managed) }
+
+    test 'should render a preview version of a template' do
+      post :preview, params: { job_template: template.to_param, template: 'uptime' }, session: set_session_user
+      assert_response :success
+    end
+
+    test 'should render a preview version of a template for a specific host' do
+      post :preview, params: {
+        job_template: template.to_param,
+        template: '<%= @host.name %>',
+        preview_host_id: host.id,
+      }, session: set_session_user
+      assert_response :success
+      assert_equal host.name, @response.body
+    end
+
+    test 'should render a error message when template has errors' do
+      InputTemplateRenderer.any_instance.stubs(:render).returns(false)
+      post :preview, params: { job_template: template.to_param }, session: set_session_user
+      assert_response :not_acceptable
+    end
+  end
+end

data/test/functional/ui_job_wizard_controller_test.rb

@@ -0,0 +1,16 @@
+require 'test_plugin_helper'
+
+class UIJobWizardControllerTest < ActionController::TestCase
+  def setup
+    FactoryBot.create(:job_template, :job_category => 'cat1')
+    FactoryBot.create(:job_template, :job_category => 'cat2')
+    FactoryBot.create(:job_template, :job_category => 'cat2')
+  end
+
+  test 'should respond with categories' do
+    get :categories, :params => {}, :session => set_session_user
+    assert_response :success
+    res = JSON.parse @response.body
+    assert_equal ['cat1','cat2'], res['job_categories']
+  end
+end

data/test/graphql/mutations/job_invocations/create_test.rb

@@ -0,0 +1,58 @@
+require 'test_plugin_helper'
+
+module Mutations
+  module JobInvocations
+    class CreateMutationTest < ActiveSupport::TestCase
+      let(:host) { FactoryBot.create(:host) }
+      let(:job_template) { FactoryBot.create(:job_template, :with_input) }
+      let(:cron_line) { '5 * * * *' }
+      let(:purpose) { 'test' }
+      let(:variables) do
+        {
+          jobInvocation: {
+            hostIds: [host.id],
+            jobTemplateId: job_template.id,
+            targetingType: 'static_query',
+            inputs: { job_template.template_inputs.first.name => "bar" },
+            recurrence: {
+              cronLine: cron_line,
+              purpose:  purpose,
+            },
+          },
+        }
+      end
+
+      let(:query) do
+        <<-GRAPHQL
+          mutation CreateJobInvocation($jobInvocation: JobInvocationInput!) {
+              createJobInvocation(input: { jobInvocation: $jobInvocation }) {
+                jobInvocation {
+                  id
+                  description
+                  recurringLogic {
+                    cronLine
+                    purpose
+                  }
+                }
+              }
+            }
+        GRAPHQL
+      end
+
+      context 'with admin user' do
+        let(:user) { FactoryBot.create(:user, :admin) }
+        let(:context) { { current_user: user } }
+
+        test 'create a job invocation' do
+          assert_difference('JobInvocation.count', +1) do
+            result = ForemanGraphqlSchema.execute(query, variables: variables, context: context)
+            assert_empty result['errors']
+            assert_empty result['data']['createJobInvocation']['jobInvocation']['errors']
+            assert_equal cron_line, result['data']['createJobInvocation']['jobInvocation']['recurringLogic']['cronLine']
+            assert_equal purpose, result['data']['createJobInvocation']['jobInvocation']['recurringLogic']['purpose']
+          end
+        end
+      end
+    end
+  end
+end

data/test/graphql/queries/job_invocation_query_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Queries
+  class JobInvocationQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query (
+        $id: String!
+      ) {
+        jobInvocation(id: $id) {
+          id
+          jobCategory
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:job_invocation) { FactoryBot.create(:job_invocation) }
+
+    let(:global_id) { Foreman::GlobalId.for(job_invocation) }
+    let(:variables) { { id: global_id } }
+    let(:data) { result['data']['jobInvocation'] }
+
+    test 'fetching job invocation attributes' do
+      assert_empty result['errors']
+
+      assert_equal global_id, data['id']
+      assert_equal job_invocation.job_category, data['jobCategory']
+    end
+  end
+end

data/test/graphql/queries/job_invocations_query_test.rb

@@ -0,0 +1,35 @@
+require 'test_plugin_helper'
+
+module Queries
+  class JobInvocationsQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query {
+        jobInvocations {
+          totalCount
+          nodes {
+            id
+            jobCategory
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:data) { result['data']['jobInvocations'] }
+
+    setup do
+      FactoryBot.create_list(:job_invocation, 2)
+    end
+
+    test 'should fetch job invocations' do
+      assert_empty result['errors']
+
+      expected_count = JobInvocation.count
+
+      assert_not_equal 0, expected_count
+      assert_equal expected_count, data['totalCount']
+      assert_equal expected_count, data['nodes'].count
+    end
+  end
+end

data/test/helpers/remote_execution_helper_test.rb

@@ -0,0 +1,46 @@
+require 'test_plugin_helper'
+
+class RemoteExecutionHelperTest < ActionView::TestCase
+  describe '#normalize_line_sets' do
+    let :line_sets do
+      [{"output_type"=>"stdout", "output"=>"one", "timestamp"=>1},
+       {"output_type"=>"stdout", "output"=>"\r\ntwo\r\n", "timestamp"=>2},
+       {"output_type"=>"stdout", "output"=>"\r\nthr", "timestamp"=>3},
+       {"output_type"=>"stdout", "output"=>"ee\r\nfour\r\n", "timestamp"=>4},
+       {"output_type"=>"stdout", "output"=>"\r\n\r\n", "timestamp"=>5},
+       {"output_type"=>"stdout", "output"=>"five\r\n", "timestamp"=>6},
+       {"output_type"=>"stdout", "output"=>"Exit status: 0", "timestamp"=>7}]
+    end
+
+    it 'ensures the line sets end with new line' do
+      new_line_sets = normalize_line_sets(line_sets)
+      expected_output = ["one\r\n",
+                         "two\r\n",
+                         "\r\nthree\r\n",
+                         "four\r\n",
+                         "\r\n\r\n",
+                         "five\r\n",
+                         "Exit status: 0"]
+      assert_equal(expected_output, new_line_sets.map { |s| s['output'] })
+    end
+  end
+
+  describe 'test correct setting' do
+    it 'should found correct template from setting' do
+      template_name = 'Job Invocation Report Template'
+      setting_key = 'remote_execution_job_invocation_report_template'
+      template = FactoryBot.create(:report_template, name: template_name)
+      input = FactoryBot.create(:template_input, name: 'job_id', input_type: 'user')
+      template.template_inputs << input
+      Setting.expects(:[]).with(setting_key).returns(template_name)
+
+      found_template = job_report_template
+
+      assert_equal template.id, found_template.id
+    end
+
+    it 'should not crash if the template cannot be found' do
+      assert_nil job_report_template
+    end
+  end
+end

data/test/support/remote_execution_helper.rb

@@ -0,0 +1,5 @@
+module RemoteExecutionHelper
+  def job_invocation_task_buttons(task)
+    return []
+  end
+end

data/test/test_plugin_helper.rb

@@ -0,0 +1,9 @@
+# This calls the main test_helper in Foreman-core
+require 'test_helper'
+require 'dynflow/testing'
+
+# Add plugin to FactoryBot's paths
+FactoryBot.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
+# Add foreman tasks factories too
+FactoryBot.definition_file_paths << "#{ForemanTasks::Engine.root}/test/factories"
+FactoryBot.reload

data/test/unit/actions/run_host_job_test.rb

@@ -0,0 +1,115 @@
+require 'test_plugin_helper'
+
+module ForemanRemoteExecution
+  class RunHostJobTest < ActiveSupport::TestCase
+    include Dynflow::Testing
+
+    subject { create_action(Actions::RemoteExecution::RunHostJob) }
+
+    describe '#secrets' do
+      let(:job_invocation) { FactoryBot.create(:job_invocation, :with_task) }
+      let(:host) { job_invocation.template_invocations.first.host }
+      let(:provider) do
+        provider = ::SSHExecutionProvider
+        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')
+        provider
+      end
+
+      it 'uses provider secrets' do
+        secrets = subject.secrets(host, job_invocation, provider)
+
+        assert_equal 'sshpass', secrets[:ssh_password]
+        assert_equal 'sudopass', secrets[:effective_user_password]
+        assert_equal 'keypass', secrets[:key_passphrase]
+      end
+
+      it 'prefers job secrets over provider secrets' do
+        job_invocation.password = 'jobsshpass'
+        job_invocation.key_passphrase = 'jobkeypass'
+        secrets = subject.secrets(host, job_invocation, provider)
+
+        assert_equal 'jobsshpass', secrets[:ssh_password]
+        assert_equal 'sudopass', secrets[:effective_user_password]
+        assert_equal 'jobkeypass', secrets[:key_passphrase]
+      end
+    end
+
+    describe '#verify_permission' do
+      let(:job_invocation) { FactoryBot.create(:job_invocation, :with_task) }
+      let(:template_invocation) { job_invocation.template_invocations.first }
+
+      before { job_invocation }
+
+      it 'raises an exception when run against an infrastructure host' do
+        template_invocation.host = FactoryBot.create(:host, :with_infrastructure_facet)
+
+        setup_user('view', 'hosts')
+        setup_user('view', 'job_templates')
+        setup_user('create', 'template_invocations')
+
+        action = Actions::RemoteExecution::RunHostJob.allocate
+        exception = assert_raises do
+          action.send(:verify_permissions, template_invocation.host, template_invocation)
+        end
+        assert_includes exception.message, "infrastructure host #{template_invocation.host.name}"
+      end
+    end
+
+    describe '#finalize' do
+      let(:host) { FactoryBot.create(:host, :with_execution) }
+
+      before do
+        subject.stubs(:input).returns({ host: { id: host.id } })
+        Host.expects(:find).with(host.id).returns(host)
+      end
+
+      describe 'updates the host status' do
+        before do
+          subject.expects(:check_exit_status).returns(nil)
+        end
+
+        context 'with stubbed status' do
+          let(:stub_status) do
+            status = HostStatus::ExecutionStatus.new
+            status.stubs(:save!).returns(true)
+            status
+          end
+
+          before do
+            host.expects(:execution_status_object).returns(stub_status)
+          end
+
+          context 'exit_status is 0' do
+            it 'updates the host status to OK' do
+              subject.stubs(:exit_status).returns(0)
+              stub_status.expects(:"status=").with(HostStatus::ExecutionStatus::OK)
+              subject.finalize
+            end
+          end
+
+          context 'exit_status is NOT 0' do
+            it 'updates the host status to ERROR' do
+              subject.stubs(:exit_status).returns(1)
+              stub_status.expects(:"status=").with(HostStatus::ExecutionStatus::ERROR)
+              subject.finalize
+            end
+          end
+        end
+
+        context 'host has no execution status yet' do
+          before do
+            assert_nil host.execution_status_object
+            subject.stubs(:exit_status).returns(0)
+          end
+
+          it 'creates a new status' do
+            subject.finalize
+            assert_not_nil host.execution_status_object
+          end
+        end
+      end
+    end
+  end
+end