foreman_remote_execution 14.1.0 → 14.1.2

data/test/unit/job_invocation_report_template_test.rb

@@ -0,0 +1,60 @@
+require 'test_plugin_helper'
+
+class JobReportTemplateTest < ActiveSupport::TestCase
+  class FakeTask < OpenStruct
+    class Jail < Safemode::Jail
+      allow :action_continuous_output, :result, :ended_at
+    end
+  end
+
+  context 'with valid job invocation report template' do
+    let(:job_invocation_template) do
+      file_path = File.read(File.expand_path(Rails.root + "app/views/unattended/report_templates/job_-_invocation_report.erb"))
+      template = ReportTemplate.import_without_save("Job Invocation Report Template", file_path)
+      template.save!
+      template
+    end
+
+    describe 'template setting' do
+      it 'in settings includes only report templates with job_id input' do
+        FactoryBot.create(:report_template, name: 'Template 1')
+        job_invocation_template
+        templates = ForemanRemoteExecution.job_invocation_report_templates_select
+
+        assert_include templates, 'Job Invocation Report Template'
+      end
+    end
+
+    describe 'task reporting' do
+      let(:fake_outputs) do
+        [
+          { 'output_type' => 'stderr', 'output' => "error" },
+          { 'output_type' => 'stdout', 'output' => "output" },
+          { 'output_type' => 'debug', 'output' => "debug" },
+        ]
+      end
+      let(:fake_task) { FakeTask.new(result: 'success', action_continuous_output: fake_outputs, :ended_at => Time.new(2020, 12, 1, 0, 0, 0).utc) }
+      let(:job_invocation) { FactoryBot.create(:job_invocation, :with_task) }
+      let(:host) { job_invocation.template_invocations.first.host }
+
+      it 'should render task outputs' do
+        JobInvocation.any_instance.expects(:sub_task_for_host).returns(fake_task)
+
+        input = job_invocation_template.template_inputs.first
+        composer_params = { template_id: job_invocation_template.id, input_values: { input.id.to_s => { value: job_invocation.id.to_s } } }
+        result = ReportComposer.new(composer_params).render
+
+        # parsing the CSV result
+        rows = CSV.parse(result.strip, headers: true)
+        assert_equal 1, rows.count
+        row = rows.first
+        assert_equal host.name, row['Host']
+        assert_equal 'success', row['Result']
+        assert_equal 'error', row['stderr']
+        assert_equal 'output', row['stdout']
+        assert_equal 'debug', row['debug']
+        assert_kind_of Time, Time.zone.parse(row['Finished']), 'Parsing of time column failed'
+      end
+    end
+  end
+end

data/test/unit/job_invocation_test.rb

