chef 12.5.0.alpha.1 → 12.5.1

data/spec/integration/recipes/resource_load_spec.rb

@@ -0,0 +1,206 @@
+require 'support/shared/integration/integration_helper'
+
+describe "Resource.load_current_value" do
+  include IntegrationSupport
+
+  module Namer
+    extend self
+    attr_accessor :current_index
+    def incrementing_value
+      @incrementing_value += 1
+      @incrementing_value
+    end
+    attr_writer :incrementing_value
+  end
+
+  before(:all) { Namer.current_index = 1 }
+  before { Namer.current_index += 1 }
+  before { Namer.incrementing_value = 0 }
+
+  let(:resource_name) { :"load_current_value_dsl#{Namer.current_index}" }
+  let(:resource_class) {
+    result = Class.new(Chef::Resource) do
+      def self.to_s; resource_name; end
+      def self.inspect; resource_name.inspect; end
+      property :x, default: lazy { "default #{Namer.incrementing_value}" }
+      def self.created_x=(value)
+        @created = value
+      end
+      def self.created_x
+        @created
+      end
+      action :create do
+        new_resource.class.created_x = x
+      end
+    end
+    result.resource_name resource_name
+    result
+  }
+
+  # Pull on resource_class to initialize it
+  before { resource_class }
+
+  context "with a resource with load_current_value" do
+    before :each do
+      resource_class.load_current_value do
+        x "loaded #{Namer.incrementing_value} (#{self.class.properties.sort_by { |name,p| name }.
+          select { |name,p| p.is_set?(self) }.
+          map { |name,p| "#{name}=#{p.get(self)}" }.
+          join(", ") })"
+      end
+    end
+
+    context "and a resource with x set to a desired value" do
+      let(:resource) do
+        e = self
+        r = nil
+        converge {
+          r = public_send(e.resource_name, 'blah') do
+            x 'desired'
+          end
+        }
+        r
+      end
+
+      it "current_resource is passed name but not x" do
+        expect(resource.current_value.x).to eq 'loaded 2 (name=blah)'
+      end
+
+      it "resource.current_value returns a different resource" do
+        expect(resource.current_value.x).to eq 'loaded 2 (name=blah)'
+        expect(resource.x).to eq 'desired'
+      end
+
+      it "resource.current_value constructs the resource anew each time" do
+        expect(resource.current_value.x).to eq 'loaded 2 (name=blah)'
+        expect(resource.current_value.x).to eq 'loaded 3 (name=blah)'
+      end
+
+      it "the provider accesses the current value of x" do
+        expect(resource.class.created_x).to eq 'desired'
+      end
+
+      context "and identity: :i and :d with desired_state: false" do
+        before {
+          resource_class.class_eval do
+            property :i, identity: true
+            property :d, desired_state: false
+          end
+        }
+
+        before {
+          resource.i 'desired_i'
+          resource.d 'desired_d'
+        }
+
+        it "i, name and d are passed to load_current_value, but not x" do
+          expect(resource.current_value.x).to eq 'loaded 2 (d=desired_d, i=desired_i, name=blah)'
+        end
+      end
+
+      context "and name_property: :i and :d with desired_state: false" do
+        before {
+          resource_class.class_eval do
+            property :i, name_property: true
+            property :d, desired_state: false
+          end
+        }
+
+        before {
+          resource.i 'desired_i'
+          resource.d 'desired_d'
+        }
+
+        it "i, name and d are passed to load_current_value, but not x" do
+          expect(resource.current_value.x).to eq 'loaded 2 (d=desired_d, i=desired_i, name=blah)'
+        end
+      end
+    end
+
+    context "and a resource with no values set" do
+      let(:resource) do
+        e = self
+        r = nil
+        converge {
+          r = public_send(e.resource_name, 'blah') do
+          end
+        }
+        r
+      end
+
+      it "the provider accesses values from load_current_value" do
+        expect(resource.class.created_x).to eq 'loaded 1 (name=blah)'
+      end
+    end
+
+    let (:subresource_name) {
+      :"load_current_value_subresource_dsl#{Namer.current_index}"
+    }
+    let (:subresource_class) {
+      r = Class.new(resource_class) do
+        property :y, default: lazy { "default_y #{Namer.incrementing_value}" }
+      end
+      r.resource_name subresource_name
+      r
+    }
+
+    # Pull on subresource_class to initialize it
+    before { subresource_class }
+
+    let(:subresource) do
+      e = self
+      r = nil
+      converge {
+        r = public_send(e.subresource_name, 'blah') do
+          x 'desired'
+        end
+      }
+      r
+    end
+
+    context "and a child resource class with no load_current_value" do
+      it "the parent load_current_value is used" do
+        expect(subresource.current_value.x).to eq 'loaded 2 (name=blah)'
+      end
+      it "load_current_value yields a copy of the child class" do
+        expect(subresource.current_value).to be_kind_of(subresource_class)
+      end
+    end
+
+    context "And a child resource class with load_current_value" do
+      before {
+        subresource_class.load_current_value do
+          y "loaded_y #{Namer.incrementing_value} (#{self.class.properties.sort_by { |name,p| name }.
+            select { |name,p| p.is_set?(self) }.
+            map { |name,p| "#{name}=#{p.get(self)}" }.
+            join(", ") })"
+        end
+      }
+
+      it "the overridden load_current_value is used" do
+        current_resource = subresource.current_value
+        expect(current_resource.x).to eq 'default 3'
+        expect(current_resource.y).to eq 'loaded_y 2 (name=blah)'
+      end
+    end
+
+    context "and a child resource class with load_current_value calling super()" do
+      before {
+        subresource_class.load_current_value do
+          super()
+          y "loaded_y #{Namer.incrementing_value} (#{self.class.properties.sort_by { |name,p| name }.
+            select { |name,p| p.is_set?(self) }.
+            map { |name,p| "#{name}=#{p.get(self)}" }.
+            join(", ") })"
+        end
+      }
+
+      it "the original load_current_value is called as well as the child one" do
+        current_resource = subresource.current_value
+        expect(current_resource.x).to eq 'loaded 3 (name=blah)'
+        expect(current_resource.y).to eq 'loaded_y 4 (name=blah, x=loaded 3 (name=blah))'
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -73,6 +73,7 @@ require 'spec/support/local_gems.rb' if File.exists?(File.join(File.dirname(__FI
 
 # Explicitly require spec helpers that need to load first
 require 'spec/support/platform_helpers'
+require 'spec/support/shared/unit/mock_shellout'
 
 # Autoloads support files
 # Excludes support/platforms by default
@@ -98,6 +99,7 @@ TEST_PLATFORM_VERSION = TEST_NODE['platform_version']
 
 RSpec.configure do |config|
   config.include(Matchers)
+  config.include(MockShellout::RSpec)
   config.filter_run :focus => true
   config.filter_run_excluding :external => true
 
@@ -126,10 +128,14 @@ RSpec.configure do |config|
   config.filter_run_excluding :mac_osx_only=> true if !mac_osx?
   config.filter_run_excluding :not_supported_on_win2k3 => true if windows_win2k3?
   config.filter_run_excluding :not_supported_on_solaris => true if solaris?
+  config.filter_run_excluding :not_supported_on_nano => true if windows_nano_server?
   config.filter_run_excluding :win2k3_only => true unless windows_win2k3?
   config.filter_run_excluding :windows_2008r2_or_later => true unless windows_2008r2_or_later?
   config.filter_run_excluding :windows64_only => true unless windows64?
   config.filter_run_excluding :windows32_only => true unless windows32?
+  config.filter_run_excluding :windows_nano_only => true unless windows_nano_server?
+  config.filter_run_excluding :ruby64_only => true unless ruby_64bit?
+  config.filter_run_excluding :ruby32_only => true unless ruby_32bit?
   config.filter_run_excluding :windows_powershell_dsc_only => true unless windows_powershell_dsc?
   config.filter_run_excluding :windows_powershell_no_dsc_only => true unless ! windows_powershell_dsc?
   config.filter_run_excluding :windows_domain_joined_only => true unless windows_domain_joined?
@@ -183,6 +189,8 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
 
   config.before(:each) do
+    Chef.reset!
+
     Chef::Config.reset
 
     # By default, treat deprecation warnings as errors in tests.

data/spec/support/platform_helpers.rb

@@ -26,6 +26,14 @@ def ruby_20?
   !!(RUBY_VERSION =~ /^2.0/)
 end
 
+def ruby_64bit?
+  !!(RbConfig::CONFIG['host_cpu'] =~ /x86_64/)
+end
+
+def ruby_32bit?
+  !!(RbConfig::CONFIG['host_cpu'] =~ /i686/)
+end
+
 def windows?
   !!(RUBY_PLATFORM =~ /mswin|mingw|windows/)
 end
@@ -75,6 +83,11 @@ def windows_powershell_dsc?
   supports_dsc
 end
 
+def windows_nano_server?
+  require 'chef/platform/query_helpers'
+  Chef::Platform.windows_nano_server?
+end
+
 def mac_osx_106?
   if File.exists? "/usr/bin/sw_vers"
     result = ShellHelpers.shell_out("/usr/bin/sw_vers")

data/{lib/chef/mixin/wstring.rb → spec/support/shared/context/win32.rb}

@@ -1,6 +1,5 @@
 #
-# Author:: Jay Mundrawala(<jdm@chef.io>)
-# Copyright:: Copyright 2015 Chef Software
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,16 +15,20 @@
 # limitations under the License.
 #
 
-class Chef
-  module Mixin
-    module WideString
-      def wstring(str)
-        if str.nil? || str.encoding == Encoding::UTF_16LE
-          str
-        else
-          str.to_wstring
-        end
-      end
+RSpec.shared_context "Win32" do
+  before(:all) do
+    @original_win32 = if defined?(Win32)
+      win32 = Object.send(:const_get, 'Win32')
+      Object.send(:remove_const, 'Win32')
+      win32
+    else
+      nil
     end
+    Win32 = Module.new
+  end
+
+  after(:all) do
+    Object.send(:remove_const, 'Win32') if defined?(Win32)
+    Object.send(:const_set, 'Win32', @original_win32) if @original_win32
   end
 end

data/spec/support/shared/functional/windows_script.rb

@@ -19,14 +19,15 @@
 # Shared context used by both Powershell and Batch script provider
 # tests.
 
+require 'chef/platform/query_helpers'
+
 shared_context Chef::Resource::WindowsScript do
   before(:all) do
-
-    ohai_reader = Ohai::System.new
-    ohai_reader.all_plugins("platform")
+    @ohai_reader = Ohai::System.new
+    @ohai_reader.all_plugins(["platform", "kernel"])
 
     new_node = Chef::Node.new
-    new_node.consume_external_attrs(ohai_reader.data,{})
+    new_node.consume_external_attrs(@ohai_reader.data,{})
 
     events = Chef::EventDispatch::Dispatcher.new
 
@@ -51,12 +52,11 @@ shared_context Chef::Resource::WindowsScript do
 
   shared_examples_for "a script resource with architecture attribute" do
     context "with the given architecture attribute value" do
-      let(:resource_architecture) { architecture }
       let(:expected_architecture) do
-        if architecture
-          expected_architecture = architecture
+        if resource_architecture
+          expected_architecture = resource_architecture
         else
-          expected_architecture = :i386
+          expected_architecture = @ohai_reader.data['kernel']['machine'].to_sym
         end
       end
       let(:expected_architecture_output) do
@@ -77,16 +77,16 @@ shared_context Chef::Resource::WindowsScript do
 
       before(:each) do
         resource.code resource_command
-        (resource.architecture architecture) if architecture
+        (resource.architecture resource_architecture) if resource_architecture
         resource.returns(0)
       end
 
-      it "should create a process with the expected architecture" do
+      it "creates a process with the expected architecture" do
         resource.run_action(:run)
         expect(get_process_architecture).to eq(expected_architecture_output.downcase)
       end
 
-      it "should execute guards with the same architecture as the resource" do
+      it "executes guards with the same architecture as the resource" do
         resource.only_if resource_guard_command
         resource.run_action(:run)
         expect(get_process_architecture).to eq(expected_architecture_output.downcase)
@@ -94,18 +94,32 @@ shared_context Chef::Resource::WindowsScript do
         expect(get_guard_process_architecture).to eq(get_process_architecture)
       end
 
-      let (:architecture) { :x86_64 }
-      it "should execute a 64-bit guard if the guard's architecture is specified as 64-bit", :windows64_only do
-        resource.only_if resource_guard_command, :architecture => :x86_64
-        resource.run_action(:run)
-        expect(get_guard_process_architecture).to eq('amd64')
+      context "when the guard's architecture is specified as 64-bit" do
+        let (:guard_architecture) { :x86_64 }
+        it "executes a 64-bit guard", :windows64_only do
+          resource.only_if resource_guard_command, :architecture => guard_architecture
+          resource.run_action(:run)
+          expect(get_guard_process_architecture).to eq('amd64')
+        end
       end
 
-      let (:architecture) { :i386 }
-      it "should execute a 32-bit guard if the guard's architecture is specified as 32-bit" do
-        resource.only_if resource_guard_command, :architecture => :i386
-        resource.run_action(:run)
-        expect(get_guard_process_architecture).to eq('x86')
+      context "when the guard's architecture is specified as 32-bit", :not_supported_on_nano do
+        let (:guard_architecture) { :i386 }
+        it "executes a 32-bit guard" do
+          resource.only_if resource_guard_command, :architecture => guard_architecture
+          resource.run_action(:run)
+          expect(get_guard_process_architecture).to eq('x86')
+        end
+      end
+
+      context "when the guard's architecture is specified as 32-bit", :windows_nano_only do
+        let (:guard_architecture) { :i386 }
+        it "raises an error" do
+          resource.only_if resource_guard_command, :architecture => guard_architecture
+          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
   end
@@ -114,7 +128,28 @@ shared_context Chef::Resource::WindowsScript do
 
     describe "when the run action is invoked on Windows" do
       it "executes the script code" do
-        resource.code("whoami > #{script_output_path}")
+        resource.code("whoami > \"#{script_output_path}\"")
+        resource.returns(0)
+        resource.run_action(:run)
+      end
+    end
+
+    context "when $env:TMP has a space" do
+      before(:each) do
+        @dir = Dir.mktmpdir("Jerry Smith")
+        @original_env = ENV.to_hash.dup
+        ENV.delete('TMP')
+        ENV['TMP'] = @dir
+      end
+
+      after(:each) do
+        FileUtils.remove_entry_secure(@dir)
+        ENV.clear
+        ENV.update(@original_env)
+      end
+
+      it "executes the script code" do
+        resource.code("whoami > \"#{script_output_path}\"")
         resource.returns(0)
         resource.run_action(:run)
       end
@@ -122,6 +157,8 @@ shared_context Chef::Resource::WindowsScript do
 
     context "when evaluating guards" do
       it "has a guard_interpreter attribute set to the short name of the resource" do
+        pending "powershell.exe always exits with 0 on nano" if Chef::Platform.windows_nano_server?
+
         expect(resource.guard_interpreter).to eq(resource.resource_name)
         resource.not_if "findstr.exe /thiscommandhasnonzeroexitstatus"
         expect(Chef::Resource).to receive(:resource_for_node).and_call_original
@@ -131,17 +168,17 @@ shared_context Chef::Resource::WindowsScript do
     end
 
     context "when the architecture attribute is not set" do
-      let(:architecture) { nil }
+      let(:resource_architecture) { nil }
       it_behaves_like "a script resource with architecture attribute"
     end
 
-    context "when the architecture attribute is :i386" do
-      let(:architecture) { :i386 }
+    context "when the architecture attribute is :i386", :not_supported_on_nano do
+      let(:resource_architecture) { :i386 }
       it_behaves_like "a script resource with architecture attribute"
     end
 
     context "when the architecture attribute is :x86_64" do
-      let(:architecture) { :x86_64 }
+      let(:resource_architecture) { :x86_64 }
       it_behaves_like "a script resource with architecture attribute"
     end
   end