foreman_remote_execution 1.4.1 → 1.4.2

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

@@ -7,7 +7,7 @@ module Api
         @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)
+        @template = FactoryBot.create(:job_template, :with_input)
       end
 
       test 'should get index' do
@@ -18,7 +18,7 @@ module Api
       end
 
       test 'should get input set detail' do
-        get :show, :id => @remote_execution_feature.to_param
+        get :show, params: { :id => @remote_execution_feature.to_param }
         assert_response :success
         remote_execution_feature = ActiveSupport::JSON.decode(@response.body)
         refute remote_execution_feature.empty?
@@ -26,8 +26,7 @@ module Api
       end
 
       test 'should update valid' do
-        put :update, :id => @remote_execution_feature.to_param,
-                     :job_template_id => @template.id
+        put :update, params: { :id => @remote_execution_feature.to_param, :job_template_id => @template.id }
         assert_response :ok
       end
     end

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

@@ -4,19 +4,19 @@ module Api
   module V2
     class TemplateInputsControllerTest < ActionController::TestCase
       setup do
-        @template = FactoryGirl.create(:job_template, :with_input)
+        @template = FactoryBot.create(:job_template, :with_input)
         @input = @template.template_inputs.first
       end
 
       test 'should get index' do
-        get :index, :template_id => @template.id
+        get :index, params: { :template_id => @template.id }
         inputs = ActiveSupport::JSON.decode(@response.body)
         assert !inputs.empty?, 'Should respond with inputs'
         assert_response :success
       end
 
       test 'should get input detail' do
-        get :show, :template_id => @template.to_param, :id => @input.to_param
+        get :show, params: { :template_id => @template.to_param, :id => @input.to_param }
         assert_response :success
         input = ActiveSupport::JSON.decode(@response.body)
         assert !input.empty?
@@ -25,34 +25,29 @@ module Api
 
       test 'should create valid' do
         valid_attrs = { :name => 'is_potato', :input_type => 'user', :options => ['true', 'false'] }
-        post :create, :template_input => valid_attrs, :template_id => @template.to_param
+        post :create, params: { :template_input => valid_attrs, :template_id => @template.to_param }
         input = ActiveSupport::JSON.decode(@response.body)
         assert input['name'] == 'is_potato'
         assert_response :success
       end
 
       test 'should not create invalid' do
-        post :create, :template_id => @template.to_param
+        post :create, params: { :template_id => @template.to_param }
         assert_response :unprocessable_entity
       end
 
       test 'should update valid' do
-        put :update,  :template_id => @template.to_param,
-                      :id => @input.to_param,
-                      :template_input => { :name => 'blah' }
+        put :update, params: { :template_id => @template.to_param, :id => @input.to_param, :template_input => { :name => 'blah' } }
         assert_response :ok
       end
 
       test 'should not update invalid' do
-        put :update,  :template_id => @template.to_param,
-                      :id => @input.to_param,
-                      :template_input => { :name => '' }
+        put :update, params: { :template_id => @template.to_param, :id => @input.to_param, :template_input => { :name => '' } }
         assert_response :unprocessable_entity
       end
 
       test 'should destroy' do
-        delete :destroy,  :template_id => @template.to_param,
-                          :id => @input.to_param
+        delete :destroy, params: { :template_id => @template.to_param, :id => @input.to_param }
         assert_response :ok
         refute TemplateInput.exists?(@input.id)
       end

data/test/test_plugin_helper.rb

@@ -2,8 +2,8 @@
 require 'test_helper'
 require 'dynflow/testing'
 
-# Add plugin to FactoryGirl's paths
-FactoryGirl.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
+# Add plugin to FactoryBot's paths
+FactoryBot.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
 # Add foreman tasks factories too
-FactoryGirl.definition_file_paths << "#{ForemanTasks::Engine.root}/test/factories"
-FactoryGirl.reload
+FactoryBot.definition_file_paths << "#{ForemanTasks::Engine.root}/test/factories"
+FactoryBot.reload

