foreman_remote_execution 14.0.2 → 14.1.0

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

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

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

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

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

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

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

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

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

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

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

data/test/test_plugin_helper.rb

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

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