foreman_remote_execution 0.2.3 → 0.3.0

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

@@ -18,7 +18,7 @@ module Api
       end
 
       test 'should get input set detail' do
-        get :show,  :template_id => @template.to_param, :id => @input_set.to_param
+        get :show, :template_id => @template.to_param, :id => @input_set.to_param
         assert_response :success
         input_set = ActiveSupport::JSON.decode(@response.body)
         assert !input_set.empty?

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

@@ -23,15 +23,6 @@ module Api
         assert_equal template['job_category'], @invocation.job_category
       end
 
-      test 'should create valid without job_template_id' do
-        attrs = { :job_category => @template.job_category, :name => 'RandomName', :targeting_type => 'static_query', :search_query => 'foobar'}
-        post :create, :job_invocation => attrs
-
-        invocation = ActiveSupport::JSON.decode(@response.body)
-        assert_equal attrs[:job_category], invocation['job_category']
-        assert_response :success
-      end
-
       test 'should create valid with job_template_id' do
         attrs = { :job_category => @template.job_category, :name => 'RandomName', :job_template_id => @template.id,
                   :targeting_type => 'static_query', :search_query => 'foobar'}

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

@@ -15,7 +15,7 @@ module Api
       end
 
       test 'should get template detail' do
-        get :show,  :id => @template.to_param
+        get :show, :id => @template.to_param
         assert_response :success
         template = ActiveSupport::JSON.decode(@response.body)
         assert !template.empty?
@@ -25,7 +25,7 @@ module Api
       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' }
-        post :create,  :job_template => valid_attrs
+        post :create, :job_template => valid_attrs
         template = ActiveSupport::JSON.decode(@response.body)
         assert template['name'] == 'RandomName'
         assert_response :success
@@ -38,26 +38,26 @@ module Api
 
       test 'should update valid' do
         JobTemplate.any_instance.stubs(:valid?).returns(true)
-        put :update,  :id => @template.to_param,
-                      :job_template => { :template => 'blah' }
+        put :update, :id => @template.to_param,
+                     :job_template => { :template => 'blah' }
         assert_response :ok
       end
 
       test 'should not update invalid' do
-        put :update,  :id => @template.to_param,
-                      :job_template => { :name => '' }
+        put :update, :id => @template.to_param,
+                     :job_template => { :name => '' }
         assert_response :unprocessable_entity
       end
 
       test 'should destroy' do
-        delete :destroy,  :id => @template.to_param
+        delete :destroy, :id => @template.to_param
         assert_response :ok
         refute JobTemplate.exists?(@template.id)
       end
 
       test 'should clone template' do
-        post :clone,  :id => @template.to_param,
-                      :job_template => {:name => 'MyClone'}
+        post :clone, :id => @template.to_param,
+                     :job_template => {:name => 'MyClone'}
         assert_response :success
         template = ActiveSupport::JSON.decode(@response.body)
         assert_equal(template['name'], 'MyClone')
@@ -65,8 +65,8 @@ module Api
       end
 
       test 'clone name should not be blank' do
-        post :clone,  :id => @template.to_param,
-                      :job_template => {:name => ''}
+        post :clone, :id => @template.to_param,
+                     :job_template => {:name => ''}
         assert_response :unprocessable_entity
       end
     end

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

@@ -0,0 +1,35 @@
+require 'test_plugin_helper'
+
+module Api
+  module V2
+    class RemoteExecutionFeaturesControllerTest < ActionController::TestCase
+      setup do
+        @remote_execution_feature = RemoteExecutionFeature.register(:my_awesome_feature, 'My awesome feature',
+                                                                    :description => 'You will not believe what it does',
+                                                                    :provided_inputs => ['awesomeness_level'])
+        @template = FactoryGirl.create(:job_template, :with_input)
+      end
+
+      test 'should get index' do
+        get :index
+        remote_execution_features = ActiveSupport::JSON.decode(@response.body)
+        refute remote_execution_features.empty?, 'Should respond with input sets'
+        assert_response :success
+      end
+
+      test 'should get input set detail' do
+        get :show, :id => @remote_execution_feature.to_param
+        assert_response :success
+        remote_execution_feature = ActiveSupport::JSON.decode(@response.body)
+        refute remote_execution_feature.empty?
+        assert_equal remote_execution_feature['name'], @remote_execution_feature.name
+      end
+
+      test 'should update valid' do
+        put :update, :id => @remote_execution_feature.to_param,
+                     :job_template_id => @template.id
+        assert_response :ok
+      end
+    end
+  end
+end

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