data/test/unit/actions/run_hosts_job_test.rb

@@ -5,11 +5,11 @@ module ForemanRemoteExecution
   class RunHostsJobTest < ActiveSupport::TestCase
     include Dynflow::Testing
 
-    let(:host) { FactoryGirl.create(:host, :with_execution) }
+    let(:host) { FactoryBot.create(:host, :with_execution) }
     let(:proxy) { host.remote_execution_proxies('SSH')[:subnet].first }
-    let(:targeting) { FactoryGirl.create(:targeting, :search_query => "name = #{host.name}", :user => User.current) }
+    let(:targeting) { FactoryBot.create(:targeting, :search_query => "name = #{host.name}", :user => User.current) }
     let(:job_invocation) do
-      FactoryGirl.build(:job_invocation, :with_template).tap do |invocation|
+      FactoryBot.build(:job_invocation, :with_template).tap do |invocation|
         invocation.targeting = targeting
         invocation.description = 'Some short description'
         invocation.save

data/test/unit/concerns/exportable_test.rb

@@ -5,7 +5,7 @@ module ForemanRemoteExecution
     class SampleModel
       include ::ForemanRemoteExecution::Exportable
 
-      attr_accessor :name, :attrs, :subnet, :mac, :password, :subnet
+      attr_accessor :name, :attrs, :subnet, :mac, :password
       attr_exportable :name, :attrs, :mac, :subnet, :mac => ->(m) { m.mac.upcase if m.mac },
                                                     :custom_attr => ->(m) { 'hello world' }
 

data/test/unit/concerns/foreman_tasks_cleaner_extensions_test.rb

@@ -2,13 +2,13 @@ require 'test_plugin_helper'
 
 class ForemanRemoteExecutionForemanTasksCleanerExtensionsTest < ActiveSupport::TestCase
   it 'tries to delete associated job invocations' do
-    job = FactoryGirl.create(:job_invocation, :with_task)
+    job = FactoryBot.create(:job_invocation, :with_task)
     ForemanTasks::Cleaner.new(:filter => "id = #{job.task.id}").delete
     JobInvocation.where(:id => job.id).must_be :empty?
   end
 
   it 'removes orphaned job invocations' do
-    job = FactoryGirl.create(:job_invocation, :with_task)
+    job = FactoryBot.create(:job_invocation, :with_task)
     JobInvocation.where(:id => job.id).count.must_equal 1
     job.task.delete
     job.reload

data/test/unit/concerns/host_extensions_test.rb

@@ -6,11 +6,11 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
   end
   let(:provider) { 'SSH' }
 
-  before { User.current = FactoryGirl.build(:user, :admin) }
+  before { User.current = FactoryBot.build(:user, :admin) }
   after { User.current = nil }
 
   describe 'ssh specific params' do
-    let(:host) { FactoryGirl.create(:host, :with_execution) }
+    let(:host) { FactoryBot.create(:host, :with_execution) }
     let(:sshkey) { 'ssh-rsa AAAAB3NzaC1yc2EAAAABJQ foo@example.com' }
 
     before do
@@ -24,7 +24,7 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
     end
 
     it 'can override ssh user' do
-      host.host_parameters << FactoryGirl.create(:host_parameter, :host => host, :name => 'remote_execution_ssh_user', :value => 'amy')
+      host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_ssh_user', :value => 'amy')
       host.params['remote_execution_ssh_user'].must_equal 'amy'
     end
 
@@ -33,7 +33,7 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
     end
 
     it 'can override effective user method' do
-      host.host_parameters << FactoryGirl.create(:host_parameter, :host => host, :name => 'remote_execution_effective_user_method', :value => 'su')
+      host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_effective_user_method', :value => 'su')
       host.params['remote_execution_effective_user_method'].must_equal 'su'
     end
 
@@ -43,7 +43,7 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
 
     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)
