foreman_remote_execution 3.0.3 → 3.1.0

data/test/functional/job_invocations_controller_test.rb

@@ -6,10 +6,10 @@ class JobInvocationsControllerTest < ActionController::TestCase
   test 'should parse inputs coming from the URL params' do
     template = FactoryBot.create(:job_template, :with_input)
     feature = FactoryBot.create(:remote_execution_feature,
-                                :job_template => template)
+      :job_template => template)
     params = {
       feature: feature.label,
-      inputs: { template.template_inputs.first.name => 'foobar' }
+      inputs: { template.template_inputs.first.name => 'foobar' },
     }
 
     get :new, params: params, session: set_session_user
@@ -19,20 +19,20 @@ class JobInvocationsControllerTest < ActionController::TestCase
         [
           {
             'value' => 'foobar',
-            'template_input_id' => template.template_inputs.first.id
-          }
+            'template_input_id' => template.template_inputs.first.id,
+          },
         ],
-        'template_id' => template.id
-      }
+        'template_id' => template.id,
+      },
     ]
     assert_equal(template_invocation_params,
-                 assigns(:composer).params['template_invocations'])
+      assigns(:composer).params['template_invocations'])
   end
 
   test 'should allow no inputs' do
     template = FactoryBot.create(:job_template)
     feature = FactoryBot.create(:remote_execution_feature,
-                                :job_template => template)
+      :job_template => template)
     params = {
       feature: feature.label,
     }
@@ -40,10 +40,10 @@ class JobInvocationsControllerTest < ActionController::TestCase
     template_invocation_params = [
       {
         'template_id' => template.id,
-        'input_values' => {}
-      }
+        'input_values' => {},
+      },
     ]
     assert_equal(template_invocation_params,
-                 assigns(:composer).params['template_invocations'])
+      assigns(:composer).params['template_invocations'])
   end
 end

data/test/functional/job_templates_controller_test.rb

@@ -16,7 +16,7 @@ class JobTemplatesControllerTest < ActionController::TestCase
       post :preview, params: {
         job_template: template.to_param,
         template: '<%= @host.name %>',
-        preview_host_id: host.id
+        preview_host_id: host.id,
       }, session: set_session_user
       assert_response :success
       assert_equal host.name, @response.body

data/test/unit/actions/run_hosts_job_test.rb

@@ -54,13 +54,13 @@ module ForemanRemoteExecution
         delayed
         assert_not targeting.resolved?
         planned
-        targeting.hosts.must_include(host)
+        _(targeting.hosts).must_include(host)
       end
 
       it 'resolves the hosts on static targeting in delay' do
         assert_not targeting.resolved?
         delayed
-        targeting.hosts.must_include(host)
+        _(targeting.hosts).must_include(host)
         # Verify Targeting#resolve_hosts! won't be hit again
         targeting.expects(:resolve_hosts!).never
         planned
@@ -68,7 +68,7 @@ module ForemanRemoteExecution
 
       it 'resolves the hosts on static targeting in plan phase if not resolved yet' do
         planned
-        targeting.hosts.must_include(host)
+        _(targeting.hosts).must_include(host)
       end
     end
 
@@ -80,16 +80,16 @@ module ForemanRemoteExecution
 
     it 'uses the BindJobInvocation middleware' do
       planned
-      job_invocation.task_id.must_equal uuid
+      _(job_invocation.task_id).must_equal uuid
     end
 
     # In plan phase this is handled by #action_subject
     #   which is expected in tests
     it 'sets input in delay phase when delayed' do
       job_invocation_hash = delayed.input[:job_invocation]
-      job_invocation_hash['id'].must_equal job_invocation.id
-      job_invocation_hash['name'].must_equal job_invocation.job_category
-      job_invocation_hash['description'].must_equal job_invocation.description
+      _(job_invocation_hash['id']).must_equal job_invocation.id
+      _(job_invocation_hash['name']).must_equal job_invocation.job_category
+      _(job_invocation_hash['description']).must_equal job_invocation.description
       planned # To make the expectations happy
     end
 
@@ -100,7 +100,7 @@ module ForemanRemoteExecution
       it 'can be disabled' do
         job_invocation.expects(:concurrency_level)
         job_invocation.expects(:time_span)
