chef 12.4.3-universal-mingw32 → 12.5.1-universal-mingw32

data/spec/functional/knife/cookbook_delete_spec.rb

@@ -40,20 +40,30 @@ describe Chef::Knife::CookbookDelete do
   end
 
   context "when the cookbook doesn't exist" do
-    before do
-      @log_output = StringIO.new
-
-      Chef::Log.logger = Logger.new(@log_output)
-      Chef::Log.level = :debug
+    let(:log_output) { StringIO.new }
 
+    before do
       @knife.name_args = %w{no-such-cookbook}
       @api.get("/cookbooks/no-such-cookbook", 404, Chef::JSONCompat.to_json({'error'=>'dear Tim, no. -Sent from my iPad'}))
     end
 
+    around do |ex|
+      old_logger = Chef::Log.logger
+      old_level = Chef::Log.level
+      begin
+        Chef::Log.logger = Logger.new(log_output)
+        Chef::Log.level = :debug
+        ex.run
+      ensure
+        Chef::Log.logger = old_logger
+        Chef::Log.level = old_level
+      end
+    end
+
     it "logs an error and exits" do
-      allow(@knife.ui).to receive(:stderr).and_return(@log_output)
+      allow(@knife.ui).to receive(:stderr).and_return(log_output)
       expect {@knife.run}.to raise_error(SystemExit)
-      expect(@log_output.string).to match(/Cannot find a cookbook named no-such-cookbook to delete/)
+      expect(log_output.string).to match(/Cannot find a cookbook named no-such-cookbook to delete/)
     end
 
   end

data/spec/functional/knife/ssh_spec.rb

@@ -31,6 +31,22 @@ describe Chef::Knife::Ssh do
     @server.stop
   end
 
+  let(:ssh_config) { Hash.new }
+  before do
+    allow(Net::SSH).to receive(:configuration_for).and_return(ssh_config)
+  end
+
+  # Force log level to info.
+  around do |ex|
+    old_level = Chef::Log.level
+    begin
+      Chef::Log.level = :info
+      ex.run
+    ensure
+      Chef::Log.level = old_level
+    end
+  end
+
   describe "identity file" do
     context "when knife[:ssh_identity_file] is set" do
       before do

data/spec/functional/rebooter_spec.rb

@@ -43,7 +43,7 @@ describe Chef::Platform::Rebooter do
 
   let(:expected) do
     {
-      :windows => 'shutdown /r /t 5 /c "rebooter spec test"',
+      :windows => 'shutdown /r /t 300 /c "rebooter spec test"',
       :linux => 'shutdown -r +5 "rebooter spec test"'
     }
   end

data/spec/functional/resource/deploy_revision_spec.rb

@@ -819,7 +819,7 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       end
 
       before do
-        expect { deploy_that_fails.run_action(:deploy) }.to raise_error(Chef::Exceptions::Exec)
+        expect { deploy_that_fails.run_action(:deploy) }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
         deploy_to_latest_with_callback_tracking.run_action(:deploy)
       end
 

data/spec/functional/resource/dsc_resource_spec.rb

@@ -43,6 +43,8 @@ describe Chef::Resource::DscResource, :windows_powershell_dsc_only do
     before do
       if !Chef::Platform.supports_dsc_invoke_resource?(node)
         skip 'Requires Powershell >= 5.0.10018.0'
+      elsif !Chef::Platform.dsc_refresh_mode_disabled?(node)
+        skip 'Requires LCM RefreshMode is Disabled'
       end
     end
     context 'with an invalid dsc resource' do

data/spec/functional/resource/dsc_script_spec.rb

@@ -19,6 +19,7 @@
 require 'spec_helper'
 require 'chef/mixin/shell_out'
 require 'chef/mixin/windows_architecture_helper'
+require 'support/shared/integration/integration_helper'
 
 describe Chef::Resource::DscScript, :windows_powershell_dsc_only do
   include Chef::Mixin::WindowsArchitectureHelper
@@ -67,8 +68,7 @@ describe Chef::Resource::DscScript, :windows_powershell_dsc_only do
     node = Chef::Node.new
     node.automatic['platform'] = 'windows'
     node.automatic['platform_version'] = '6.1'