+      FactoryBot.create(:smart_proxy, :ssh)
       host.interfaces.first.subnet.remote_execution_proxies.clear
       User.current = nil
       host.remote_execution_ssh_keys.must_include sshkey
@@ -51,10 +51,10 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
   end
 
   context 'host has multiple nics' do
-    let(:host) { FactoryGirl.build(:host, :with_execution) }
+    let(:host) { FactoryBot.build(:host, :with_execution) }
 
     it 'should only have one execution interface' do
-      host.interfaces << FactoryGirl.build(:nic_managed)
+      host.interfaces << FactoryBot.build(:nic_managed)
       host.interfaces.each { |interface| interface.execution = true }
       host.wont_be :valid?
     end
@@ -66,14 +66,14 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
 
   context 'scoped search' do
     let(:job) do
-      job = FactoryGirl.create(:job_invocation, :with_task)
-      job.template_invocations << FactoryGirl.create(:template_invocation, :with_host, :with_failed_task)
+      job = FactoryBot.create(:job_invocation, :with_task)
+      job.template_invocations << FactoryBot.create(:template_invocation, :with_host, :with_failed_task)
       job
     end
 
     let(:job2) do
-      job = FactoryGirl.create(:job_invocation, :with_task)
-      job.template_invocations << FactoryGirl.create(:template_invocation, :with_host, :with_failed_task)
+      job = FactoryBot.create(:job_invocation, :with_task)
+      job.template_invocations << FactoryBot.create(:template_invocation, :with_host, :with_failed_task)
       job
     end
 
@@ -112,17 +112,17 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
 
   describe 'proxy determination strategies' do
     context 'subnet strategy' do
-      let(:host) { FactoryGirl.build(:host, :with_execution) }
+      let(:host) { FactoryBot.build(:host, :with_execution) }
       it { host.remote_execution_proxies(provider)[:subnet].must_include host.subnet.remote_execution_proxies.first }
     end
 
     context 'fallback strategy' do
-      let(:host) { FactoryGirl.build(:host, :with_puppet) }
+      let(:host) { FactoryBot.build(:host, :with_puppet) }
 
       context 'enabled' do
         before do
           Setting[:remote_execution_fallback_proxy] = true
-          host.puppet_proxy.features << FactoryGirl.create(:feature, :ssh)
+          host.puppet_proxy.features << FactoryBot.create(:feature, :ssh)
         end
 
         it 'returns a fallback proxy' do
@@ -133,7 +133,7 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
       context 'disabled' do
         before do
           Setting[:remote_execution_fallback_proxy] = false
-          host.puppet_proxy.features << FactoryGirl.create(:feature, :ssh)
+          host.puppet_proxy.features << FactoryBot.create(:feature, :ssh)
         end
 
         it 'returns no proxy' do
@@ -143,11 +143,11 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
     end
 
     context 'global strategy' do
-      let(:tax_organization) { FactoryGirl.build(:organization) }
-      let(:tax_location) { FactoryGirl.build(:location) }
-      let(:host) { FactoryGirl.build(:host, :organization => tax_organization, :location => tax_location) }
-      let(:proxy_in_taxonomies) { FactoryGirl.create(:smart_proxy, :ssh, :organizations => [tax_organization], :locations => [tax_location]) }
-      let(:proxy_no_taxonomies) { FactoryGirl.create(:smart_proxy, :ssh) }
+      let(:tax_organization) { FactoryBot.build(:organization) }
+      let(:tax_location) { FactoryBot.build(:location) }
+      let(:host) { FactoryBot.build(:host, :organization => tax_organization, :location => tax_location) }
+      let(:proxy_in_taxonomies) { FactoryBot.create(:smart_proxy, :ssh, :organizations => [tax_organization], :locations => [tax_location]) }
+      let(:proxy_no_taxonomies) { FactoryBot.create(:smart_proxy, :ssh) }
 
       context 'enabled' do
         before { Setting[:remote_execution_global_proxy] = true }

