chef 12.6.0-universal-mingw32 → 12.7.2-universal-mingw32

data/spec/functional/resource/mount_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Copyright:: Copyright 2013-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,12 +16,13 @@
 # limitations under the License.
 #
 
-require 'functional/resource/base'
-require 'chef/mixin/shell_out'
-require 'tmpdir'
+require "spec_helper"
+require "functional/resource/base"
+require "chef/mixin/shell_out"
+require "tmpdir"
 
 # run this test only for following platforms.
-include_flag = !(['ubuntu', 'centos', 'solaris2'].include?(ohai[:platform]))
+include_flag = !(["ubuntu", "centos", "aix", "solaris2"].include?(ohai[:platform]))
 
 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
@@ -34,16 +35,13 @@ describe Chef::Resource::Mount, :requires_root, :skip_travis, :external => inclu
   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.
-    # TODO: These tests only work in LPARs, not WPARs on AIX.
     case ohai[:platform]
     when "aix"
-      ramdisk = shell_out!("mkramdisk 16M").stdout
-
-      # identify device, for /dev/rramdisk0 it is /dev/ramdisk0
-      device = ramdisk.tr("\n","").gsub(/\/rramdisk/, '/ramdisk')
-
-      fstype = "jfs2"
-      shell_out!("mkfs  -V #{fstype} #{device}")
+      # On AIX, we can't create a ramdisk inside a WPAR, so we use
+      # a "namefs" mount against / to test
+      # https://www-304.ibm.com/support/knowledgecenter/ssw_aix_71/com.ibm.aix.performance/namefs_file_sys.htm
+      device = "/"
+      fstype = "namefs"
     when "ubuntu", "centos"
       device = "/dev/ram1"
       shell_out("ls -1 /dev/ram*").stdout.each_line do |d|
@@ -63,15 +61,6 @@ describe Chef::Resource::Mount, :requires_root, :skip_travis, :external => inclu
     [device, fstype]
   end
 
-  def cleanup_device(device)
-    case ohai[:platform]
-    when "aix"
-      ramdisk = device.gsub(/\/ramdisk/, '/rramdisk')
-      shell_out("rmramdisk #{ramdisk}")
-    else
-    end
-  end
-
   def cleanup_mount(mount_point)
     shell_out("umount #{mount_point}")
   end
@@ -90,9 +79,9 @@ describe Chef::Resource::Mount, :requires_root, :skip_travis, :external => inclu
 
   def unix_mount_config_file
     case ohai[:platform]
-    when 'aix'
+    when "aix"
       mount_config = "/etc/filesystems"
-    when 'solaris2'
+    when "solaris2"
       mount_config = "/etc/vfstab"
     else
       mount_config = "/etc/fstab"
@@ -101,7 +90,7 @@ describe Chef::Resource::Mount, :requires_root, :skip_travis, :external => inclu
 
   def mount_should_be_enabled(mount_point, device)
     case ohai[:platform]
-    when 'aix'
+    when "aix"
       expect(shell_out("cat #{unix_mount_config_file} | grep \"#{mount_point}:\" ").exitstatus).to eq(0)
     else
       expect(shell_out("cat #{unix_mount_config_file} | grep \"#{mount_point}\" | grep \"#{device}\" ").exitstatus).to eq(0)
@@ -117,7 +106,7 @@ describe Chef::Resource::Mount, :requires_root, :skip_travis, :external => inclu
     new_resource.device      @device
     new_resource.name        @mount_point
     new_resource.fstype      @fstype
-    new_resource.options     "log=NULL" if ohai[:platform] == 'aix'
+    new_resource.options     "log=NULL" if ohai[:platform] == "aix"
     new_resource
   end
 
@@ -149,7 +138,6 @@ describe Chef::Resource::Mount, :requires_root, :skip_travis, :external => inclu
 
   after(:all) do
     Dir.rmdir(@mount_point)
-    cleanup_device(@device)
   end
 
   after(:each) do
@@ -175,10 +163,10 @@ describe Chef::Resource::Mount, :requires_root, :skip_travis, :external => inclu
       mount_should_exist(new_resource.mount_point, new_resource.device)
 
       new_resource.supports[:remount] = true