@@ -16,7 +16,7 @@ module Api
       end
 
       test 'should get input detail' do
-        get :show,  :template_id => @template.to_param, :id => @input.to_param
+        get :show, :template_id => @template.to_param, :id => @input.to_param
         assert_response :success
         input = ActiveSupport::JSON.decode(@response.body)
         assert !input.empty?

data/test/unit/actions/run_hosts_job_test.rb

@@ -22,10 +22,13 @@ module ForemanRemoteExecution
       end
     end
     let(:action) do
-      action = create_action(Actions::RemoteExecution::RunHostsJob)
-      action.expects(:action_subject).with(job_invocation)
-      ForemanTasks::Task::DynflowTask.stubs(:where).returns(mock.tap { |m| m.stubs(:first! => task) })
-      plan_action(action, job_invocation)
+      create_action(Actions::RemoteExecution::RunHostsJob).tap do |action|
+        action.expects(:action_subject).with(job_invocation)
+        ForemanTasks::Task::DynflowTask.stubs(:where).returns(mock.tap { |m| m.stubs(:first! => task) })
+      end
+    end
+    let(:planned) do
+      plan_action action, job_invocation
     end
 
     before do
@@ -35,17 +38,55 @@ module ForemanRemoteExecution
     end
 
     it 'resolves the hosts on targeting in plan phase' do
+      planned
       targeting.hosts.must_include(host)
     end
 
     it 'triggers the RunHostJob actions on the resolved hosts in run phase' do
-      action.expects(:trigger).with() { |*args| args[0] == Actions::RemoteExecution::RunHostJob }
-      action.create_sub_plans
+      planned.expects(:trigger).with() { |*args| args[0] == Actions::RemoteExecution::RunHostJob }
+      planned.create_sub_plans
     end
 
     it 'uses the BindJobInvocation middleware' do
-      action
+      planned
       job_invocation.task_id.must_equal '123'
     end
+
+    describe 'concurrency control' do
+      let(:level) { 5 }
+      let(:span) { 60 }
+
+      it 'can be disabled' do
+        job_invocation.expects(:concurrency_level)
+        job_invocation.expects(:time_span)
+        action.expects(:limit_concurrency_level).never
+        action.expects(:distribute_over_time).never
+        planned
+      end
+
+      it 'can limit concurrency level' do
+        job_invocation.expects(:concurrency_level).returns(level).twice
+        job_invocation.expects(:time_span)
+        action.expects(:limit_concurrency_level).with(level)
+        action.expects(:distribute_over_time).never
+        planned
+      end
+
+      it 'can distribute tasks over time' do
+        job_invocation.expects(:time_span).returns(span).twice
+        job_invocation.expects(:concurrency_level)
+        action.expects(:distribute_over_time).with(span)
+        action.expects(:distribute_over_time).never
+        planned
+      end
+
+      it 'can use both' do
+        job_invocation.expects(:time_span).returns(span).twice
+        action.expects(:distribute_over_time).with(span)
+        job_invocation.expects(:concurrency_level).returns(level).twice
+        action.expects(:limit_concurrency_level).with(level)
+        planned
+      end
+    end
   end
 end

data/test/unit/actions/run_proxy_command_test.rb

@@ -50,7 +50,7 @@ module ForemanRemoteExecution
       describe 'when the task is finished' do
         before do
           task.state = 'stopped'
-          task.ended_at = Time.at(timestamp + 1)
+          task.ended_at = Time.at(timestamp + 1).utc
         end
 
         describe 'the task finished sucessfully' do

data/test/unit/concerns/host_extensions_test.rb

