chef 12.0.1-x86-mingw32 → 12.0.3-x86-mingw32

data/lib/chef/resource_collection/resource_set.rb

@@ -44,7 +44,7 @@ class Chef
         is_chef_resource!(resource)
         resource_type ||= resource.resource_name
         instance_name ||= resource.name
-        key = ResourceSet.create_key(resource_type, instance_name)
+        key = create_key(resource_type, instance_name)
         @resources_by_key[key] = resource
       end
 
@@ -53,7 +53,7 @@ class Chef
           when key.kind_of?(String)
             lookup_by = key
           when key.kind_of?(Chef::Resource)
-            lookup_by = ResourceSet.create_key(key.resource_name, key.name)
+            lookup_by = create_key(key.resource_name, key.name)
           else
             raise ArgumentError, "Must pass a Chef::Resource or String to lookup"
         end
@@ -128,18 +128,18 @@ class Chef
         end
       end
 
-      def self.create_key(resource_type, instance_name)
+      private
+
+      def create_key(resource_type, instance_name)
         "#{resource_type}[#{instance_name}]"
       end
 
-      private
-
       def find_resource_by_hash(arg)
         results = Array.new
         arg.each do |resource_type, name_list|
           instance_names = name_list.kind_of?(Array) ? name_list : [ name_list ]
           instance_names.each do |instance_name|
-            results << lookup(ResourceSet.create_key(resource_type, instance_name))
+            results << lookup(create_key(resource_type, instance_name))
           end
         end
         return results
@@ -153,12 +153,12 @@ class Chef
             arg =~ /^.+\[(.+)\]$/
             resource_list = $1
             resource_list.split(",").each do |instance_name|
-              results << lookup(ResourceSet.create_key(resource_type, instance_name))
+              results << lookup(create_key(resource_type, instance_name))
             end
           when SINGLE_RESOURCE_MATCH
             resource_type = $1
             name = $2
-            results << lookup(ResourceSet.create_key(resource_type, name))
+            results << lookup(create_key(resource_type, name))
           else
             raise ArgumentError, "Bad string format #{arg}, you must have a string like resource_type[name]!"
         end

data/lib/chef/run_context.rb

@@ -100,7 +100,7 @@ class Chef
       if nr.instance_of?(Chef::Resource)
         @immediate_notification_collection[nr.name] << notification
       else
-        @immediate_notification_collection[nr.to_s] << notification
+        @immediate_notification_collection[nr.declared_key] << notification
       end
     end
 
@@ -111,7 +111,7 @@ class Chef
       if nr.instance_of?(Chef::Resource)
         @delayed_notification_collection[nr.name] << notification
       else
-        @delayed_notification_collection[nr.to_s] << notification
+        @delayed_notification_collection[nr.declared_key] << notification
       end
     end
 
@@ -119,7 +119,7 @@ class Chef
       if resource.instance_of?(Chef::Resource)
         return @immediate_notification_collection[resource.name]
       else
-        return @immediate_notification_collection[resource.to_s]
+        return @immediate_notification_collection[resource.declared_key]
       end
     end
 
@@ -127,7 +127,7 @@ class Chef
       if resource.instance_of?(Chef::Resource)
         return @delayed_notification_collection[resource.name]
       else
-        return @delayed_notification_collection[resource.to_s]
+        return @delayed_notification_collection[resource.declared_key]
       end
     end
 

data/lib/chef/version.rb

@@ -17,7 +17,7 @@
 
 class Chef
   CHEF_ROOT = File.dirname(File.expand_path(File.dirname(__FILE__)))
-  VERSION = '12.0.1'
+  VERSION = '12.0.3'
 end
 
 #

data/lib/chef/whitelist.rb

@@ -57,7 +57,9 @@ class Chef
         all_data = all_data[part]
       end
 
