foreman_remote_execution 14.0.2 → 14.1.0

data/test/benchmark/run_hosts_job_benchmark.rb

@@ -1,70 +0,0 @@
-require 'benchmark/benchmark_helper'
-require 'dynflow/testing'
-
-# Add plugin to FactoryBot's paths
-FactoryBot.definition_file_paths << File.expand_path('../../factories', __FILE__)
-FactoryBot.definition_file_paths << "#{ForemanTasks::Engine.root}/test/factories"
-FactoryBot.reload
-
-module Actions
-  module RemoteExecution
-    class RunHostsJob < Actions::ActionWithSubPlans
-      # stub function that calls other actions.
-      def trigger(*args)
-        nil
-      end
-    end
-  end
-end
-
-module Support
-  class DummyDynflowAction < Dynflow::Action
-  end
-end
-
-def generate_hosts(total)
-  FactoryBot.create_list(:host, total, :comment => "benchmark-#{Foreman.uuid}")
-end
-
-Rails.logger.level = Logger::ERROR
-
-class ActionTester
-  include Dynflow::Testing::Factories
-
-  def initialize(task)
-    @task = task
-  end
-
-  def run_action(*args)
-    action = create_action(Actions::RemoteExecution::RunHostsJob)
-    @task.update(:external_id => action.execution_plan_id)
-    plan_action(action, *args)
-  end
-end
-
-puts 'generating admin user'
-admin = FactoryBot.build(:user, :admin)
-admin.save(:validate => false)
-User.current = admin
-targeting = FactoryBot.create(:targeting, :search_query => "comment = benchmark-#{Foreman.uuid}", :user => User.current)
-template_invocation = FactoryBot.build(:template_invocation, :job_invocation => nil)
-job_invocation = FactoryBot.build(:job_invocation, :targeting => targeting, :pattern_template_invocations => [template_invocation]).tap do |invocation|
-  invocation.targeting = targeting
-  invocation.save
-end
-
-task = FactoryBot.create(:dynflow_task, :external_id => '1')
-tester = ActionTester.new(task)
-
-puts 'generating hosts'
-generate_hosts(1000)
-puts 'starting benchmarking'
-foreman_benchmark do
-  Benchmark.ips do |x|
-    x.config(:time => 10, :warmup => 0)
-
-    x.report('rex-run-hosts-job') do
-      tester.run_action(job_invocation)
-    end
-  end
-end

data/test/benchmark/targeting_benchmark.rb

@@ -1,31 +0,0 @@
-require 'benchmark/benchmark_helper'
-require 'dynflow/testing'
-
-# Add plugin to FactoryBot's paths
-FactoryBot.definition_file_paths << File.expand_path('../../factories', __FILE__)
-FactoryBot.reload
-
-def generate_hosts(total)
-  FactoryBot.create_list(:host, total, :comment => "benchmark-#{Foreman.uuid}")
-end
-
-Rails.logger.level = Logger::ERROR
-
-puts 'generating hosts'
-generate_hosts(1000)
-puts 'generating admin user'
-admin = FactoryBot.build(:user, :admin)
-admin.save(:validate => false)
-User.current = admin
-
-puts 'starting benchmarking'
-foreman_benchmark do
-  Benchmark.ips do |x|
-    x.config(:time => 10, :warmup => 0)
-
-    x.report('rex-targeting-resolve-hosts') do
-      targeting = FactoryBot.create(:targeting, :search_query => "comment = benchmark-#{Foreman.uuid}", :user => User.current)
-      targeting.resolve_hosts!
-    end
-  end
-end

data/test/factories/foreman_remote_execution_factories.rb

