foreman_remote_execution 0.1.2 → 0.2.1

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

@@ -10,7 +10,7 @@ module Api
       test 'should get index' do
         get :index
         templates = ActiveSupport::JSON.decode(@response.body)
-        assert !templates.empty?, "Should response with template"
+        assert !templates.empty?, 'Should response with template'
         assert_response :success
       end
 
@@ -19,15 +19,15 @@ module Api
         assert_response :success
         template = ActiveSupport::JSON.decode(@response.body)
         assert !template.empty?
-        assert_equal template["name"], @template.name
+        assert_equal template['name'], @template.name
       end
 
       test 'should create valid' do
         JobTemplate.any_instance.stubs(:valid?).returns(true)
-        valid_attrs = { :template => "This is a test template", :name => "RandomName", :provider_type => 'ssh' }
+        valid_attrs = { :template => 'This is a test template', :name => 'RandomName', :provider_type => 'ssh' }
         post :create,  :job_template => valid_attrs
         template = ActiveSupport::JSON.decode(@response.body)
-        assert template["name"] == "RandomName"
+        assert template['name'] == 'RandomName'
         assert_response :success
       end
 
@@ -39,13 +39,13 @@ module Api
       test 'should update valid' do
         JobTemplate.any_instance.stubs(:valid?).returns(true)
         put :update,  :id => @template.to_param,
-                      :job_template => { :template => "blah" }
+                      :job_template => { :template => 'blah' }
         assert_response :ok
       end
 
       test 'should not update invalid' do
         put :update,  :id => @template.to_param,
-                      :job_template => { :name => "" }
+                      :job_template => { :name => '' }
         assert_response :unprocessable_entity
       end
 

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

@@ -11,7 +11,7 @@ module Api
       test 'should get index' do
         get :index, :template_id => @template.id
         inputs = ActiveSupport::JSON.decode(@response.body)
-        assert !inputs.empty?, "Should respond with inputs"
+        assert !inputs.empty?, 'Should respond with inputs'
         assert_response :success
       end
 
@@ -20,7 +20,7 @@ module Api
         assert_response :success
         input = ActiveSupport::JSON.decode(@response.body)
         assert !input.empty?
-        assert_equal input["name"], @input.name
+        assert_equal input['name'], @input.name
       end
 
       test 'should create valid' do
@@ -39,7 +39,7 @@ module Api
       test 'should update valid' do
         put :update,  :template_id => @template.to_param,
                       :id => @input.to_param,
-                      :template_input => { :name => "blah" }
+                      :template_input => { :name => 'blah' }
         assert_response :ok
       end
 

data/test/unit/actions/run_hosts_job_test.rb

@@ -1,12 +1,12 @@
 
-require "test_plugin_helper"
+require 'test_plugin_helper'
 
 module ForemanRemoteExecution
   class RunHostsJobTest < ActiveSupport::TestCase
     include Dynflow::Testing
 
     let(:host) { FactoryGirl.create(:host, :with_execution) }
-    let(:proxy) { host.remote_execution_proxies('Ssh')[:subnet].first }
+    let(:proxy) { host.remote_execution_proxies('SSH')[:subnet].first }
     let(:targeting) { FactoryGirl.create(:targeting, :search_query => "name = #{host.name}", :user => User.current) }
     let(:job_invocation) do
       FactoryGirl.build(:job_invocation, :with_template).tap do |invocation|
@@ -39,8 +39,7 @@ module ForemanRemoteExecution
     end
 
     it 'triggers the RunHostJob actions on the resolved hosts in run phase' do
-      template_invocation = job_invocation.template_invocation_for_host(host)
-      action.expects(:trigger).with(Actions::RemoteExecution::RunHostJob, job_invocation, host, template_invocation, proxy)
+      action.expects(:trigger).with() { |*args| args[0] == Actions::RemoteExecution::RunHostJob }
       action.create_sub_plans
     end
 

data/test/unit/actions/run_proxy_command_test.rb

@@ -1,11 +1,11 @@
-require "test_plugin_helper"
+require 'test_plugin_helper'
 
 module ForemanRemoteExecution
   class RunProxyCommandTest < ActiveSupport::TestCase
     include Dynflow::Testing
 
     let(:host) { FactoryGirl.build(:host, :with_execution) }
-    let(:proxy) { host.remote_execution_proxies('Ssh')[:subnet].first }
+    let(:proxy) { host.remote_execution_proxies('SSH')[:subnet].first }
     let(:hostname) { 'myhost.example.com' }
     let(:script) { 'ping -c 5 redhat.com' }
     let(:connection_options) { { 'retry_interval' => 15, 'retry_count' => 4, 'timeout' => 60 } }
