chef 14.14.29-universal-mingw32 → 14.15.6-universal-mingw32

data/spec/functional/resource/link_spec.rb

@@ -133,9 +133,9 @@ describe Chef::Resource::Link do
   end
 
   def get_sid(value)
-    if value.kind_of?(String)
+    if value.is_a?(String)
       Chef::ReservedNames::Win32::Security::SID.from_account(value)
-    elsif value.kind_of?(Chef::ReservedNames::Win32::Security::SID)
+    elsif value.is_a?(Chef::ReservedNames::Win32::Security::SID)
       value
     else
       raise "Must specify username or SID: #{value}"

data/spec/functional/resource/mount_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
-# Copyright:: Copyright 2013-2018, Chef Software Inc.
+# Copyright:: Copyright 2013-2019, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,14 +24,10 @@ require "tmpdir"
 # run this test only for following platforms.
 include_flag = !(%w{debian rhel amazon aix solaris2}.include?(ohai[:platform_family]))
 
-describe Chef::Resource::Mount, :requires_root, :skip_travis, external: include_flag do
-  # Disabled in travis because it refuses to let us mount a ramdisk. /dev/ramX does not
-  # exist even after loading the kernel module
-
+describe Chef::Resource::Mount, :requires_root, external: include_flag do
   include Chef::Mixin::ShellOut
 
   # Platform specific setup, cleanup and validation helpers.
-
   def setup_device_for_mount
     # use ramdisk for creating a test device for mount.
     # This can cleaner if we have chef resource/provider for ramdisk.
@@ -73,7 +69,7 @@ describe Chef::Resource::Mount, :requires_root, :skip_travis, external: include_
   def mount_should_exist(mount_point, device, fstype = nil, options = nil)
     validation_cmd = "mount | grep #{mount_point} | grep #{device} "
     validation_cmd << " | grep #{fstype} " unless fstype.nil?
-    validation_cmd << " | grep #{options.join(',')} " unless options.nil? || options.empty?
+    validation_cmd << " | grep #{options.join(",")} " unless options.nil? || options.empty?
     expect(shell_out(validation_cmd).exitstatus).to eq(0)
   end
 

data/spec/functional/resource/powershell_script_spec.rb

@@ -28,13 +28,13 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
 
   it_behaves_like "a Windows script running on Windows"
 
-  let(:successful_executable_script_content) { "#{ENV['SystemRoot']}\\system32\\attrib.exe $env:systemroot" }
-  let(:failed_executable_script_content) { "#{ENV['SystemRoot']}\\system32\\attrib.exe /badargument" }
+  let(:successful_executable_script_content) { "#{ENV["SystemRoot"]}\\system32\\attrib.exe $env:systemroot" }
+  let(:failed_executable_script_content) { "#{ENV["SystemRoot"]}\\system32\\attrib.exe /badargument" }
   let(:processor_architecture_script_content) { "echo $env:PROCESSOR_ARCHITECTURE" }
   let(:native_architecture_script_content) { "echo $env:PROCESSOR_ARCHITECTUREW6432" }
   let(:cmdlet_exit_code_not_found_content) { "get-item '.\\thisdoesnotexist'" }
   let(:cmdlet_exit_code_success_content) { "get-item ." }
-  let(:windows_process_exit_code_success_content) { "#{ENV['SystemRoot']}\\system32\\attrib.exe $env:systemroot" }
+  let(:windows_process_exit_code_success_content) { "#{ENV["SystemRoot"]}\\system32\\attrib.exe $env:systemroot" }
   let(:windows_process_exit_code_not_found_content) { "findstr /notavalidswitch" }
   let(:arbitrary_nonzero_process_exit_code) { 4193 }
   let(:arbitrary_nonzero_process_exit_code_content) { "exit #{arbitrary_nonzero_process_exit_code}" }
@@ -473,26 +473,26 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       end
 
       it "evaluates a not_if block using the cwd guard parameter" do
-        custom_cwd = "#{ENV['SystemRoot']}\\system32\\drivers\\etc"
+        custom_cwd = "#{ENV["SystemRoot"]}\\system32\\drivers\\etc"
         resource.not_if "exit ! [int32]($pwd.path -eq '#{custom_cwd}')", cwd: custom_cwd
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates an only_if block using the cwd guard parameter" do
-        custom_cwd = "#{ENV['SystemRoot']}\\system32\\drivers\\etc"
+        custom_cwd = "#{ENV["SystemRoot"]}\\system32\\drivers\\etc"
         resource.only_if "exit ! [int32]($pwd.path -eq '#{custom_cwd}')", cwd: custom_cwd
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "inherits cwd from the parent resource for only_if" do
-        custom_cwd = "#{ENV['SystemRoot']}\\system32\\drivers\\etc"
+        custom_cwd = "#{ENV["SystemRoot"]}\\system32\\drivers\\etc"
         resource.cwd custom_cwd
         resource.only_if "exit ! [int32]($pwd.path -eq '#{custom_cwd}')"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "inherits cwd from the parent resource for not_if" do
