chef 12.5.1-universal-mingw32 → 12.6.0-universal-mingw32

data/spec/unit/provider/user/dscl_spec.rb

@@ -760,6 +760,13 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
         provider.dscl_create_comment
       end
 
+      it "sets the comment field to username" do
+        new_resource.comment nil
+        expect(provider).to receive(:run_dscl).with("create /Users/toor RealName '#mockssuck'").and_return(true)
+        provider.dscl_create_comment
+        expect(new_resource.comment).to eq("#mockssuck")
+      end
+
       it "should run run_dscl with create /Users/user PrimaryGroupID to set the users primary group" do
         expect(provider).to receive(:run_dscl).with("create /Users/toor PrimaryGroupID '1001'").and_return(true)
         provider.dscl_set_gid
@@ -789,6 +796,13 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
         expect { provider.dscl_set_gid }.to raise_error(Chef::Exceptions::GroupIDNotFound)
       end
     end
+
+    it "should set group ID to 20 if it's not specified" do
+      new_resource.gid nil
+      expect(provider).to receive(:run_dscl).with("create /Users/toor PrimaryGroupID '20'").ordered.and_return(true)
+      provider.dscl_set_gid
+      expect(new_resource.gid).to eq(20)
+    end
   end
 
   describe "when the user exists and chef is managing it" do

data/spec/unit/provider/user/windows_spec.rb

@@ -107,8 +107,8 @@ describe Chef::Provider::User::Windows do
         expect(@provider.set_options[:home_dir]).to eq('/home/adam')
       end
 
-      it "marks the primary_group_id attribute to be updated" do
-        expect(@provider.set_options[:primary_group_id]).to eq(1000)
+      it "ignores the primary_group_id attribute" do
+        expect(@provider.set_options[:primary_group_id]).to eq(nil)
       end
 
       it "marks the user_id attribute to be updated" do

data/spec/unit/provider/user_spec.rb

@@ -452,11 +452,20 @@ describe Chef::Provider::User do
 
     it "should raise an error if we can't translate the group name during resource assertions" do
       expect(Etc).to receive(:getgrnam).and_raise(ArgumentError)
+      @provider.action = :create
       @provider.define_resource_requirements
       @provider.convert_group_name
       expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::User)
     end
 
+    it "does not raise an error if we can't translate the group name during resource assertions if we are removing the user" do
+      expect(Etc).to receive(:getgrnam).and_raise(ArgumentError)
+      @provider.action = :remove
+      @provider.define_resource_requirements
+      @provider.convert_group_name
+      expect { @provider.process_resource_requirements }.not_to raise_error
+    end
+
     it "should set the new resources gid to the integerized version if available" do
       expect(Etc).to receive(:getgrnam).with("999").and_return(@group)
       @provider.convert_group_name

data/spec/unit/provider_resolver_spec.rb

@@ -147,25 +147,17 @@ describe Chef::ProviderResolver do
         services.each do |service|
           case service
           when :debian
-            directory 'usr/sbin/update-rc.d'
+            file 'usr/sbin/update-rc.d', ''
           when :invokercd
-            directory 'usr/sbin/invoke-rc.d'
+            file 'usr/sbin/invoke-rc.d', ''
           when :insserv
-            directory 'sbin/insserv'
+            file 'sbin/insserv', ''
           when :upstart
-            directory 'etc/init'
-            directory 'sbin/start'
+            file 'sbin/initctl', ''
           when :redhat
-            directory 'sbin/chkconfig'
+            file 'sbin/chkconfig', ''
           when :systemd
-            file 'bin/systemctl', ''
-            # Make systemctl executable
-            File.chmod(0755, path_to('bin/systemctl'))
-            # Windows doesn't respect executable bit, do this to let Windows users see if they've broken the resolver
-            allow(::File).to receive(:executable?) { |p| p == path_to('bin/systemctl') } if windows?
             file 'proc/1/comm', "systemd\n"