@@ -40,6 +40,17 @@ describe ForemanRemoteExecution::HostExtensions do
     it 'has ssh keys in the parameters' do
       host.remote_execution_ssh_keys.must_include sshkey
     end
+
+    it 'has ssh keys in the parameters even when no user specified' do
+      # this is a case, when using the helper in provisioning templates
+      FactoryGirl.create(:smart_proxy, :ssh) do |proxy|
+        proxy.organizations << host.organization
+        proxy.locations << host.location
+      end
+      host.interfaces.first.subnet.remote_execution_proxies.clear
+      User.current = nil
+      host.remote_execution_ssh_keys.must_include sshkey
+    end
   end
 
   context 'host has multiple nics' do

data/test/unit/input_template_renderer_test.rb

@@ -2,14 +2,14 @@ require 'test_plugin_helper'
 
 describe InputTemplateRenderer do
   context 'renderer for simple template without inputs' do
-    let(:renderer) { InputTemplateRenderer.new(FactoryGirl.build(:job_template, :template => 'id')) }
+    let(:renderer) { InputTemplateRenderer.new(FactoryGirl.build(:job_template, :template => 'id <%= preview? %>')) }
 
     it 'should render the content' do
-      renderer.render.must_equal 'id'
+      renderer.render.must_equal 'id false'
     end
 
     it 'should render preview' do
-      renderer.preview.must_equal 'id'
+      renderer.preview.must_equal 'id true'
     end
   end
 
@@ -147,7 +147,7 @@ describe InputTemplateRenderer do
       end
 
       let(:package_template) do
-        FactoryGirl.build(:job_template, :name => 'package action', :template => <<TEMPLATE)  do |template|
+        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')

data/test/unit/job_invocation_composer_test.rb

@@ -210,7 +210,7 @@ describe JobInvocationComposer do
           { :job_template_id => trying_job_template_1.id.to_s,
             :job_templates => {
               trying_job_template_1.id.to_s => {
-                :input_values => { input1.id.to_s => { :value => 'value1' },  unauthorized_input1.id.to_s => { :value => 'dropped' } }
+                :input_values => { input1.id.to_s => { :value => 'value1' }, unauthorized_input1.id.to_s => { :value => 'dropped' } }
               }
             }
           }
@@ -429,6 +429,25 @@ describe JobInvocationComposer do
         end
       end
 
+      describe 'concurrency control' do
+
+        describe 'with concurrency control set' do
+          let(:params) do
+            { :job_invocation => { :providers => { :ssh => ssh_params }, :concurrency_level => "5", :time_span => "60" } }.with_indifferent_access
+          end
+
+          it 'accepts the concurrency options' do
+            composer.job_invocation.concurrency_level.must_equal 5
+            composer.job_invocation.time_span.must_equal 60
+          end
+        end
+
+        it 'can be disabled' do
+          composer.job_invocation.concurrency_level.must_be_nil
+          composer.job_invocation.time_span.must_be_nil
+        end
+      end
+
       describe 'triggering' do
         let(:params) do
           { :job_invocation => { :providers => { :ssh => ssh_params } }, :triggering => { :mode => 'future' }}.with_indifferent_access
