chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/spec/functional/resource/env_spec.rb

@@ -22,8 +22,11 @@ describe Chef::Resource::Env, :windows_only do
   context 'when running on Windows' do
     let(:chef_env_test_lower_case) { 'chefenvtest' }
     let(:chef_env_test_mixed_case) { 'chefENVtest' }
+    let(:env_dne_key) { 'env_dne_key' }
     let(:env_value1) { 'value1' }
     let(:env_value2) { 'value2' }
+
+    let(:env_value_expandable) { '%SystemRoot%' }
     let(:test_run_context) {
       node = Chef::Node.new
       node.default['platform'] = 'windows'
@@ -71,6 +74,14 @@ describe Chef::Resource::Env, :windows_only do
         test_resource.run_action(:create)
         expect(ENV[chef_env_test_lower_case]).to eq(env_value2)
       end
+
+      it 'should not expand environment variables if the variable is not PATH' do
+        expect(ENV[chef_env_test_lower_case]).to eq(nil)
+        test_resource.key_name(chef_env_test_lower_case)
+        test_resource.value(env_value_expandable)
+        test_resource.run_action(:create)
+        expect(ENV[chef_env_test_lower_case]).to eq(env_value_expandable)
+      end
     end
 
     context "when the modify action is invoked" do
@@ -102,6 +113,41 @@ describe Chef::Resource::Env, :windows_only do
         test_resource.run_action(:modify)
         expect(ENV[chef_env_test_lower_case]).to eq(env_value2)
       end
+
+      it 'should not expand environment variables if the variable is not PATH' do
+        test_resource.key_name(chef_env_test_lower_case)
+        test_resource.value(env_value1)
+        test_resource.run_action(:create)
+        expect(ENV[chef_env_test_lower_case]).to eq(env_value1)
+        test_resource.value(env_value_expandable)
+        test_resource.run_action(:modify)
+        expect(ENV[chef_env_test_lower_case]).to eq(env_value_expandable)
+      end
+
+      context 'when using PATH' do
+        let(:random_name) { Time.now.to_i }
+        let(:env_val) { "#{env_value_expandable}_#{random_name}"}
+        let!(:path_before) { test_resource.provider_for_action(test_resource.action).env_value('PATH') || '' }
+        let!(:env_path_before) { ENV['PATH'] }
+
+        it 'should expand PATH' do
+          path_before.should_not include(env_val)
+          test_resource.key_name('PATH')
+          test_resource.value("#{path_before};#{env_val}")
+          test_resource.run_action(:create)
+          ENV['PATH'].should_not include(env_val)
+          ENV['PATH'].should include("#{random_name}")
+        end
+
+        after(:each) do
+          # cleanup so we don't flood the path
+          test_resource.key_name('PATH')
+          test_resource.value(path_before)
+          test_resource.run_action(:create)
+          ENV['PATH'] = env_path_before
+        end
+      end
+
     end
 
     context "when the delete action is invoked" do
@@ -132,6 +178,14 @@ describe Chef::Resource::Env, :windows_only do
         expect(ENV[chef_env_test_lower_case]).to eq(nil)
         expect(ENV[chef_env_test_mixed_case]).to eq(nil)
       end
+
+      it "should delete a value from the current process even if it is not in the registry" do
+        expect(ENV[env_dne_key]).to eq(nil)
+        ENV[env_dne_key] = env_value1
+        test_resource.key_name(env_dne_key)
+        test_resource.run_action(:delete)
+        expect(ENV[env_dne_key]).to eq(nil)
+      end
     end
   end
 end

data/spec/functional/resource/execute_spec.rb

@@ -0,0 +1,113 @@
+#
+# Author:: Serdar Sutay (<serdar@opscode.com>)
+# Copyright:: Copyright (c) 2014 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'functional/resource/base'
+
+describe Chef::Resource::Execute do
+  let(:execute_resource) {
+    exec_resource = Chef::Resource::Execute.new("foo_resource", run_context)
+
+    exec_resource.environment(resource_environment) if resource_environment
+    exec_resource.cwd(resource_cwd) if resource_cwd
+    exec_resource.command("echo hello")
+    if guard
+      if guard_options
+        exec_resource.only_if(guard, guard_options)
+      else
+        exec_resource.only_if(guard)
+      end
+    end
+    exec_resource
+  }
+
+  let(:resource_environment) { nil }
+  let(:resource_cwd) { nil }
+  let(:guard) { nil }
+  let(:guard_options) { nil }
+
+  describe "when guard is ruby block" do
+    it "guard can still run" do
+      execute_resource.only_if do
+        true
+      end
+      execute_resource.run_action(:run)
+      execute_resource.should be_updated_by_last_action
+    end
+  end
+
+  describe "when parent resource sets :cwd" do
+    let(:resource_cwd) { CHEF_SPEC_DATA }
+
+    let(:guard) { %{ruby -e 'exit 1 unless File.exists?("./big_json_plus_one.json")'} }
+
+    it "guard inherits :cwd from resource" do
+      execute_resource.run_action(:run)
+      execute_resource.should be_updated_by_last_action
+    end
+  end
+
+  describe "when parent resource sets :environment" do
+    let(:resource_environment) do
+      {
+        "SAWS_SECRET"  => "supersecret",
+        "SAWS_KEY"     => "qwerty"
+      }
+    end
+
+    # We use ruby command so that we don't need to deal with platform specific
+    # commands while testing execute resource. We set it so that the resource
+    # will be updated if the ENV variable is set to what we are intending
+    let(:guard) { %{ruby -e 'exit 1 if ENV["SAWS_SECRET"] != "supersecret"'} }
+
+    it "guard inherits :environment value from resource" do
+      execute_resource.run_action(:run)
+      execute_resource.should be_updated_by_last_action
+    end
+
+    describe "when guard sets additional values in the :environment" do
+      let(:guard) { %{ruby -e 'exit 1 if ENV["SGCE_SECRET"] != "regularsecret"'} }
+
+      let(:guard_options) do
+        {
+          :environment => { 'SGCE_SECRET' => "regularsecret" }
+        }
+      end
+
+      it "guard sees merged value for in its ENV" do
+        execute_resource.run_action(:run)
+        execute_resource.should be_updated_by_last_action
+      end
+    end
+
+    describe "when guard sets same value in the :environment" do
+      let(:guard) { %{ruby -e 'exit 1 if ENV["SAWS_SECRET"] != "regularsecret"'} }
+
+      let(:guard_options) do
+        {
+          :environment => { 'SAWS_SECRET' => "regularsecret" }
+        }
+      end
+
+      it "guard sees value from guard options in its ENV" do
+        execute_resource.run_action(:run)
+        execute_resource.should be_updated_by_last_action
+      end
+    end
+  end
+end

data/spec/functional/resource/file_spec.rb

@@ -17,6 +17,7 @@
 #
 
 require 'spec_helper'
+require 'tmpdir'
 
 describe Chef::Resource::File do
   include_context Chef::Resource::File
@@ -30,6 +31,7 @@ describe Chef::Resource::File do
     run_context = Chef::RunContext.new(node, {}, events)
 
     use_path = if opts[:use_relative_path]
+      Dir.chdir(Dir.tmpdir)
       File.basename(path)
     else
       path

data/spec/functional/resource/group_spec.rb

@@ -28,10 +28,10 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
   def group_should_exist(group)
     case ohai[:platform_family]
     when "debian", "fedora", "rhel", "suse", "gentoo", "slackware", "arch"
-      expect { Etc::getgrnam(group) }.to_not raise_error(ArgumentError, "can't find group for #{group}")
+      expect { Etc::getgrnam(group) }.not_to raise_error
       expect(group).to eq(Etc::getgrnam(group).name)
     when "windows"
-      expect { Chef::Util::Windows::NetGroup.new(group).local_get_members }.to_not raise_error(ArgumentError, "The group name could not be found.")
+      expect { Chef::Util::Windows::NetGroup.new(group).local_get_members }.not_to raise_error
     end
   end
 
@@ -369,9 +369,12 @@ downthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreeQQQQQQ" }
     let(:tested_action) { :manage }
 
     describe "when there is no group" do
-      it "should raise an error" do
+      it "raises an error on modify" do
+        lambda { group_resource.run_action(:modify) }.should raise_error
+      end
+
+      it "does not raise an error on manage" do
         lambda { group_resource.run_action(:manage) }.should_not raise_error
-        group_should_not_exist(group_name)
       end
     end
 

data/spec/functional/resource/powershell_spec.rb

@@ -22,6 +22,12 @@ 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 ' }
+
+  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(:processor_architecture_script_content) { "echo $env:PROCESSOR_ARCHITECTURE" }
@@ -36,6 +42,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
   let(:arbitrary_nonzero_process_exit_code_content) { "exit #{arbitrary_nonzero_process_exit_code}" }
   let(:invalid_powershell_interpreter_flag) { "/thisflagisinvalid" }
   let(:valid_powershell_interpreter_flag) { "-Sta" }
+
   let!(:resource) do
     r = Chef::Resource::WindowsScript::PowershellScript.new("Powershell resource functional test", @run_context)
     r.code(successful_executable_script_content)
@@ -162,6 +169,13 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       resource.returns(0)
       resource.run_action(:run)
     end
+
+    it "raises an error when given a block and a guard_interpreter" do
+      resource.guard_interpreter :sh
+      resource.only_if { true }
+      expect { resource.should_skip?(:run) }.to raise_error(ArgumentError, /guard_interpreter does not support blocks/)
+    end
+
   end
 
   context "when running on a 32-bit version of Windows", :windows32_only do
@@ -204,237 +218,236 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
   end
 
   describe "when executing guards" do
-
     before(:each) do
       resource.not_if.clear
       resource.only_if.clear
-      resource.guard_interpreter :powershell_script
     end
 
-    it "evaluates a succeeding not_if block using cmd.exe as false by default" do
-      resource.guard_interpreter :default
-      resource.not_if  "exit /b 0"
-      resource.should_skip?(:run).should be_true
-    end
+    context "when the guard_interpreter's default value of :powershell_script is overridden to :default" do
+      before(:each) do
+        resource.guard_interpreter :default
+      end
 
-    it "evaluates a failing not_if block using cmd.exe as true by default" do
-      resource.guard_interpreter :default
-      resource.not_if  "exit /b 2"
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates a succeeding not_if block using cmd.exe as false by default" do
+        resource.not_if  "exit /b 0"
+        resource.should_skip?(:run).should be_true
+      end
 
-    it "evaluates an succeeding only_if block using cmd.exe as true by default" do
-      resource.guard_interpreter :default
-      resource.only_if  "exit /b 0"
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates a failing not_if block using cmd.exe as true by default" do
+        resource.not_if  "exit /b 2"
+        resource.should_skip?(:run).should be_false
+      end
 
-    it "evaluates a failing only_if block using cmd.exe as false by default" do
-      resource.guard_interpreter :default
-      resource.only_if  "exit /b 2"
-      resource.should_skip?(:run).should be_true
-    end
+      it "evaluates an succeeding only_if block using cmd.exe as true by default" do
+        resource.only_if  "exit /b 0"
+        resource.should_skip?(:run).should be_false
+      end
 
-    it "evaluates a powershell $false for a not_if block as true" do
-      resource.not_if  "$false"
-      resource.should_skip?(:run).should be_false
+      it "evaluates a failing only_if block using cmd.exe as false by default" do
+        resource.only_if  "exit /b 2"
+        resource.should_skip?(:run).should be_true
+      end
     end
 
-    it "evaluates a powershell $true for a not_if block as false" do
-      resource.not_if  "$true"
-      resource.should_skip?(:run).should be_true
-    end
+    context "the only_if is specified before the guard" do
+      before do
+        resource.guard_interpreter :default
+      end
 
-    it "evaluates a powershell $false for an only_if block as false" do
-      resource.only_if  "$false"
-      resource.should_skip?(:run).should be_true
+      it "evaluates a powershell $true for a only_if block as true" do
+        resource.only_if "$true"
+        resource.guard_interpreter :powershell_script
+        resource.should_skip?(:run).should be_false
+      end
     end
 
-    it "evaluates a powershell $true for a only_if block as true" do
-      resource.only_if  "$true"
-      resource.should_skip?(:run).should be_false
-    end
+    context "with powershell_script as the guard_interpreter" do
 
-    it "evaluates a not_if block using powershell.exe" do
-      resource.not_if  "exit([int32](![System.Environment]::CommandLine.Contains('powershell.exe')))"
-      resource.should_skip?(:run).should be_true
-    end
+      it "has a guard_interpreter attribute set to :powershell_script" do
+        expect(resource.guard_interpreter).to eq(:powershell_script)
+      end
 
-    it "evaluates an only_if block using powershell.exe" do
-      resource.only_if  "exit([int32](![System.Environment]::CommandLine.Contains('powershell.exe')))"
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates a powershell $false for a not_if block as true" do
+        resource.not_if  "$false"
+        resource.should_skip?(:run).should be_false
+      end
 
-    it "evaluates a not_if block as false" do
-      resource.not_if { false }
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates a powershell $true for a not_if block as false" do
+        resource.not_if  "$true"
+        resource.should_skip?(:run).should be_true
+      end
 
-    it "evaluates a not_if block as true" do
-      resource.not_if { true }
-      resource.should_skip?(:run).should be_true
-    end
+      it "evaluates a powershell $false for an only_if block as false" do
+        resource.only_if  "$false"
+        resource.should_skip?(:run).should be_true
+      end
 
-    it "evaluates an only_if block as false" do
-      resource.only_if { false }
-      resource.should_skip?(:run).should be_true
-    end
+      it "evaluates a powershell $true for a only_if block as true" do
+        resource.only_if  "$true"
+        resource.should_skip?(:run).should be_false
+      end
 
-    it "evaluates an only_if block as true" do
-      resource.only_if { true }
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates a not_if block using powershell.exe" do
+        resource.not_if  "exit([int32](![System.Environment]::CommandLine.Contains('powershell.exe')))"
+        resource.should_skip?(:run).should be_true
+      end
 
-    it "evaluates a non-zero powershell exit status for not_if as true" do
-      resource.not_if  "exit 37"
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates an only_if block using powershell.exe" do
+        resource.only_if  "exit([int32](![System.Environment]::CommandLine.Contains('powershell.exe')))"
+        resource.should_skip?(:run).should be_false
+      end
 
-    it "evaluates a zero powershell exit status for not_if as false" do
-      resource.not_if  "exit 0"
-      resource.should_skip?(:run).should be_true
-    end
+      it "evaluates a non-zero powershell exit status for not_if as true" do
+        resource.not_if  "exit 37"
+        resource.should_skip?(:run).should be_false
+      end
 
-    it "evaluates a failed executable exit status for not_if as false" do
-      resource.not_if  windows_process_exit_code_not_found_content
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates a zero powershell exit status for not_if as false" do
+        resource.not_if  "exit 0"
+        resource.should_skip?(:run).should be_true
+      end
 
-    it "evaluates a successful executable exit status for not_if as true" do
-      resource.not_if  windows_process_exit_code_success_content
-      resource.should_skip?(:run).should be_true
-    end
+      it "evaluates a failed executable exit status for not_if as false" do
+        resource.not_if  windows_process_exit_code_not_found_content
+        resource.should_skip?(:run).should be_false
+      end
 
-    it "evaluates a failed executable exit status for only_if as false" do
-      resource.only_if  windows_process_exit_code_not_found_content
-      resource.should_skip?(:run).should be_true
-    end
+      it "evaluates a successful executable exit status for not_if as true" do
+        resource.not_if  windows_process_exit_code_success_content
+        resource.should_skip?(:run).should be_true
+      end
 
-    it "evaluates a successful executable exit status for only_if as true" do
-      resource.only_if  windows_process_exit_code_success_content
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates a failed executable exit status for only_if as false" do
+        resource.only_if  windows_process_exit_code_not_found_content
+        resource.should_skip?(:run).should be_true
+      end
 
-    it "evaluates a failed cmdlet exit status for not_if as true" do
-      resource.not_if  "throw 'up'"
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates a successful executable exit status for only_if as true" do
+        resource.only_if  windows_process_exit_code_success_content
+        resource.should_skip?(:run).should be_false
+      end
 
-    it "evaluates a successful cmdlet exit status for not_if as true" do
-      resource.not_if  "cd ."
-      resource.should_skip?(:run).should be_true
-    end
+      it "evaluates a failed cmdlet exit status for not_if as true" do
+        resource.not_if  "throw 'up'"
+        resource.should_skip?(:run).should be_false
+      end
 
-    it "evaluates a failed cmdlet exit status for only_if as false" do
-      resource.only_if  "throw 'up'"
-      resource.should_skip?(:run).should be_true
-    end
+      it "evaluates a successful cmdlet exit status for not_if as true" do
+        resource.not_if  "cd ."
+        resource.should_skip?(:run).should be_true
+      end
 
-    it "evaluates a successful cmdlet exit status for only_if as true" do
-      resource.only_if  "cd ."
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates a failed cmdlet exit status for only_if as false" do
+        resource.only_if  "throw 'up'"
+        resource.should_skip?(:run).should be_true
+      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.should_skip?(:run).should be_true
-    end
+      it "evaluates a successful cmdlet exit status for only_if as true" do
+        resource.only_if  "cd ."
+        resource.should_skip?(:run).should be_false
+      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.should_skip?(:run).should be_false
-    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.should_skip?(:run).should be_true
+      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.should_skip?(:run).should be_false
-    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.should_skip?(:run).should be_false
+      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.should_skip?(:run).should be_true
-    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.should_skip?(:run).should be_false
+      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.should_skip?(:run).should be_false
-    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.should_skip?(:run).should be_true
+      end
 
-    it "evaluates a 64-bit resource with a 64-bit guard and interprets boolean true as nonzero status code", :windows64_only do
-      resource.architecture :x86_64
-      resource.only_if  "exit [int32]($env:PROCESSOR_ARCHITECTURE -eq 'AMD64')"
-      resource.should_skip?(:run).should be_true
-    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.should_skip?(:run).should be_false
+      end
 
-    it "evaluates a 32-bit resource with a 32-bit guard and interprets boolean false as zero status code" do
-      resource.architecture :i386
-      resource.only_if  "exit [int32]($env:PROCESSOR_ARCHITECTURE -ne 'X86')"
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates a 64-bit resource with a 64-bit guard and interprets boolean true as nonzero status code", :windows64_only do
+        resource.architecture :x86_64
+        resource.only_if  "exit [int32]($env:PROCESSOR_ARCHITECTURE -eq 'AMD64')"
+        resource.should_skip?(:run).should be_true
+      end
 
-    it "evaluates a 32-bit resource with a 32-bit guard and interprets boolean true as nonzero status code" do
-      resource.architecture :i386
-      resource.only_if  "exit [int32]($env:PROCESSOR_ARCHITECTURE -eq 'X86')"
-      resource.should_skip?(:run).should be_true
-    end
+      it "evaluates a 32-bit resource with a 32-bit guard and interprets boolean false as zero status code" do
+        resource.architecture :i386
+        resource.only_if  "exit [int32]($env:PROCESSOR_ARCHITECTURE -ne 'X86')"
+        resource.should_skip?(:run).should be_false
+      end
 
-    it "evaluates a simple boolean false as nonzero status code when convert_boolean_return is true for only_if" do
-      resource.convert_boolean_return true
-      resource.only_if  "$false"
-      resource.should_skip?(:run).should be_true
-    end
+      it "evaluates a 32-bit resource with a 32-bit guard and interprets boolean true as nonzero status code" do
+        resource.architecture :i386
+        resource.only_if  "exit [int32]($env:PROCESSOR_ARCHITECTURE -eq 'X86')"
+        resource.should_skip?(:run).should be_true
+      end
 
-    it "evaluates a simple boolean false as nonzero status code when convert_boolean_return is true for not_if" do
-      resource.convert_boolean_return true
-      resource.not_if  "$false"
-      resource.should_skip?(:run).should be_false
-    end
+      it "evaluates a simple boolean false as nonzero status code when convert_boolean_return is true for only_if" do
+        resource.convert_boolean_return true
+        resource.only_if  "$false"
+        resource.should_skip?(:run).should be_true
+      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.should_skip?(:run).should be_false
-    end
+      it "evaluates a simple boolean false as nonzero status code when convert_boolean_return is true for not_if" do
+        resource.convert_boolean_return true
+        resource.not_if  "$false"
+        resource.should_skip?(:run).should be_false
+      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.should_skip?(:run).should be_true
-    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.should_skip?(:run).should be_false
+      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" do
-      resource.convert_boolean_return true
-      resource.architecture :i386
-      resource.only_if  "$env:PROCESSOR_ARCHITECTURE -eq 'X86'"
-      resource.should_skip?(:run).should be_false
-    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.should_skip?(:run).should be_true
+      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" do
-      resource.convert_boolean_return true
-      resource.architecture :i386
-      resource.not_if  "$env:PROCESSOR_ARCHITECTURE -ne 'X86'"
-      resource.should_skip?(:run).should be_false
-    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" do
+        resource.convert_boolean_return true
+        resource.architecture :i386
+        resource.only_if  "$env:PROCESSOR_ARCHITECTURE -eq 'X86'"
+        resource.should_skip?(:run).should be_false
+      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" do
-      resource.convert_boolean_return true
-      resource.architecture :i386
-      resource.only_if  "$env:PROCESSOR_ARCHITECTURE -ne 'X86'"
-      resource.should_skip?(:run).should be_true
-    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" do
+        resource.convert_boolean_return true
+        resource.architecture :i386
+        resource.not_if  "$env:PROCESSOR_ARCHITECTURE -ne 'X86'"
+        resource.should_skip?(:run).should be_false
+      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" do
-      resource.convert_boolean_return true
-      resource.architecture :i386
-      resource.not_if  "$env:PROCESSOR_ARCHITECTURE -eq 'X86'"
-      resource.should_skip?(:run).should be_true
+      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" do
+        resource.convert_boolean_return true
+        resource.architecture :i386
+        resource.only_if  "$env:PROCESSOR_ARCHITECTURE -ne 'X86'"
+        resource.should_skip?(:run).should be_true
+      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" do
+        resource.convert_boolean_return true
+        resource.architecture :i386
+        resource.not_if  "$env:PROCESSOR_ARCHITECTURE -eq 'X86'"
+        resource.should_skip?(:run).should be_true
+      end
     end
   end