foreman_remote_execution 1.4.1 → 1.4.2

data/test/unit/job_invocation_composer_test.rb

@@ -4,6 +4,7 @@ RemoteExecutionProvider.register(:Mcollective, OpenStruct)
 
 class JobInvocationComposerTest < ActiveSupport::TestCase
   before do
+    setup_user('create', 'template_invocations')
     setup_user('view',   'job_templates', 'name ~ trying*')
     setup_user('create', 'job_templates', 'name ~ trying*')
     setup_user('view',   'job_invocations')
@@ -15,17 +16,17 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
     setup_user('create', 'hosts')
   end
 
-  let(:trying_job_template_1) { FactoryGirl.create(:job_template, :job_category => 'trying_job_template_1', :name => 'trying1', :provider_type => 'SSH') }
-  let(:trying_job_template_2) { FactoryGirl.create(:job_template, :job_category => 'trying_job_template_2', :name => 'trying2', :provider_type => 'Mcollective') }
-  let(:trying_job_template_3) { FactoryGirl.create(:job_template, :job_category => 'trying_job_template_1', :name => 'trying3', :provider_type => 'SSH') }
-  let(:unauthorized_job_template_1) { FactoryGirl.create(:job_template, :job_category => 'trying_job_template_1', :name => 'unauth1', :provider_type => 'SSH') }
-  let(:unauthorized_job_template_2) { FactoryGirl.create(:job_template, :job_category => 'unauthorized_job_template_2', :name => 'unauth2', :provider_type => 'Ansible') }
+  let(:trying_job_template_1) { FactoryBot.create(:job_template, :job_category => 'trying_job_template_1', :name => 'trying1', :provider_type => 'SSH') }
+  let(:trying_job_template_2) { FactoryBot.create(:job_template, :job_category => 'trying_job_template_2', :name => 'trying2', :provider_type => 'Mcollective') }
+  let(:trying_job_template_3) { FactoryBot.create(:job_template, :job_category => 'trying_job_template_1', :name => 'trying3', :provider_type => 'SSH') }
+  let(:unauthorized_job_template_1) { FactoryBot.create(:job_template, :job_category => 'trying_job_template_1', :name => 'unauth1', :provider_type => 'SSH') }
+  let(:unauthorized_job_template_2) { FactoryBot.create(:job_template, :job_category => 'unauthorized_job_template_2', :name => 'unauth2', :provider_type => 'Ansible') }
 
 
-  let(:input1) { FactoryGirl.create(:template_input, :template => trying_job_template_1, :input_type => 'user') }
-  let(:input2) { FactoryGirl.create(:template_input, :template => trying_job_template_3, :input_type => 'user') }
-  let(:input3) { FactoryGirl.create(:template_input, :template => trying_job_template_1, :input_type => 'user', :required => true) }
-  let(:unauthorized_input1) { FactoryGirl.create(:template_input, :template => unauthorized_job_template_1, :input_type => 'user') }
+  let(:input1) { FactoryBot.create(:template_input, :template => trying_job_template_1, :input_type => 'user') }
+  let(:input2) { FactoryBot.create(:template_input, :template => trying_job_template_3, :input_type => 'user') }
+  let(:input3) { FactoryBot.create(:template_input, :template => trying_job_template_1, :input_type => 'user', :required => true) }
+  let(:unauthorized_input1) { FactoryBot.create(:template_input, :template => unauthorized_job_template_1, :input_type => 'user') }
 
   let(:ansible_params) { { } }
   let(:ssh_params) { { } }
@@ -140,7 +141,7 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
 
       describe '#templates_for_provider(provider_type)' do
         it 'returns all templates for a given provider respecting template permissions' do
-          trying_job_template_4 = FactoryGirl.create(:job_template, :job_category => 'trying_job_template_1', :name => 'trying4', :provider_type => 'Ansible')
+          trying_job_template_4 = FactoryBot.create(:job_template, :job_category => 'trying_job_template_1', :name => 'trying4', :provider_type => 'Ansible')
           result = composer.templates_for_provider('SSH')
           result.must_include trying_job_template_1
           result.must_include trying_job_template_3
@@ -161,8 +162,8 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
         end
 
         context 'extra unavailable templates id were selected' do