@@ -0,0 +1,232 @@
+require 'test_plugin_helper'
+
+class JobInvocationTest < ActiveSupport::TestCase
+  let(:job_invocation) { FactoryBot.build(:job_invocation, :description => 'A text with "quotes"') }
+  let(:template) { FactoryBot.create(:job_template, :with_input) }
+
+  context 'search for job invocations' do
+    before do
+      job_invocation.save
+    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')
+      assert_equal [job_invocation], found_jobs
+    end
+
+    it 'is able to auto complete description' do
+      expected = 'description =  "A text with \"quotes\""'
+      assert_equal [expected], JobInvocation.complete_for('description = ')
+    end
+  end
+
+  context 'able to be created' do
+    it { assert job_invocation.save }
+  end
+
+  context 'requires targeting' do
+    before { job_invocation.targeting = nil }
+
+    it { refute_valid job_invocation }
+  end
+
+  context 'can delete a host' do
+    let(:host) do
+      FactoryBot.create(:host)
+    end
+
+    it 'can remove a host' do
+      job_invocation.template_invocations.build(:host_id => host.id, :template_id => template.id)
+      job_invocation.save!
+      host.destroy
+      job_invocation.reload
+      assert_empty job_invocation.template_invocations
+    end
+  end
+
+  context 'has template invocations with input values' do
+    let(:job_invocation) { FactoryBot.create(:job_invocation, :with_template) }
+
+    before do
+      input = job_invocation.pattern_template_invocations.first.template.template_inputs.create!(:name => 'foo', :required => true, :input_type => 'user')
+      input2 = job_invocation.pattern_template_invocations.first.template.template_inputs.create!(:name => 'bar', :required => true, :input_type => 'user')
+      FactoryBot.create(:template_invocation_input_value,
+        :template_invocation => job_invocation.pattern_template_invocations.first,
+        :template_input => input2)
+      @input_value = FactoryBot.create(:template_invocation_input_value,
+        :template_invocation => job_invocation.pattern_template_invocations.first,
+        :template_input => input)
+      job_invocation.reload
+      job_invocation.pattern_template_invocations.first.reload
+    end
+
+    it { assert_not job_invocation.reload.pattern_template_invocations.empty? }
+    it { assert_not job_invocation.reload.pattern_template_invocations.first.input_values.empty? }
+
+    it "can look up templates not belonging to user's organization" do
+      organization = job_invocation.pattern_template_invocations.first.template.organizations.first
+      Organization.current = organization
+      job_invocation.pattern_template_invocations.first.template.organizations = []
+      # The following line raises UndefinedMethod if the user can't look up the template
+      job_invocation.pattern_template_invocations.first.template.name
+
+      # Restore things to original state
+      job_invocation.pattern_template_invocations.first.template.organizations = [organization]
+      Organization.current = nil
+    end
+
+    it 'validates required inputs have values' do
+      assert job_invocation.valid?
+      @input_value.destroy
+      assert_not job_invocation.reload.valid?
+    end
+
+    describe 'descriptions' do
+      it 'generates description from input values' do
+        job_invocation.description_format = '%{job_category} - %{foo}'
+        job_invocation.generate_description
+        assert_equal "#{job_invocation.job_category} - #{@input_value.value}", job_invocation.description
+      end
+
+      it 'handles missing keys correctly' do
+        job_invocation.description_format = '%{job_category} - %{missing_key}'
+        job_invocation.generate_description
+        assert_equal "#{job_invocation.job_category} - ''", job_invocation.description
+      end
+
+      it 'truncates generated description to 255 characters' do
+        column_limit = 255 # There is a 255 character limit on the database level
+        expected_result = 'a' * column_limit
+        job_invocation.description_format = '%{job_category}'
+        job_invocation.job_category = 'a' * 1000
+        job_invocation.generate_description
+        assert_equal expected_result, job_invocation.description
+      end
+    end
+  end
+
+  context 'future execution' do
+    it 'can report host count' do
+      assert_equal 'N/A', job_invocation.total_hosts_count
+      job_invocation.targeting.expects(:resolved_at).returns(Time.now.getlocal)
+      assert_equal 0, job_invocation.total_hosts_count
+    end
+
+    # task does not exist
+    specify { assert_equal HostStatus::ExecutionStatus::QUEUED, job_invocation.status }
+    specify { assert_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::QUEUED], job_invocation.status_label }
+    specify { assert_equal 0, job_invocation.progress }
+  end
+
+  context 'with task' do
+    let(:task) { ForemanTasks::Task.new }
+    let(:progress_report_without_sub_tasks) do
+      {
+        :error     => 0,
+        :warning   => 0,
+        :total     => 0,
+        :success   => 0,
+        :cancelled => 0,
+        :failed    => 0,
+        :pending   => 0,
+        :progress  => 0,
+        :running   => 0,
+      }
+    end
+    before { job_invocation.task = task }
+
+    context 'which is scheduled' do
+      before { task.state = 'scheduled' }
+
+      specify { assert_equal HostStatus::ExecutionStatus::QUEUED, job_invocation.status }
+      specify { assert job_invocation.queued? }
+      specify { assert_equal 0, job_invocation.progress }
+      specify { assert_equal progress_report_without_sub_tasks, job_invocation.progress_report }
+    end
+
+    context 'with cancelled task' do
+      before do
+        task.state = 'stopped'
+        task.result = 'error'
+      end
+
+      it 'calculates the progress correctly' do
+        job_invocation.targeting.stubs(:resolved?).returns(true)
+        task.expects(:sub_tasks_counts).never
+        assert_equal progress_report_without_sub_tasks, job_invocation.progress_report
+      end
+    end
+
+    context 'with succeeded task' do
+      before do
+        task.state = 'stopped'
+        task.result = 'success'
+      end
+
+      specify { assert_equal HostStatus::ExecutionStatus::OK, job_invocation.status }
+      specify { refute job_invocation.queued? }
+
+      it 'calculates the progress correctly' do
+        sub_tasks = [ForemanTasks::Task.new]
+        job_invocation.targeting.expects(:resolved?).returns(true)
+        job_invocation.targeting.expects(:hosts).returns([1])
+        sub_tasks.expects(:where).with(:result => %w(success warning error)).returns(sub_tasks)
+        job_invocation.stubs(:sub_tasks).returns(sub_tasks)
+
+        assert_equal 100, job_invocation.progress
+      end
+    end
+  end
+
+  describe '#finished?' do
+    let(:task) { ForemanTasks::Task.new }
+    before { job_invocation.task = task }
+
+    it 'returns false if task state is pending' do
+      job_invocation.task.expects(:pending?).returns(true)
+      assert_not job_invocation.finished?
+    end
+
+    it 'returns true if task is not pending' do
+      job_invocation.task.expects(:pending?).returns(false)
+      assert job_invocation.finished?
+    end
+  end
+
+  describe '#failed_hosts' do
+    let(:invocation) do
+      invocation = FactoryBot.build(:job_invocation, :with_template, :with_task, :with_failed_task, :with_unplanned_host)
+      invocation.template_invocations.each { |ti| invocation.targeting.hosts << ti.host }
+      invocation.save!
+      invocation
+    end
+
+    it 'returns only failed hosts when not #finished?' do
+      invocation.stubs(:finished?).returns(false)
+      assert_equal 1, invocation.failed_hosts.count
+    end
+
+    it 'returns failed hosts and hosts without task when #finished?' do
+      invocation.stubs(:finished?).returns(true)
+      assert_equal 2, invocation.failed_hosts.count
+    end
+
+    describe '#failed_template_invocations' do
+      it 'finds only failed template invocations' do
+        template_invocations = invocation.send(:failed_template_invocations)
+        assert_equal 1, template_invocations.count
+        template_invocation = template_invocations.first
+        assert_equal 'error', template_invocation.run_host_job_task.result
+      end
+    end
+
+    describe '#not_failed_template_invocations' do
+      it 'finds only non-failed template invocations' do
+        template_invocations = invocation.send(:not_failed_template_invocations)
+        assert_equal 1, template_invocations.count
+        template_invocation = template_invocations.first
+        assert_equal 'success', template_invocation.run_host_job_task.result
+      end
+    end
+  end
+end