-            mock_shellout_command("/bin/systemctl --all", stdout: "")
-            mock_shellout_command("/bin/systemctl list-unit-files", stdout: "")
           else
             raise ArgumentError, service
           end
@@ -186,24 +178,8 @@ describe Chef::ProviderResolver do
           when :usr_local_etc_rcd
             file "usr/local/etc/rc.d/#{service_name}", ""
           when :systemd
-            file 'bin/systemctl', ''
-            # Make systemctl executable
-            File.chmod(0755, path_to("bin/systemctl"))
-            # Windows doesn't respect executable bit, do this to let Windows users see if they've broken the resolver
-            allow(::File).to receive(:executable?) { |p| p == path_to('bin/systemctl') } if windows?
             file 'proc/1/comm', "systemd\n"
-            mock_shellout_command("/bin/systemctl --all", stdout: <<-EOM)
-  superv  loaded
-  stinky  something-else
-  #{service_name} loaded
-  blargh  not-found
-  EOM
-            mock_shellout_command("/bin/systemctl list-unit-files", stdout: <<-EOM)
-  usuperv  loaded
-  ustinky  something-else
-  u#{service_name}    loaded
-  ublargh  not-found
-  EOM
+            file "etc/systemd/system/#{service_name}.service", ""
           else
             raise ArgumentError, config
           end

data/spec/unit/recipe_spec.rb

@@ -3,7 +3,7 @@
 # Author:: Christopher Walters (<cw@opscode.com>)
 # Author:: Tim Hinderliter (<tim@opscode.com>)
 # Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Copyright:: Copyright (c) 2008-2011 Opscode, Inc.
+# Copyright:: Copyright (c) 2008-2015 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,25 +24,19 @@ require 'chef/platform/resource_priority_map'
 
 describe Chef::Recipe do
 
-  let(:cookbook_repo) { File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "cookbooks")) }
-
-  let(:cookbook_loader) do
-    loader = Chef::CookbookLoader.new(cookbook_repo)
-    loader.load_cookbooks
-    loader
+  let(:cookbook_collection) do
+    cookbook_repo = File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "cookbooks"))
+    cookbook_loader = Chef::CookbookLoader.new(cookbook_repo)
+    cookbook_loader.load_cookbooks
+    Chef::CookbookCollection.new(cookbook_loader)
   end
 
-  let(:cookbook_collection) { Chef::CookbookCollection.new(cookbook_loader) }
-
   let(:node) do
-    Chef::Node.new.tap {|n| n.normal[:tags] = [] }
-  end
-
-  let(:events) do
-    Chef::EventDispatch::Dispatcher.new
+    Chef::Node.new
   end
 
   let(:run_context) do
+    events = Chef::EventDispatch::Dispatcher.new
     Chef::RunContext.new(node, cookbook_collection, events)
   end
 
@@ -305,6 +299,34 @@ describe Chef::Recipe do
         zm_resource # force let binding evaluation
         expect(run_context.resource_collection.resources(:zen_master => "klopp")).to eq(zm_resource)
       end
+
+      it "will insert another resource if create_if_missing is not set (cloned resource as of Chef-12)" do
+        zm_resource
+        recipe.declare_resource(:zen_master, "klopp")
+        expect(run_context.resource_collection.count).to eql(2)
+      end
+
+      it "does not insert two resources if create_if_missing is used" do
+        zm_resource
+        recipe.declare_resource(:zen_master, "klopp", create_if_missing: true)
+        expect(run_context.resource_collection.count).to eql(1)
+      end
+
+      context "injecting a different run_context" do
+        let(:run_context2) do
+          events = Chef::EventDispatch::Dispatcher.new
+          Chef::RunContext.new(node, cookbook_collection, events)
+        end
+
+        it "should insert resources into the correct run_context" do
+          zm_resource
+          recipe.declare_resource(:zen_master, "klopp2", run_context: run_context2)
+          run_context2.resource_collection.lookup("zen_master[klopp2]")
+          expect {run_context2.resource_collection.lookup("zen_master[klopp]")}.to raise_error(Chef::Exceptions::ResourceNotFound)
+          expect {run_context.resource_collection.lookup("zen_master[klopp2]")}.to raise_error(Chef::Exceptions::ResourceNotFound)
+          run_context.resource_collection.lookup("zen_master[klopp]")
+        end
+      end
     end
 
     describe "creating a resource with short name" do