@@ -1,147 +0,0 @@
-FactoryBot.define do
-  factory :job_template do
-    sequence(:name) { |n| "Job template #{n}" }
-    sequence(:job_category) { |n| "Job name #{n}" }
-    template { 'id' }
-    provider_type { 'SSH' }
-    organizations { [Organization.find_by(name: 'Organization 1')] }
-    locations { [Location.find_by(name: 'Location 1')] }
-
-    trait :with_input do
-      after(:build) do |template, evaluator|
-        template.template_inputs << FactoryBot.build(:template_input)
-      end
-    end
-
-    trait :with_description_format do
-      description_format { 'Factory-built %{job_category}' }
-    end
-
-    trait :with_feature do
-      remote_execution_feature
-    end
-  end
-
-  factory :foreign_input_set
-
-  factory :targeting do
-    search_query { 'name = foo' }
-    targeting_type { 'static_query' }
-    user
-
-    trait :with_randomized_ordering do
-      randomized_ordering { true }
-    end
-  end
-
-  factory :job_invocation do |f|
-    targeting
-    f.sequence(:job_category) { |n| "Job name #{n}" }
-    f.description_format { "%{job_category}" }
-    trait :with_template do
-      after(:build) do |invocation, evaluator|
-        invocation.pattern_template_invocations << FactoryBot.build(:template_invocation)
-      end
-    end
-
-    trait :with_failed_task do
-      after(:build) do |invocation, _evaluator|
-        invocation.template_invocations << FactoryBot.build(:template_invocation, :with_failed_task, :with_host)
-        invocation.task = FactoryBot.build(:some_task)
-      end
-    end
-
-    trait :with_task do
-      after(:build) do |invocation, _evaluator|
-        invocation.template_invocations << FactoryBot.build(:template_invocation, :with_task, :with_host)
-        invocation.task = FactoryBot.build(:some_task)
-      end
-    end
-
-    trait :with_unplanned_host do
-      after(:build) do |invocation, _evaluator|
-        invocation.targeting.hosts << FactoryBot.build(:host)
-      end
-    end
-  end
-
-  factory :remote_execution_provider do |f|
-    f.sequence(:name) { |n| "Provider #{n}" }
-  end
-
-  factory :template_invocation do
-    job_invocation
-    association :template, :factory => :job_template
-
-    trait :with_task do
-      after(:build) do |template, _evaluator|
-        template.run_host_job_task = FactoryBot.build(:some_task)
-      end
-    end
-
-    trait :with_failed_task do
-      after(:build) do |template, _evaluator|
-        template.run_host_job_task = FactoryBot.build(:some_task, :result => 'error')
-      end
-    end
-
-    trait :with_host do
-      after(:build) do |template, _evaluator|
-        template.host = FactoryBot.build(:host)
-      end
-    end
-  end
-
-  factory :template_invocation_input_value do |f|
-    f.sequence(:value) { |n| "Input Value #{n}" }
-  end
-
-  factory :remote_execution_feature do |f|
-    f.sequence(:label) { |n| "remote_execution_feature_#{n}" }
-    f.sequence(:name) { |n| "Remote Execution Feature #{n}" }
-  end
-end
-
-FactoryBot.modify do
-  factory :feature do
-    trait :ssh do
-      name { 'SSH' }
-    end
-  end
-
-  factory :smart_proxy do
-    trait :ssh do
-      features { [FactoryBot.create(:feature, :ssh)] }
-      pubkey { 'ssh-rsa AAAAB3N...' }
-    end
-  end
-
-  factory :subnet do
-    trait :execution do
-      remote_execution_proxies { [FactoryBot.build(:smart_proxy, :ssh)] }
-    end
-  end
-
-  factory :host do
-    trait :with_execution do
-      managed
-      domain
-      subnet do
-        overrides = {
-          :remote_execution_proxies => [FactoryBot.create(:smart_proxy, :ssh)],
-        }
-
-        overrides[:locations] = [location] unless location.nil?
-        overrides[:organizations] = [organization] unless organization.nil?
-
-        FactoryBot.create(
-          :subnet_ipv4,
-          overrides
-        )
-      end
-      interfaces do
-        [FactoryBot.build(:nic_primary_and_provision, :ip => subnet.network.sub(/0\Z/, '1'), :execution => true)]
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-require 'test_plugin_helper'
-
-module Api
-  module V2
-    class ForeignInputSetsControllerTest < ActionController::TestCase
-      setup do
-        @template = FactoryBot.create(:job_template)
-        @foreign_template = FactoryBot.create(:job_template, :with_input)
-        @new_foreign_template = FactoryBot.create(:job_template, :with_input)
-        @input_set = @template.foreign_input_sets.create(:target_template_id => @foreign_template.id)
-      end
-
-      test 'should get index' do
-        get :index, params: { :template_id => @template.id }
-        input_sets = ActiveSupport::JSON.decode(@response.body)
-        assert_not input_sets.empty?, 'Should respond with input sets'
-        assert_response :success
-      end
-
-      test 'should get input set detail' do
-        get :show, params: { :template_id => @template.to_param, :id => @input_set.to_param }
-        assert_response :success
-        input_set = ActiveSupport::JSON.decode(@response.body)
-        assert_not input_set.empty?
-        assert_equal input_set['target_template_name'], @foreign_template.name
-      end
-
-      test 'should create valid' do
-        valid_attrs = { :target_template_id => @new_foreign_template.id }
-        post :create, params: { :foreign_input_set => valid_attrs, :template_id => @template.to_param }
-        input_set = ActiveSupport::JSON.decode(@response.body)
-        assert_equal input_set['target_template_name'], @new_foreign_template.name
-        assert_response :success
-      end
-
-      test 'should not create invalid' do
-        post :create, params: { :template_id => @template.to_param }
-        assert_response :unprocessable_entity
-      end
-
-      test 'should update valid' do
-        put :update, params: { :template_id => @template.to_param, :id => @input_set.to_param, :foreign_input_set => { :include_all => false } }
-        assert_response :ok
-      end
-
-      test 'should not update invalid' do
-        put :update, params: { :template_id => @template.to_param, :id => @input_set.to_param, :foreign_input_set => { :target_template_id => '' } }
-        assert_response :unprocessable_entity
-      end
-
-      test 'should destroy' do
-        delete :destroy, params: { :template_id => @template.to_param, :id => @input_set.to_param }
-        assert_response :ok
-        assert_not ForeignInputSet.exists?(@input_set.id)
-      end
-    end
-  end
-end