-        planned.input.key?(:concurrency_control).must_equal false
+        _(planned.input.key?(:concurrency_control)).must_equal false
       end
 
       it 'can limit concurrency level' do

data/test/unit/concerns/foreman_tasks_cleaner_extensions_test.rb

@@ -18,11 +18,11 @@ class ForemanRemoteExecutionForemanTasksCleanerExtensionsTest < ActiveSupport::T
 
   it 'removes orphaned job invocations' do
     job = FactoryBot.create(:job_invocation, :with_task)
-    JobInvocation.where(:id => job.id).count.must_equal 1
+    _(JobInvocation.where(:id => job.id).count).must_equal 1
     job.task.delete
     job.reload
-    job.task.must_be :nil?
-    job.task_id.wont_be :nil?
+    _(job.task).must_be :nil?
+    _(job.task_id).wont_be :nil?
     ForemanTasks::Cleaner.new(:filter => '').delete
     JobInvocation.where(:id => job.id).must_be :empty?
   end

data/test/unit/concerns/host_extensions_test.rb

@@ -20,32 +20,32 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
     end
 
     it 'has ssh user in the parameters' do
-      host.host_param('remote_execution_ssh_user').must_equal Setting[:remote_execution_ssh_user]
+      _(host.host_param('remote_execution_ssh_user')).must_equal Setting[:remote_execution_ssh_user]
     end
 
     it 'can override ssh user' do
       host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_ssh_user', :value => 'amy')
-      host.host_param('remote_execution_ssh_user').must_equal 'amy'
+      _(host.host_param('remote_execution_ssh_user')).must_equal 'amy'
     end
 
     it 'has effective user method in the parameters' do
-      host.host_param('remote_execution_effective_user_method').must_equal Setting[:remote_execution_effective_user_method]
+      _(host.host_param('remote_execution_effective_user_method')).must_equal Setting[:remote_execution_effective_user_method]
     end
 
     it 'can override effective user method' do
       host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_effective_user_method', :value => 'su')
-      host.host_param('remote_execution_effective_user_method').must_equal 'su'
+      _(host.host_param('remote_execution_effective_user_method')).must_equal 'su'
     end
 
     it 'has ssh keys in the parameters' do
-      host.remote_execution_ssh_keys.must_include sshkey
+      _(host.remote_execution_ssh_keys).must_include sshkey
     end
 
     it 'merges ssh keys from host parameters and proxies' do
       key = 'ssh-rsa not-even-a-key something@somewhere.com'
       host.host_parameters << FactoryBot.create(:host_parameter, :host => host, :name => 'remote_execution_ssh_keys', :value => [key])
-      host.host_param('remote_execution_ssh_keys').must_include key
-      host.host_param('remote_execution_ssh_keys').must_include sshkey
+      _(host.host_param('remote_execution_ssh_keys')).must_include key
+      _(host.host_param('remote_execution_ssh_keys')).must_include sshkey
     end
 
     it 'has ssh keys in the parameters even when no user specified' do
@@ -53,7 +53,7 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
       FactoryBot.create(:smart_proxy, :ssh)
       host.interfaces.first.subnet.remote_execution_proxies.clear
       User.current = nil
-      host.remote_execution_ssh_keys.must_include sshkey
+      _(host.remote_execution_ssh_keys).must_include sshkey
     end
   end
 
@@ -63,11 +63,11 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
     it 'should only have one execution interface' do
       host.interfaces << FactoryBot.build(:nic_managed)
       host.interfaces.each { |interface| interface.execution = true }
-      host.wont_be :valid?
+      _(host).wont_be :valid?
     end
 
     it 'returns the execution interface' do
-      host.execution_interface.must_be_kind_of Nic::Managed
+      _(host.execution_interface).must_be_kind_of Nic::Managed
     end
   end
 
@@ -86,16 +86,16 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
 
     it 'finds hosts for job_invocation.id' do
       found_ids = Host.search_for("job_invocation.id = #{job.id}").map(&:id).sort
-      found_ids.must_equal job.template_invocations_host_ids.sort
+      _(found_ids).must_equal job.template_invocations_host_ids.sort
     end
 
     it 'finds hosts by job_invocation.result' do
       success, failed = job.template_invocations
                            .partition { |template| template.run_host_job_task.result == 'success' }
       found_ids = Host.search_for('job_invocation.result = success').map(&:id)