-    node.automatic['kernel'][:machine] =
-      is_i386_process_on_x86_64_windows? ? :x86_64 : :i386
+    node.automatic['kernel'][:machine] = :x86_64  # Only 64-bit architecture is supported
     node.automatic[:languages][:powershell][:version] = '4.0'
     empty_events = Chef::EventDispatch::Dispatcher.new
     Chef::RunContext.new(node, {}, empty_events)
@@ -379,4 +379,93 @@ EOH
     it_behaves_like 'a dsc_script with configuration data that takes parameters'
     it_behaves_like 'a dsc_script without configuration data that takes parameters'
   end
+
+  context 'when using ps_credential' do
+    include IntegrationSupport
+
+    before(:each) do
+      delete_user(dsc_user)
+      ohai_reader = Ohai::System.new
+      ohai_reader.all_plugins(["platform", "os", "languages/powershell"])
+      dsc_test_run_context.node.consume_external_attrs(ohai_reader.data,{})
+    end
+
+    let(:configuration_data_path) { 'C:\\configurationdata.psd1' }
+
+    let(:self_signed_cert_path) do
+      File.join(CHEF_SPEC_DATA, 'dsc_lcm.pfx')
+    end
+
+    let(:dsc_configuration_script) do
+      <<-MYCODE
+cd c:\\
+configuration LCM
+{
+  param ($thumbprint)
+  localconfigurationmanager
+  {
+    RebootNodeIfNeeded = $false
+    ConfigurationMode = 'ApplyOnly'
+    CertificateID = $thumbprint
+  }
+}
+$cert = ls Cert:\\LocalMachine\\My\\ |
+  Where-Object {$_.Subject -match "ChefTest"} |
+  Select -first 1
+
+if($cert -eq $null) {
+  $pfxpath = '#{self_signed_cert_path}'
+  $password = ''
+  $cert = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2($pfxpath, $password, ([System.Security.Cryptography.X509Certificates.X509KeyStorageFlags]::PersistKeySet -bor [System.Security.Cryptography.X509Certificates.X509KeyStorageFlags]::MachineKeyset))
+  $store = New-Object System.Security.Cryptography.X509Certificates.X509Store "My", ([System.Security.Cryptography.X509Certificates.StoreLocation]::LocalMachine)
+  $store.Open([System.Security.Cryptography.X509Certificates.OpenFlags]::ReadWrite)
+  $store.Add($cert)
+  $store.Close()
+}
+
+lcm -thumbprint $cert.thumbprint
+set-dsclocalconfigurationmanager -path ./LCM  
+$ConfigurationData = @"
+@{
+AllNodes = @( 
+  @{  
+  NodeName = "localhost"; 
+  CertificateID = '$($cert.thumbprint)';
+  };
+);
+}
+"@
+$ConfigurationData | out-file '#{configuration_data_path}' -force
+  MYCODE
+    end
+
+    let(:powershell_script_resource) do
+      Chef::Resource::PowershellScript.new('configure-lcm', dsc_test_run_context).tap do |r|
+        r.code(dsc_configuration_script)
+        r.architecture(:x86_64)
+      end
+    end
+
+    let(:dsc_script_resource) do
+      dsc_test_resource_base.tap do |r|
+        r.code <<-EOF
+User dsctestusercreate
+{
+    UserName = '#{dsc_user}'
+    Password = #{r.ps_credential('jf9a8m49jrajf4#')}
+    Ensure = "Present"
+}
+EOF
+        r.configuration_data_script(configuration_data_path)
+      end
+    end
+
+    it 'allows the use of ps_credential' do
+      expect(user_exists?(dsc_user)).to eq(false)
+      powershell_script_resource.run_action(:run)
+      expect(File).to exist(configuration_data_path)
+      dsc_script_resource.run_action(:run)
+      expect(user_exists?(dsc_user)).to eq(true)
+    end
+  end
 end

data/spec/functional/resource/group_spec.rb

@@ -95,7 +95,7 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
 
   def create_user(username)
     user(username).run_action(:create) if ! windows_domain_user?(username)
-    # TODO: User shouldn't exist
+    # TODO: User should exist
   end
 
   def remove_user(username)