-          let(:unauthorized) { FactoryGirl.create(:job_template, :job_category => 'trying_job_template_1', :name => 'unauth3', :provider_type => 'Ansible') }
-          let(:mcollective_authorized) { FactoryGirl.create(:job_template, :job_category => 'trying_job_template_1', :name => 'trying4', :provider_type => 'Mcollective') }
+          let(:unauthorized) { FactoryBot.create(:job_template, :job_category => 'trying_job_template_1', :name => 'unauth3', :provider_type => 'Ansible') }
+          let(:mcollective_authorized) { FactoryBot.create(:job_template, :job_category => 'trying_job_template_1', :name => 'trying4', :provider_type => 'Mcollective') }
           let(:ssh_params) { { :job_template_id => trying_job_template_1.id.to_s } }
           let(:ansible_params) { { :job_template_id => unauthorized.id.to_s } }
           let(:mcollective_params) { { :job_template_id => mcollective_authorized.id.to_s } }
@@ -270,7 +271,7 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
           composer.displayed_search_query.must_be_empty
         end
 
-        let(:host) { FactoryGirl.create(:host) }
+        let(:host) { FactoryBot.create(:host) }
         let(:bookmark) { Bookmark.create!(:query => 'b', :name => 'bookmark', :public => true, :controller => 'hosts') }
 
         context 'all targetings parameters are present' do
@@ -336,7 +337,7 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
       end
 
       describe '#targeted_hosts_count' do
-        let(:host) { FactoryGirl.create(:host) }
+        let(:host) { FactoryBot.create(:host) }
 
         it 'obeys authorization' do
           composer.stubs(:displayed_search_query => "name = #{host.name}")
@@ -402,7 +403,7 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
       end
 
       describe '#valid?' do
