foreman_remote_execution 14.0.0 → 14.1.0

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

data/test/unit/input_template_renderer_test.rb

@@ -1,503 +0,0 @@
-require 'test_plugin_helper'
-
-class InputTemplateRendererTest < ActiveSupport::TestCase
-  let(:host) { FactoryBot.build(:host) }
-
-  context 'renderer for simple template without inputs' do
-    let(:renderer) { InputTemplateRenderer.new(FactoryBot.build(:job_template, :template => 'id <%= preview? %>')) }
-
-    it 'should render the content' do
-      assert_equal 'id false', renderer.render
-    end
-
-    it 'should render preview' do
-      assert_equal 'id true', renderer.preview
-    end
-
-    it 'should allow accessing current_user' do
-      setup_user(:view_job_templates)
-      renderer = InputTemplateRenderer.new(FactoryBot.build(:job_template, :template => "They call me '<%= current_user %>'"))
-      assert_equal "They call me '#{User.current.login}'", renderer.preview
-    end
-  end
-
-  context 'renderer for template with user input used' do
-    let(:template) { FactoryBot.build(:job_template, :template => 'service restart <%= input("service_name") -%>') }
-    let(:renderer) { InputTemplateRenderer.new(template) }
-
-    context 'but without input defined' do
-      describe 'rendering' do
-        let(:result) { renderer.render }
-        it 'should return false' do
-          refute result
-        end
-
-        it 'should register an error' do
-          result # let is lazy
-          assert_not_nil renderer.error_message
-          assert_not_empty renderer.error_message
-        end
-      end
-
-      describe 'preview' do
-        let(:result) { renderer.preview }
-        it 'should return false' do
-          refute result
-        end
-
-        it 'should register an error' do
-          result # let is lazy
-          assert_not_nil renderer.error_message
-          assert_not_empty renderer.error_message
-        end
-      end
-    end
-
-    context 'with matching input defined' do
-
-      let(:job_invocation) { FactoryBot.create(:job_invocation) }
-      let(:template_invocation) { FactoryBot.build(:template_invocation, :template => template) }
-      let(:result) { renderer.render }
-
-      before do
-        template.template_inputs << FactoryBot.build(:template_input, :name => 'service_name', :input_type => 'user')
-        job_invocation.template_invocations << template_invocation
-      end
-
-      describe 'rendering' do
-        it 'can preview' do
-          assert_equal 'service restart $USER_INPUT[service_name]', renderer.preview
-        end
-
-        context 'with invocation specified and a required input' do
-          before do
-            template.template_inputs.first.update(:required => true)
-            template_invocation.reload
-            renderer.invocation = template_invocation
-          end
-
-          it 'cannot render the content' do
-            assert_not result
-            refute_nil renderer.error_message
-            refute_empty renderer.error_message
-          end
-        end
-
-        context 'with invocation specified' do
-          before do
-            FactoryBot.create(:template_invocation_input_value,
-              :template_invocation => template_invocation,
-              :template_input => template.template_inputs.first,
-              :value => 'foreman')
-            template_invocation.reload # need to get input_values findable
-            renderer.invocation = template_invocation
-          end
-
-          it 'can render with job invocation with corresponding value' do
-            assert_equal 'service restart foreman', renderer.render
-          end
-        end
-
-        it 'renders even without an input value' do
-          renderer.invocation = template_invocation
-          assert_equal 'service restart ', renderer.render
-        end
-
-        describe 'with circular reference' do
-          let(:recursive_template_with_inputs) do
-            FactoryBot.create(:job_template, :name => 'test', :template => 'test')
-          end
-
-          let(:template_with_inputs) do
-            FactoryBot.create(:job_template, :template => 'test').tap do |template|
-              template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => recursive_template_with_inputs)
-            end
-          end
-
-          let(:recursive_template_without_inputs) do
-            FactoryBot.create(:job_template, :name => 'recursive template', :template => '<%= render_template("template with inputs", "action" => "install") %>')
-          end
-
-          let(:template_without_inputs) do
-            FactoryBot.create(:job_template, :name => 'template with inputs', :template => "<%= render_template('#{recursive_template_without_inputs.name}') %>")
-          end
-
-          before do
-            User.current = users :admin
-          end
-
-          it 'handles circular references in templates' do
-            renderer.invocation = FactoryBot.build(:template_invocation, :template => template_without_inputs)
-            renderer.template = template_without_inputs
-            assert_not renderer.render
-            assert_includes renderer.error_message, 'Recursive rendering of templates detected'
-          end
-
-          it 'handles circular references in inputs' do
-            assert_raises(ActiveRecord::RecordInvalid) do
-              input_set = FactoryBot.build(:foreign_input_set, :target_template => template_with_inputs, :include_all => false,
-                                                               :include => 'package, debug', :exclude => 'action,debug')
-              recursive_template_with_inputs.foreign_input_sets << input_set
-              recursive_template_with_inputs.save!
-            end
-          end
-        end
-      end
-    end
-
-    context 'renderer for template with input set and render_template' do
-      let(:command_template) do
-        FactoryBot.build(:job_template, :name => 'command action', :template => '<%= input("command") -%>').tap do |template|
-          template.template_inputs << FactoryBot.build(:template_input, :name => 'command', :input_type => 'user')
-          template.template_inputs << FactoryBot.build(:template_input, :name => 'debug', :input_type => 'user')
-        end
-      end
-
-      let(:package_template) do
-        FactoryBot.build(:job_template, :name => 'package action', :template => <<-TEMPLATE.strip_heredoc) do |template|
-          <%= render_template("command action", "command" => "yum -y \#{ input("action") } \#{ input('package') }") -%>
-        TEMPLATE
-          template.template_inputs << FactoryBot.build(:template_input, :name => 'package', :input_type => 'user')
-          template.template_inputs << FactoryBot.build(:template_input, :name => 'action', :input_type => 'user')
-          template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => command_template, :include_all => true, :exclude => 'command')
-        end
-      end
-
-      let(:template) do
-        FactoryBot.create(:job_template,
-          :template => '<%= render_template("package action", { :action => "install" }, { :with_foreign_input_set => true }) %>').tap do |template|
-          template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => package_template, :include_all => true, :exclude => 'action')
-        end
-      end
-
-      let(:job_invocation) { FactoryBot.create(:job_invocation) }
-      let(:template_invocation) { FactoryBot.build(:template_invocation, :template => template) }
-      let(:renderer) { InputTemplateRenderer.new(template) }
-      let(:result) { renderer.render }
-
-      before do
-        User.current = users :admin
-        command_template.save!
-        package_template.save!
-        job_invocation.template_invocations << template_invocation
-      end
-
-      describe 'foreign input set' do
-        describe 'with include_all' do
-          let(:template) do
-            FactoryBot.create(:job_template, :template => '<%= render_template("package action", "action" => "install") %>').tap do |template|
-              template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => package_template, :include_all => true)
-            end
-          end
-
-          let(:template_2) do
-            FactoryBot.create(:job_template, :template => '<%= render_template("package action", "action" => "install") %>').tap do |template|
-              template.foreign_input_sets << FactoryBot.build(:foreign_input_set,
-                :target_template => package_template, :include_all => true, :include => '', :exclude => '')
-            end
-          end
-
-          it 'includes all inputs from the imported template' do
-            assert_equal ['action', 'debug', 'package'], template.template_inputs_with_foreign.map(&:name).sort
-            assert_equal ['action', 'debug', 'package'], template_2.template_inputs_with_foreign.map(&:name).sort
-          end
-        end
-
-        describe 'with include_all and some excludes' do
-          let(:template) do
-            FactoryBot.create(:job_template, :template => '<%= render_template("package action", "action" => "install") %>').tap do |template|
-              template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => package_template, :include_all => true, :exclude => 'action,debug')
-            end
-          end
-
-          it 'includes all inputs from the imported template except the listed once' do
-            assert_equal ['package'], template.template_inputs_with_foreign.map(&:name).sort
-          end
-        end
-
-        describe 'with some includes and some excludes' do
-          let(:template) do
-            FactoryBot.create(:job_template, :template => '<%= render_template("package action", "action" => "install") %>').tap do |template|
-              template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => package_template, :include_all => false,
-                                                                                  :include => 'package, debug', :exclude => 'action,debug')
-            end
-          end
-
-          it 'includes all inputs from the imported template' do
-            assert_equal ['package'], template.template_inputs_with_foreign.map(&:name).sort
-          end
-        end
-      end
-
-      context 'with invocation specified' do
-        before do
-          FactoryBot.create(:template_invocation_input_value,
-            :template_invocation => template_invocation,
-            :template_input => template.template_inputs_with_foreign.find { |input| input.name == 'package' },
-            :value => 'zsh')
-          renderer.invocation = template_invocation
-          renderer.invocation.reload
-        end
-
-        it 'can render with job invocation with corresponding value' do
-          rendered = renderer.render
-          assert_nil renderer.error_message
-          assert_equal 'yum -y install zsh', rendered
-        end
-      end
-
-      context 'with explicitly specifying inputs' do
-        let(:template) do
-          FactoryBot.create(:job_template,
-            :template => '<%= render_template("package action", {"action" => "install", :package => "zsh"}) %>')
-        end
-
-        before do
-          template_invocation.reload
-          renderer.invocation = template_invocation
-        end
-
-        it 'can render with job invocation with corresponding value' do
-          rendered = renderer.render
-          assert_nil renderer.error_message
-          assert_equal 'yum -y install zsh', rendered
-        end
-      end
-
-      it 'renders even without an input value' do
-        renderer.invocation = template_invocation
-        rendered = renderer.render
-        assert_nil renderer.error_message
-        assert_equal 'yum -y install ', rendered
-      end
-    end
-
-    context 'with options specified' do
-      let(:job_invocation) { FactoryBot.create(:job_invocation) }
-      let(:template_invocation) { FactoryBot.build(:template_invocation, :template => template) }
-      let(:result) { renderer.render }
-      let(:required) { false }
-      let(:input) do
-        FactoryBot.create(:template_invocation_input_value,
-          :template_invocation => template_invocation,
-          :template_input => template.template_inputs.first,
-          :value => 'foreman')
-      end
-
-      before do
-        template.template_inputs << FactoryBot.build(:template_input, :name => 'service_name', :input_type => 'user', :options => "httpd\nforeman", :required => required)
-        job_invocation.template_invocations << template_invocation
-        input
-        template_invocation.reload
-        renderer.invocation = template_invocation
-      end
-
-      context 'with a valid input defined' do
-        context 'with an optional input' do
-          it 'can render with job invocation with corresponding value' do
-            assert_equal 'service restart foreman', result
-          end
-        end
-
-        context 'with required input' do
-          let(:required) { true }
-
-          it 'renders the template when the input is provided' do
-            assert_equal 'service restart foreman', result
-          end
-        end
-      end
-
-      context 'without provided input' do
-        let(:input) { nil }
-
-        context 'with optional input' do
-          it 'renders the template' do
-            assert_equal 'service restart ', result
-          end
-        end
-
-        context 'with required input' do
-          let(:required) { true }
-
-          it 'renders the template' do
-            result
-            assert_match(/Value for required input '.*' was not specified/, renderer.error_message)
-          end
-        end
-      end
-    end
-  end
-
-  context 'renderer for template with fact input used' do
-    let(:template) { FactoryBot.build(:job_template, :template => 'echo <%= input("issue") -%> > /etc/issue') }
-    let(:renderer) { InputTemplateRenderer.new(template) }
-
-    context 'with matching input defined' do
-      before { renderer.template.template_inputs<< FactoryBot.build(:template_input, :name => 'issue', :input_type => 'fact', :fact_name => 'issue', :required => true) }
-      let(:result) { renderer.render }
-
-      describe 'rendering' do
-        it 'can\'t render the content without host since we don\'t have facts' do
-          assert_not result
-        end
-
-        it 'registers an error' do
-          result # let is lazy
-          assert_not_nil renderer.error_message
-          assert_not_empty renderer.error_message
-        end
-
-        context 'with host specified' do
-          before { renderer.host = FactoryBot.create(:host) }
-
-          describe 'rendering' do
-            it 'can\'t render the content without host since we don\'t have fact value' do
-              assert_not result
-            end
-
-            it 'registers an error' do
-              result # let is lazy
-              assert_not_nil renderer.error_message
-              assert_not_empty renderer.error_message
-            end
-          end
-
-          describe 'preview' do
-            it 'should render preview' do
-              assert_equal 'echo $FACT_INPUT[issue] > /etc/issue', renderer.preview
-            end
-          end
-
-          context 'with existing fact' do
-            let(:fact) { FactoryBot.create(:fact_name, :name => 'issue') }
-
-            describe 'rendering' do
-              it 'can\'t render the content without host since we don\'t have fact value' do
-                fact # let is lazy
-                assert_not result
-              end
-
-              it 'registers an error' do
-                result # let is lazy
-                assert_not_nil renderer.error_message
-                assert_not_empty renderer.error_message
-              end
-            end
-
-            describe 'preview' do
-              it 'should render preview' do
-                assert_equal 'echo $FACT_INPUT[issue] > /etc/issue', renderer.preview
-              end
-            end
-
-            context 'with fact issue value' do
-              before { FactoryBot.create(:fact_value, :host => renderer.host, :fact_name => fact, :value => 'banner') }
-
-              let(:result) { renderer.render }
-
-              it 'can render with job invocation with corresponding value' do
-                assert_equal 'echo banner > /etc/issue', result
-              end
-            end
-          end
-        end
-      end
-
-      describe 'preview' do
-        it 'should render preview' do
-          assert_equal 'echo $FACT_INPUT[issue] > /etc/issue', renderer.preview
-        end
-
-        context 'with host specified' do
-          before do
-            host = FactoryBot.create(:host)
-            fact = FactoryBot.create(:fact_name, :name => 'issue')
-            FactoryBot.create(:fact_value, :host => host, :fact_name => fact, :value => 'banner')
-            renderer.host = host
-          end
-
-          let(:result) { renderer.render }
-
-          it 'uses the value even in preview' do
-            assert_equal 'echo banner > /etc/issue', result
-          end
-        end
-      end
-    end
-  end
-
-  context 'renderer for template with variable input used' do
-    let(:template) { FactoryBot.build(:job_template, :template => 'echo <%= input("client_key") -%> > /etc/chef/client.pem') }
-    let(:renderer) { InputTemplateRenderer.new(template) }
-
-    context 'with matching input defined' do
-      before { renderer.template.template_inputs<< FactoryBot.build(:template_input, :name => 'client_key', :input_type => 'variable', :variable_name => 'client_key') }
-      let(:result) { renderer.render }
-
-      describe 'rendering' do
-        it 'can\'t render the content without host since we don\'t have host so no classification' do
-          assert_not result
-        end
-
-        it 'registers an error' do
-          result # let is lazy
-          refute_nil renderer.error_message
-          refute_empty renderer.error_message
-        end
-
-        context 'with host specified' do
-          before { User.current = FactoryBot.build(:user, :admin) }
-          after { User.current = nil }
-
-          before { renderer.host = FactoryBot.create(:host) }
-
-          describe 'rendering' do
-            it 'can\'t render the content without host since we don\'t have variable value in classification' do
-              assert_not result
-            end
-
-            it 'registers an error' do
-              result # let is lazy
-              refute_nil renderer.error_message
-              refute_empty renderer.error_message
-            end
-          end
-
-          describe 'preview' do
-            it 'should render preview' do
-              assert_equal 'echo $VARIABLE_INPUT[client_key] > /etc/chef/client.pem', renderer.preview
-            end
-          end
-
-
-          context 'with existing variable implemented as host parameter' do
-            let(:parameter) { FactoryBot.create(:host_parameter, :host => renderer.host, :name => 'client_key', :value => 'RSA KEY') }
-
-            describe 'rendering' do
-              it 'renders the value from host parameter' do
-                parameter
-                renderer.host.reload
-                assert_equal 'echo RSA KEY > /etc/chef/client.pem', result
-              end
-            end
-
-            describe 'preview' do
-              it 'should render preview' do
-                parameter
-                renderer.host.reload
-                assert_equal 'echo RSA KEY > /etc/chef/client.pem', renderer.preview
-              end
-            end
-          end
-        end
-
-        describe 'preview' do
-          it 'should render preview' do
-            assert_equal 'echo $VARIABLE_INPUT[client_key] > /etc/chef/client.pem', renderer.preview
-          end
-        end
-      end
-    end
-  end
-end