-        custom_cwd = "#{ENV['SystemRoot']}\\system32\\drivers\\etc"
+        custom_cwd = "#{ENV["SystemRoot"]}\\system32\\drivers\\etc"
         resource.cwd custom_cwd
         resource.not_if "exit ! [int32]($pwd.path -eq '#{custom_cwd}')"
         expect(resource.should_skip?(:run)).to be_truthy
@@ -584,7 +584,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
         resource.only_if "$true", architecture: :i386
         expect { resource.run_action(:run) }.to raise_error(
           Chef::Exceptions::Win32ArchitectureIncorrect,
-          /cannot execute script with requested architecture 'i386' on Windows Nano Server/)
+          /cannot execute script with requested architecture 'i386' on Windows Nano Server/
+        )
       end
     end
   end

data/spec/functional/resource/reboot_spec.rb

@@ -45,7 +45,7 @@ describe Chef::Resource::Reboot do
   shared_context "testing run context modification" do
     def test_reboot_action(resource)
       reboot_info = resource.run_context.reboot_info
-      expect(reboot_info.keys.sort).to eq([:delay_mins, :reason, :requested_by, :timestamp])
+      expect(reboot_info.keys.sort).to eq(%i{delay_mins reason requested_by timestamp})
       expect(reboot_info[:delay_mins]).to eq(expected[:delay_mins])
       expect(reboot_info[:reason]).to eq(expected[:reason])
       expect(reboot_info[:requested_by]).to eq(expected[:requested_by])

data/spec/functional/resource/remote_file_spec.rb

@@ -134,7 +134,7 @@ describe Chef::Resource::RemoteFile do
       let(:smb_file_local_file_name) { "smb_file.txt" }
       let(:smb_file_local_path) { File.join( smb_share_root_directory, smb_file_local_file_name ) }
       let(:smb_share_name) { "chef_smb_test" }