-      found_ids.must_equal success.map(&:host_id)
+      _(found_ids).must_equal success.map(&:host_id)
       found_ids = Host.search_for('job_invocation.result = failed').map(&:id)
-      found_ids.must_equal failed.map(&:host_id)
+      _(found_ids).must_equal failed.map(&:host_id)
     end
 
     it 'finds hosts by job_invocation.id and job_invocation.result' do
@@ -103,17 +103,17 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
       job
       job2
 
-      Host.search_for("job_invocation.id = #{job.id}").count.must_equal 2
-      Host.search_for("job_invocation.id = #{job2.id}").count.must_equal 2
-      Host.search_for('job_invocation.result = success').count.must_equal 2
-      Host.search_for('job_invocation.result = failed').count.must_equal 2
+      _(Host.search_for("job_invocation.id = #{job.id}").count).must_equal 2
+      _(Host.search_for("job_invocation.id = #{job2.id}").count).must_equal 2
+      _(Host.search_for('job_invocation.result = success').count).must_equal 2
+      _(Host.search_for('job_invocation.result = failed').count).must_equal 2
 
       success, failed = job.template_invocations
                            .partition { |template| template.run_host_job_task.result == 'success' }
       found_ids = Host.search_for("job_invocation.id = #{job.id} AND job_invocation.result = success").map(&:id)
-      found_ids.must_equal success.map(&:host_id)
+      _(found_ids).must_equal success.map(&:host_id)
       found_ids = Host.search_for("job_invocation.id = #{job.id} AND job_invocation.result = failed").map(&:id)
-      found_ids.must_equal failed.map(&:host_id)
+      _(found_ids).must_equal failed.map(&:host_id)
     end
   end
 

data/test/unit/concerns/nic_extensions_test.rb

@@ -4,6 +4,6 @@ class ForemanRemoteExecutionNicExtensionsTest < ActiveSupport::TestCase
   let(:host) { FactoryBot.create(:host) }
 
   it 'sets the first primary interface as the execution interface' do
-    host.execution_interface.must_equal host.interfaces.first
+    _(host.execution_interface).must_equal host.interfaces.first
   end
 end

data/test/unit/execution_task_status_mapper_test.rb

@@ -5,11 +5,11 @@ class ExecutionTaskStatusMapperTest < ActiveSupport::TestCase
     let(:subject) { HostStatus::ExecutionStatus::ExecutionTaskStatusMapper }
 
     it 'accepts status number as well as string representation' do
-      subject.sql_conditions_for(HostStatus::ExecutionStatus::ERROR).must_equal subject.sql_conditions_for('failed')
+      _(subject.sql_conditions_for(HostStatus::ExecutionStatus::ERROR)).must_equal subject.sql_conditions_for('failed')
     end
 
     it 'does not find any task for unknown state' do
-      subject.sql_conditions_for(-1).must_equal [ '1 = 0' ]
+      _(subject.sql_conditions_for(-1)).must_equal [ '1 = 0' ]
     end
   end
 
@@ -22,12 +22,12 @@ class ExecutionTaskStatusMapperTest < ActiveSupport::TestCase
     describe 'is queued' do
       context 'when there is no task' do
         before { subject.task = nil }
-        specify { subject.status.must_equal HostStatus::ExecutionStatus::QUEUED }
+        specify { _(subject.status).must_equal HostStatus::ExecutionStatus::QUEUED }
       end
 
       context 'when the task is scheduled in future' do
         before { subject.task.state = 'scheduled' }
-        specify { subject.status.must_equal HostStatus::ExecutionStatus::QUEUED }
+        specify { _(subject.status).must_equal HostStatus::ExecutionStatus::QUEUED }
       end
     end
 
@@ -37,19 +37,19 @@ class ExecutionTaskStatusMapperTest < ActiveSupport::TestCase
       describe 'is succeeded' do
         context 'without error' do
           before { subject.task.result = 'success' }
-          specify { subject.status.must_equal HostStatus::ExecutionStatus::OK }
+          specify { _(subject.status).must_equal HostStatus::ExecutionStatus::OK }
         end
       end
 
       describe 'is failed' do
         context 'with error' do
           before { subject.task.result = 'error' }