data/test/unit/concerns/nic_extensions_test.rb

@@ -1,7 +1,7 @@
 require 'test_plugin_helper'
 
 class ForemanRemoteExecutionNicExtensionsTest < ActiveSupport::TestCase
-  let(:host) { FactoryGirl.create(:host) }
+  let(:host) { FactoryBot.create(:host) }
 
   it 'sets the first primary interface as the execution interface' do
     host.execution_interface.must_equal host.interfaces.first

data/test/unit/input_template_renderer_test.rb

@@ -2,7 +2,7 @@ require 'test_plugin_helper'
 
 class InputTemplateRendererTest < ActiveSupport::TestCase
   context 'renderer for simple template without inputs' do
-    let(:renderer) { InputTemplateRenderer.new(FactoryGirl.build(:job_template, :template => 'id <%= preview? %>')) }
+    let(:renderer) { InputTemplateRenderer.new(FactoryBot.build(:job_template, :template => 'id <%= preview? %>')) }
 
     it 'should render the content' do
       renderer.render.must_equal 'id false'
@@ -14,7 +14,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
   end
 
   context 'renderer for template with user input used' do
-    let(:template) { FactoryGirl.build(:job_template, :template => 'service restart <%= input("service_name") -%>') }
+    let(:template) { FactoryBot.build(:job_template, :template => 'service restart <%= input("service_name") -%>') }
     let(:renderer) { InputTemplateRenderer.new(template) }
 
     context 'but without input defined' do
@@ -43,12 +43,12 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
     context 'with matching input defined' do
 
-      let(:job_invocation) { FactoryGirl.create(:job_invocation) }
-      let(:template_invocation) { FactoryGirl.build(:template_invocation, :template => template) }
+      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 << FactoryGirl.build(:template_input, :name => 'service_name', :input_type => 'user')
+        template.template_inputs << FactoryBot.build(:template_input, :name => 'service_name', :input_type => 'user')
         job_invocation.template_invocations << template_invocation
       end
 
@@ -78,10 +78,10 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         context 'with invocation specified' do
           before do
-            FactoryGirl.create(:template_invocation_input_value,
-                               :template_invocation => template_invocation,
-                               :template_input => template.template_inputs.first,
-                               :value => 'foreman')
+            FactoryBot.create(:template_invocation_input_value,
+                              :template_invocation => template_invocation,
+                              :template_input => template.template_inputs.first,
+                              :value => 'foreman')
             renderer.invocation = template_invocation
             renderer.invocation.reload
           end
@@ -98,21 +98,21 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         describe 'with circular reference' do
           let(:recursive_template_with_inputs) do
-            FactoryGirl.create(:job_template, :name => 'test', :template => 'test')
+            FactoryBot.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)
+            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
-            FactoryGirl.create(:job_template, :name => 'recursive template', :template => '<%= render_template("template with inputs", "action" => "install") %>')
+            FactoryBot.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}') %>")
+            FactoryBot.create(:job_template, :name => 'template with inputs', :template => "<%= render_template('#{recursive_template_without_inputs.name}') %>")
           end
 
           before do
@@ -120,7 +120,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
           end
 
           it 'handles circular references in templates' do
-            renderer.invocation = FactoryGirl.build(:template_invocation, :template => template_without_inputs)
+            renderer.invocation = FactoryBot.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'
@@ -128,8 +128,8 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
           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')
+              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
@@ -140,31 +140,31 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
     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')
+        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
-        FactoryGirl.build(:job_template, :name => 'package action', :template => <<-TEMPLATE.strip_heredoc) do |template|
+        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 << 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')
+          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
-        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')
+        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) { FactoryGirl.create(:job_invocation) }
-      let(:template_invocation) { FactoryGirl.build(:template_invocation, :template => template) }
+      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 }
 
@@ -178,15 +178,15 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
       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)
+            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
-            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 => '')
+            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
 