-      let(:smb_remote_path) { File.join("//#{ENV['COMPUTERNAME']}", smb_share_name, smb_file_local_file_name).gsub(/\//, "\\") }
+      let(:smb_remote_path) { File.join("//#{ENV["COMPUTERNAME"]}", smb_share_name, smb_file_local_file_name).gsub(%r{/}, "\\") }
       let(:smb_file_content) { "hellofun" }
       let(:local_destination_path) { File.join(Dir.tmpdir, make_tmpname("chef_remote_file")) }
       let(:windows_current_user) { ENV["USERNAME"] }
@@ -155,7 +155,7 @@ describe Chef::Resource::RemoteFile do
       before do
         shell_out("net.exe share #{smb_share_name} /delete")
         File.write(smb_file_local_path, smb_file_content )
-        shell_out!("net.exe share #{smb_share_name}=\"#{smb_share_root_directory.gsub(/\//, '\\')}\" /grant:\"authenticated users\",read")
+        shell_out!("net.exe share #{smb_share_name}=\"#{smb_share_root_directory.gsub(%r{/}, '\\')}\" /grant:\"authenticated users\",read")
       end
 
       after do

data/spec/functional/resource/template_spec.rb

@@ -21,7 +21,7 @@ require "spec_helper"
 describe Chef::Resource::Template do
 
   def binread(file)
-    File.open(file, "rb") { |f| f.read }
+    File.open(file, "rb", &:read)
   end
 
   include_context Chef::Resource::File

data/spec/functional/resource/user/windows_spec.rb

@@ -47,13 +47,13 @@ describe Chef::Provider::User::Windows, :windows_only do
   end
 
   def backup_secedit_policy
-    backup_command = "secedit /export /cfg #{ENV['TEMP']}\\secedit_restore.inf /areas SECURITYPOLICY"
+    backup_command = "secedit /export /cfg #{ENV["TEMP"]}\\secedit_restore.inf /areas SECURITYPOLICY"
     shell_out(backup_command)
   end
 
   def restore_secedit_policy
     security_database = "C:\\windows\\security\\database\\seceditnew.sdb"
-    restore_command = "secedit /configure /db #{security_database} /cfg #{ENV['TEMP']}\\secedit_restore.inf /areas SECURITYPOLICY"
+    restore_command = "secedit /configure /db #{security_database} /cfg #{ENV["TEMP"]}\\secedit_restore.inf /areas SECURITYPOLICY"
     shell_out(restore_command)
   end
 

data/spec/functional/resource/windows_certificate_spec.rb

@@ -81,9 +81,9 @@ describe Chef::Resource::WindowsCertificate, :windows_only, :appveyor_only do
 
     # Byepassing the validation so that we may create a custom store
     allow_any_instance_of(Chef::Mixin::ParamsValidate)
-          .to receive(:_pv_equal_to)
-          .with(opts, key, to_be)
-          .and_return(true)
+      .to receive(:_pv_equal_to)
+      .with(opts, key, to_be)
+      .and_return(true)
 
     # Creating a custom store for the testing
     create_store(store)

data/spec/functional/resource/windows_service_spec.rb

@@ -24,7 +24,7 @@ describe Chef::Resource::WindowsService, :windows_only, :system_windows_service_
   include_context "using Win32::Service"
 
   let(:username) { "service_spec_user" }
-  let(:qualified_username) { "#{ENV['COMPUTERNAME']}\\#{username}" }
+  let(:qualified_username) { "#{ENV["COMPUTERNAME"]}\\#{username}" }
   let(:password) { "1a2b3c4X!&narf" }
 
   let(:user_resource) do
@@ -36,7 +36,7 @@ describe Chef::Resource::WindowsService, :windows_only, :system_windows_service_
   end
 
   let(:global_service_file_path) do
-    "#{ENV['WINDIR']}\\temp\\#{File.basename(test_service[:service_file_path])}"
+    "#{ENV["WINDIR"]}\\temp\\#{File.basename(test_service[:service_file_path])}"
   end
 
   let(:service_params) do
@@ -59,7 +59,7 @@ describe Chef::Resource::WindowsService, :windows_only, :system_windows_service_
 
   let(:service_resource) do
     r = Chef::Resource::WindowsService.new(service_params[:service_name], run_context)
-    [:run_as_user, :run_as_password].each { |prop| r.send(prop, service_params[prop]) }
+    %i{run_as_user run_as_password}.each { |prop| r.send(prop, service_params[prop]) }
     r
   end
 

data/spec/functional/resource/windows_task_spec.rb

@@ -1283,6 +1283,57 @@ describe Chef::Resource::WindowsTask, :windows_only do
         expect(subject).not_to be_updated_by_last_action
       end
     end
+
+    context "when start_when_available is passed" do
+      subject do
+        new_resource = Chef::Resource::WindowsTask.new(task_name, run_context)
+        new_resource.command task_name
+        new_resource.run_level :highest
+        new_resource.execution_time_limit = 259200 / 60 # converting "PT72H" into minutes and passing here since win32-taskscheduler accespts this
+        new_resource
+      end
+
+      it "sets start_when_available to true" do
+        subject.frequency :minute
+        subject.start_when_available true
+        call_for_create_action
+        # loading current resource again to check new task is creted and it matches task parameters
+        current_resource = call_for_load_current_resource
+        expect(current_resource.exists).to eq(true)
+        expect(current_resource.task.settings[:start_when_available]).to eql(true)
+      end
+
+      it "sets start_when_available to false" do
+        subject.frequency :minute
+        subject.start_when_available false
+        call_for_create_action
+        # loading current resource again to check new task is created and it matches task parameters
+        current_resource = call_for_load_current_resource
+        expect(current_resource.exists).to eq(true)
+        expect(current_resource.task.settings[:start_when_available]).to eql(false)
+      end
+
+      it "sets the default if start_when_available is nil" do
+        subject.frequency :minute
+        subject.start_when_available nil
+        call_for_create_action
+        # loading current resource again to check new task is created and it matches task parameters
+        current_resource = call_for_load_current_resource
+        expect(current_resource.exists).to eq(true)
+        expect(current_resource.task.settings[:start_when_available]).to eql(false)
+      end
+
+      it "does not converge the resource if it is already converged" do
+        subject.frequency :minute
+        subject.start_when_available true
+        subject.run_action(:create)
+        subject.frequency :minute
+        subject.start_when_available true
+        subject.disallow_start_if_on_batteries false
+        subject.run_action(:create)
+        expect(subject).not_to be_updated_by_last_action
+      end
+    end
   end
 
   context "task_name with parent folder" do

data/spec/functional/run_lock_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2012-2016, Chef Software, Inc.
+# Copyright:: Copyright 2012-2020, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -334,6 +334,7 @@ describe Chef::RunLock do
       loop do
         line = readline_nonblock(read_from_process)
         break if line.nil?
+
         event, time = line.split("@")
         example.log_event("#{name}.last_event got #{event}")
         example.log_event("[#{name}] #{event}", time.strip)
@@ -346,7 +347,7 @@ describe Chef::RunLock do
       example.log_event("#{name}.run_to(#{to_event.inspect})")
 
       # Start the process if it's not started
-      start if !pid
+      start unless pid
 
       # Tell the process what to stop at (also means it can go)
       write_to_process.print "#{to_event}\n"
@@ -370,7 +371,7 @@ describe Chef::RunLock do
     def run_to_completion
       example.log_event("#{name}.run_to_completion")
       # Start the process if it's not started
-      start if !pid
+      start unless pid
 
       # Tell the process to stop at nothing (no blocking)
       @write_to_process.print "nothing\n"
@@ -403,6 +404,12 @@ describe Chef::RunLock do
           example.log_event("#{name}.stop finished (pid #{pid} wasn't running)")
         end
       end
+
+      # close the IO.pipes so we don't leak them as open filehandles
+      @read_from_process.close rescue nil
+      @write_to_tests.close rescue nil
+      @read_from_tests.close rescue nil
+      @write_to_process.close rescue nil
     end
 
     def fire_event(event)

data/spec/functional/shell_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2012-2017, Chef Software Inc.
+# Copyright:: Copyright 2012-2019, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/functional/util/powershell/cmdlet_spec.rb

@@ -29,7 +29,7 @@ describe Chef::Util::Powershell::Cmdlet, :windows_powershell_dsc_only do
   let(:invalid_cmdlet) { Chef::Util::Powershell::Cmdlet.new(@node, "get-idontexist", cmd_output_format) }
   let(:cmdlet_get_item_requires_switch_or_argument) { Chef::Util::Powershell::Cmdlet.new(@node, "get-item", cmd_output_format, { depth: 2 }) }
   let(:cmdlet_alias_requires_switch_or_argument) { Chef::Util::Powershell::Cmdlet.new(@node, "alias", cmd_output_format, { depth: 2 }) }
-  let(:etc_directory) { "#{ENV['systemroot']}\\system32\\drivers\\etc" }
+  let(:etc_directory) { "#{ENV["systemroot"]}\\system32\\drivers\\etc" }
   let(:architecture_cmdlet) { Chef::Util::Powershell::Cmdlet.new(@node, "$env:PROCESSOR_ARCHITECTURE") }
 
   it "executes a simple process" do

data/spec/functional/version_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Serdar Sutay (<dan@chef.io>)
-# Copyright:: Copyright 2013-2016, Chef Software Inc.
+# Copyright:: Copyright 2013-2019, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/functional/win32/security_spec.rb

@@ -61,7 +61,8 @@ describe "Chef::Win32::Security", :windows_only do
   describe "get_file_security" do
     it "should return a security descriptor when called with a path that exists" do
       security_descriptor = Chef::ReservedNames::Win32::Security.get_file_security(
-        "C:\\Program Files")
+        "C:\\Program Files"
+      )
       # Make sure the security descriptor works
       expect(security_descriptor.dacl_present?).to be true
     end
@@ -70,7 +71,8 @@ describe "Chef::Win32::Security", :windows_only do
   describe "access_check" do
     let(:security_descriptor) do
       Chef::ReservedNames::Win32::Security.get_file_security(
-        "C:\\Program Files")
+        "C:\\Program Files"
+      )
     end
 
     let(:token_rights) { Chef::ReservedNames::Win32::Security::TOKEN_ALL_ACCESS }