-          specify { subject.status.must_equal HostStatus::ExecutionStatus::ERROR }
+          specify { _(subject.status).must_equal HostStatus::ExecutionStatus::ERROR }
         end
 
         context 'without error but just with warning (sub task failed)' do
           before { subject.task.result = 'warning' }
-          specify { subject.status.must_equal HostStatus::ExecutionStatus::ERROR }
+          specify { _(subject.status).must_equal HostStatus::ExecutionStatus::ERROR }
         end
       end
     end
@@ -58,7 +58,7 @@ class ExecutionTaskStatusMapperTest < ActiveSupport::TestCase
       before { subject.task.state = 'running' }
 
       describe 'is pending' do
-        specify { subject.status.must_equal HostStatus::ExecutionStatus::RUNNING }
+        specify { _(subject.status).must_equal HostStatus::ExecutionStatus::RUNNING }
       end
     end
   end
@@ -73,7 +73,7 @@ class ExecutionTaskStatusMapperTest < ActiveSupport::TestCase
       end
 
       it 'returns ok label' do
-        subject.must_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::OK]
+        _(subject).must_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::OK]
       end
     end
 
@@ -84,7 +84,7 @@ class ExecutionTaskStatusMapperTest < ActiveSupport::TestCase
       end
 
       it 'returns failed label' do
-        subject.must_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::ERROR]
+        _(subject).must_equal HostStatus::ExecutionStatus::STATUS_NAMES[HostStatus::ExecutionStatus::ERROR]
       end
     end
   end

data/test/unit/input_template_renderer_test.rb

@@ -7,17 +7,17 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
     let(:renderer) { InputTemplateRenderer.new(FactoryBot.build(:job_template, :template => 'id <%= preview? %>')) }
 
     it 'should render the content' do
-      renderer.render.must_equal 'id false'
+      _(renderer.render).must_equal 'id false'
     end
 
     it 'should render preview' do
-      renderer.preview.must_equal 'id true'
+      _(renderer.preview).must_equal 'id true'
     end
 
     it 'should allow accessing current_user' do
       setup_user(:view_job_templates)
       renderer = InputTemplateRenderer.new(FactoryBot.build(:job_template, :template => "They call me '<%= current_user %>'"))
-      renderer.preview.must_equal "They call me '#{User.current.login}'"
+      _(renderer.preview).must_equal "They call me '#{User.current.login}'"
     end
   end
 
@@ -28,23 +28,23 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
     context 'but without input defined' do
       describe 'rendering' do
         let(:result) { renderer.render }
-        it { result.must_equal false }
+        it { _(result).must_equal false }
 
         it 'registers an error' do
           result # let is lazy
-          renderer.error_message.wont_be_nil
-          renderer.error_message.wont_be_empty
+          _(renderer.error_message).wont_be_nil
+          _(renderer.error_message).wont_be_empty
         end
       end
 
       describe 'preview' do
         let(:result) { renderer.preview }
-        it { result.must_equal false }
+        it { _(result).must_equal false }
 
         it 'registers an error' do
           result # let is lazy
-          renderer.error_message.wont_be_nil
-          renderer.error_message.wont_be_empty
+          _(renderer.error_message).wont_be_nil
+          _(renderer.error_message).wont_be_empty
         end
       end
     end
@@ -62,41 +62,41 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
       describe 'rendering' do
         it 'can preview' do
-          renderer.preview.must_equal 'service restart $USER_INPUT[service_name]'
+          _(renderer.preview).must_equal 'service restart $USER_INPUT[service_name]'
         end
 
         context 'with invocation specified and a required input' do
           before do
-            template.template_inputs.first.update_attributes(:required => true)
+            template.template_inputs.first.update(:required => true)
             template_invocation.reload
             renderer.invocation = template_invocation
           end
 
           it 'cannot render the content' do
             assert_not result