@@ -615,21 +637,25 @@ describe Chef::Recipe do
       end
     end
 
+    it "should initialize tags to an empty Array" do
+      expect(node.tags).to eql([])
+    end
+
     it "should set tags via tag" do
       recipe.tag "foo"
-      expect(node[:tags]).to include("foo")
+      expect(node.tags).to include("foo")
     end
 
     it "should set multiple tags via tag" do
       recipe.tag "foo", "bar"
-      expect(node[:tags]).to include("foo")
-      expect(node[:tags]).to include("bar")
+      expect(node.tags).to include("foo")
+      expect(node.tags).to include("bar")
     end
 
     it "should not set the same tag twice via tag" do
       recipe.tag "foo"
       recipe.tag "foo"
-      expect(node[:tags]).to eql([ "foo" ])
+      expect(node.tags).to eql([ "foo" ])
     end
 
     it "should return the current list of tags from tag with no arguments" do
@@ -653,13 +679,13 @@ describe Chef::Recipe do
     it "should remove a tag from the tag list via untag" do
       recipe.tag "foo"
       recipe.untag "foo"
-      expect(node[:tags]).to eql([])
+      expect(node.tags).to eql([])
     end
 
     it "should remove multiple tags from the tag list via untag" do
       recipe.tag "foo", "bar"
       recipe.untag "bar", "foo"
-      expect(node[:tags]).to eql([])
+      expect(node.tags).to eql([])
     end
   end
 

data/spec/unit/resource/chef_gem_spec.rb

@@ -52,7 +52,7 @@ describe Chef::Resource::ChefGem, "gem_binary" do
 
   context "when building the resource" do
     let(:node) do
-      Chef::Node.new.tap {|n| n.normal[:tags] = [] }
+      Chef::Node.new
     end
 
     let(:run_context) do

data/spec/unit/resource/dsc_resource_spec.rb

@@ -15,13 +15,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
 require 'spec_helper'
-
 describe Chef::Resource::DscResource do
   let(:dsc_test_resource_name) { 'DSCTest' }
   let(:dsc_test_property_name) { :DSCTestProperty }
   let(:dsc_test_property_value) { 'DSCTestValue' }
+  let(:dsc_test_reboot_action) { :reboot_now }
+  let(:dsc_test_timeout) { 101 }
 
   context 'when Powershell supports Dsc' do
     let(:dsc_test_run_context) {
@@ -30,6 +30,7 @@ describe Chef::Resource::DscResource do
       empty_events = Chef::EventDispatch::Dispatcher.new
       Chef::RunContext.new(node, {}, empty_events)
     }
+
     let(:dsc_test_resource) {
       Chef::Resource::DscResource.new(dsc_test_resource_name, dsc_test_run_context)
     }
@@ -38,7 +39,7 @@ describe Chef::Resource::DscResource do
       expect(dsc_test_resource.action).to eq([:run])
     end
 
-    it "has an allowed_actions attribute with only the `:run` and `:nothing` attributes" do
+    it "has an ed_actions attribute with only the `:run` and `:nothing` attributes" do
       expect(dsc_test_resource.allowed_actions.to_set).to eq([:run,:nothing].to_set)
     end
 
@@ -52,6 +53,16 @@ describe Chef::Resource::DscResource do
       expect(dsc_test_resource.module_name).to eq(dsc_test_resource_name)
     end
 