@@ -78,7 +80,8 @@ describe "Chef::Win32::Security", :windows_only do
     let(:token) do
       Chef::ReservedNames::Win32::Security.open_process_token(
         Chef::ReservedNames::Win32::Process.get_current_process,
-        token_rights).duplicate_token(:SecurityImpersonation)
+        token_rights
+      ).duplicate_token(:SecurityImpersonation)
     end
 
     let(:mapping) do
@@ -94,7 +97,7 @@ describe "Chef::Win32::Security", :windows_only do
 
     it "should check if the provided token has the desired access" do
       expect(Chef::ReservedNames::Win32::Security.access_check(security_descriptor,
-                     token, desired_access, mapping)).to be true
+        token, desired_access, mapping)).to be true
     end
   end
 
@@ -102,7 +105,8 @@ describe "Chef::Win32::Security", :windows_only do
     let(:token) do
       Chef::ReservedNames::Win32::Security.open_process_token(
         Chef::ReservedNames::Win32::Process.get_current_process,
-        token_rights)
+        token_rights
+      )
     end
     context "with all rights" do
       let(:token_rights) { Chef::ReservedNames::Win32::Security::TOKEN_ALL_ACCESS }
@@ -127,11 +131,12 @@ describe "Chef::Win32::Security", :windows_only do
     let(:token) do
       Chef::ReservedNames::Win32::Security.open_process_token(
         Chef::ReservedNames::Win32::Process.get_current_process,
-        token_rights)
+        token_rights
+      )
     end
 
     context "when the token is valid" do