-        let(:host) { FactoryGirl.create(:host) }
+        let(:host) { FactoryBot.create(:host) }
         let(:ssh_params) do
           { :job_template_id => trying_job_template_1.id.to_s,
             :job_templates => {
@@ -484,7 +485,7 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
       end
 
       describe '#compose_from_invocation(existing_invocation)' do
-        let(:host) { FactoryGirl.create(:host) }
+        let(:host) { FactoryBot.create(:host) }
         let(:ssh_params) do
           { :job_template_id => trying_job_template_1.id.to_s,
             :job_templates => {

data/test/unit/job_invocation_test.rb

@@ -1,8 +1,8 @@
 require 'test_plugin_helper'
 
 class JobInvocationTest < ActiveSupport::TestCase
-  let(:job_invocation) { FactoryGirl.build(:job_invocation) }
-  let(:template) { FactoryGirl.create(:job_template, :with_input) }
+  let(:job_invocation) { FactoryBot.build(:job_invocation) }
+  let(:template) { FactoryBot.create(:job_template, :with_input) }
 
   context 'search for job invocations' do
     before do
@@ -27,7 +27,7 @@ class JobInvocationTest < ActiveSupport::TestCase
 
   context 'can delete a host' do
     let(:host) do
-      FactoryGirl.create(:host)
+      FactoryBot.create(:host)
     end
 
     it 'can remove a host' do
@@ -40,17 +40,17 @@ class JobInvocationTest < ActiveSupport::TestCase
   end
 
   context 'has template invocations with input values' do
-    let(:job_invocation) { FactoryGirl.create(:job_invocation, :with_template) }
+    let(:job_invocation) { FactoryBot.create(:job_invocation, :with_template) }
 
     before do
       input = job_invocation.pattern_template_invocations.first.template.template_inputs.create!(:name => 'foo', :required => true, :input_type => 'user')
       input2 = job_invocation.pattern_template_invocations.first.template.template_inputs.create!(:name => 'bar', :required => true, :input_type => 'user')
-      FactoryGirl.create(:template_invocation_input_value,
-                         :template_invocation => job_invocation.pattern_template_invocations.first,
-                         :template_input => input2)
-      @input_value = FactoryGirl.create(:template_invocation_input_value,
-                                        :template_invocation => job_invocation.pattern_template_invocations.first,
-                                        :template_input => input)
+      FactoryBot.create(:template_invocation_input_value,
+                        :template_invocation => job_invocation.pattern_template_invocations.first,
+                        :template_input => input2)
+      @input_value = FactoryBot.create(:template_invocation_input_value,
+                                       :template_invocation => job_invocation.pattern_template_invocations.first,
+                                       :template_input => input)
       job_invocation.reload
       job_invocation.pattern_template_invocations.first.reload
     end

data/test/unit/job_template_effective_user_test.rb

@@ -1,7 +1,7 @@
 require 'test_plugin_helper'
 
 class JobTemplateEffectiveUserTest < ActiveSupport::TestCase
-  let(:job_template) { FactoryGirl.build(:job_template, :job_category => '') }
+  let(:job_template) { FactoryBot.build(:job_template, :job_category => '') }
   let(:effective_user) { job_template.effective_user }
 
   before do
@@ -20,7 +20,7 @@ class JobTemplateEffectiveUserTest < ActiveSupport::TestCase
 
   describe 'compute value' do
     it 'computes the value based on the current user when current_user set to true' do
-      user = FactoryGirl.create(:user)
+      user = FactoryBot.create(:user)
       User.current = user
       effective_user.current_user = true
       effective_user.compute_value.must_equal user.login

data/test/unit/job_template_importer_test.rb

@@ -5,7 +5,7 @@ class JobTemplateImporterTest < ActiveSupport::TestCase
     # JobTemplate tests handle most of this, we just check that the shim
     # correctly loads a template returns a hash
     let(:remote_execution_feature) do
-      FactoryGirl.create(:remote_execution_feature)
+      FactoryBot.create(:remote_execution_feature)
     end
 
     let(:result) do
@@ -46,7 +46,7 @@ class JobTemplateImporterTest < ActiveSupport::TestCase
   context 'updating locked template' do
     it 'does not update locked template' do
       name = 'Locked job template'
-      template = FactoryGirl.create(:job_template, :locked => true, :name => name)
+      template = FactoryBot.create(:job_template, :locked => true, :name => name)
       res = JobTemplateImporter.import!(name, 'some text', 'metadata')
       assert_equal "Skipping Template #{template.id}:#{template.name} - template is locked", res[:result]
     end
@@ -58,7 +58,7 @@ class JobTemplateImporterTest < ActiveSupport::TestCase
         'kind' => 'job_template',
         'name' => name
       }
-      template = FactoryGirl.create(:job_template, :locked => true, :name => name)
+      template = FactoryBot.create(:job_template, :locked => true, :name => name)
       res = JobTemplateImporter.import!(name, 'some text', metadata, true)
       assert_equal "  Updated Template #{template.id}:Locked job template again", res[:result]
     end

data/test/unit/job_template_test.rb

@@ -2,17 +2,17 @@ require 'test_plugin_helper'
 
 class JobTemplateTest < ActiveSupport::TestCase
   context 'when creating a template' do
-    let(:job_template) { FactoryGirl.build(:job_template, :job_category => '') }
+    let(:job_template) { FactoryBot.build(:job_template, :job_category => '') }
     let(:template_with_inputs) do
-      FactoryGirl.build(:job_template, :template => 'test').tap do |template|
-        template.template_inputs << FactoryGirl.build(:template_input, :name => 'command', :input_type => 'user')
+      FactoryBot.build(:job_template, :template => 'test').tap do |template|
+        template.template_inputs << FactoryBot.build(:template_input, :name => 'command', :input_type => 'user')
         template.save!
       end
     end
 
     it 'has a unique name' do
-      template1 = FactoryGirl.create(:job_template)
-      template2 = FactoryGirl.build(:job_template, :name => template1.name)
+      template1 = FactoryBot.create(:job_template)
+      template2 = FactoryBot.build(:job_template, :name => template1.name)
       refute template2.valid?
     end
 
@@ -27,17 +27,17 @@ class JobTemplateTest < ActiveSupport::TestCase
 
     it 'validates the inputs are uniq in the template' do
       job_template.job_category = 'Miscellaneous'
-      job_template.foreign_input_sets << FactoryGirl.build(:foreign_input_set, :target_template => template_with_inputs)
-      job_template.foreign_input_sets << FactoryGirl.build(:foreign_input_set, :target_template => template_with_inputs)
+      job_template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => template_with_inputs)
+      job_template.foreign_input_sets << FactoryBot.build(:foreign_input_set, :target_template => template_with_inputs)
       refute job_template.valid?
       job_template.errors.full_messages.first.must_include 'Duplicated inputs detected: ["command"]'
     end
   end
 
   context 'description format' do
-    let(:template_with_description) { FactoryGirl.build(:job_template, :with_description_format, :job_category => 'test job') }
-    let(:template) { FactoryGirl.build(:job_template, :with_input, :job_category => 'test job') }
-    let(:minimal_template) { FactoryGirl.build(:job_template) }
+    let(:template_with_description) { FactoryBot.build(:job_template, :with_description_format, :job_category => 'test job') }
+    let(:template) { FactoryBot.build(:job_template, :with_input, :job_category => 'test job') }
+    let(:minimal_template) { FactoryBot.build(:job_template) }
 
     it 'uses the description_format attribute if set' do
       template_with_description.generate_description_format.must_equal template_with_description.description_format
@@ -59,7 +59,7 @@ class JobTemplateTest < ActiveSupport::TestCase
   end
 
   context 'cloning' do
-    let(:job_template) { FactoryGirl.build(:job_template, :with_input) }
+    let(:job_template) { FactoryBot.build(:job_template, :with_input) }
 
     describe '#dup' do
       it 'duplicates also template inputs' do
@@ -74,7 +74,7 @@ class JobTemplateTest < ActiveSupport::TestCase
 
   context 'importing a new template' do
     let(:remote_execution_feature) do
-      FactoryGirl.create(:remote_execution_feature)
+      FactoryBot.create(:remote_execution_feature)
     end
 
     let(:template) do
@@ -239,7 +239,7 @@ class JobTemplateTest < ActiveSupport::TestCase
 
   context 'template export' do
     let(:exportable_template) do
-      FactoryGirl.create(:job_template, :with_input)
+      FactoryBot.create(:job_template, :with_input)
     end
 
     let(:erb) do
@@ -270,7 +270,7 @@ class JobTemplateTest < ActiveSupport::TestCase
   end
 
   context 'there is existing template invocation of a job template' do
-    let(:job_invocation) { FactoryGirl.create(:job_invocation, :with_template) }
+    let(:job_invocation) { FactoryBot.create(:job_invocation, :with_template) }
     let(:job_template) { job_invocation.pattern_template_invocations.first.template }
 
     describe 'job template deletion' do
@@ -283,7 +283,7 @@ class JobTemplateTest < ActiveSupport::TestCase
 
   context 'template locked' do
     it 'inputs cannot be changed' do
-      job_template = FactoryGirl.create(:job_template, :with_input, :locked => true)
+      job_template = FactoryBot.create(:job_template, :with_input, :locked => true)
       Foreman.expects(:in_rake?).returns(false).at_least_once
       assert_valid job_template
       job_template.template_inputs.first.name = 'something else'

data/test/unit/remote_execution_feature_test.rb

@@ -13,14 +13,14 @@ class RemoteExecutionFeatureTest < ActiveSupport::TestCase
   end
 
   let(:package_template) do
-    FactoryGirl.create(:job_template).tap do |job_template|
+    FactoryBot.create(:job_template).tap do |job_template|
       job_template.job_category = 'Package Action'
       job_template.name = 'Package Action - SSH Default'
       job_template.template_inputs.create(:name => 'package', :input_type => 'user')
     end
   end
 
-  let(:host) { FactoryGirl.create(:host) }
+  let(:host) { FactoryBot.create(:host) }
 
   before do
     User.current = users :admin
@@ -76,7 +76,7 @@ class RemoteExecutionFeatureTest < ActiveSupport::TestCase
 
 
     it 'updates a feature if it exists' do
-      existing = FactoryGirl.create(:remote_execution_feature, :name => 'existing_feature_withou_action_button')
+      existing = FactoryBot.create(:remote_execution_feature, :name => 'existing_feature_withou_action_button')
       feature = RemoteExecutionFeature.register(existing.label, existing.name, :host_action_button => true)
       feature.must_be :persisted?
       existing.reload

data/test/unit/remote_execution_provider_test.rb

@@ -51,16 +51,16 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
   end
 
   describe SSHExecutionProvider do
-    before { User.current = FactoryGirl.build(:user, :admin) }
+    before { User.current = FactoryBot.build(:user, :admin) }
     after { User.current = nil }
 
     before do
       Setting::RemoteExecution.load_defaults
     end
 
-    let(:job_invocation) { FactoryGirl.create(:job_invocation, :with_template) }
+    let(:job_invocation) { FactoryBot.create(:job_invocation, :with_template) }
     let(:template_invocation) { job_invocation.pattern_template_invocations.first }
-    let(:host) { FactoryGirl.create(:host) }
+    let(:host) { FactoryBot.create(:host) }
     let(:proxy_options) { SSHExecutionProvider.proxy_command_options(template_invocation, host) }
 
     describe 'effective user' do
@@ -73,7 +73,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
     describe 'ssh user' do
       it 'uses the remote_execution_ssh_user on the host param' do
         host.params['remote_execution_ssh_user'] = 'my user'
-        host.host_parameters << FactoryGirl.create(:host_parameter, :host => host, :name => 'remote_execution_ssh_user', :value => 'my user')
+        host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_ssh_user', :value => 'my user')
         proxy_options[:ssh_user].must_equal 'my user'
       end
     end
@@ -81,7 +81,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
     describe 'sudo' do
       it 'uses the remote_execution_ssh_user on the host param' do
         host.params['remote_execution_effective_user_method'] = 'sudo'
-        method_param = FactoryGirl.create(:host_parameter, :host => host, :name => 'remote_execution_effective_user_method', :value => 'sudo')
+        method_param = FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_effective_user_method', :value => 'sudo')
         host.host_parameters << method_param
         proxy_options[:effective_user_method].must_equal 'sudo'
         method_param.update_attributes!(:value => 'su')
@@ -105,7 +105,7 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
     describe 'ssh port from params' do
       it 'takes ssh port number from params and check return type' do
         host.params['remote_execution_ssh_port'] = '30'
-        host.host_parameters << FactoryGirl.build(:host_parameter, :name => 'remote_execution_ssh_port', :value => '30')
+        host.host_parameters << FactoryBot.build(:host_parameter, :name => 'remote_execution_ssh_port', :value => '30')
         host.clear_host_parameters_cache!
         proxy_options[:ssh_port].must_be_kind_of Integer
         proxy_options[:ssh_port].must_equal 30
@@ -114,9 +114,9 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
 
     describe '#find_ip_or_hostname' do
       let(:host) do
-        FactoryGirl.create(:host) do |host|
-          host.interfaces = [FactoryGirl.build(:nic_managed, flags.merge(:ip => nil, :name => 'somehost.somedomain.org', :primary => true)),
-                             FactoryGirl.build(:nic_managed, flags.merge(:ip => '127.0.0.1'))]
+        FactoryBot.create(:host) do |host|
+          host.interfaces = [FactoryBot.build(:nic_managed, flags.merge(:ip => nil, :name => 'somehost.somedomain.org', :primary => true)),
+                             FactoryBot.build(:nic_managed, flags.merge(:ip => '127.0.0.1'))]
         end
       end
 
@@ -129,8 +129,8 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         SSHExecutionProvider.find_ip_or_hostname(host).must_equal 'somehost.somedomain.org'
 
         # execution wins if present
-        execution_interface = FactoryGirl.build(:nic_managed,
-                                                flags.merge(:execution => true, :name => 'special.somedomain.org'))
+        execution_interface = FactoryBot.build(:nic_managed,
+                                               flags.merge(:execution => true, :name => 'special.somedomain.org'))
         host.interfaces << execution_interface
         host.primary_interface.update_attributes(:execution => false)
         host.interfaces.each(&:save)
@@ -144,8 +144,8 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         SSHExecutionProvider.find_ip_or_hostname(host).must_equal 'somehost.somedomain.org'
 
         # provision interface with ip while primary without
-        provision_interface = FactoryGirl.build(:nic_managed,
-                                                flags.merge(:provision => true, :ip => '10.0.0.1'))
+        provision_interface = FactoryBot.build(:nic_managed,
+                                               flags.merge(:provision => true, :ip => '10.0.0.1'))
         host.interfaces << provision_interface
         host.primary_interface.update_attributes(:provision => false)
         host.interfaces.each(&:save)
@@ -158,8 +158,8 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         SSHExecutionProvider.find_ip_or_hostname(host).must_equal host.primary_interface.ip
 
         # there is an execution interface with IP: it wins
-        execution_interface = FactoryGirl.build(:nic_managed,
-                                                flags.merge(:execution => true, :ip => '10.0.0.3'))
+        execution_interface = FactoryBot.build(:nic_managed,
+                                               flags.merge(:execution => true, :ip => '10.0.0.3'))
         host.interfaces << execution_interface
         host.primary_interface.update_attributes(:execution => false)
         host.interfaces.each(&:save)

data/test/unit/targeting_test.rb

@@ -1,9 +1,9 @@
 require 'test_plugin_helper'
 
 class TargetingTest < ActiveSupport::TestCase
-  let(:targeting) { FactoryGirl.build(:targeting) }
+  let(:targeting) { FactoryBot.build(:targeting) }
   let(:bookmark) { bookmarks(:one) }
-  let(:host) { FactoryGirl.create(:host) }
+  let(:host) { FactoryBot.create(:host) }
 
   before do
     bookmark.query = 'name = bar'
@@ -78,7 +78,7 @@ class TargetingTest < ActiveSupport::TestCase
   end
 
   describe '#build_query_from_hosts(ids)' do
-    let(:second_host) { FactoryGirl.create(:host) }
+    let(:second_host) { FactoryBot.create(:host) }
 
     before do
       host

data/test/unit/template_input_test.rb

@@ -1,7 +1,7 @@
 require 'test_plugin_helper'
 
 class TemplateInputTest < ActiveSupport::TestCase
-  let(:template_input) { FactoryGirl.build(:template_input) }
+  let(:template_input) { FactoryBot.build(:template_input) }
 
   context 'export' do
     before do

data/test/unit/template_invocation_input_value_test.rb

@@ -1,38 +1,38 @@
 require 'test_plugin_helper'
 
 class TemplateInvocationInputTest < ActiveSupport::TestCase
-  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) }
-  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 }
 
   context 'with selectable options' do
     before do
       result # let is lazy