@@ -50,7 +50,7 @@ module ForemanRemoteExecution
       describe 'when the task is finished' do
         before do
           task.state = 'stopped'
-          task.ended_at = timestamp + 1
+          task.ended_at = Time.at(timestamp + 1)
         end
 
         describe 'the task finished sucessfully' do
@@ -88,10 +88,10 @@ module ForemanRemoteExecution
 
       describe 'when something went wrong while fetching the data' do
         before do
-          action.proxy.expects(:status_of_task).raises("Something went wrong")
+          action.proxy.expects(:status_of_task).raises('Something went wrong')
         end
 
-        it "reports the failure as part of the live output" do
+        it 'reports the failure as part of the live output' do
           live_output.size.must_equal 1
           live_output.first['output_type'].must_equal 'debug'
           live_output.first['output'].must_equal 'Error loading data from proxy: RuntimeError - Something went wrong'
@@ -105,7 +105,7 @@ module ForemanRemoteExecution
                                :metadata => { :failed_proxy_tasks => [action.send(:format_exception, RuntimeError.new('Connection error'))]})
         end
 
-        it "reports the failure as part of the live output" do
+        it 'reports the failure as part of the live output' do
           live_output.size.must_equal 1
           live_output.first['output_type'].must_equal 'debug'
           live_output.first['output'].must_equal 'Initialization error: RuntimeError - Connection error'
@@ -122,7 +122,7 @@ module ForemanRemoteExecution
                                                                                          'timestamp' => timestamp }]}}])
         end
 
-        it "reports the failure as part of the live output" do
+        it 'reports the failure as part of the live output' do
           live_output.size.must_equal 1
           live_output.first['output_type'].must_equal 'stdout'
           live_output.first['output'].must_equal 'Hello'

data/test/unit/concerns/host_extensions_test.rb

@@ -1,7 +1,7 @@
 require 'test_plugin_helper'
 
 describe ForemanRemoteExecution::HostExtensions do
-  let(:provider) { 'Ssh' }
+  let(:provider) { 'SSH' }
 
   before do
     User.current = FactoryGirl.build(:user, :admin)

data/test/unit/execution_task_status_mapper_test.rb

@@ -0,0 +1,93 @@
+require 'test_plugin_helper'
+
+describe HostStatus::ExecutionStatus::ExecutionTaskStatusMapper do
+
+  describe '.sql_conditions_for(status)' do
+    subject { HostStatus::ExecutionStatus::ExecutionTaskStatusMapper }
+
+    it 'accepts status number as well as string representation' do
+      subject.sql_conditions_for(HostStatus::ExecutionStatus::ERROR).must_equal subject.sql_conditions_for('failed')
+    end
+
+    it 'does not find any task for unknown state' do
+      subject.sql_conditions_for(-1).must_equal [ '1 = 0' ]
+    end
+  end
+
+  let(:task) { ForemanTasks::Task.new }
+  let(:mapper) { HostStatus::ExecutionStatus::ExecutionTaskStatusMapper.new(task) }
+
+  describe '#status' do
+    subject { mapper }
+
+    describe 'is queued' do
+      context 'when there is no task' do
+        before { subject.task = nil }
+        specify { subject.status.must_equal HostStatus::ExecutionStatus::QUEUED }
+      end
+
+      context 'when the task is scheduled in future' do
+        before { subject.task.state = 'scheduled' }
+        specify { subject.status.must_equal HostStatus::ExecutionStatus::QUEUED }
+      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 { subject.status.must_equal HostStatus::ExecutionStatus::OK }
+        end
+      end
+
+      describe 'is failed' do
+        context 'with error' do
+          before { subject.task.result = 'error' }
+          specify { subject.status.must_equal HostStatus::ExecutionStatus::ERROR }
+        end
+
+        context 'without error but just with warning (sub task failed)' do
+          before { subject.task.result = 'warning' }
+          specify { subject.status.must_equal HostStatus::ExecutionStatus::ERROR }
+        end
+      end
+    end
+
+    context 'when task is pending' do
+      before { subject.task.state = 'running' }
+
+      describe 'is pending' do
+        specify { subject.status.must_equal HostStatus::ExecutionStatus::RUNNING }
+      end
+    end
+  end
+
+  describe '#status_label' do
+    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
+        subject.must_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::OK]
+      end
+    end
+
+    context 'status is ERROR' do
+      before do
+        mapper.task.state = 'stopped'
+        mapper.task.result = 'error'
+      end
+
+      it 'returns failed label' do
+        subject.must_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::ERROR]
+      end
+    end
+  end
+
+end

data/test/unit/input_template_renderer_test.rb