-      let(:token_elevation_type) { [:TokenElevationTypeDefault, :TokenElevationTypeFull, :TokenElevationTypeLimited] }
+      let(:token_elevation_type) { %i{TokenElevationTypeDefault TokenElevationTypeFull TokenElevationTypeLimited} }
 
       it "returns the token elevation type" do
         elevation_type = Chef::ReservedNames::Win32::Security.get_token_information_elevation_type(token)

data/spec/functional/win32/service_manager_spec.rb

@@ -43,7 +43,7 @@ describe "Chef::Application::WindowsServiceManager", :windows_only, :system_wind
     end
 
     it "throws an error with required missing options" do
-      [:service_name, :service_display_name, :service_description, :service_file_path].each do |key|
+      %i{service_name service_display_name service_description service_file_path}.each do |key|
         service_def = test_service.dup
         service_def.delete(key)
 

data/spec/functional/win32/version_info_spec.rb

@@ -32,12 +32,12 @@ describe "Chef::ReservedNames::Win32::File::VersionInfo", :windows_only do
 
   subject { Chef::ReservedNames::Win32::File::VersionInfo.new(file_path) }
 
-  it "file version has the same version as windows" do
-    expect(subject.FileVersion).to start_with(os_version)
+  it "file version has the same major.minor version as windows" do
+    expect(subject.FileVersion).to start_with(os_version.rpartition(".").first)
   end
 
-  it "product version has the same version as windows" do
-    expect(subject.ProductVersion).to start_with(os_version)
+  it "product version has the same major.minor version as windows" do
+    expect(subject.ProductVersion).to start_with(os_version.rpartition(".").first)
   end
 
   it "company is microsoft" do

data/spec/integration/client/client_spec.rb

@@ -20,9 +20,7 @@ describe "chef-client" do
     # just a normal file
     # (expected_content should be uncompressed)
     @api.get("/recipes.tgz", 200) do
-      File.open(recipes_filename, "rb") do |f|
-        f.read
-      end
+      File.open(recipes_filename, "rb", &:read)
     end
   end
 
@@ -56,35 +54,19 @@ describe "chef-client" do
     it "should complete with success" do
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
-
-      shell_out!("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
-    end
-
-    it "should complete successfully with no other environment variables", skip: (Chef::Platform.windows?) do
-      file "config/client.rb", <<~EOM
-        local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
 
-      begin
-        result = shell_out("env -i #{critical_env_vars} #{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
-        result.error!
-      rescue
-        Chef::Log.info "Bare invocation will have the following load-path."
-        Chef::Log.info shell_out!("env -i #{critical_env_vars} ruby -e 'puts $:'").stdout
-        raise
-      end
+      shell_out!("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
     end
 
     it "should complete successfully with --no-listen" do
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
 
-      result = shell_out("#{chef_client} --no-listen -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      result = shell_out("#{chef_client} --no-listen -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
       result.error!
     end
 
@@ -125,10 +107,10 @@ EOM
     it "should complete with success" do
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
 
-      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
       result.error!
     end
 
@@ -162,40 +144,40 @@ EOM
           syHLXYFNy0OxMtH/bBAXBGNHd9gf5uOnqh0pYcbe/uRAxumC7Rl0cL509eURiA2T
           +vFmf54y9YdnLXaqv+FhJT6B6V7WX7IpU9BMqJY1cJYXHuHG2KA=
           -----END RSA PRIVATE KEY-----
-EOM
+        EOM
       end
 
       it "should complete with success even with a client key" do
         file "config/client.rb", <<~EOM
           local_mode true
-          client_key #{path_to('mykey.pem').inspect}
-          cookbook_path #{path_to('cookbooks').inspect}
-EOM
+          client_key #{path_to("mykey.pem").inspect}
+          cookbook_path #{path_to("cookbooks").inspect}
+        EOM
 
-        result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+        result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
         result.error!
       end
 
       it "should run recipes specified directly on the command line" do
         file "config/client.rb", <<~EOM
           local_mode true
-          client_key #{path_to('mykey.pem').inspect}
-          cookbook_path #{path_to('cookbooks').inspect}
-EOM
+          client_key #{path_to("mykey.pem").inspect}
+          cookbook_path #{path_to("cookbooks").inspect}
+        EOM
 
         file "arbitrary.rb", <<~EOM
-          file #{path_to('tempfile.txt').inspect} do
+          file #{path_to("tempfile.txt").inspect} do
             content '1'
           end
-EOM
+        EOM
 
         file "arbitrary2.rb", <<~EOM
-          file #{path_to('tempfile2.txt').inspect} do
+          file #{path_to("tempfile2.txt").inspect} do
             content '2'
           end
-EOM
+        EOM
 
-        result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" #{path_to('arbitrary.rb')} #{path_to('arbitrary2.rb')}", cwd: chef_dir)
+        result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" #{path_to("arbitrary.rb")} #{path_to("arbitrary2.rb")}", cwd: chef_dir)
         result.error!
 
         expect(IO.read(path_to("tempfile.txt"))).to eq("1")
@@ -205,17 +187,17 @@ EOM
       it "should run recipes specified as relative paths directly on the command line" do
         file "config/client.rb", <<~EOM
           local_mode true
-          client_key #{path_to('mykey.pem').inspect}
-          cookbook_path #{path_to('cookbooks').inspect}
-EOM
+          client_key #{path_to("mykey.pem").inspect}
+          cookbook_path #{path_to("cookbooks").inspect}
+        EOM
 
         file "arbitrary.rb", <<~EOM
-          file #{path_to('tempfile.txt').inspect} do
+          file #{path_to("tempfile.txt").inspect} do
             content '1'
           end
-EOM
+        EOM
 
-        result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" arbitrary.rb", cwd: path_to(""))
+        result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" arbitrary.rb", cwd: path_to(""))
         result.error!
 
         expect(IO.read(path_to("tempfile.txt"))).to eq("1")