@@ -135,44 +135,75 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
       group_should_not_exist(group_name)
     end
 
-    describe "when append is not set" do
-      let(:included_members) { [spec_members[1]] }
-
-      before do
-        create_user(spec_members[1])
-        create_user(spec_members[0])
-        add_members_to_group([spec_members[0]])
-      end
+    # dscl doesn't perform any error checking and will let you add users that don't exist.
+    describe "when no users exist", :not_supported_on_mac_osx do
+      describe "when append is not set" do
+        # excluded_members can only be used when append is set.  It is ignored otherwise.
+        let(:excluded_members) { [] }
 
-      after do
-        remove_user(spec_members[1])
-        remove_user(spec_members[0])
+        it "should raise an error" do
+          expect { group_resource.run_action(tested_action) }.to raise_error()
+        end
       end
 
-      it "should remove the existing users and add the new users to the group" do
-        group_resource.run_action(tested_action)
+      describe "when append is set" do
+        before do
+          group_resource.append(true)
+        end
 
-        expect(user_exist_in_group?(spec_members[1])).to eq(true)
-        expect(user_exist_in_group?(spec_members[0])).to eq(false)
+        it "should raise an error" do
+          expect { group_resource.run_action(tested_action) }.to raise_error()
+        end
       end
     end
 
-    describe "when append is set" do
-      before(:each) do
-        group_resource.append(true)
+    describe "when the users exist" do
+      before do
+        (spec_members).each do |member|
+          create_user(member)
+        end
       end
 
-      describe "when the users exist" do
-        before do
-          (included_members + excluded_members).each do |member|
-            create_user(member)
+      after do
+        (spec_members).each do |member|
+          remove_user(member)
+        end
+      end
+
+      describe "when append is not set" do
+        it "should set the group to to contain given members" do
+          group_resource.run_action(tested_action)
+
+          included_members.each do |member|
+            expect(user_exist_in_group?(member)).to eq(true)
+          end
+          (spec_members - included_members).each do |member|
+            expect(user_exist_in_group?(member)).to eq(false)
           end
         end
 
-        after do
-          (included_members + excluded_members).each do |member|
-            remove_user(member)
+        describe "when group already contains some users" do
+          before do
+            add_members_to_group([included_members[0]])
+            add_members_to_group(spec_members - included_members)
           end
+
+          it "should remove all existing users and only add the new users to the group" do
+            group_resource.run_action(tested_action)
+
+            included_members.each do |member|
+              expect(user_exist_in_group?(member)).to eq(true)
+            end
+            (spec_members - included_members).each do |member|
+              expect(user_exist_in_group?(member)).to eq(false)
+            end
+          end
+        end
+      end
+
+      describe "when append is set" do
+        before(:each) do
+          group_resource.append(true)
         end
 
         it "should add included members to the group" do
@@ -186,9 +217,9 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
           end
         end
 
-        describe "when group contains some users" do
+        describe "when group already contains some users" do
           before(:each) do
-            add_members_to_group([ spec_members[0], spec_members[2] ])
+            add_members_to_group([included_members[0], excluded_members[0]])
           end
 
           it "should add the included users and remove excluded users" do
@@ -203,20 +234,6 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
           end
         end
       end
-
-      describe "when the users doesn't exist" do
-        describe "when append is not set" do
-          it "should raise an error" do
-            expect { @grp_resource.run_action(tested_action) }.to raise_error
-          end
-        end
-
-        describe "when append is set" do
-          it "should raise an error" do
-            expect { @grp_resource.run_action(tested_action) }.to raise_error
-          end
-        end
-      end
     end
   end
 
@@ -231,6 +248,12 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
       group_should_exist(group_name)
     end
 
+    after(:each) do
+      group_resource.run_action(:remove)
+    end
+
+    # TODO: The ones below might actually return ArgumentError now - but I don't have
+    # a way to verify that.  Change it and delete this comment if that's the case.
     describe "when updating membership" do
       it "raises an error for a non well-formed domain name" do
         group_resource.members [invalid_domain_user_name]
@@ -256,7 +279,7 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
     end
   end
 