+    it "allows the reboot_action attribute to be set" do
+      dsc_test_resource.reboot_action(dsc_test_reboot_action)
+      expect(dsc_test_resource.reboot_action).to eq(dsc_test_reboot_action)
+    end
+
+    it "allows the timeout attribute to be set" do
+      dsc_test_resource.timeout(dsc_test_timeout)
+      expect(dsc_test_resource.timeout).to eq(dsc_test_timeout)
+    end
+
     context "when setting a dsc property" do
       it "allows setting a dsc property with a property name of type Symbol" do
         dsc_test_resource.property(dsc_test_property_name, dsc_test_property_value)

data/spec/unit/resource/ksh_spec.rb

@@ -0,0 +1,40 @@
+#
+# Author:: Nolan Davidson (<nolan.davidson@gmail.com>)
+# Copyright:: Copyright (c) 2015 Chef Software, 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'
+
+describe Chef::Resource::Ksh do
+
+  before(:each) do
+    @resource = Chef::Resource::Ksh.new("fakey_fakerton")
+  end
+
+  it "should create a new Chef::Resource::Ksh" do
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Ksh)
+  end
+
+  it "should have a resource name of :ksh" do
+    expect(@resource.resource_name).to eql(:ksh)
+  end
+
+  it "should have an interpreter of ksh" do
+    expect(@resource.interpreter).to eql("ksh")
+  end
+
+end

data/spec/unit/resource/registry_key_spec.rb

@@ -91,7 +91,7 @@ describe Chef::Resource::RegistryKey, "values" do
 
   it "should return checksummed data if the type is unsafe" do
     @resource.values( { :name => 'poosh', :type => :binary, :data => 255.chr * 1 })