-      new_resource.options "rw,log=NULL" if ohai[:platform] == 'aix'
+      new_resource.options "rw" if ohai[:platform] == "aix"
       new_resource.run_action(:remount)
 
-      mount_should_exist(new_resource.mount_point, new_resource.device, nil, (ohai[:platform] == 'aix') ? new_resource.options : nil)
+      mount_should_exist(new_resource.mount_point, new_resource.device, nil, (ohai[:platform] == "aix") ? new_resource.options : nil)
     end
   end
 

data/spec/functional/resource/ohai_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Serdar Sutay (<serdar@opscode.com>)
-# Copyright:: Copyright (c) 2014 Opscode, Inc.
+# Author:: Serdar Sutay (<serdar@chef.io>)
+# Copyright:: Copyright 2014-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,13 +16,11 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::Resource::Ohai do
   let(:ohai) {
-    o = Ohai::System.new
-    o.all_plugins
-    o
+    OHAI_SYSTEM
   }
 
   let(:node) { Chef::Node.new }
@@ -47,7 +45,7 @@ describe Chef::Resource::Ohai do
   end
 
   describe "when reloading all plugins" do
-    let(:ohai_resource) { Chef::Resource::Ohai.new("reload all", run_context)}
+    let(:ohai_resource) { Chef::Resource::Ohai.new("reload all", run_context) }
 
     it_behaves_like "reloaded :uptime"
   end
@@ -59,7 +57,6 @@ describe Chef::Resource::Ohai do
       r
     }
 
-
     it_behaves_like "reloaded :uptime"
   end
 end

data/spec/functional/resource/package_spec.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 #
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2013-2015 Chef Software, Inc.
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2013-2016, Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,8 +17,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'webrick'
+require "spec_helper"
+require "webrick"
 
 module AptServer
   def enable_testing_apt_source
@@ -54,7 +54,7 @@ module AptServer
       :DocumentRoot => apt_data_dir + "/var/www/apt",
       # Make WEBrick quiet, comment out for debug.
       :Logger       => Logger.new(StringIO.new),
-      :AccessLog    => [ StringIO.new, WEBrick::AccessLog::COMMON_LOG_FORMAT ]
+      :AccessLog    => [ StringIO.new, WEBrick::AccessLog::COMMON_LOG_FORMAT ],
     )
   end
 
@@ -87,9 +87,9 @@ module AptServer
 end
 
 metadata = { :unix_only => true,
-  :requires_root => true,
-  :provider => {:package => Chef::Provider::Package::Apt},
-  :arch => "x86_64" # test packages are 64bit
+             :requires_root => true,
+             :provider => { :package => Chef::Provider::Package::Apt },
+             :arch => "x86_64" # test packages are 64bit
 }
 
 describe Chef::Resource::Package, metadata do
@@ -112,7 +112,6 @@ describe Chef::Resource::Package, metadata do
       shell_out!("apt-get clean")
     end
 
-
     after do
       shell_out!("dpkg -r chef-integration-test")
       shell_out("dpkg --clear-avail")
@@ -239,7 +238,7 @@ describe Chef::Resource::Package, metadata do
             it "does not update the package configuration" do
               package_resource.run_action(:install)
               cmd = shell_out!("debconf-show chef-integration-test")
-              expect(cmd.stdout).to include('chef-integration-test/sample-var: INVALID')
+              expect(cmd.stdout).to include("chef-integration-test/sample-var: INVALID")
               expect(package_resource).to be_updated_by_last_action
             end
 
@@ -276,7 +275,7 @@ describe Chef::Resource::Package, metadata do
               r = base_resource
               r.cookbook_name = "preseed"
               r.response_file("preseed-template-variables.seed")
-              r.response_file_variables({ :template_variable => 'SUPPORTS VARIABLES' })
+              r.response_file_variables({ :template_variable => "SUPPORTS VARIABLES" })
               r
             end
 
@@ -325,14 +324,13 @@ describe Chef::Resource::Package, metadata do
       # un  chef-integration-test             <none>                                    (no description available)
       def pkg_should_be_removed
         # will raise if exit code != 0,1
-        pkg_check = shell_out!("dpkg -l chef-integration-test", :returns => [0,1])
+        pkg_check = shell_out!("dpkg -l chef-integration-test", :returns => [0, 1])
 
         if pkg_check.exitstatus == 0
           expect(pkg_check.stdout).to match(/un[\s]+chef-integration-test/)
         end
       end
 