@@ -481,7 +500,11 @@ describe JobInvocationComposer do
         let(:params) do
           {
             :job_invocation => {
-              :providers => { :ssh => ssh_params }
+              :providers => { :ssh => ssh_params },
+              :concurrency_control => {
+                :level => 5,
+                :time_span => 60
+              }
             },
             :targeting => {
               :search_query => "name = #{host.name}",
@@ -514,6 +537,11 @@ describe JobInvocationComposer do
           new_composer.pattern_template_invocations.size.must_equal existing.pattern_template_invocations.size
         end
 
+        it 'sets the same concurrency control options' do
+          new_composer.job_invocation.concurrency_level.must_equal existing.concurrency_level
+          new_composer.job_invocation.time_span.must_equal existing.time_span
+        end
+
       end
     end
   end
@@ -591,6 +619,28 @@ describe JobInvocationComposer do
       end
     end
 
+    context 'with concurrency_control' do
+      let(:level) { 5 }
+      let(:time_span) { 60 }
+      let(:params) do
+        { :job_category => trying_job_template_1.job_category,
+          :job_template_id => trying_job_template_1.id,
+          :concurrency_control => {
+            :concurrency_level => level,
+            :time_span => time_span
+          },
+          :targeting_type => 'static_query',
+          :search_query => 'some hosts',
+          :inputs => {input1.name => 'some_value'}}
+      end
+
+      it 'sets the concurrency level and time span based on the input' do
+        assert composer.save!
+        composer.job_invocation.time_span.must_equal time_span
+        composer.job_invocation.concurrency_level.must_equal level
+      end
+    end
+
     context 'with invalid targeting' do
       let(:params) do
         { :job_category => trying_job_template_1.job_category,

data/test/unit/job_invocation_test.rb

@@ -92,7 +92,7 @@ describe JobInvocation do
   context 'future execution' do
     it 'can report host count' do
       job_invocation.total_hosts_count.must_equal 'N/A'
-      job_invocation.targeting.expects(:resolved_at).returns(Time.now)
+      job_invocation.targeting.expects(:resolved_at).returns(Time.now.getlocal)
       job_invocation.total_hosts_count.must_equal 0
     end
 

data/test/unit/job_template_test.rb

@@ -10,6 +10,12 @@ describe JobTemplate do
       end
     end
 
+    it 'has a unique name' do
+      template1 = FactoryGirl.create(:job_template)
+      template2 = FactoryGirl.build(:job_template, :name => template1.name)
+      refute template2.valid?
+    end
+
     it 'needs a job_category' do
       refute job_template.valid?
     end
@@ -45,7 +51,7 @@ describe JobTemplate do
 
     it 'generates the description_format if not set or blank and has inputs' do
       input_name = template.template_inputs.first.name
-      expected_result = %Q(%{job_category} with inputs #{input_name}="%{#{input_name}}")
+      expected_result = %(%{job_category} with inputs #{input_name}="%{#{input_name}}")
       template.generate_description_format.must_equal expected_result
       template.description_format = ''
       template.generate_description_format.must_equal expected_result
@@ -66,7 +72,7 @@ describe JobTemplate do
     end
   end
 
-  context 'importing a template' do
+  context 'importing a new template' do
     let(:template) do
       template = <<-END_TEMPLATE
       <%#
@@ -78,12 +84,32 @@ describe JobTemplate do
       - name: service_name
         input_type: user
         required: true
+      - name: verbose
+        input_type: user
       %>
 
       service <%= input("service_name") %> restart
       END_TEMPLATE
 
-      JobTemplate.import(template, :default => true)
+      JobTemplate.import!(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!(template_with_input_sets, :default => true)
     end
 
     it 'sets the name' do
@@ -98,11 +124,108 @@ describe JobTemplate do
       template.template_inputs.first.name.must_equal 'service_name'
     end
 
+    it 'imports input sets' do
+      template_with_input_sets.foreign_input_sets.first.target_template.must_equal template
+      template_with_input_sets.template_inputs_with_foreign.map(&:name).must_equal ['service_name']
+    end
+
     it 'sets additional options' do
       template.default.must_equal 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!(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!(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
+      refute JobTemplate.import!(updated)
+    end
+
+    let(:synced_template) do
+      existing
+      JobTemplate.import!(updated, :update => true)
+      existing.reload
+    end
+
+    it 'syncs inputs' do
+      hostname = synced_template.template_inputs.find { |input| input.name == 'hostname' }
+      hostname.options.must_equal 'www.redhat.com'
+    end
+
+    it 'syncs content' do
+      synced_template.template.must_match(/\s+ping -c <%= input\('count'\) %> <%= input\('hostname'\) %>\s+/m)
+    end
+
+    it 'syncs input sets' do
+      synced_template.foreign_input_sets.first.target_template.must_equal included
+      synced_template.template_inputs_with_foreign.map(&:name).must_equal ["hostname", "count"]
+    end
+  end
+
   context 'there is existing template invocation of a job template' do
     let(:job_invocation) { FactoryGirl.create(:job_invocation, :with_template) }
     let(:job_template) { job_invocation.pattern_template_invocations.first.template }