-    expect(@resource.values).to eql([ { :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" } ])
+    expect(@resource.values).to eql([ { :name => 'poosh', :type => :binary, :data => 'a8100ae6aa1940d0b663bb31cd466142ebbdbd5187131b92d93818987832eb89' } ])
   end
 
   it "should throw an exception if the name field is missing" do
@@ -194,6 +194,6 @@ describe Chef::Resource::RegistryKey, "state" do
 
   it "should return scrubbed values" do
     @resource.values([ { :name => 'poosh', :type => :binary, :data => 255.chr * 1 } ])
-    expect(@resource.state).to eql( { :values => [{ :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" }] } )
+    expect(@resource.state).to eql( { :values => [{ :name => 'poosh', :type => :binary, :data => 'a8100ae6aa1940d0b663bb31cd466142ebbdbd5187131b92d93818987832eb89'}] } )
   end
 end

data/spec/unit/resource/resource_notification_spec.rb

@@ -19,149 +19,148 @@ require 'spec_helper'
 require 'chef/resource/resource_notification'
 
 describe Chef::Resource::Notification do
-  before do
-    @notification = Chef::Resource::Notification.new(:service_apache, :restart, :template_httpd_conf)
-  end
+
+  let(:notification) { Chef::Resource::Notification.new(:service_apache, :restart, :template_httpd_conf) }
 
   it "has a resource to be notified" do
-    expect(@notification.resource).to eq(:service_apache)
+    expect(notification.resource).to eq(:service_apache)
   end
 
   it "has an action to take on the service" do
-    expect(@notification.action).to eq(:restart)
+    expect(notification.action).to eq(:restart)
   end
 
   it "has a notifying resource" do
-    expect(@notification.notifying_resource).to eq(:template_httpd_conf)
+    expect(notification.notifying_resource).to eq(:template_httpd_conf)
   end
 
   it "is a duplicate of another notification with the same target resource and action" do
     other = Chef::Resource::Notification.new(:service_apache, :restart, :sync_web_app_code)
-    expect(@notification.duplicates?(other)).to be_truthy
+    expect(notification.duplicates?(other)).to be_truthy
   end
 
   it "is not a duplicate of another notification if the actions differ" do
     other = Chef::Resource::Notification.new(:service_apache, :enable, :install_apache)
-    expect(@notification.duplicates?(other)).to be_falsey
+    expect(notification.duplicates?(other)).to be_falsey
   end
 
   it "is not a duplicate of another notification if the target resources differ" do
     other = Chef::Resource::Notification.new(:service_sshd, :restart, :template_httpd_conf)
-    expect(@notification.duplicates?(other)).to be_falsey
+    expect(notification.duplicates?(other)).to be_falsey
   end
 
   it "raises an ArgumentError if you try to check a non-ducktype object for duplication" do
-    expect {@notification.duplicates?(:not_a_notification)}.to raise_error(ArgumentError)
+    expect {notification.duplicates?(:not_a_notification)}.to raise_error(ArgumentError)
   end
 
   it "takes no action to resolve a resource reference that doesn't need to be resolved" do
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
-    @notification.resource = @keyboard_cat
+    notification.resource = @keyboard_cat
     @long_cat = Chef::Resource::Cat.new("long_cat")
-    @notification.notifying_resource = @long_cat
+    notification.notifying_resource = @long_cat
     @resource_collection = Chef::ResourceCollection.new
     # would raise an error since the resource is not in the collection
-    @notification.resolve_resource_reference(@resource_collection)
-    expect(@notification.resource).to eq(@keyboard_cat)
+    notification.resolve_resource_reference(@resource_collection)
+    expect(notification.resource).to eq(@keyboard_cat)
   end
 
   it "resolves a lazy reference to a resource" do
-    @notification.resource = {:cat => "keyboard_cat"}
+    notification.resource = {:cat => "keyboard_cat"}
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @keyboard_cat
     @long_cat = Chef::Resource::Cat.new("long_cat")
-    @notification.notifying_resource = @long_cat
-    @notification.resolve_resource_reference(@resource_collection)
-    expect(@notification.resource).to eq(@keyboard_cat)
+    notification.notifying_resource = @long_cat
+    notification.resolve_resource_reference(@resource_collection)
+    expect(notification.resource).to eq(@keyboard_cat)
   end
 
   it "resolves a lazy reference to its notifying resource" do
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
-    @notification.resource = @keyboard_cat
-    @notification.notifying_resource = {:cat => "long_cat"}
+    notification.resource = @keyboard_cat
+    notification.notifying_resource = {:cat => "long_cat"}
     @long_cat = Chef::Resource::Cat.new("long_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @long_cat
-    @notification.resolve_resource_reference(@resource_collection)
-    expect(@notification.notifying_resource).to eq(@long_cat)
+    notification.resolve_resource_reference(@resource_collection)
+    expect(notification.notifying_resource).to eq(@long_cat)
   end
 
   it "resolves lazy references to both its resource and its notifying resource" do
-    @notification.resource = {:cat => "keyboard_cat"}
+    notification.resource = {:cat => "keyboard_cat"}
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @keyboard_cat
-    @notification.notifying_resource = {:cat => "long_cat"}
+    notification.notifying_resource = {:cat => "long_cat"}
     @long_cat = Chef::Resource::Cat.new("long_cat")
     @resource_collection << @long_cat
-    @notification.resolve_resource_reference(@resource_collection)
-    expect(@notification.resource).to eq(@keyboard_cat)
-    expect(@notification.notifying_resource).to eq(@long_cat)
+    notification.resolve_resource_reference(@resource_collection)
+    expect(notification.resource).to eq(@keyboard_cat)
+    expect(notification.notifying_resource).to eq(@long_cat)
   end
 
   it "raises a RuntimeError if you try to reference multiple resources" do
-    @notification.resource = {:cat => ["keyboard_cat", "cheez_cat"]}
+    notification.resource = {:cat => ["keyboard_cat", "cheez_cat"]}
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
     @cheez_cat = Chef::Resource::Cat.new("cheez_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @keyboard_cat
     @resource_collection << @cheez_cat
     @long_cat = Chef::Resource::Cat.new("long_cat")
-    @notification.notifying_resource = @long_cat
-    expect {@notification.resolve_resource_reference(@resource_collection)}.to raise_error(RuntimeError)
+    notification.notifying_resource = @long_cat
+    expect {notification.resolve_resource_reference(@resource_collection)}.to raise_error(RuntimeError)
   end
 
   it "raises a RuntimeError if you try to reference multiple notifying resources" do
-    @notification.notifying_resource = {:cat => ["long_cat", "cheez_cat"]}
+    notification.notifying_resource = {:cat => ["long_cat", "cheez_cat"]}
     @long_cat = Chef::Resource::Cat.new("long_cat")
     @cheez_cat = Chef::Resource::Cat.new("cheez_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @long_cat
     @resource_collection << @cheez_cat
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
-    @notification.resource = @keyboard_cat
-    expect {@notification.resolve_resource_reference(@resource_collection)}.to raise_error(RuntimeError)
+    notification.resource = @keyboard_cat
+    expect {notification.resolve_resource_reference(@resource_collection)}.to raise_error(RuntimeError)
   end
 
   it "raises a RuntimeError if it can't find a resource in the resource collection when resolving a lazy reference" do
-    @notification.resource = {:cat => "keyboard_cat"}
+    notification.resource = {:cat => "keyboard_cat"}
     @cheez_cat = Chef::Resource::Cat.new("cheez_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @cheez_cat
     @long_cat = Chef::Resource::Cat.new("long_cat")
-    @notification.notifying_resource = @long_cat
-    expect {@notification.resolve_resource_reference(@resource_collection)}.to raise_error(RuntimeError)
+    notification.notifying_resource = @long_cat
+    expect {notification.resolve_resource_reference(@resource_collection)}.to raise_error(RuntimeError)
   end
 
   it "raises a RuntimeError if it can't find a notifying resource in the resource collection when resolving a lazy reference" do
-    @notification.notifying_resource = {:cat => "long_cat"}
+    notification.notifying_resource = {:cat => "long_cat"}
     @cheez_cat = Chef::Resource::Cat.new("cheez_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @cheez_cat
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
-    @notification.resource = @keyboard_cat
-    expect {@notification.resolve_resource_reference(@resource_collection)}.to raise_error(RuntimeError)
+    notification.resource = @keyboard_cat
+    expect {notification.resolve_resource_reference(@resource_collection)}.to raise_error(RuntimeError)
   end
 
   it "raises an ArgumentError if improper syntax is used in the lazy reference to its resource" do
-    @notification.resource = "cat => keyboard_cat"
+    notification.resource = "cat => keyboard_cat"
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @keyboard_cat
     @long_cat = Chef::Resource::Cat.new("long_cat")
-    @notification.notifying_resource = @long_cat
-    expect {@notification.resolve_resource_reference(@resource_collection)}.to raise_error(ArgumentError)
+    notification.notifying_resource = @long_cat
+    expect {notification.resolve_resource_reference(@resource_collection)}.to raise_error(ArgumentError)
   end
 
   it "raises an ArgumentError if improper syntax is used in the lazy reference to its notifying resource" do
-    @notification.notifying_resource = "cat => long_cat"
+    notification.notifying_resource = "cat => long_cat"
     @long_cat = Chef::Resource::Cat.new("long_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @long_cat
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
-    @notification.resource = @keyboard_cat
-    expect {@notification.resolve_resource_reference(@resource_collection)}.to raise_error(ArgumentError)
+    notification.resource = @keyboard_cat
+    expect {notification.resolve_resource_reference(@resource_collection)}.to raise_error(ArgumentError)
   end
 
   # Create test to resolve lazy references to both notifying resource and dest. resource