-
       it "removes the package for action :remove" do
         package_resource.run_action(:remove)
         pkg_should_be_removed

data/spec/functional/resource/powershell_script_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Adam Edwards (<adamed@opscode.com>)
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Author:: Adam Edwards (<adamed@chef.io>)
+# Copyright:: Copyright 2013-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,15 +16,15 @@
 # limitations under the License.
 #
 
-require 'chef/platform/query_helpers'
-require 'spec_helper'
+require "chef/platform/query_helpers"
+require "spec_helper"
 
 describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
 
   include_context Chef::Resource::WindowsScript
 
-  let (:architecture_command) { 'echo $env:PROCESSOR_ARCHITECTURE' }
-  let (:output_command) { ' | out-file -encoding ASCII ' }
+  let (:architecture_command) { "echo $env:PROCESSOR_ARCHITECTURE" }
+  let (:output_command) { " | out-file -encoding ASCII " }
 
   it_behaves_like "a Windows script running on Windows"
 
@@ -59,7 +59,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     it "returns the exit status 27 for a powershell script that exits with 27" do
       pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
-      file = Tempfile.new(['foo', '.ps1'])
+      file = Tempfile.new(["foo", ".ps1"])
       begin
         file.write "exit 27"
         file.close
@@ -79,9 +79,9 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
 
       # Versions of PowerShell prior to 4.0 return a 16-bit unsigned value --
       # PowerShell 4.0 and later versions return a 32-bit signed value.
-      file = Tempfile.new(['foo', '.ps1'])
+      file = Tempfile.new(["foo", ".ps1"])
       begin
-        file.write "exit #{negative_exit_status.to_s}"
+        file.write "exit #{negative_exit_status}"
         file.close
         resource.code(". \"#{file.path}\"")
 
@@ -114,7 +114,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     end
 
     it "returns 0 if the last command was a cmdlet that succeeded and was preceded by a non-cmdlet Windows binary that failed" do
-      resource.code([windows_process_exit_code_not_found_content, cmdlet_exit_code_success_content].join(';'))
+      resource.code([windows_process_exit_code_not_found_content, cmdlet_exit_code_success_content].join(";"))
       resource.returns(0)
       resource.run_action(:run)
     end
@@ -130,7 +130,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     it "returns 1 if the last command was a cmdlet that failed and was preceded by a successfully executed non-cmdlet Windows binary" do
       pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
-      resource.code([windows_process_exit_code_success_content, cmdlet_exit_code_not_found_content].join(';'))
+      resource.code([windows_process_exit_code_success_content, cmdlet_exit_code_not_found_content].join(";"))
       resource.returns(1)
       expect { resource.run_action(:run) }.not_to raise_error
     end
@@ -138,7 +138,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     it "raises a Mixlib::ShellOut::ShellCommandFailed error if the script is not syntactically correct" do
       pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
-      resource.code('if({)')
+      resource.code("if({)")
       resource.returns(0)
       expect { resource.run_action(:run) }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
     end
@@ -148,7 +148,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       # The error is a false-positive.
       skip "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
-      resource.code('if({)')
+      resource.code("if({)")
       resource.returns(1)
       expect { resource.run_action(:run) }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
     end
@@ -164,7 +164,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     it "returns 1 if the last command was a cmdlet that failed and was preceded by an unsuccessfully executed non-cmdlet Windows binary" do
       pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
-      resource.code([arbitrary_nonzero_process_exit_code_content,cmdlet_exit_code_not_found_content].join(';'))
+      resource.code([arbitrary_nonzero_process_exit_code_content, cmdlet_exit_code_not_found_content].join(";"))
       resource.returns(arbitrary_nonzero_process_exit_code)
       resource.run_action(:run)
     end
@@ -172,7 +172,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     it "returns 0 if the last command was a non-cmdlet Windows binary that succeeded and was preceded by a failed cmdlet" do
       pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
-      resource.code([cmdlet_exit_code_success_content, arbitrary_nonzero_process_exit_code_content].join(';'))
+      resource.code([cmdlet_exit_code_success_content, arbitrary_nonzero_process_exit_code_content].join(";"))
       resource.returns(arbitrary_nonzero_process_exit_code)
       resource.run_action(:run)
     end