data/test/unit/job_template_effective_user_test.rb

@@ -0,0 +1,37 @@
+require 'test_plugin_helper'
+
+class JobTemplateEffectiveUserTest < ActiveSupport::TestCase
+  let(:job_template) { FactoryBot.build(:job_template, :job_category => '') }
+  let(:effective_user) { job_template.effective_user }
+
+  describe 'by default' do
+    it 'is overridable' do
+      assert effective_user.overridable?
+    end
+
+    it 'does not use the current user' do
+      assert_not effective_user.current_user?
+    end
+  end
+
+  describe 'compute value' do
+    it 'computes the value based on the current user when current_user set to true' do
+      user = FactoryBot.create(:user)
+      User.current = user
+      effective_user.current_user = true
+      assert_equal user.login, effective_user.compute_value
+    end
+
+    it 'returns the value when not current user is set to true' do
+      effective_user.current_user = false
+      effective_user.value = 'testuser'
+      assert_equal 'testuser', effective_user.compute_value
+    end
+
+    it 'returns a default value when no value is specified for the user' do
+      effective_user.value = ''
+      Setting[:remote_execution_effective_user] = 'myuser'
+      assert_equal 'myuser', effective_user.compute_value
+    end
+  end
+end

data/test/unit/job_template_test.rb