-      unless all_data[parts[-1]]
+      # Note: You can't do all_data[parts[-1]] here because the value
+      # may be false-y
+      unless all_data.key?(parts[-1])
         Chef::Log.warn("Could not find whitelist attribute #{item}.")
         return nil
       end

data/lib/chef/win32/api/file.rb

@@ -457,11 +457,25 @@ BOOL WINAPI DeviceIoControl(
         # takes the given path pre-pends "\\?\" and
         # UTF-16LE encodes it.  Used to prepare paths
         # to be passed to the *W vesion of WinAPI File
-        # functions
+        # functions.
+        # This function is used by the "Link" resources where we need
+        # preserve relative paths because symbolic links can actually
+        # point to a relative path (relative to the link itself).
         def encode_path(path)
+          (path_prepender << path.gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR)).to_wstring
+        end
+
+        # Expands the path, prepends "\\?\" and UTF-16LE encodes it.
+        # This function is used by the "File" resources where we need
+        # convert relative paths to fully qualified paths.
+        def canonical_encode_path(path)
           Chef::Util::PathHelper.canonical_path(path).to_wstring
         end
 
+        def path_prepender
+          "\\\\?\\"
+        end
+
         # retrieves a file search handle and passes it
         # to +&block+ along with the find_data.  also
         # ensures the handle is closed on exit of the block