@@ -224,22 +206,22 @@ EOM
       it "should run recipes specified directly on the command line AFTER recipes in the run list" do
         file "config/client.rb", <<~EOM
           local_mode true
-          client_key #{path_to('mykey.pem').inspect}
-          cookbook_path #{path_to('cookbooks').inspect}
-EOM
+          client_key #{path_to("mykey.pem").inspect}
+          cookbook_path #{path_to("cookbooks").inspect}
+        EOM
 
         file "cookbooks/x/recipes/constant_definition.rb", <<~EOM
           class ::Blah
             THECONSTANT = '1'
           end
-EOM
+        EOM
         file "arbitrary.rb", <<~EOM
-          file #{path_to('tempfile.txt').inspect} do
+          file #{path_to("tempfile.txt").inspect} do
             content ::Blah::THECONSTANT
           end
-EOM
+        EOM
 
-        result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o x::constant_definition arbitrary.rb", cwd: path_to(""))
+        result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o x::constant_definition arbitrary.rb", cwd: path_to(""))
         result.error!
 
         expect(IO.read(path_to("tempfile.txt"))).to eq("1")
@@ -250,30 +232,30 @@ EOM
     it "should complete with success when passed the -z flag" do
       file "config/client.rb", <<~EOM
         chef_server_url 'http://omg.com/blah'
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
 
-      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' -z", cwd: chef_dir)
+      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' -z", cwd: chef_dir)
       result.error!
     end
 
     it "should complete with success when passed the --local-mode flag" do
       file "config/client.rb", <<~EOM
         chef_server_url 'http://omg.com/blah'
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
 
-      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --local-mode", cwd: chef_dir)
+      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --local-mode", cwd: chef_dir)
       result.error!
     end
 
     it "should not print SSL warnings when running in local-mode" do
       file "config/client.rb", <<~EOM
         chef_server_url 'http://omg.com/blah'
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
 
-      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --local-mode", cwd: chef_dir)
+      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --local-mode", cwd: chef_dir)
       expect(result.stdout).not_to include("SSL validation of HTTPS requests is disabled.")
       result.error!
     end
@@ -281,20 +263,20 @@ EOM
     it "should complete with success when passed -z and --chef-zero-port" do
       file "config/client.rb", <<~EOM
         chef_server_url 'http://omg.com/blah'
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
 
-      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' -z", cwd: chef_dir)
+      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' -z", cwd: chef_dir)
       result.error!
     end
 
     it "should complete with success when setting the run list with -r" do
       file "config/client.rb", <<~EOM
         chef_server_url 'http://omg.com/blah'
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
 
-      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -r 'x::default' -z -l info", cwd: chef_dir)
+      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -r 'x::default' -z -l info", cwd: chef_dir)
       expect(result.stdout).not_to include("Overridden Run List")
       expect(result.stdout).to include("Run List is [recipe[x::default]]")
       result.error!
@@ -303,9 +285,9 @@ EOM
     it "should complete with success when using --profile-ruby and output a profile file", :not_supported_on_aix do
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
-      result = shell_out!("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' -z --profile-ruby", cwd: chef_dir)
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
+      result = shell_out!("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' -z --profile-ruby", cwd: chef_dir)
       result.error!
       expect(File.exist?(path_to("config/local-mode-cache/cache/graph_profile.out"))).to be true
     end
@@ -313,9 +295,9 @@ EOM
     it "doesn't produce a profile when --profile-ruby is not present" do
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
-      result = shell_out!("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' -z", cwd: chef_dir)
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
+      result = shell_out!("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' -z", cwd: chef_dir)
       result.error!
       expect(File.exist?(path_to("config/local-mode-cache/cache/graph_profile.out"))).to be false
     end