-            renderer.error_message.wont_be_nil
-            renderer.error_message.wont_be_empty
+            _(renderer.error_message).wont_be_nil
+            _(renderer.error_message).wont_be_empty
           end
         end
 
         context 'with invocation specified' do
           before do
             FactoryBot.create(:template_invocation_input_value,
-                              :template_invocation => template_invocation,
-                              :template_input => template.template_inputs.first,
-                              :value => 'foreman')
+              :template_invocation => template_invocation,
+              :template_input => template.template_inputs.first,
+              :value => 'foreman')
             template_invocation.reload # need to get input_values findable
             renderer.invocation = template_invocation
           end
 
           it 'can render with job invocation with corresponding value' do
-            renderer.render.must_equal 'service restart foreman'
+            _(renderer.render).must_equal 'service restart foreman'
           end
         end
 
         it 'renders even without an input value' do
           renderer.invocation = template_invocation
-          renderer.render.must_equal 'service restart '
+          _(renderer.render).must_equal 'service restart '
         end
 
         describe 'with circular reference' do
@@ -126,7 +126,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
             renderer.invocation = FactoryBot.build(:template_invocation, :template => template_without_inputs)
             renderer.template = template_without_inputs
             assert_not renderer.render
-            renderer.error_message.must_include 'Recursive rendering of templates detected'
+            _(renderer.error_message).must_include 'Recursive rendering of templates detected'
           end
 
           it 'handles circular references in inputs' do
@@ -161,7 +161,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
       let(:template) do
         FactoryBot.create(:job_template,
-                          :template => '<%= render_template("package action", { :action => "install" }, { :with_foreign_input_set => true }) %>').tap do |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
@@ -189,13 +189,13 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
           let(:template_2) do
             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 => '')
+                :target_template => package_template, :include_all => true, :include => '', :exclude => '')
             end
           end
 
           it 'includes all inputs from the imported template' do
-            template.template_inputs_with_foreign.map(&:name).sort.must_equal ['action', 'debug', 'package']
-            template_2.template_inputs_with_foreign.map(&:name).sort.must_equal ['action', 'debug', 'package']
+            _(template.template_inputs_with_foreign.map(&:name).sort).must_equal ['action', 'debug', 'package']
+            _(template_2.template_inputs_with_foreign.map(&:name).sort).must_equal ['action', 'debug', 'package']
           end
         end
 
@@ -207,7 +207,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
           end
 
           it 'includes all inputs from the imported template except the listed once' do
-            template.template_inputs_with_foreign.map(&:name).sort.must_equal ['package']
+            _(template.template_inputs_with_foreign.map(&:name).sort).must_equal ['package']
           end
         end
 
@@ -220,7 +220,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
           end
 
           it 'includes all inputs from the imported template' do
-            template.template_inputs_with_foreign.map(&:name).sort.must_equal ['package']
+            _(template.template_inputs_with_foreign.map(&:name).sort).must_equal ['package']
           end
         end
       end
@@ -228,24 +228,24 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
       context 'with invocation specified' do
         before do
           FactoryBot.create(:template_invocation_input_value,
-                            :template_invocation => template_invocation,
-                            :template_input => template.template_inputs_with_foreign.find { |input| input.name == 'package' },
-                            :value => 'zsh')
+            :template_invocation => template_invocation,
+            :template_input => template.template_inputs_with_foreign.find { |input| input.name == 'package' },
+            :value => 'zsh')
           renderer.invocation = template_invocation
           renderer.invocation.reload
         end
 
         it 'can render with job invocation with corresponding value' do
           rendered = renderer.render
-          renderer.error_message.must_be_nil
-          rendered.must_equal 'yum -y install zsh'
+          _(renderer.error_message).must_be_nil
+          _(rendered).must_equal 'yum -y install zsh'
         end
       end
 
       context 'with explicitly specifying inputs' do
         let(:template) do
           FactoryBot.create(:job_template,
-                            :template => '<%= render_template("package action", {"action" => "install", :package => "zsh"}) %>')
+            :template => '<%= render_template("package action", {"action" => "install", :package => "zsh"}) %>')
         end
 
         before do
@@ -255,16 +255,16 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         it 'can render with job invocation with corresponding value' do
           rendered = renderer.render
-          renderer.error_message.must_be_nil
-          rendered.must_equal 'yum -y install zsh'
+          _(renderer.error_message).must_be_nil
+          _(rendered).must_equal 'yum -y install zsh'
         end
       end
 
       it 'renders even without an input value' do
         renderer.invocation = template_invocation
         rendered = renderer.render