-      template.template_inputs << FactoryGirl.build(:template_input, :name => 'service_name', :input_type => 'user',
-                                                                     :required => true, :options => "foreman\nhttpd")
+      template.template_inputs << FactoryBot.build(:template_input, :name => 'service_name', :input_type => 'user',
+                                                                    :required => true, :options => "foreman\nhttpd")
     end
 
     it 'fails with an invalid option' do
-      refute_valid FactoryGirl.build(:template_invocation_input_value, :template_invocation => template_invocation,
-                                                                       :template_input => template.template_inputs.first,
-                                                                       :value => 'sendmail')
+      refute_valid FactoryBot.build(:template_invocation_input_value, :template_invocation => template_invocation,
+                                                                      :template_input => template.template_inputs.first,
+                                                                      :value => 'sendmail')
     end
 
     it 'succeeds with valid option' do
-      assert_valid FactoryGirl.build(:template_invocation_input_value, :template_invocation => template_invocation,
-                                                                       :template_input => template.template_inputs.first,
-                                                                       :value => 'foreman')
+      assert_valid FactoryBot.build(:template_invocation_input_value, :template_invocation => template_invocation,
+                                                                      :template_input => template.template_inputs.first,
+                                                                      :value => 'foreman')
     end
   end
 
   it 'supports large inputs' do
-    template.template_inputs << FactoryGirl.build(:template_input, :name => 'service_name',
-                                                                   :input_type => 'user', :required => true)
-    assert_valid FactoryGirl.create(:template_invocation_input_value,
-                                    :template_invocation => template_invocation,
-                                    :template_input => template.template_inputs.first,
-                                    :value => 'foreman' * 1_000_000)
+    template.template_inputs << FactoryBot.build(:template_input, :name => 'service_name',
+                                                                  :input_type => 'user', :required => true)
+    assert_valid FactoryBot.create(:template_invocation_input_value,
+                                   :template_invocation => template_invocation,
+                                   :template_input => template.template_inputs.first,
+                                   :value => 'foreman' * 1_000_000)
   end
 end