@@ -198,8 +198,8 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         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')
+            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
 
@@ -210,9 +210,9 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         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')
+            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
 
@@ -224,10 +224,10 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
       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')
+          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
@@ -241,8 +241,8 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
       context 'with explicitly specifying inputs' do
         let(:template) do
-          FactoryGirl.create(:job_template,
-                             :template => '<%= render_template("package action", {"action" => "install", :package => "zsh"}) %>')
+          FactoryBot.create(:job_template,
+                            :template => '<%= render_template("package action", {"action" => "install", :package => "zsh"}) %>')
         end
 
         before do
@@ -267,12 +267,12 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
     context 'with options specified' do
 
-      let(:job_invocation) { FactoryGirl.create(:job_invocation) }
-      let(:template_invocation) { FactoryGirl.build(:template_invocation, :template => template) }
+      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 << FactoryGirl.build(:template_input, :name => 'service_name', :input_type => 'user', :options => "httpd\nforeman")
+        template.template_inputs << FactoryBot.build(:template_input, :name => 'service_name', :input_type => 'user', :options => "httpd\nforeman")
       end
 
       context 'with a valid input defined' do
@@ -280,10 +280,10 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
           job_invocation.template_invocations << template_invocation
           renderer.invocation = template_invocation
 
-          FactoryGirl.create(:template_invocation_input_value,
-                             :template_invocation => template_invocation,
-                             :template_input => template.template_inputs.first,
-                             :value => 'foreman')
+          FactoryBot.create(:template_invocation_input_value,
+                            :template_invocation => template_invocation,
+                            :template_input => template.template_inputs.first,
+                            :value => 'foreman')
           renderer.invocation.reload
         end
 
@@ -295,11 +295,11 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
   end
 
   context 'renderer for template with fact input used' do
-    let(:template) { FactoryGirl.build(:job_template, :template => 'echo <%= input("issue") -%> > /etc/issue') }
+    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<< FactoryGirl.build(:template_input, :name => 'issue', :input_type => 'fact', :fact_name => 'issue') }
+      before { renderer.template.template_inputs<< FactoryBot.build(:template_input, :name => 'issue', :input_type => 'fact', :fact_name => 'issue') }
       let(:result) { renderer.render }
 
       describe 'rendering' do
@@ -314,7 +314,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
         end
 
         context 'with host specified' do
-          before { renderer.host = FactoryGirl.create(:host) }
+          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
@@ -335,7 +335,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
           end
 
           context 'with existing fact' do
-            let(:fact) { FactoryGirl.create(:fact_name, :name => 'issue') }
+            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
@@ -357,7 +357,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
             end
 
             context 'with fact issue value' do
-              before { FactoryGirl.create(:fact_value, :host => renderer.host, :fact_name => fact, :value => 'banner') }
+              before { FactoryBot.create(:fact_value, :host => renderer.host, :fact_name => fact, :value => 'banner') }
 
               let(:result) { renderer.render }
 
@@ -376,9 +376,9 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         context 'with host specified' do
           before do
-            host = FactoryGirl.create(:host)
-            fact = FactoryGirl.create(:fact_name, :name => 'issue')
-            FactoryGirl.create(:fact_value, :host => host, :fact_name => fact, :value => 'banner')
+            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
 
@@ -393,11 +393,11 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
   end
 
   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(: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<< FactoryGirl.build(:template_input, :name => 'client_key', :input_type => 'variable', :variable_name => 'client_key') }
+      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
@@ -412,11 +412,11 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
         end
 
         context 'with host specified' do
-          before { User.current = FactoryGirl.build(:user, :admin) }
+          before { User.current = FactoryBot.build(:user, :admin) }
           after { User.current = nil }
 