@@ -1,7 +1,7 @@
 require 'test_plugin_helper'
 
 describe InputTemplateRenderer do
-  context "renderer for simple template without inputs" do
+  context 'renderer for simple template without inputs' do
     let(:renderer) { InputTemplateRenderer.new(FactoryGirl.build(:job_template, :template => 'id')) }
 
     it 'should render the content' do
@@ -13,7 +13,7 @@ describe InputTemplateRenderer do
     end
   end
 
-  context "renderer for template with user input used" do
+  context 'renderer for template with user input used' do
     let(:template) { FactoryGirl.build(:job_template, :template => 'service restart <%= input("service_name") -%>') }
     let(:renderer) { InputTemplateRenderer.new(template) }
 
@@ -95,6 +95,173 @@ describe InputTemplateRenderer do
           renderer.invocation = template_invocation
           renderer.render.must_equal 'service restart '
         end
+
+        describe 'with circular reference' do
+          let(:recursive_template_with_inputs) do
+            FactoryGirl.create(:job_template, :name => 'test', :template => 'test')
+          end
+
+          let(:template_with_inputs) do
+            FactoryGirl.create(:job_template, :template => 'test').tap do |template|
+              template.foreign_input_sets << FactoryGirl.build(:foreign_input_set, :target_template => recursive_template_with_inputs)
+            end
+          end
+
+          let(:recursive_template_without_inputs) do
+            FactoryGirl.create(:job_template, :name => 'recursive template', :template => '<%= render_template("template with inputs", "action" => "install") %>')
+          end
+
+          let(:template_without_inputs) do
+            FactoryGirl.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 = FactoryGirl.build(:template_invocation, :template => template_without_inputs)
+            renderer.template = template_without_inputs
+            refute renderer.render
+            renderer.error_message.must_include 'Recursive rendering of templates detected'
+          end
+
+          it 'handles circular references in inputs' do
+            assert_raises(ActiveRecord::RecordInvalid) do
+              input_set = FactoryGirl.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
+        FactoryGirl.build(:job_template, :name => 'command action', :template => '<%= input("command") -%>').tap do |template|
+          template.template_inputs << FactoryGirl.build(:template_input, :name => 'command', :input_type => 'user')
+          template.template_inputs << FactoryGirl.build(:template_input, :name => 'debug', :input_type => 'user')
+        end
+      end
+
+      let(:package_template) do
+        FactoryGirl.build(:job_template, :name => 'package action', :template => <<TEMPLATE)  do |template|
+<%= render_template("command action", "command" => "yum -y \#{ input("action") } \#{ input('package') }") -%>
+TEMPLATE
+          template.template_inputs << FactoryGirl.build(:template_input, :name => 'package', :input_type => 'user')
+          template.template_inputs << FactoryGirl.build(:template_input, :name => 'action', :input_type => 'user')
+          template.foreign_input_sets << FactoryGirl.build(:foreign_input_set, :target_template => command_template, :include_all => true, :exclude => 'command')
+        end
+      end
+
+      let(:template) do
+        FactoryGirl.create(:job_template,
+                           :template => '<%= render_template("package action", { :action => "install" }, { :with_foreign_input_set => true }) %>').tap do |template|
+          template.foreign_input_sets << FactoryGirl.build(:foreign_input_set, :target_template => package_template, :include_all => true, :exclude => 'action')
+        end
+      end
+
+      let(:job_invocation) { FactoryGirl.create(:job_invocation) }
+      let(:template_invocation) { FactoryGirl.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
+            FactoryGirl.create(:job_template, :template => '<%= render_template("package action", "action" => "install") %>').tap do |template|
+              template.foreign_input_sets << FactoryGirl.build(:foreign_input_set, :target_template => package_template, :include_all => true)
+            end
+          end
+
+          let(:template_2) do
+            FactoryGirl.create(:job_template, :template => '<%= render_template("package action", "action" => "install") %>').tap do |template|
+              template.foreign_input_sets << FactoryGirl.build(:foreign_input_set,
+                                                               :target_template => package_template, :include_all => true, :include => '', :exclude => '')
+            end
+          end
+
+          it 'includes all inputs from the imported template' do
+            template.template_inputs_with_foreign.map(&:name).sort.must_equal ['action', 'debug', 'package']
+            template_2.template_inputs_with_foreign.map(&:name).sort.must_equal ['action', 'debug', 'package']
+          end
+        end
+
+        describe 'with include_all and some excludes' do
+          let(:template) do
+            FactoryGirl.create(:job_template, :template => '<%= render_template("package action", "action" => "install") %>').tap do |template|
+              template.foreign_input_sets << FactoryGirl.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
+            template.template_inputs_with_foreign.map(&:name).sort.must_equal ['package']
+          end
+        end
+
+        describe 'with some includes and some excludes' do
+          let(:template) do
+            FactoryGirl.create(:job_template, :template => '<%= render_template("package action", "action" => "install") %>').tap do |template|
+              template.foreign_input_sets << FactoryGirl.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
+            template.template_inputs_with_foreign.map(&:name).sort.must_equal ['package']
+          end
+        end
+      end
+
+      context 'with invocation specified' do
+        before do
+          FactoryGirl.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
+          renderer.error_message.must_be_nil
+          rendered.must_equal 'yum -y install zsh'
+        end
+      end
+
+      context 'with explicitly specifying inputs' do
+        let(:template) do
+          FactoryGirl.create(:job_template,
+                             :template => '<%= render_template("package action", {"action" => "install", :package => "zsh"}) %>')
+        end
+
+        before do
+          renderer.invocation = template_invocation
+          renderer.invocation.reload
+        end
+
+        it 'can render with job invocation with corresponding value' do
+          rendered = renderer.render
+          renderer.error_message.must_be_nil
+          rendered.must_equal 'yum -y install zsh'
+        end
+      end
+
+      it 'renders even without an input value' do
+        renderer.invocation = template_invocation
+        rendered = renderer.render
+        renderer.error_message.must_be_nil
+        rendered.must_equal 'yum -y install '
       end
     end
 
@@ -127,7 +294,7 @@ describe InputTemplateRenderer do
     end
   end
 
-  context "renderer for template with fact input used" do
+  context 'renderer for template with fact input used' do
     let(:template) { FactoryGirl.build(:job_template, :template => 'echo <%= input("issue") -%> > /etc/issue') }
     let(:renderer) { InputTemplateRenderer.new(template) }
 
@@ -225,7 +392,7 @@ describe InputTemplateRenderer do
     end
   end
 
-  context "renderer for template with variable input used" do
+  context 'renderer for template with variable input used' do
     let(:template) { FactoryGirl.build(:job_template, :template => 'echo <%= input("client_key") -%> > /etc/chef/client.pem') }
     let(:renderer) { InputTemplateRenderer.new(template) }
 
@@ -288,13 +455,17 @@ describe InputTemplateRenderer do
           end
 
           context 'with existing variable implemented as smart variable' do
-            let(:puppet_class) { FactoryGirl.create(:puppetclass, :environments => [environment], :hosts => [renderer.host]) }
+            let(:puppet_class) do
+              puppetclass = FactoryGirl.create(:puppetclass, :environments => [environment])
+              puppetclass.update_attribute(:hosts, [renderer.host])
+              puppetclass
+            end
             let(:lookup_key) do
               lookup_key_factory = SETTINGS[:version].short == '1.9' ? :lookup_key : :variable_lookup_key
               FactoryGirl.create(lookup_key_factory,
                                  :key => 'client_key',
                                  :puppetclass => puppet_class,
-                                 :overrides => {"fqdn=#{renderer.host.fqdn}" => "RSA KEY"})
+                                 :overrides => {"fqdn=#{renderer.host.fqdn}" => 'RSA KEY'})
             end
 
             describe 'rendering' do