@@ -180,7 +180,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     it "returns a specific error code if the last command was a non-cmdlet Windows binary that failed and was preceded by cmdlet that succeeded" do
       pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
-      resource.code([cmdlet_exit_code_success_content, arbitrary_nonzero_process_exit_code_content].join(';'))
+      resource.code([cmdlet_exit_code_success_content, arbitrary_nonzero_process_exit_code_content].join(";"))
       resource.returns(arbitrary_nonzero_process_exit_code)
       resource.run_action(:run)
     end
@@ -188,7 +188,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     it "returns a specific error code if the last command was a non-cmdlet Windows binary that failed and was preceded by cmdlet that failed" do
       pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
-      resource.code([cmdlet_exit_code_not_found_content, arbitrary_nonzero_process_exit_code_content].join(';'))
+      resource.code([cmdlet_exit_code_not_found_content, arbitrary_nonzero_process_exit_code_content].join(";"))
       resource.returns(arbitrary_nonzero_process_exit_code)
       resource.run_action(:run)
     end
@@ -226,9 +226,9 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       resource.returns(0)
       resource.run_action(:run)
 
-      is_64_bit = (ENV['PROCESSOR_ARCHITECTURE'] == 'AMD64') || (ENV['PROCESSOR_ARCHITEW6432'] == 'AMD64')
+      is_64_bit = (ENV["PROCESSOR_ARCHITECTURE"] == "AMD64") || (ENV["PROCESSOR_ARCHITEW6432"] == "AMD64")
 
-      detected_64_bit = source_contains_case_insensitive_content?( get_script_output, 'AMD64' )
+      detected_64_bit = source_contains_case_insensitive_content?( get_script_output, "AMD64" )
 
       expect(is_64_bit).to eq(detected_64_bit)
     end
@@ -280,7 +280,7 @@ configuration LCM
       resource.returns(0)
       resource.run_action(:run)
 
-      expect(source_contains_case_insensitive_content?( get_script_output, 'x86' )).to eq(true)
+      expect(source_contains_case_insensitive_content?( get_script_output, "x86" )).to eq(true)
     end
 
     context "when running on a 64-bit version of Windows", :windows64_only do
@@ -290,7 +290,7 @@ configuration LCM
         resource.returns(0)
         resource.run_action(:run)
 
-        expect(source_contains_case_insensitive_content?( get_script_output, 'AMD64' )).to eq(true)
+        expect(source_contains_case_insensitive_content?( get_script_output, "AMD64" )).to eq(true)
       end
     end
 
@@ -311,7 +311,7 @@ configuration LCM
       resource.returns(0)
       resource.run_action(:run)
 
-      expect(source_contains_case_insensitive_content?( get_script_output, 'AMD64' )).to eq(true)
+      expect(source_contains_case_insensitive_content?( get_script_output, "AMD64" )).to eq(true)
     end
 
     it "executes a script with a 32-bit process if :i386 arch is specified", :not_supported_on_nano do
@@ -320,12 +320,12 @@ configuration LCM
       resource.returns(0)
       resource.run_action(:run)
 
-      expect(source_contains_case_insensitive_content?( get_script_output, 'x86' )).to eq(true)
+      expect(source_contains_case_insensitive_content?( get_script_output, "x86" )).to eq(true)
     end
 
     it "raises an error when executing a script with a 32-bit process on Windows Nano Server", :windows_nano_only do
       resource.code(processor_architecture_script_content + " | out-file -encoding ASCII #{script_output_path}")