@@ -328,14 +310,14 @@ EOM
         name 'x'
         version '0.0.1'
         chef_version '~> 999.99'
-EOM
+      EOM
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
     end
     it "should fail the chef client run" do
-      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
       expect(command.exitstatus).to eql(1)
       expect(command.stdout).to match(/Chef::Exceptions::CookbookChefVersionMismatch/)
     end
@@ -356,12 +338,12 @@ EOM
       EOM
       file "config/client.rb", <<-EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
+        cookbook_path "#{path_to("cookbooks")}"
       EOM
     end
 
     it "the cheffish DSL is loaded lazily" do
-      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
       expect(command.exitstatus).to eql(0)
     end
   end
@@ -373,16 +355,16 @@ EOM
       EOM
       file "config/client.rb", <<-EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
+        cookbook_path "#{path_to("cookbooks")}"
       EOM
     end
 
     it "the cheffish DSL tries to load but fails (because chef-provisioning is not there)" do
       # we'd need to have a custom bundle to fix this that omitted chef-provisioning, but that would dig our crazy even deeper, so lets not
       skip "but if chef-provisioning is in our bundle or in our gemset then this test, very annoyingly, always fails"
-      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
       expect(command.exitstatus).to eql(1)
-      expect(command.stdout).to match(/cannot load such file -- chef\/provisioning/)
+      expect(command.stdout).to match(%r{cannot load such file -- chef/provisioning})
     end
   end
 
@@ -407,15 +389,15 @@ EOM
     it "should output each deprecation warning only once, at the end of the run" do
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
+        cookbook_path "#{path_to("cookbooks")}"
         # Mimick what happens when you are on the console
         formatters << :doc
         log_level :warn
-EOM
+      EOM
 
       ENV.delete("CHEF_TREAT_DEPRECATION_WARNINGS_AS_ERRORS")
 