@@ -322,7 +493,7 @@ describe InputTemplateRenderer do
     end
   end
 
-  context "renderer for template with puppet parameter input used" do
+  context 'renderer for template with puppet parameter input used' do
     let(:template) { FactoryGirl.build(:job_template, :template => 'echo "This is WebServer with nginx <%= input("nginx_version") -%>" > /etc/motd') }
     let(:renderer) { InputTemplateRenderer.new(template) }
 
@@ -371,7 +542,9 @@ describe InputTemplateRenderer do
 
           context 'with existing puppet parameter with matching override' do
             let(:puppet_class) do
-              FactoryGirl.create(:puppetclass, :environments => [environment], :hosts => [renderer.host], :name => 'nginx')
+              puppetclass = FactoryGirl.create(:puppetclass, :environments => [environment], :name => 'nginx')
+              puppetclass.update_attribute(:hosts, [renderer.host])
+              puppetclass
             end
             let(:lookup_key) do
               lookup_key_factory = SETTINGS[:version].short == '1.9' ? :lookup_key : :puppetclass_lookup_key
@@ -380,7 +553,7 @@ describe InputTemplateRenderer do
                                  :puppetclass => puppet_class,
                                  :path => 'fqdn',
                                  :override => true,
-                                 :overrides => {"fqdn=#{renderer.host.fqdn}" => "1.4.7"})
+                                 :overrides => {"fqdn=#{renderer.host.fqdn}" => '1.4.7'})
             end
 
             describe 'rendering' do