-      expect{ resource.architecture(:i386) }.to raise_error(Chef::Exceptions::Win32ArchitectureIncorrect,
+      expect { resource.architecture(:i386) }.to raise_error(Chef::Exceptions::Win32ArchitectureIncorrect,
         "cannot execute script with requested architecture 'i386' on Windows Nano Server")
     end
   end
@@ -342,22 +342,22 @@ configuration LCM
       end
 
       it "evaluates a succeeding not_if block using cmd.exe as false by default" do
-        resource.not_if  "exit /b 0"
+        resource.not_if "exit /b 0"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a failing not_if block using cmd.exe as true by default" do
-        resource.not_if  "exit /b 2"
+        resource.not_if "exit /b 2"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates an succeeding only_if block using cmd.exe as true by default" do
-        resource.only_if  "exit /b 0"
+        resource.only_if "exit /b 0"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a failing only_if block using cmd.exe as false by default" do
-        resource.only_if  "exit /b 2"
+        resource.only_if "exit /b 2"
         expect(resource.should_skip?(:run)).to be_truthy
       end
     end
@@ -383,77 +383,77 @@ configuration LCM
       it "evaluates a powershell $false for a not_if block as true" do
         pending "powershell.exe always exits with $true on nano" if Chef::Platform.windows_nano_server?
 
-        resource.not_if  "$false"
+        resource.not_if "$false"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a powershell $true for a not_if block as false" do
-        resource.not_if  "$true"
+        resource.not_if "$true"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a powershell $false for an only_if block as false" do
         pending "powershell.exe always exits with $true on nano" if Chef::Platform.windows_nano_server?
 
-        resource.only_if  "$false"
+        resource.only_if "$false"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a powershell $true for a only_if block as true" do
-        resource.only_if  "$true"
+        resource.only_if "$true"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a not_if block using powershell.exe" do
-        resource.not_if  "exit([int32](![System.Environment]::CommandLine.Contains('powershell.exe')))"
+        resource.not_if "exit([int32](![System.Environment]::CommandLine.Contains('powershell.exe')))"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates an only_if block using powershell.exe" do
-        resource.only_if  "exit([int32](![System.Environment]::CommandLine.Contains('powershell.exe')))"
+        resource.only_if "exit([int32](![System.Environment]::CommandLine.Contains('powershell.exe')))"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a non-zero powershell exit status for not_if as true" do
         pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
-        resource.not_if  "exit 37"
+        resource.not_if "exit 37"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a zero powershell exit status for not_if as false" do
-        resource.not_if  "exit 0"
+        resource.not_if "exit 0"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a failed executable exit status for not_if as false" do
         pending "powershell.exe always exits with success on nano" if Chef::Platform.windows_nano_server?
 
-        resource.not_if  windows_process_exit_code_not_found_content
+        resource.not_if windows_process_exit_code_not_found_content
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a successful executable exit status for not_if as true" do
-        resource.not_if  windows_process_exit_code_success_content
+        resource.not_if windows_process_exit_code_success_content
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a failed executable exit status for only_if as false" do
         pending "powershell.exe always exits with success on nano" if Chef::Platform.windows_nano_server?
 
-        resource.only_if  windows_process_exit_code_not_found_content
+        resource.only_if windows_process_exit_code_not_found_content
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a successful executable exit status for only_if as true" do
-        resource.only_if  windows_process_exit_code_success_content
+        resource.only_if windows_process_exit_code_success_content
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a failed cmdlet exit status for not_if as true" do
         pending "powershell.exe always exits with success on nano" if Chef::Platform.windows_nano_server?
 
-        resource.not_if  "throw 'up'"
+        resource.not_if "throw 'up'"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
@@ -465,44 +465,44 @@ configuration LCM
       it "evaluates a failed cmdlet exit status for only_if as false" do
         pending "powershell.exe always exits with success on nano" if Chef::Platform.windows_nano_server?
 
-        resource.only_if  "throw 'up'"
+        resource.only_if "throw 'up'"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a successful cmdlet exit status for only_if as true" do
-        resource.only_if  "cd ."
+        resource.only_if "cd ."
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a not_if block using the cwd guard parameter" do
         custom_cwd = "#{ENV['SystemRoot']}\\system32\\drivers\\etc"
-        resource.not_if  "exit ! [int32]($pwd.path -eq '#{custom_cwd}')", :cwd => custom_cwd
+        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"
-        resource.only_if  "exit ! [int32]($pwd.path -eq '#{custom_cwd}')", :cwd => custom_cwd
+        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"
         resource.cwd custom_cwd
-        resource.only_if  "exit ! [int32]($pwd.path -eq '#{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"
         resource.cwd custom_cwd
-        resource.not_if  "exit ! [int32]($pwd.path -eq '#{custom_cwd}')"
+        resource.not_if "exit ! [int32]($pwd.path -eq '#{custom_cwd}')"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a 64-bit resource with a 64-bit guard and interprets boolean false as zero status code", :windows64_only do
         resource.architecture :x86_64
-        resource.only_if  "exit [int32]($env:PROCESSOR_ARCHITECTURE -ne 'AMD64')"
+        resource.only_if "exit [int32]($env:PROCESSOR_ARCHITECTURE -ne 'AMD64')"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
@@ -510,19 +510,19 @@ configuration LCM
         pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
         resource.architecture :x86_64
-        resource.only_if  "exit [int32]($env:PROCESSOR_ARCHITECTURE -eq 'AMD64')"
+        resource.only_if "exit [int32]($env:PROCESSOR_ARCHITECTURE -eq 'AMD64')"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a 32-bit resource with a 32-bit guard and interprets boolean false as zero status code", :not_supported_on_nano do
         resource.architecture :i386
-        resource.only_if  "exit [int32]($env:PROCESSOR_ARCHITECTURE -ne 'X86')"
+        resource.only_if "exit [int32]($env:PROCESSOR_ARCHITECTURE -ne 'X86')"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a 32-bit resource with a 32-bit guard and interprets boolean true as nonzero status code", :not_supported_on_nano do
         resource.architecture :i386
-        resource.only_if  "exit [int32]($env:PROCESSOR_ARCHITECTURE -eq 'X86')"
+        resource.only_if "exit [int32]($env:PROCESSOR_ARCHITECTURE -eq 'X86')"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
@@ -530,7 +530,7 @@ configuration LCM
         pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
         resource.convert_boolean_return true
-        resource.only_if  "$false"
+        resource.only_if "$false"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
@@ -538,53 +538,53 @@ configuration LCM
         pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
 
         resource.convert_boolean_return true
-        resource.not_if  "$false"
+        resource.not_if "$false"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a simple boolean true as 0 status code when convert_boolean_return is true for only_if" do
         resource.convert_boolean_return true
-        resource.only_if  "$true"
+        resource.only_if "$true"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a simple boolean true as 0 status code when convert_boolean_return is true for not_if" do
         resource.convert_boolean_return true
-        resource.not_if  "$true"
+        resource.not_if "$true"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a 32-bit resource with a 32-bit guard and interprets boolean false as zero status code using convert_boolean_return for only_if", :not_supported_on_nano do
         resource.convert_boolean_return true
         resource.architecture :i386
-        resource.only_if  "$env:PROCESSOR_ARCHITECTURE -eq 'X86'"
+        resource.only_if "$env:PROCESSOR_ARCHITECTURE -eq 'X86'"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a 32-bit resource with a 32-bit guard and interprets boolean false as zero status code using convert_boolean_return for not_if", :not_supported_on_nano do
         resource.convert_boolean_return true
         resource.architecture :i386
-        resource.not_if  "$env:PROCESSOR_ARCHITECTURE -ne 'X86'"
+        resource.not_if "$env:PROCESSOR_ARCHITECTURE -ne 'X86'"
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
       it "evaluates a 32-bit resource with a 32-bit guard and interprets boolean true as nonzero status code using convert_boolean_return for only_if", :not_supported_on_nano do
         resource.convert_boolean_return true
         resource.architecture :i386
-        resource.only_if  "$env:PROCESSOR_ARCHITECTURE -ne 'X86'"
+        resource.only_if "$env:PROCESSOR_ARCHITECTURE -ne 'X86'"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a 32-bit resource with a 32-bit guard and interprets boolean true as nonzero status code using convert_boolean_return for not_if", :not_supported_on_nano do
         resource.convert_boolean_return true
         resource.architecture :i386
-        resource.not_if  "$env:PROCESSOR_ARCHITECTURE -eq 'X86'"
+        resource.not_if "$env:PROCESSOR_ARCHITECTURE -eq 'X86'"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "raises an error when a 32-bit guard is used on Windows Nano Server", :windows_nano_only do
         resource.only_if "$true", :architecture => :i386
-        expect{resource.run_action(:run)}.to raise_error(
+        expect { resource.run_action(:run) }.to raise_error(
           Chef::Exceptions::Win32ArchitectureIncorrect,
           /cannot execute script with requested architecture 'i386' on Windows Nano Server/)
       end