-      result = shell_out!("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      result = shell_out!("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
       expect(result.error?).to be_falsey
 
       # Search to the end of the client run in the output
@@ -432,10 +414,10 @@ EOM
     before do
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
+        cookbook_path "#{path_to("cookbooks")}"
         audit_mode :enabled
         silence_deprecation_warnings %w{chef-27}
-EOM
+      EOM
     end
 
     it "should exit with a zero code when there is not an audit failure" do
@@ -447,7 +429,7 @@ EOM
         end
       RECIPE
 
-      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'audit_test::succeed' -l info", cwd: chef_dir)
+      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'audit_test::succeed' -l info", cwd: chef_dir)
       expect(result.error?).to be_falsey
       expect(result.stdout).to include("Successfully executed all `control_group` blocks and contained examples")
     end
@@ -461,7 +443,7 @@ EOM
         end
       RECIPE
 
-      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'audit_test::fail'", cwd: chef_dir)
+      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'audit_test::fail'", cwd: chef_dir)
       expect(result.error?).to be_truthy
       expect(result.stdout).to include("Failure/Error: expect(2 - 2).to eq(1)")
     end
@@ -470,7 +452,7 @@ EOM
   when_the_repository "has a cookbook that deploys a file" do
     before do
       file "cookbooks/x/recipes/default.rb", <<~RECIPE
-        cookbook_file #{path_to('tempfile.txt').inspect} do
+        cookbook_file #{path_to("tempfile.txt").inspect} do
           source "my_file"
         end
       RECIPE
@@ -486,9 +468,9 @@ EOM
           file "config/client.rb", <<~EOM
             no_lazy_load #{lazy}
             local_mode true
-            cookbook_path "#{path_to('cookbooks')}"
-EOM
-          result = shell_out("#{chef_client} -l debug -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+            cookbook_path "#{path_to("cookbooks")}"
+          EOM
+          result = shell_out("#{chef_client} -l debug -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
           result.error!
 
           expect(IO.read(path_to("tempfile.txt")).strip).to eq("this is my file")
@@ -500,7 +482,7 @@ EOM
   when_the_repository "has a cookbook with an ohai plugin" do
     before do
       file "cookbooks/x/recipes/default.rb", <<~RECIPE
-        file #{path_to('tempfile.txt').inspect} do
+        file #{path_to("tempfile.txt").inspect} do
           content node["english"]["version"]
         end
       RECIPE
@@ -518,12 +500,12 @@ EOM
 
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
     end
 
     it "should run the ohai plugin" do
-      result = shell_out("#{chef_client} -l debug -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      result = shell_out("#{chef_client} -l debug -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
       result.error!
 
       expect(IO.read(path_to("tempfile.txt"))).to eq("2014")
@@ -545,8 +527,8 @@ EOM
     it "should complete with success when passed -z and --recipe-url" do
       file "config/client.rb", <<~EOM
         chef_repo_path "#{tmp_dir}"
-EOM
-      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" --recipe-url=http://localhost:9000/recipes.tgz -o 'x::default' -z", cwd: tmp_dir)
+      EOM
+      result = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" --recipe-url=http://localhost:9000/recipes.tgz -o 'x::default' -z", cwd: tmp_dir)
       result.error!
     end
 
@@ -569,27 +551,27 @@ EOM
         name 'x'
         version '0.0.1'
         raise "TEH SADNESS"
-EOM
+      EOM
       file "cookbooks/x/metadata.json", <<~EOM
         {
           "name": "x",
           "version": "0.0.1"
         }
-EOM
+      EOM
 
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
     end
 
     it "the chef client run should succeed" do
-      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
       command.error!
     end
 
     it "a chef-solo run should succeed" do
-      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
       command.error!
     end
   end
@@ -603,30 +585,30 @@ EOM
 EOM
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
     end
 
     it "a chef client run should not log to info by default" do
-      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
       command.error!
       expect(command.stdout).not_to include("INFO")
     end
 
     it "a chef client run to a pipe should not log to info by default" do
-      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork | tee #{path_to('chefrun.out')}", cwd: chef_dir)
+      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork | tee #{path_to("chefrun.out")}", cwd: chef_dir)
       command.error!
       expect(command.stdout).not_to include("INFO")
     end
 
     it "a chef solo run should not log to info by default" do
-      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
       command.error!
       expect(command.stdout).not_to include("INFO")
     end
 
     it "a chef solo run to a pipe should not log to info by default" do
-      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork | tee #{path_to('chefrun.out')}", cwd: chef_dir)
+      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork | tee #{path_to("chefrun.out")}", cwd: chef_dir)
       command.error!
       expect(command.stdout).not_to include("INFO")
     end
@@ -636,45 +618,45 @@ EOM
     before do
       file "cookbooks/x/recipes/default.rb", <<~EOM
         puts Chef::Config[:client_fork] ? "WITHFORK" : "NOFORK"
-EOM
+      EOM
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
-EOM
+        cookbook_path "#{path_to("cookbooks")}"
+      EOM
     end
 
     it "chef-client runs by default with no supervisor" do
-      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
       command.error!
       expect(command.stdout).to include("NOFORK")
     end
 
     it "chef-solo runs by default with no supervisor" do
-      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
       command.error!
       expect(command.stdout).to include("NOFORK")
     end
 
     it "chef-client --no-fork does not fork" do
-      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
       command.error!
       expect(command.stdout).to include("NOFORK")
     end
 
     it "chef-solo --no-fork does not fork" do
-      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", cwd: chef_dir)
+      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --no-fork", cwd: chef_dir)
       command.error!
       expect(command.stdout).to include("NOFORK")
     end
 
     it "chef-client with --fork uses a supervisor" do
-      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --fork", cwd: chef_dir)
+      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --fork", cwd: chef_dir)
       command.error!
       expect(command.stdout).to include("WITHFORK")
     end
 
     it "chef-solo with --fork uses a supervisor" do
-      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --fork", cwd: chef_dir)
+      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default' --fork", cwd: chef_dir)
       command.error!
       expect(command.stdout).to include("WITHFORK")
     end
@@ -684,22 +666,22 @@ EOM
     before do
       file "cookbooks/x/recipes/default.rb", <<~EOM
         puts Chef::Config[:client_fork] ? "WITHFORK" : "NOFORK"
-EOM
+      EOM
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
+        cookbook_path "#{path_to("cookbooks")}"
         client_fork true
-EOM
+      EOM
     end
 
     it "chef-client uses a supervisor" do
-      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
       command.error!
       expect(command.stdout).to include("WITHFORK")
     end
 
     it "chef-solo uses a supervisor" do
-      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
       command.error!
       expect(command.stdout).to include("WITHFORK")
     end
@@ -709,22 +691,22 @@ EOM
     before do
       file "cookbooks/x/recipes/default.rb", <<~EOM
         puts Chef::Config[:client_fork] ? "WITHFORK" : "NOFORK"
-EOM
+      EOM
       file "config/client.rb", <<~EOM
         local_mode true
-        cookbook_path "#{path_to('cookbooks')}"
+        cookbook_path "#{path_to("cookbooks")}"
         client_fork false
-EOM
+      EOM
     end
 
     it "chef-client uses a supervisor" do
-      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command = shell_out("#{chef_client} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
       command.error!
       expect(command.stdout).to include("NOFORK")
     end
 
     it "chef-solo uses a supervisor" do
-      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default'", cwd: chef_dir)
+      command = shell_out("#{chef_solo} -c \"#{path_to("config/client.rb")}\" -o 'x::default'", cwd: chef_dir)
       command.error!
       expect(command.stdout).to include("NOFORK")
     end