-  let(:group_name) { "t-#{SecureRandom.random_number(9999)}" }
+  let(:group_name) { "group#{SecureRandom.random_number(9999)}" }
   let(:included_members) { nil }
   let(:excluded_members) { nil }
   let(:group_resource) {
@@ -300,7 +323,7 @@ theoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalking\
 downthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreeQQQQQQ" }
 
       it "should not create a group" do
-        expect { group_resource.run_action(:create) }.to raise_error
+        expect { group_resource.run_action(:create) }.to raise_error(ArgumentError)
         group_should_not_exist(group_name)
       end
     end

data/spec/functional/resource/{powershell_spec.rb → powershell_script_spec.rb}

@@ -16,6 +16,7 @@
 # limitations under the License.
 #
 
+require 'chef/platform/query_helpers'
 require 'spec_helper'
 
 describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
@@ -27,7 +28,6 @@ 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(:processor_architecture_script_content) { "echo $env:PROCESSOR_ARCHITECTURE" }
@@ -57,6 +57,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     end
 
     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'])
       begin
         file.write "exit 27"
@@ -73,6 +75,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     let (:negative_exit_status) { -27 }
     let (:unsigned_exit_status) { (-negative_exit_status ^ 65535) + 1 }
     it "returns the exit status -27 as a signed integer or an unsigned 16-bit 2's complement value of 65509 for a powershell script that exits with -27" do
+      pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
+
       # 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'])
@@ -96,6 +100,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     end
 
     it "returns the process exit code" do
+      pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
+
       resource.code(arbitrary_nonzero_process_exit_code_content)
       resource.returns(arbitrary_nonzero_process_exit_code)
       resource.run_action(:run)
@@ -114,27 +120,37 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     end
 
     it "returns 1 if the last command was a 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)
       resource.returns(1)
       resource.run_action(:run)
     end
 
     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.returns(1)
       expect { resource.run_action(:run) }.not_to raise_error
     end
 
-    it "raises an error if the script is not syntactically correct and returns is not set to 1" 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.returns(0)
       expect { resource.run_action(:run) }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
     end
 
-    it "returns 1 if the script provided to the code attribute is not syntactically correct" do
+    it "raises an error if the script is not syntactically correct even if returns is set to 1 which is what powershell.exe returns for syntactically invalid scripts" do
+      # This test fails because shell_out expects the exit status to be 1, but it is actually 0
+      # 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.returns(1)
-      expect { resource.run_action(:run) }.not_to raise_error
+      expect { resource.run_action(:run) }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
     end
 
     # This somewhat ambiguous case, two failures of different types,
@@ -146,24 +162,32 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     # errors than 0 or 1, we return that instead, which is acceptable
     # since callers can test for nonzero rather than testing for 1.
     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.returns(arbitrary_nonzero_process_exit_code)
       resource.run_action(:run)
     end
 
     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.returns(arbitrary_nonzero_process_exit_code)
       resource.run_action(:run)
     end
 
     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.returns(arbitrary_nonzero_process_exit_code)
       resource.run_action(:run)
     end
 
     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.returns(arbitrary_nonzero_process_exit_code)
       resource.run_action(:run)
@@ -182,6 +206,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     end
 
     it "returns 1 for $false as the last line of the script when convert_boolean_return is true" do
+      pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
+
       resource.convert_boolean_return true
       resource.code "$false"
       resource.returns(1)
@@ -208,6 +234,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     end
 
     it "returns 1 if an invalid flag is passed to the interpreter" do
+      pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
+
       resource.code(cmdlet_exit_code_success_content)
       resource.flags(invalid_powershell_interpreter_flag)
       resource.returns(1)
@@ -227,10 +255,25 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       expect { resource.should_skip?(:run) }.to raise_error(ArgumentError, /guard_interpreter does not support blocks/)
     end
 
+    context "when dsc is supported", :windows_powershell_dsc_only do
+      it "can execute LCM configuration code" do
+        resource.code <<-EOF
+configuration LCM
+{
+  param ($thumbprint)
+  localconfigurationmanager
+  {
+    RebootNodeIfNeeded = $false
+    ConfigurationMode = 'ApplyOnly'
+  }
+}
+        EOF
+        expect { resource.run_action(:run) }.not_to raise_error
+      end
+    end
   end
 
-  context "when running on a 32-bit version of Windows", :windows32_only do
-
+  context "when running on a 32-bit version of Ruby", :ruby32_only do
     it "executes a script with a 32-bit process if process architecture :i386 is specified" do
       resource.code(processor_architecture_script_content + " | out-file -encoding ASCII #{script_output_path}")
       resource.architecture(:i386)
@@ -240,15 +283,28 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       expect(source_contains_case_insensitive_content?( get_script_output, 'x86' )).to eq(true)
     end
 
-    it "raises an exception if :x86_64 process architecture is specified" do
-      begin
-        expect(resource.architecture(:x86_64)).to raise_error Chef::Exceptions::Win32ArchitectureIncorrect
-      rescue Chef::Exceptions::Win32ArchitectureIncorrect
+    context "when running on a 64-bit version of Windows", :windows64_only do
+      it "executes a script with a 64-bit process if :x86_64 arch is specified" do
+        resource.code(processor_architecture_script_content + " | out-file -encoding ASCII #{script_output_path}")
+        resource.architecture(:x86_64)
+        resource.returns(0)
+        resource.run_action(:run)
+
+        expect(source_contains_case_insensitive_content?( get_script_output, 'AMD64' )).to eq(true)
+      end
+    end
+
+    context "when running on a 32-bit version of Windows", :windows32_only do
+      it "raises an exception if :x86_64 process architecture is specified" do
+        begin
+          expect(resource.architecture(:x86_64)).to raise_error Chef::Exceptions::Win32ArchitectureIncorrect
+        rescue Chef::Exceptions::Win32ArchitectureIncorrect
+        end
       end
     end
   end
 
-  context "when running on a 64-bit version of Windows", :windows64_only do
+  context "when running on a 64-bit version of Ruby", :ruby64_only do
     it "executes a script with a 64-bit process if :x86_64 arch is specified" do
       resource.code(processor_architecture_script_content + " | out-file -encoding ASCII #{script_output_path}")
       resource.architecture(:x86_64)
@@ -258,7 +314,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       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" do
+    it "executes a script with a 32-bit process if :i386 arch is specified", :not_supported_on_nano do
       resource.code(processor_architecture_script_content + " | out-file -encoding ASCII #{script_output_path}")
       resource.architecture(:i386)
       resource.returns(0)
@@ -266,6 +322,12 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
 
       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,
+        "cannot execute script with requested architecture 'i386' on Windows Nano Server")
+    end
   end
 
   describe "when executing guards" do