@@ -0,0 +1,316 @@
+require 'test_plugin_helper'
+
+class JobTemplateTest < ActiveSupport::TestCase
+  context 'when creating a template' do
+    let(:job_template) { FactoryBot.build(:job_template, :job_category => '') }
+    let(:template_with_inputs) do
+      FactoryBot.build(:job_template, :template => 'test').tap do |template|
+        template.template_inputs << FactoryBot.build(:template_input, :name => 'command', :input_type => 'user')
+        template.save!
+      end
+    end
+
+    it 'has a unique name' do
+      template1 = FactoryBot.create(:job_template)
+      template2 = FactoryBot.build(:job_template, :name => template1.name)
+      assert_not template2.valid?
+    end
+
+    it 'needs a job_category' do
+      assert_not job_template.valid?
+    end
+
+    it 'does not need a job_category if it is a snippet' do
+      job_template.snippet = true
+      assert job_template.valid?
+    end
+
+    it 'validates the inputs are uniq in the template' do
+      job_template.job_category = 'Miscellaneous'
+      job_template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => template_with_inputs)
+      job_template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => template_with_inputs)
+      assert_not job_template.valid?
+      assert_includes job_template.errors.full_messages.first, 'Duplicated inputs detected: ["command"]'
+    end
+  end
+
+  context 'description format' do
+    let(:template_with_description) { FactoryBot.build(:job_template, :with_description_format, :job_category => 'test job') }
+    let(:template) { FactoryBot.build(:job_template, :with_input, :job_category => 'test job') }
+    let(:minimal_template) { FactoryBot.build(:job_template) }
+
+    it 'uses the description_format attribute if set' do
+      assert_equal template_with_description.generate_description_format, template_with_description.description_format
+    end
+
+    it 'uses the job name as description_format if not set or blank and has no inputs' do
+      assert_equal minimal_template.generate_description_format, '%{template_name}'
+      minimal_template.description_format = ''
+      assert_equal minimal_template.generate_description_format, '%{template_name}'
+    end
+
+    it 'generates the description_format if not set or blank and has inputs' do
+      input_name = template.template_inputs.first.name
+      expected_result = %(%{template_name} with inputs #{input_name}="%{#{input_name}}")
+      assert_equal template.generate_description_format, expected_result
+      template.description_format = ''
+      assert_equal template.generate_description_format, expected_result
+    end
+  end
+
+  context 'cloning' do
+    let(:job_template) { FactoryBot.build(:job_template, :with_input) }
+
+    describe '#dup' do
+      it 'duplicates also template inputs' do
+        duplicate = job_template.dup
+        refute_equal duplicate, job_template
+        refute_empty duplicate.template_inputs
+        refute_equal duplicate.template_inputs.first, job_template.template_inputs.first
+        assert_equal duplicate.template_inputs.first.name, job_template.template_inputs.first.name
+      end
+    end
+  end
+
+  context 'importing a new template' do
+    let(:remote_execution_feature) do
+      FactoryBot.create(:remote_execution_feature)
+    end
+
+    let(:template) do
+      template = <<-END_TEMPLATE
+      <%#
+      kind: job_template
+      name: Service Restart
+      job_category: Service Restart
+      provider_type: SSH
+      feature: #{remote_execution_feature.label}
+      template_inputs:
+      - name: service_name
+        input_type: user
+        required: true
+      - name: verbose
+        input_type: user
+      %>
+
+      service <%= input("service_name") %> restart
+
+      <%# test comment %>
+      END_TEMPLATE
+
+      JobTemplate.import_raw!(template, :default => true)
+    end
+
+    let(:template_with_input_sets) do
+      template_with_input_sets = <<-END_TEMPLATE
+      <%#
+      kind: job_template
+      name: Service Restart - Custom
+      job_category: Service Restart
+      provider_type: SSH
+      foreign_input_sets:
+      - template: #{template.name}
+        exclude: verbose
+      %>
+
+      service <%= input("service_name") %> restart
+      END_TEMPLATE
+
+      JobTemplate.import_raw!(template_with_input_sets, :default => true)
+    end
+
+    it 'sets the name' do
+      assert_equal template.name, 'Service Restart'
+    end
+
+    it 'has a template' do
+      assert_equal template.template.squish, 'service <%= input("service_name") %> restart <%# test comment %>'
+    end
+
+    it 'imports inputs' do
+      assert_equal template.template_inputs.first.name, 'service_name'
+    end
+
+    it 'imports input sets' do
+      assert_equal template_with_input_sets.foreign_input_sets.first.target_template, template
+      assert_equal template_with_input_sets.template_inputs_with_foreign.map(&:name), ['service_name']
+    end
+
+    it 'imports feature' do
+      template # let is lazy
+      remote_execution_feature.reload
+      assert_equal remote_execution_feature.job_template, template
+    end
+
+    it 'sets additional options' do
+      assert_equal template.default, true
+    end
+  end
+
+  context 'importing an existing template' do
+    let(:included) do
+      template = <<-END_TEMPLATE
+      <%#
+      kind: job_template
+      name: Banner
+      job_category: Commands
+      provider_type: SSH
+      template_inputs:
+      - name: banner_message
+        input_type: user
+        required: true
+      %>
+
+      echo input(:banner_message)
+      END_TEMPLATE
+
+      JobTemplate.import_raw!(template, :default => true)
+    end
+
+    let(:existing) do
+      template = <<-END_TEMPLATE
+      <%#
+      kind: job_template
+      name: Ping a Thing
+      job_category: Commands
+      provider_type: SSH
+      template_inputs:
+      - name: hostname
+        input_type: user
+        options: "www.google.com"
+        required: true
+      foreign_input_sets:
+        - template: #{included.name}
+      %>
+
+      ping -c 5 <%= input("hostname") %>
+      END_TEMPLATE
+
+      JobTemplate.import_raw!(template, :default => true)
+    end
+
+    let(:updated) do
+      <<-END_TEMPLATE
+      <%#
+      kind: job_template
+      name: Ping a Thing
+      job_category: Commands
+      provider_type: SSH
+      template_inputs:
+      - name: hostname
+        input_type: user
+        options: 'www.redhat.com'
+        required: true
+      - name: count
+        input_type: user
+        required: true
+      foreign_input_sets:
+        - template: #{included.name}
+          exclude: banner_message
+      %>
+
+      ping -c <%= input('count') %> <%= input('hostname') %>
+      END_TEMPLATE
+    end
+
+    it 'will not overwrite by default' do
+      existing
+      assert_not JobTemplate.import_raw!(updated)
+    end
+
+    let(:synced_template) do
+      existing
+      JobTemplate.import_raw!(updated, :update => true)
+      existing.reload
+    end
+
+    it 'syncs inputs' do
+      hostname = synced_template.template_inputs.find { |input| input.name == 'hostname' }
+      assert_equal hostname.options, 'www.redhat.com'
+    end
+
+    it 'syncs content' do
+      assert_match(/ping -c <%= input\('count'\) %> <%= input\('hostname'\) %>/m, synced_template.template)
+    end
+
+    it 'syncs input sets' do
+      assert_equal synced_template.foreign_input_sets.first.target_template, included
+      assert_equal synced_template.template_inputs_with_foreign.map(&:name), ['hostname', 'count']
+    end
+  end
+
+  context 'template export' do
+    let(:exportable_template) do
+      FactoryBot.create(:job_template, :with_input)
+    end
+
+    let(:erb) do
+      exportable_template.to_erb
+    end
+
+    it 'exports name' do
+      assert_match(/^name: #{exportable_template.name}$/, erb)
+    end
+
+    it 'includes template inputs' do
+      assert_match(/^template_inputs:$/, erb)
+    end
+
+    it 'includes template contents' do
+      assert_includes erb, exportable_template.template
+    end
+
+    it 'is importable' do
+      erb
+      old_name = exportable_template.name
+      exportable_template.update(:name => "#{old_name}_renamed")
+
+      imported = JobTemplate.import_raw!(erb)
+      assert_equal imported.name, old_name
+      assert_equal imported.template_inputs.first.to_export, exportable_template.template_inputs.first.to_export
+    end
+
+    it 'has taxonomies in metadata' do
+      assert_equal 'Organization 1', exportable_template.to_export["organizations"].first
+      assert_equal 'Location 1', exportable_template.to_export["locations"].first
+    end
+  end
+
+  context 'there is existing template invocation of a job template' do
+    let(:job_invocation) { FactoryBot.create(:job_invocation, :with_template) }
+    let(:job_template) { job_invocation.pattern_template_invocations.first.template }
+
+    describe 'job template deletion' do
+      it 'succeeds' do
+        refute_empty job_template.pattern_template_invocations
+        assert job_template.destroy
+      end
+    end
+  end
+
+  context 'template locked' do
+    it 'inputs cannot be changed' do
+      job_template = FactoryBot.create(:job_template, :with_input, :locked => true)
+      Foreman.expects(:in_rake?).returns(false).at_least_once
+      assert_valid job_template
+      job_template.template_inputs.first.name = 'something else'
+      refute_valid job_template
+    end
+  end
+
+  context 'rendering' do
+    it 'renders nested template as a non-admin user' do
+      inner = FactoryBot.create(:job_template)
+      template_invocation = FactoryBot.create(:template_invocation)
+      template_invocation.template.template = "<wrap><%= render_template('#{inner.name}') %></wrap>"
+      template_invocation.template.save!
+
+      setup_user('view', 'job_templates')
+      renderer = InputTemplateRenderer.new template_invocation.template,
+        template_invocation.host,
+        template_invocation
+      result = renderer.render
+      assert_equal result, "<wrap>#{inner.template}</wrap>"
+    end
+  end
+end