-          let(:environment) { FactoryGirl.create(:environment) }
-          before { renderer.host = FactoryGirl.create(:host, :environment => environment) }
+          let(:environment) { FactoryBot.create(:environment) }
+          before { renderer.host = FactoryBot.create(:host, :environment => environment) }
 
           describe 'rendering' do
             it 'can\'t render the content without host since we don\'t have variable value in classification' do
@@ -438,7 +438,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
 
           context 'with existing variable implemented as host parameter' do
-            let(:parameter) { FactoryGirl.create(:host_parameter, :host => renderer.host, :name => 'client_key', :value => 'RSA KEY') }
+            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
@@ -459,15 +459,15 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
           context 'with existing variable implemented as smart variable' do
             let(:puppet_class) do
-              puppetclass = FactoryGirl.create(:puppetclass, :environments => [environment])
+              puppetclass = FactoryBot.create(:puppetclass, :environments => [environment])
               puppetclass.update_attribute(:hosts, [renderer.host])
               puppetclass
             end
             let(:lookup_key) do
-              FactoryGirl.create(:variable_lookup_key,
-                                 :key => 'client_key',
-                                 :puppetclass => puppet_class,
-                                 :overrides => {"fqdn=#{renderer.host.fqdn}" => 'RSA KEY'})
+              FactoryBot.create(:variable_lookup_key,
+                                :key => 'client_key',
+                                :puppetclass => puppet_class,
+                                :overrides => {"fqdn=#{renderer.host.fqdn}" => 'RSA KEY'})
             end
 
             describe 'rendering' do
@@ -496,16 +496,16 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
   end
 
   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(:template) { FactoryBot.build(:job_template, :template => 'echo "This is WebServer with nginx <%= input("nginx_version") -%>" > /etc/motd') }
     let(:renderer) { InputTemplateRenderer.new(template) }
 
     context 'with matching input defined' do
       before do
-        renderer.template.template_inputs<< FactoryGirl.build(:template_input,
-                                                              :name => 'nginx_version',
-                                                              :input_type => 'puppet_parameter',
-                                                              :puppet_parameter_name => 'version',
-                                                              :puppet_class_name => 'nginx')
+        renderer.template.template_inputs<< FactoryBot.build(:template_input,
+                                                             :name => 'nginx_version',
+                                                             :input_type => 'puppet_parameter',
+                                                             :puppet_parameter_name => 'version',
+                                                             :puppet_class_name => 'nginx')
       end
       let(:result) { renderer.render }
 
@@ -521,8 +521,8 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
         end
 
         context 'with host specified' do
-          let(:environment) { FactoryGirl.create(:environment) }
-          before { renderer.host = FactoryGirl.create(:host, :environment => environment) }
+          let(:environment) { FactoryBot.create(:environment) }
+          before { renderer.host = FactoryBot.create(:host, :environment => environment) }
 
           describe 'rendering' do
             it 'can\'t render the content without host since we don\'t have puppet parameter in classification' do
@@ -544,17 +544,17 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
           context 'with existing puppet parameter with matching override' do
             let(:puppet_class) do
-              puppetclass = FactoryGirl.create(:puppetclass, :environments => [environment], :name => 'nginx')
+              puppetclass = FactoryBot.create(:puppetclass, :environments => [environment], :name => 'nginx')
               puppetclass.update_attribute(:hosts, [renderer.host])
               puppetclass
             end
             let(:lookup_key) do
-              FactoryGirl.create(:puppetclass_lookup_key, :as_smart_class_param,
-                                 :key => 'version',
-                                 :puppetclass => puppet_class,
-                                 :path => 'fqdn',
-                                 :override => true,
-                                 :overrides => {"fqdn=#{renderer.host.fqdn}" => '1.4.7'})
+              FactoryBot.create(:puppetclass_lookup_key, :as_smart_class_param,
+                                :key => 'version',
+                                :puppetclass => puppet_class,
+                                :path => 'fqdn',
+                                :override => true,
+                                :overrides => {"fqdn=#{renderer.host.fqdn}" => '1.4.7'})
             end
 
             describe 'rendering' do