@@ -319,6 +381,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       end
 
       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"
         expect(resource.should_skip?(:run)).to be_falsey
       end
@@ -329,6 +393,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       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"
         expect(resource.should_skip?(:run)).to be_truthy
       end
@@ -349,6 +415,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       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"
         expect(resource.should_skip?(:run)).to be_falsey
       end
@@ -359,6 +427,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       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
         expect(resource.should_skip?(:run)).to be_falsey
       end
@@ -369,6 +439,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       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
         expect(resource.should_skip?(:run)).to be_truthy
       end
@@ -379,6 +451,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       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'"
         expect(resource.should_skip?(:run)).to be_falsey
       end
@@ -389,6 +463,8 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       end
 
       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'"
         expect(resource.should_skip?(:run)).to be_truthy
       end
@@ -431,30 +507,36 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
       end
 
       it "evaluates a 64-bit resource with a 64-bit guard and interprets boolean true as nonzero status code", :windows64_only do
+        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')"
         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" do
+      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')"
         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" do
+      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')"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a simple boolean false as nonzero status code when convert_boolean_return is true for only_if" do
+        pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
+
         resource.convert_boolean_return true
         resource.only_if  "$false"
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates a simple boolean false as nonzero status code when convert_boolean_return is true for not_if" do
+        pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
+
         resource.convert_boolean_return true
         resource.not_if  "$false"
         expect(resource.should_skip?(:run)).to be_falsey
@@ -472,33 +554,40 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
         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" do
+      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'"
         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" do
+      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'"
         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" do
+      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'"
         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" do
+      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'"
         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(
+          Chef::Exceptions::Win32ArchitectureIncorrect,
+          /cannot execute script with requested architecture 'i386' on Windows Nano Server/)
+      end
     end
   end