-        renderer.error_message.must_be_nil
-        rendered.must_equal 'yum -y install '
+        _(renderer.error_message).must_be_nil
+        _(rendered).must_equal 'yum -y install '
       end
     end
 
@@ -275,9 +275,9 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
       let(:required) { false }
       let(:input) do
         FactoryBot.create(:template_invocation_input_value,
-                          :template_invocation => template_invocation,
-                          :template_input => template.template_inputs.first,
-                          :value => 'foreman')
+          :template_invocation => template_invocation,
+          :template_input => template.template_inputs.first,
+          :value => 'foreman')
       end
 
       before do
@@ -291,7 +291,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
       context 'with a valid input defined' do
         context 'with an optional input' do
           it 'can render with job invocation with corresponding value' do
-            result.must_equal 'service restart foreman'
+            _(result).must_equal 'service restart foreman'
           end
         end
 
@@ -299,7 +299,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
           let(:required) { true }
 
           it 'renders the template when the input is provided' do
-            result.must_equal 'service restart foreman'
+            _(result).must_equal 'service restart foreman'
           end
         end
       end
@@ -309,7 +309,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         context 'with optional input' do
           it 'renders the template' do
-            result.must_equal 'service restart '
+            _(result).must_equal 'service restart '
           end
         end
 
@@ -340,8 +340,8 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         it 'registers an error' do
           result # let is lazy
-          renderer.error_message.wont_be_nil
-          renderer.error_message.wont_be_empty
+          _(renderer.error_message).wont_be_nil
+          _(renderer.error_message).wont_be_empty
         end
 
         context 'with host specified' do
@@ -354,14 +354,14 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
             it 'registers an error' do
               result # let is lazy
-              renderer.error_message.wont_be_nil
-              renderer.error_message.wont_be_empty
+              _(renderer.error_message).wont_be_nil
+              _(renderer.error_message).wont_be_empty
             end
           end
 
           describe 'preview' do
             it 'should render preview' do
-              renderer.preview.must_equal 'echo $FACT_INPUT[issue] > /etc/issue'
+              _(renderer.preview).must_equal 'echo $FACT_INPUT[issue] > /etc/issue'
             end
           end
 
@@ -376,14 +376,14 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
               it 'registers an error' do
                 result # let is lazy
-                renderer.error_message.wont_be_nil
-                renderer.error_message.wont_be_empty
+                _(renderer.error_message).wont_be_nil
+                _(renderer.error_message).wont_be_empty
               end
             end
 
             describe 'preview' do
               it 'should render preview' do
-                renderer.preview.must_equal 'echo $FACT_INPUT[issue] > /etc/issue'
+                _(renderer.preview).must_equal 'echo $FACT_INPUT[issue] > /etc/issue'
               end
             end
 
@@ -393,7 +393,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
               let(:result) { renderer.render }
 
               it 'can render with job invocation with corresponding value' do
-                result.must_equal 'echo banner > /etc/issue'
+                _(result).must_equal 'echo banner > /etc/issue'
               end
             end
           end
@@ -402,7 +402,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
       describe 'preview' do
         it 'should render preview' do
-          renderer.preview.must_equal 'echo $FACT_INPUT[issue] > /etc/issue'
+          _(renderer.preview).must_equal 'echo $FACT_INPUT[issue] > /etc/issue'
         end
 
         context 'with host specified' do
@@ -416,7 +416,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
           let(:result) { renderer.render }
 
           it 'uses the value even in preview' do
-            result.must_equal 'echo banner > /etc/issue'
+            _(result).must_equal 'echo banner > /etc/issue'
           end
         end
       end
@@ -438,8 +438,8 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         it 'registers an error' do
           result # let is lazy
-          renderer.error_message.wont_be_nil
-          renderer.error_message.wont_be_empty
+          _(renderer.error_message).wont_be_nil
+          _(renderer.error_message).wont_be_empty
         end
 
         context 'with host specified' do
@@ -456,14 +456,14 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
             it 'registers an error' do
               result # let is lazy
-              renderer.error_message.wont_be_nil
-              renderer.error_message.wont_be_empty
+              _(renderer.error_message).wont_be_nil
+              _(renderer.error_message).wont_be_empty
             end
           end
 
           describe 'preview' do
             it 'should render preview' do