@@ -474,7 +488,7 @@ BOOL WINAPI DeviceIoControl(
             # broader fix to map all the paths starting with "/" to
             # SYSTEM_DRIVE on windows.
             path = ::File.expand_path(path) if path.start_with? "/"
-            path = encode_path(path)
+            path = canonical_encode_path(path)
             find_data = WIN32_FIND_DATA.new
             handle = FindFirstFileW(path, find_data)
             if handle == INVALID_HANDLE_VALUE
@@ -491,7 +505,7 @@ BOOL WINAPI DeviceIoControl(
         # ensures the handle is closed on exit of the block
         def file_handle(path, &block)
           begin
-            path = encode_path(path)
+            path = canonical_encode_path(path)
             handle = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ,
                                   nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, nil)
 

data/spec/functional/notifications_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+require 'chef/recipe'
+
+
+# The goal of these tests is to make sure that loading resources from a file creates the necessary notifications.
+# Then once converge has started, both immediate and delayed notifications are called as the resources are converged.
+# We want to do this WITHOUT actually converging any resources - we don't want to take time changing the system,
+# we just want to make sure the run_context, the notification DSL and the converge hooks are working together
+# to perform notifications.
+
+# This test is extremely fragile since it mocks MANY different systems at once - any of them changes, this test
+# breaks
+describe "Notifications" do
+
+  # We always pretend we are on OSx because that has a specific provider (HomebrewProvider) so it
+  # tests the translation from Provider => HomebrewProvider
+  let(:node) {
+    n = Chef::Node.new
+    n.override[:os] = "darwin"
+    n
+  }
+  let(:cookbook_collection) { double("Chef::CookbookCollection").as_null_object }
+  let(:events) { double("Chef::EventDispatch::Dispatcher").as_null_object }
+  let(:run_context) { Chef::RunContext.new(node, cookbook_collection, events) }
+  let(:recipe) { Chef::Recipe.new("notif", "test", run_context) }
+  let(:runner) { Chef::Runner.new(run_context) }
+
+  before do
+    # By default, every provider will do nothing
+    p = Chef::Provider.new(nil, run_context)
+    allow_any_instance_of(Chef::Resource).to receive(:provider_for_action).and_return(p)
+    allow(p).to receive(:run_action)
+  end
+
+  it "should subscribe from one resource to another" do
+    log_resource = recipe.declare_resource(:log, "subscribed-log") do
+      message "This is a log message"
+      action :nothing
+      subscribes :write, "package[vim]", :immediately
+    end
+
+    package_resource = recipe.declare_resource(:package, "vim") do
+      action :install
+    end
+
+    expect(log_resource).to receive(:run_action).with(:nothing, nil, nil).and_call_original
+
+    expect(package_resource).to receive(:run_action).with(:install, nil, nil).and_call_original
+    update_action(package_resource)
+
+    expect(log_resource).to receive(:run_action).with(:write, :immediate, package_resource).and_call_original
+
+    runner.converge
+  end
+
+  it "should notify from one resource to another immediately" do
+    log_resource = recipe.declare_resource(:log, "log") do
+      message "This is a log message"
+      action :write
+      notifies :install, "package[vim]", :immediately
+    end
+
+    package_resource = recipe.declare_resource(:package, "vim") do
+      action :nothing
+    end
+
+    expect(log_resource).to receive(:run_action).with(:write, nil, nil).and_call_original
+    update_action(log_resource)
+
+    expect(package_resource).to receive(:run_action).with(:install, :immediate, log_resource).ordered.and_call_original
+
+    expect(package_resource).to receive(:run_action).with(:nothing, nil, nil).ordered.and_call_original
+
+    runner.converge
+  end
+
+  it "should notify from one resource to another delayed" do
+    log_resource = recipe.declare_resource(:log, "log") do
+      message "This is a log message"
+      action :write
+      notifies :install, "package[vim]", :delayed
+    end
+
+    package_resource = recipe.declare_resource(:package, "vim") do
+      action :nothing
+    end
+
+    expect(log_resource).to receive(:run_action).with(:write, nil, nil).and_call_original
+    update_action(log_resource)
+
+    expect(package_resource).to receive(:run_action).with(:nothing, nil, nil).ordered.and_call_original
+
+    expect(package_resource).to receive(:run_action).with(:install, :delayed, nil).ordered.and_call_original
+
+    runner.converge
+  end
+  
+  describe "when one resource is defined lazily" do
+
+    it "subscribes to a resource defined in a ruby block" do
+      r = recipe
+      t = self
+      ruby_block = recipe.declare_resource(:ruby_block, "rblock") do
+        block do
+          log_resource = r.declare_resource(:log, "log") do
+            message "This is a log message"
+            action :write
+          end
+          t.expect(log_resource).to t.receive(:run_action).with(:write, nil, nil).and_call_original
+          t.update_action(log_resource)
+        end
+      end
+
+      package_resource = recipe.declare_resource(:package, "vim") do
+        action :nothing
+        subscribes :install, "log[log]", :delayed
+      end
+
+      # RubyBlock needs to be able to run for our lazy examples to work - and it alone cannot affect the system
+      expect(ruby_block).to receive(:provider_for_action).and_call_original
+
+      expect(package_resource).to receive(:run_action).with(:nothing, nil, nil).ordered.and_call_original
+
+      expect(package_resource).to receive(:run_action).with(:install, :delayed, nil).ordered.and_call_original
+
+      runner.converge
+    end
+
+    it "notifies from inside a ruby_block to a resource defined outside" do
+      r = recipe
+      t = self
+      ruby_block = recipe.declare_resource(:ruby_block, "rblock") do
+        block do
+          log_resource = r.declare_resource(:log, "log") do
+            message "This is a log message"
+            action :write
+            notifies :install, "package[vim]", :immediately
+          end
+          t.expect(log_resource).to t.receive(:run_action).with(:write, nil, nil).and_call_original
+          t.update_action(log_resource)
+        end
+      end
+
+      package_resource = recipe.declare_resource(:package, "vim") do
+        action :nothing
+      end
+
+      # RubyBlock needs to be able to run for our lazy examples to work - and it alone cannot affect the system
+      expect(ruby_block).to receive(:provider_for_action).and_call_original
+
+      expect(package_resource).to receive(:run_action).with(:install, :immediate, instance_of(Chef::Resource::Log)).ordered.and_call_original
+
+      expect(package_resource).to receive(:run_action).with(:nothing, nil, nil).ordered.and_call_original
+
+      runner.converge
+    end
+
+  end
+
+  # Mocks having the provider run successfully and update the resource
+  def update_action(resource)
+    p = Chef::Provider.new(resource, run_context)
+    expect(resource).to receive(:provider_for_action).and_return(p)
+    expect(p).to receive(:run_action) {
+      resource.updated_by_last_action(true)
+    }
+  end
+
+end

data/spec/functional/resource/link_spec.rb

@@ -72,8 +72,8 @@ describe Chef::Resource::Link do
     end
   end
 
-  def paths_eql?(path1, path2)
-    Chef::Util::PathHelper.paths_eql?(path1, path2)
+  def canonicalize(path)
+    windows? ? path.gsub('/', '\\') : path
   end
 
   def symlink(a, b)
@@ -179,8 +179,8 @@ describe Chef::Resource::Link do
         end
 
         it 'links to the target file' do
-          symlink?(target_file).should be_true
-          paths_eql?(readlink(target_file), to).should be_true
+          expect(symlink?(target_file)).to be_true
+          expect(readlink(target_file)).to eq(canonicalize(to))
         end
         it 'marks the resource updated' do
           resource.should be_updated
@@ -200,8 +200,8 @@ describe Chef::Resource::Link do
         end
 
         it 'leaves the file linked' do
-          symlink?(target_file).should be_true
-          paths_eql?(readlink(target_file), to).should be_true
+          expect(symlink?(target_file)).to be_true
+          expect(readlink(target_file)).to eq(canonicalize(to))
         end
         it 'does not mark the resource updated' do
           resource.should_not be_updated
@@ -278,8 +278,8 @@ describe Chef::Resource::Link do
           context 'pointing at the target' do
             before(:each) do
               symlink(to, target_file)
-              symlink?(target_file).should be_true
-              paths_eql?(readlink(target_file), to).should be_true
+              expect(symlink?(target_file)).to be_true
+              expect(readlink(target_file)).to eq(canonicalize(to))
             end
             include_context 'create symbolic link is noop'
             include_context 'delete succeeds'
@@ -293,8 +293,8 @@ describe Chef::Resource::Link do
               @other_target = File.join(test_file_dir, make_tmpname('other_spec'))
               File.open(@other_target, 'w') { |file| file.write('eek') }
               symlink(@other_target, target_file)
-              symlink?(target_file).should be_true
-              paths_eql?(readlink(target_file), @other_target).should be_true
+              expect(symlink?(target_file)).to be_true
+              expect(readlink(target_file)).to eq(canonicalize(@other_target))
             end
             after(:each) do
               File.delete(@other_target)
@@ -310,8 +310,8 @@ describe Chef::Resource::Link do
             before(:each) do
               nonexistent = File.join(test_file_dir, make_tmpname('nonexistent_spec'))
               symlink(nonexistent, target_file)
-              symlink?(target_file).should be_true
-              paths_eql?(readlink(target_file), nonexistent).should be_true
+              expect(symlink?(target_file)).to be_true
+              expect(readlink(target_file)).to eq(canonicalize(nonexistent))
             end
             include_context 'create symbolic link succeeds'
             include_context 'delete succeeds'
@@ -392,8 +392,8 @@ describe Chef::Resource::Link do
             @other_target = File.join(test_file_dir, make_tmpname("other_spec"))
             File.open(@other_target, "w") { |file| file.write("eek") }
             symlink(@other_target, to)
-            symlink?(to).should be_true
-            paths_eql?(readlink(to), @other_target).should be_true
+            expect(symlink?(to)).to be_true
+            expect(readlink(to)).to eq(canonicalize(@other_target))
           end
           after(:each) do
             File.delete(@other_target)
@@ -407,8 +407,8 @@ describe Chef::Resource::Link do
           before(:each) do
             @other_target = File.join(test_file_dir, make_tmpname("other_spec"))
             symlink(@other_target, to)
-            symlink?(to).should be_true
-            paths_eql?(readlink(to), @other_target).should be_true
+            expect(symlink?(to)).to be_true
+            expect(readlink(to)).to eq(canonicalize(@other_target))
           end
           context 'and the link does not yet exist' do
             include_context 'create symbolic link succeeds'
@@ -440,8 +440,8 @@ describe Chef::Resource::Link do
           context 'when the link already exists and points at the target' do
             before(:each) do
               symlink(to, target_file)
-              symlink?(target_file).should be_true
-              paths_eql?(readlink(target_file), to).should be_true
+              expect(symlink?(target_file)).to be_true
+              expect(readlink(target_file)).to eq(canonicalize(to))
             end
             include_context 'create symbolic link is noop'
             include_context 'delete succeeds'
@@ -449,8 +449,8 @@ describe Chef::Resource::Link do
           context 'when the link already exists and points at the target with an absolute path' do
             before(:each) do
               symlink(absolute_to, target_file)
-              symlink?(target_file).should be_true
-              paths_eql?(readlink(target_file), absolute_to).should be_true
+              expect(symlink?(target_file)).to be_true
+              expect(readlink(target_file)).to eq(canonicalize(absolute_to))
             end
             include_context 'create symbolic link succeeds'
             include_context 'delete succeeds'
@@ -477,8 +477,8 @@ describe Chef::Resource::Link do
         context "and the link already exists and is a symbolic link pointing at the same file" do
           before(:each) do
             symlink(to, target_file)
-            symlink?(target_file).should be_true
-            paths_eql?(readlink(target_file), to).should be_true
+            expect(symlink?(target_file)).to be_true
+            expect(readlink(target_file)).to eq(canonicalize(to))
           end
           include_context 'create hard link succeeds'
           it_behaves_like 'delete errors out'
@@ -551,8 +551,8 @@ describe Chef::Resource::Link do
             @other_target = File.join(test_file_dir, make_tmpname("other_spec"))
             File.open(@other_target, "w") { |file| file.write("eek") }
             symlink(@other_target, to)
-            symlink?(to).should be_true
-            paths_eql?(readlink(to), @other_target).should be_true
+            expect(symlink?(to)).to be_true
+            expect(readlink(to)).to eq(canonicalize(@other_target))
           end
           after(:each) do
             File.delete(@other_target)
@@ -562,10 +562,9 @@ describe Chef::Resource::Link do
               resource.run_action(:create)
               File.exists?(target_file).should be_true
               # OS X gets angry about this sort of link.  Bug in OS X, IMO.
-              pending('OS X/FreeBSD/AIX symlink? and readlink working on hard links to symlinks', :if => (os_x? or freebsd? or aix?)) do
-                symlink?(target_file).should be_true
-                paths_eql?(readlink(target_file), @other_target).should be_true
-              end
+              pending('OS X/FreeBSD/AIX symlink? and readlink working on hard links to symlinks') if (os_x? or freebsd? or aix?)
+              expect(symlink?(target_file)).to be_true
+              expect(readlink(target_file)).to eq(canonicalize(@other_target))
             end
             include_context 'delete is noop'
           end
@@ -574,8 +573,8 @@ describe Chef::Resource::Link do
           before(:each) do
             @other_target = File.join(test_file_dir, make_tmpname("other_spec"))
             symlink(@other_target, to)
-            symlink?(to).should be_true
-            paths_eql?(readlink(to), @other_target).should be_true
+            expect(symlink?(to)).to be_true
+            expect(readlink(to)).to eq(canonicalize(@other_target))
           end
           context 'and the link does not yet exist' do
             it 'links to the target file' do
@@ -587,8 +586,8 @@ describe Chef::Resource::Link do
                 else
                   File.exists?(target_file).should be_false
                 end
-                symlink?(target_file).should be_true
-                paths_eql?(readlink(target_file), @other_target).should be_true
+                expect(symlink?(target_file)).to be_true
+                expect(readlink(target_file)).to eq(canonicalize(@other_target))
               end
             end
             include_context 'delete is noop'