-              renderer.preview.must_equal 'echo $VARIABLE_INPUT[client_key] > /etc/chef/client.pem'
+              _(renderer.preview).must_equal 'echo $VARIABLE_INPUT[client_key] > /etc/chef/client.pem'
             end
           end
 
@@ -475,7 +475,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
               it 'renders the value from host parameter' do
                 parameter
                 renderer.host.reload
-                result.must_equal 'echo RSA KEY > /etc/chef/client.pem'
+                _(result).must_equal 'echo RSA KEY > /etc/chef/client.pem'
               end
             end
 
@@ -483,7 +483,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
               it 'should render preview' do
                 parameter
                 renderer.host.reload
-                renderer.preview.must_equal 'echo RSA KEY > /etc/chef/client.pem'
+                _(renderer.preview).must_equal 'echo RSA KEY > /etc/chef/client.pem'
               end
             end
           end
@@ -491,7 +491,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         describe 'preview' do
           it 'should render preview' do
-            renderer.preview.must_equal 'echo $VARIABLE_INPUT[client_key] > /etc/chef/client.pem'
+            _(renderer.preview).must_equal 'echo $VARIABLE_INPUT[client_key] > /etc/chef/client.pem'
           end
         end
       end
@@ -505,10 +505,10 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
     context 'with matching input defined' do
       before do
         renderer.template.template_inputs<< FactoryBot.build(:template_input,
-                                                             :name => 'nginx_version',
-                                                             :input_type => 'puppet_parameter',
-                                                             :puppet_parameter_name => 'version',
-                                                             :puppet_class_name => 'nginx')
+          :name => 'nginx_version',
+          :input_type => 'puppet_parameter',
+          :puppet_parameter_name => 'version',
+          :puppet_class_name => 'nginx')
       end
       let(:result) { renderer.render }
 
@@ -519,8 +519,8 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         it 'registers an error' do
           result # let is lazy
-          renderer.error_message.wont_be_nil
-          renderer.error_message.wont_be_empty
+          _(renderer.error_message).wont_be_nil
+          _(renderer.error_message).wont_be_empty
         end
 
         context 'with host specified' do
@@ -534,14 +534,14 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
             it 'registers an error' do
               result # let is lazy
-              renderer.error_message.wont_be_nil
-              renderer.error_message.wont_be_empty
+              _(renderer.error_message).wont_be_nil
+              _(renderer.error_message).wont_be_empty
             end
           end
 
           describe 'preview' do
             it 'should render preview' do
-              renderer.preview.must_equal 'echo "This is WebServer with nginx $PUPPET_PARAMETER_INPUT[nginx_version]" > /etc/motd'
+              _(renderer.preview).must_equal 'echo "This is WebServer with nginx $PUPPET_PARAMETER_INPUT[nginx_version]" > /etc/motd'
             end
           end
 
@@ -553,24 +553,24 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
             end
             let(:lookup_key) do
               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'})
+                :key => 'version',
+                :puppetclass => puppet_class,
+                :path => 'fqdn',
+                :override => true,
+                :overrides => {"fqdn=#{renderer.host.fqdn}" => '1.4.7'})
             end
 
             describe 'rendering' do
               it 'renders the value from puppet parameter' do
                 lookup_key
-                result.must_equal 'echo "This is WebServer with nginx 1.4.7" > /etc/motd'
+                _(result).must_equal 'echo "This is WebServer with nginx 1.4.7" > /etc/motd'
               end
             end
 
             describe 'preview' do
               it 'should render preview' do
                 lookup_key
-                renderer.preview.must_equal 'echo "This is WebServer with nginx 1.4.7" > /etc/motd'
+                _(renderer.preview).must_equal 'echo "This is WebServer with nginx 1.4.7" > /etc/motd'
               end
             end
           end
@@ -578,7 +578,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
 
         describe 'preview' do
           it 'should render preview' do
-            renderer.preview.must_equal 'echo "This is WebServer with nginx $PUPPET_PARAMETER_INPUT[nginx_version]" > /etc/motd'
+            _(renderer.preview).must_equal 'echo "This is WebServer with nginx $PUPPET_PARAMETER_INPUT[nginx_version]" > /etc/motd'
           end
         end
       end