chef 12.0.3 → 12.1.0.rc.0

data/spec/unit/provider/service_spec.rb

@@ -69,7 +69,7 @@ describe Chef::Provider::Service do
   describe "action_start" do
     it "should start the service if it isn't running and set the resource as updated" do
       @current_resource.running(false)
-      expect(@provider).to receive(:start_service).with.and_return(true)
+      expect(@provider).to receive(:start_service).with(no_args).and_return(true)
       @provider.run_action(:start)
       expect(@provider.new_resource).to be_updated
     end

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

@@ -171,7 +171,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
 
   describe "uid_used?" do
     it "should return false if not given any valid uid number" do
-      expect(provider.uid_used?(nil)).to be_false
+      expect(provider.uid_used?(nil)).to be_falsey
     end
 
     describe "when called with a user id" do
@@ -180,11 +180,11 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
       end
 
       it "should return true for a used uid number" do
-        expect(provider.uid_used?(500)).to be_true
+        expect(provider.uid_used?(500)).to be_truthy
       end
 
       it "should return false for an unused uid number" do
-        expect(provider.uid_used?(501)).to be_false
+        expect(provider.uid_used?(501)).to be_falsey
       end
     end
   end
@@ -400,7 +400,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
 
       it "should set @user_exists" do
         provider.load_current_resource
-        expect(provider.instance_variable_get(:@user_exists)).to be_false
+        expect(provider.instance_variable_get(:@user_exists)).to be_falsey
       end
 
       it "should set username" do
@@ -422,7 +422,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
         it "collects the user data correctly" do
           provider.load_current_resource
           expect(provider.current_resource.comment).to eq("vagrant")
-          expect(provider.current_resource.uid).to eq("11112222-3333-4444-AAAA-BBBBCCCCDDDD")
+          expect(provider.current_resource.uid).to eq("501")
           expect(provider.current_resource.gid).to eq("80")
           expect(provider.current_resource.home).to eq("/Users/vagrant")
           expect(provider.current_resource.shell).to eq("/bin/bash")
@@ -434,7 +434,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
 
           it "diverged_password? should report false" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_false
+            expect(provider.diverged_password?).to be_falsey
           end
         end
 
@@ -443,7 +443,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
 
           it "diverged_password? should report true" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_true
+            expect(provider.diverged_password?).to be_truthy
           end
         end
 
@@ -453,7 +453,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
 
           it "diverged_password? should report false" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_false
+            expect(provider.diverged_password?).to be_falsey
           end
         end
 
@@ -462,7 +462,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
 
           it "diverged_password? should report true" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_true
+            expect(provider.diverged_password?).to be_truthy
           end
         end
 
@@ -472,7 +472,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
 
           it "diverged_password? should report false" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_false
+            expect(provider.diverged_password?).to be_falsey
           end
         end
       end
@@ -487,7 +487,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
         it "collects the user data correctly" do
           provider.load_current_resource
           expect(provider.current_resource.comment).to eq("vagrant")
-          expect(provider.current_resource.uid).to eq("11112222-3333-4444-AAAA-BBBBCCCCDDDD")
+          expect(provider.current_resource.uid).to eq("501")
           expect(provider.current_resource.gid).to eq("80")
           expect(provider.current_resource.home).to eq("/Users/vagrant")
           expect(provider.current_resource.shell).to eq("/bin/bash")
@@ -513,7 +513,7 @@ e68d1f9821b26689312366")
         it "collects the user data correctly" do
           provider.load_current_resource
           expect(provider.current_resource.comment).to eq("vagrant")
-          expect(provider.current_resource.uid).to eq("11112222-3333-4444-AAAA-BBBBCCCCDDDD")
+          expect(provider.current_resource.uid).to eq("501")
           expect(provider.current_resource.gid).to eq("80")
           expect(provider.current_resource.home).to eq("/Users/vagrant")
           expect(provider.current_resource.shell).to eq("/bin/bash")
@@ -525,7 +525,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
         describe "when a plain text password is set" do
           it "reports password needs to be updated" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_true
+            expect(provider.diverged_password?).to be_truthy
           end
         end
 
@@ -536,7 +536,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
 
           it "reports password needs to be updated" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_true
+            expect(provider.diverged_password?).to be_truthy
           end
         end
       end
@@ -551,7 +551,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
         it "collects the user data correctly" do
           provider.load_current_resource
           expect(provider.current_resource.comment).to eq("vagrant")
-          expect(provider.current_resource.uid).to eq("11112222-3333-4444-AAAA-BBBBCCCCDDDD")
+          expect(provider.current_resource.uid).to eq("501")
           expect(provider.current_resource.gid).to eq("80")
           expect(provider.current_resource.home).to eq("/Users/vagrant")
           expect(provider.current_resource.shell).to eq("/bin/bash")
@@ -565,7 +565,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
 
           it "diverged_password? should report false" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_false
+            expect(provider.diverged_password?).to be_falsey
           end
         end
 
@@ -574,7 +574,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
 
           it "diverged_password? should report true" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_true
+            expect(provider.diverged_password?).to be_truthy
           end
         end
 
@@ -585,7 +585,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
 
           it "diverged_password? should report true" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_true
+            expect(provider.diverged_password?).to be_truthy
           end
         end
 
@@ -596,7 +596,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
 
           it "diverged_password? should report true" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_true
+            expect(provider.diverged_password?).to be_truthy
           end
         end
 
@@ -607,7 +607,15 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
 
           it "diverged_password? should report true" do
             provider.load_current_resource
-            expect(provider.diverged_password?).to be_true
+            expect(provider.diverged_password?).to be_truthy
+          end
+        end
+
+        describe "when salt isn't found" do
+          it "diverged_password? should report true" do
+            provider.load_current_resource
+            provider.current_resource.salt(nil)
+            expect(provider.diverged_password?).to be_truthy
           end
         end
       end
@@ -616,23 +624,23 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
 
   describe "salted_sha512_pbkdf2?" do
     it "should return true when the string is a salted_sha512_pbkdf2 hash" do
-      expect(provider.salted_sha512_pbkdf2?(salted_sha512_pbkdf2_password)).to be_true
+      expect(provider.salted_sha512_pbkdf2?(salted_sha512_pbkdf2_password)).to be_truthy
     end
 
     it "should return false otherwise" do
-      expect(provider.salted_sha512_pbkdf2?(salted_sha512_password)).to be_false
-      expect(provider.salted_sha512_pbkdf2?("any other string")).to be_false
+      expect(provider.salted_sha512_pbkdf2?(salted_sha512_password)).to be_falsey
+      expect(provider.salted_sha512_pbkdf2?("any other string")).to be_falsey
     end
   end
 
   describe "salted_sha512?" do
     it "should return true when the string is a salted_sha512_pbkdf2 hash" do
-      expect(provider.salted_sha512_pbkdf2?(salted_sha512_pbkdf2_password)).to be_true
+      expect(provider.salted_sha512_pbkdf2?(salted_sha512_pbkdf2_password)).to be_truthy
     end
 
     it "should return false otherwise" do
-      expect(provider.salted_sha512?(salted_sha512_pbkdf2_password)).to be_false
-      expect(provider.salted_sha512?("any other string")).to be_false
+      expect(provider.salted_sha512?(salted_sha512_pbkdf2_password)).to be_falsey
+      expect(provider.salted_sha512?("any other string")).to be_falsey
     end
   end
 
@@ -649,7 +657,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
           shadow_info = provider.prepare_password_shadow_info
           expect(shadow_info).to have_key("SALTED-SHA512")
           info = shadow_info["SALTED-SHA512"].string.unpack('H*').first
-          expect(provider.salted_sha512?(info)).to be_true
+          expect(provider.salted_sha512?(info)).to be_truthy
         end
       end
 
@@ -660,7 +668,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
           shadow_info = provider.prepare_password_shadow_info
           expect(shadow_info).to have_key("SALTED-SHA512")
           info = shadow_info["SALTED-SHA512"].string.unpack('H*').first
-          expect(provider.salted_sha512?(info)).to be_true
+          expect(provider.salted_sha512?(info)).to be_truthy
           expect(info).to eq(vagrant_sha_512)
         end
       end
@@ -682,7 +690,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
             expect(shadow_info["SALTED-SHA512-PBKDF2"]).to have_key("salt")
             expect(shadow_info["SALTED-SHA512-PBKDF2"]).to have_key("iterations")
             info = shadow_info["SALTED-SHA512-PBKDF2"]["entropy"].string.unpack('H*').first
-            expect(provider.salted_sha512_pbkdf2?(info)).to be_true
+            expect(provider.salted_sha512_pbkdf2?(info)).to be_truthy
           end
         end
 
@@ -698,7 +706,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
             expect(shadow_info["SALTED-SHA512-PBKDF2"]).to have_key("salt")
             expect(shadow_info["SALTED-SHA512-PBKDF2"]).to have_key("iterations")
             info = shadow_info["SALTED-SHA512-PBKDF2"]["entropy"].string.unpack('H*').first
-            expect(provider.salted_sha512_pbkdf2?(info)).to be_true
+            expect(provider.salted_sha512_pbkdf2?(info)).to be_truthy
             expect(info).to eq(vagrant_sha_512_pbkdf2)
           end
         end

data/spec/unit/provider/user_spec.rb

@@ -91,7 +91,7 @@ describe Chef::Provider::User do
       expect(@current_resource.username).to eq(@new_resource.username)
     end
 
-    it "should change the encoding of gecos to the encoding of the new resource", :ruby_gte_19_only do
+    it "should change the encoding of gecos to the encoding of the new resource" do
       @pw_user.gecos.force_encoding('ASCII-8BIT')
       @provider.load_current_resource
       expect(@provider.current_resource.comment.encoding).to eq(@new_resource.comment.encoding)

data/spec/unit/provider_resolver_spec.rb

@@ -511,10 +511,11 @@ describe Chef::ProviderResolver do
 
       supported_providers = [
         :apt_package, :bash, :breakpoint, :chef_gem, :cookbook_file, :csh, :deploy,
-        :deploy_revision, :directory, :dpkg_package, :easy_install_package,
-        :erl_call, :execute, :file, :gem_package, :git, :http_request, :link, :log, :pacman_package, :paludis_package,
-        :perl, :python, :remote_directory, :route, :rpm_package, :ruby, :ruby_block, :script,
-        :subversion, :template, :timestamped_deploy, :whyrun_safe_ruby_block, :yum_package, :homebrew_package,
+        :deploy_revision, :directory, :dpkg_package, :easy_install_package, :erl_call,
+        :execute, :file, :gem_package, :git, :homebrew_package, :http_request, :link,
+        :log, :macports_package, :pacman_package, :paludis_package, :perl, :python,
+        :remote_directory, :route, :rpm_package, :ruby, :ruby_block, :script, :subversion,
+        :template, :timestamped_deploy, :whyrun_safe_ruby_block, :yum_package,
       ]
 
       supported_providers.each do |static_resource|
@@ -530,9 +531,8 @@ describe Chef::ProviderResolver do
       end
 
       unsupported_providers = [
-        :bff_package, :dsc_script, :ips_package, :macports_package,
-        :smartos_package, :solaris_package, :windows_package,
-        :windows_service,
+        :bff_package, :dsc_script, :ips_package, :smartos_package,
+        :solaris_package, :windows_package, :windows_service,
       ]
 
       unsupported_providers.each do |static_resource|

data/spec/unit/provider_spec.rb

@@ -74,23 +74,23 @@ describe Chef::Provider do
   end
 
   it "should store the resource passed to new as new_resource" do
-    @provider.new_resource.should eql(@resource)
+    expect(@provider.new_resource).to eql(@resource)
   end
 
   it "should store the node passed to new as node" do
-    @provider.node.should eql(@node)
+    expect(@provider.node).to eql(@node)
   end
 
   it "should have nil for current_resource by default" do
-    @provider.current_resource.should eql(nil)
+    expect(@provider.current_resource).to eql(nil)
   end
 
   it "should not support whyrun by default" do
-    @provider.send(:whyrun_supported?).should eql(false)
+    expect(@provider.send(:whyrun_supported?)).to eql(false)
   end
 
   it "should return true for action_nothing" do
-    @provider.action_nothing.should eql(true)
+    expect(@provider.action_nothing).to eql(true)
   end
 
   it "evals embedded recipes with a pristine resource collection" do
@@ -98,27 +98,27 @@ describe Chef::Provider do
     temporary_collection = nil
     snitch = Proc.new {temporary_collection = @run_context.resource_collection}
     @provider.send(:recipe_eval, &snitch)
-    temporary_collection.should be_an_instance_of(Chef::ResourceCollection)
-    @provider.run_context.instance_variable_get(:@resource_collection).should == "doesn't matter what this is"
+    expect(temporary_collection).to be_an_instance_of(Chef::ResourceCollection)
+    expect(@provider.run_context.instance_variable_get(:@resource_collection)).to eq("doesn't matter what this is")
   end
 
   it "does not re-load recipes when creating the temporary run context" do
     # we actually want to test that RunContext#load is never called, but we
     # can't stub all instances of an object with rspec's mocks. :/
-    Chef::RunContext.stub(:new).and_raise("not supposed to happen")
+    allow(Chef::RunContext).to receive(:new).and_raise("not supposed to happen")
     snitch = Proc.new {temporary_collection = @run_context.resource_collection}
     @provider.send(:recipe_eval, &snitch)
   end
 
   context "when no converge actions are queued" do
     before do
-      @provider.stub(:whyrun_supported?).and_return(true)
-      @provider.stub(:load_current_resource)
+      allow(@provider).to receive(:whyrun_supported?).and_return(true)
+      allow(@provider).to receive(:load_current_resource)
     end
 
     it "does not mark the new resource as updated" do
-      @resource.should_not be_updated
-      @resource.should_not be_updated_by_last_action
+      expect(@resource).not_to be_updated
+      expect(@resource).not_to be_updated_by_last_action
     end
   end
 
@@ -129,23 +129,23 @@ describe Chef::Provider do
       end
 
       it "should tell us that it does support whyrun" do
-        @provider.should be_whyrun_supported
+        expect(@provider).to be_whyrun_supported
       end
 
       it "queues up converge actions" do
         @provider.action_foo
-        @provider.send(:converge_actions).should have(1).actions
+        expect(@provider.send(:converge_actions).actions.size).to eq(1)
       end
 
       it "executes pending converge actions to converge the system" do
         @provider.run_action(:foo)
-        @provider.instance_variable_get(:@system_state_altered).should be_true
+        expect(@provider.instance_variable_get(:@system_state_altered)).to be_truthy
       end
 
       it "marks the resource as updated" do
         @provider.run_action(:foo)
-        @resource.should be_updated
-        @resource.should be_updated_by_last_action
+        expect(@resource).to be_updated
+        expect(@resource).to be_updated_by_last_action
       end
     end
 
@@ -160,20 +160,20 @@ describe Chef::Provider do
       end
 
       it "should tell us that it doesn't support whyrun" do
-        @provider.should_not be_whyrun_supported
+        expect(@provider).not_to be_whyrun_supported
       end
 
       it "should automatically generate a converge_by block on the provider's behalf" do
         @provider.run_action(:foo)
-        @provider.send(:converge_actions).should have(0).actions
-        @provider.system_state_altered.should be_false
+        expect(@provider.send(:converge_actions).actions.size).to eq(0)
+        expect(@provider.system_state_altered).to be_falsey
       end
 
       it "should automatically execute the generated converge_by block" do
         @provider.run_action(:foo)
-        @provider.system_state_altered.should be_false
-        @resource.should_not be_updated
-        @resource.should_not be_updated_by_last_action
+        expect(@provider.system_state_altered).to be_falsey
+        expect(@resource).not_to be_updated
+        expect(@resource).not_to be_updated_by_last_action
       end
     end
   end

data/spec/unit/recipe_spec.rb

@@ -52,50 +52,50 @@ describe Chef::Recipe do
   describe "method_missing" do
     describe "resources" do
       it "should load a two word (zen_master) resource" do
-        lambda do
+        expect do
           recipe.zen_master "monkey" do
             peace true
           end
-        end.should_not raise_error
+        end.not_to raise_error
       end
 
       it "should load a one word (cat) resource" do
-        lambda do
+        expect do
           recipe.cat "loulou" do
             pretty_kitty true
           end
-        end.should_not raise_error
+        end.not_to raise_error
       end
 
       it "should load a four word (one_two_three_four) resource" do
-        lambda do
+        expect do
           recipe.one_two_three_four "numbers" do
             i_can_count true
           end
-        end.should_not raise_error
+        end.not_to raise_error
       end
 
       it "should throw an error if you access a resource that we can't find" do
-        lambda { recipe.not_home("not_home_resource") }.should raise_error(NameError)
+        expect { recipe.not_home("not_home_resource") }.to raise_error(NameError)
       end
 
       it "should require a name argument" do
-        lambda {
+        expect {
           recipe.cat
-        }.should raise_error(ArgumentError, "You must supply a name when declaring a cat resource")
+        }.to raise_error(ArgumentError, "You must supply a name when declaring a cat resource")
       end
 
       it "should allow regular errors (not NameErrors) to pass unchanged" do
-        lambda {
+        expect {
           recipe.cat("felix") { raise ArgumentError, "You Suck" }
-        }.should raise_error(ArgumentError)
+        }.to raise_error(ArgumentError)
       end
 
       it "should add our zen_master to the collection" do
         recipe.zen_master "monkey" do
           peace true
         end
-        run_context.resource_collection.lookup("zen_master[monkey]").name.should eql("monkey")
+        expect(run_context.resource_collection.lookup("zen_master[monkey]").name).to eql("monkey")
       end
 
       it "should add our zen masters to the collection in the order they appear" do
@@ -105,15 +105,15 @@ describe Chef::Recipe do
           end
         end
 
-        run_context.resource_collection.map{|r| r.name}.should eql(["monkey", "dog", "cat"])
+        expect(run_context.resource_collection.map{|r| r.name}).to eql(["monkey", "dog", "cat"])
       end
 
       it "should return the new resource after creating it" do
         res = recipe.zen_master "makoto" do
           peace true
         end
-        res.resource_name.should eql(:zen_master)
-        res.name.should eql("makoto")
+        expect(res.resource_name).to eql(:zen_master)
+        expect(res.name).to eql("makoto")
       end
 
       describe "should locate platform mapped resources" do
@@ -124,7 +124,7 @@ describe Chef::Recipe do
           node.automatic[:platform] = "television"
           node.automatic[:platform_version] = "123"
           res = recipe.laughter "timmy"
-          res.name.should eql("timmy")
+          expect(res.name).to eql("timmy")
           res.kind_of?(ShaunTheSheep)
         end
 
@@ -132,7 +132,7 @@ describe Chef::Recipe do
           YourMom = Class.new(Chef::Resource)
           YourMom.provides :love_and_caring
           res = recipe.love_and_caring "mommy"
-          res.name.should eql("mommy")
+          expect(res.name).to eql("mommy")
           res.kind_of?(YourMom)
         end
 
@@ -147,21 +147,96 @@ describe Chef::Recipe do
       end
 
       it "applies attributes from the block to the resource" do
-        zm_resource.something.should == "bvb"
+        expect(zm_resource.something).to eq("bvb")
       end
 
       it "sets contextual attributes on the resource" do
-        zm_resource.recipe_name.should == "test"
-        zm_resource.cookbook_name.should == "hjk"
-        zm_resource.source_line.should include(__FILE__)
-        zm_resource.declared_type.should == :zen_master
+        expect(zm_resource.recipe_name).to eq("test")
+        expect(zm_resource.cookbook_name).to eq("hjk")
+        expect(zm_resource.source_line).to include(__FILE__)
+        expect(zm_resource.declared_type).to eq(:zen_master)
       end
 
       it "does not add the resource to the resource collection" do
         zm_resource # force let binding evaluation
         expect { run_context.resource_collection.resources(:zen_master => "klopp") }.to raise_error(Chef::Exceptions::ResourceNotFound)
       end
+    end
+
+    describe "when cloning resources" do
+      def expect_warning
+        expect(Chef::Log).to receive(:warn).with(/3694/)
+        expect(Chef::Log).to receive(:warn).with(/Previous/)
+        expect(Chef::Log).to receive(:warn).with(/Current/)
+      end
+
+      it "should emit a 3694 warning when attributes change" do
+        recipe.zen_master "klopp" do
+          something "bvb"
+        end
+        expect_warning
+        recipe.zen_master "klopp" do
+          something "vbv"
+        end
+      end
+
+      it "should emit a 3694 warning when attributes change" do
+        recipe.zen_master "klopp" do
+          something "bvb"
+        end
+        expect_warning
+        recipe.zen_master "klopp" do
+          something "bvb"
+          peace true
+        end
+      end
+
+      it "should emit a 3694 warning when attributes change" do
+        recipe.zen_master "klopp" do
+          something "bvb"
+          peace true
+        end
+        expect_warning
+        recipe.zen_master "klopp" do
+          something "bvb"
+        end
+      end
+
+      it "should emit a 3694 warning for non-trivial attributes (unfortunately)" do
+        recipe.zen_master "klopp" do
+          something "bvb"
+        end
+        expect_warning
+        recipe.zen_master "klopp" do
+          something "bvb"
+        end
+      end
 
+      it "should not emit a 3694 warning for completely trivial resource cloning" do
+        recipe.zen_master "klopp"
+        expect(Chef::Log).to_not receive(:warn)
+        recipe.zen_master "klopp"
+      end
+
+      it "should not emit a 3694 warning when attributes do not change and the first action is :nothing" do
+        recipe.zen_master "klopp" do
+          action :nothing
+        end
+        expect(Chef::Log).to_not receive(:warn)
+        recipe.zen_master "klopp" do
+          action :score
+        end
+      end
+
+      it "should not emit a 3694 warning when attributes do not change and the second action is :nothing" do
+        recipe.zen_master "klopp" do
+          action :score
+        end
+        expect(Chef::Log).to_not receive(:warn)
+        recipe.zen_master "klopp" do
+          action :nothing
+        end
+      end
     end
 
     describe "creating resources via declare_resource" do
@@ -172,18 +247,18 @@ describe Chef::Recipe do
       end
 
       it "applies attributes from the block to the resource" do
-        zm_resource.something.should == "bvb"
+        expect(zm_resource.something).to eq("bvb")
       end
 
       it "sets contextual attributes on the resource" do
-        zm_resource.recipe_name.should == "test"
-        zm_resource.cookbook_name.should == "hjk"
-        zm_resource.source_line.should include(__FILE__)
+        expect(zm_resource.recipe_name).to eq("test")
+        expect(zm_resource.cookbook_name).to eq("hjk")
+        expect(zm_resource.source_line).to include(__FILE__)
       end
 
       it "adds the resource to the resource collection" do
         zm_resource # force let binding evaluation
-        run_context.resource_collection.resources(:zen_master => "klopp").should == zm_resource
+        expect(run_context.resource_collection.resources(:zen_master => "klopp")).to eq(zm_resource)
       end
     end
 
@@ -202,7 +277,7 @@ describe Chef::Recipe do
 
       it "defines the resource using the declaration name with short name" do
         resource_follower
-        run_context.resource_collection.lookup("follower[srst]").should_not be_nil
+        expect(run_context.resource_collection.lookup("follower[srst]")).not_to be_nil
       end
     end
 
@@ -216,25 +291,25 @@ describe Chef::Recipe do
 
       it "defines the resource using the declaration name with long name" do
         resource_zn_follower
-        run_context.resource_collection.lookup("zen_follower[srst]").should_not be_nil
+        expect(run_context.resource_collection.lookup("zen_follower[srst]")).not_to be_nil
       end
     end
 
     describe "when attempting to create a resource of an invalid type" do
 
       it "gives a sane error message when using method_missing" do
-        lambda do
+        expect do
           recipe.no_such_resource("foo")
-        end.should raise_error(NoMethodError, %q[No resource or method named `no_such_resource' for `Chef::Recipe "test"'])
+        end.to raise_error(NoMethodError, %q[No resource or method named `no_such_resource' for `Chef::Recipe "test"'])
       end
 
       it "gives a sane error message when using method_missing 'bare'" do
-        lambda do
+        expect do
           recipe.instance_eval do
             # Giving an argument will change this from NameError to NoMethodError
             no_such_resource
           end
-        end.should raise_error(NameError, %q[No resource, method, or local variable named `no_such_resource' for `Chef::Recipe "test"'])
+        end.to raise_error(NameError, %q[No resource, method, or local variable named `no_such_resource' for `Chef::Recipe "test"'])
       end
 
       it "gives a sane error message when using build_resource" do
@@ -250,11 +325,11 @@ describe Chef::Recipe do
     describe "when creating a resource that contains an error in the attributes block" do
 
       it "does not obfuscate the error source" do
-        lambda do
+        expect do
           recipe.zen_master("klopp") do
             this_method_doesnt_exist
           end
-        end.should raise_error(NoMethodError, "undefined method `this_method_doesnt_exist' for Chef::Resource::ZenMaster")
+        end.to raise_error(NoMethodError, "undefined method `this_method_doesnt_exist' for Chef::Resource::ZenMaster")
 
       end
 
@@ -281,28 +356,28 @@ describe Chef::Recipe do
       end
 
       it "copies attributes from the first resource" do
-        duplicated_resource.something.should == "bvb09"
+        expect(duplicated_resource.something).to eq("bvb09")
       end
 
       it "does not copy the action from the first resource" do
-        original_resource.action.should == [:score]
-        duplicated_resource.action.should == :nothing
+        expect(original_resource.action).to eq([:score])
+        expect(duplicated_resource.action).to eq(:nothing)
       end
 
       it "does not copy the source location of the first resource" do
         # sanity check source location:
-        original_resource.source_line.should include(__FILE__)
-        duplicated_resource.source_line.should include(__FILE__)
+        expect(original_resource.source_line).to include(__FILE__)
+        expect(duplicated_resource.source_line).to include(__FILE__)
         # actual test:
-        original_resource.source_line.should_not == duplicated_resource.source_line
+        expect(original_resource.source_line).not_to eq(duplicated_resource.source_line)
       end
 
       it "sets the cookbook name on the cloned resource to that resource's cookbook" do
-        duplicated_resource.cookbook_name.should == "second_cb"
+        expect(duplicated_resource.cookbook_name).to eq("second_cb")
       end
 
       it "sets the recipe name on the cloned resource to that resoure's recipe" do
-        duplicated_resource.recipe_name.should == "second_recipe"
+        expect(duplicated_resource.recipe_name).to eq("second_recipe")
       end
 
     end
@@ -320,8 +395,8 @@ describe Chef::Recipe do
         recipe.crow "mine" do
           peace true
         end
-        run_context.resource_collection.resources(:zen_master => "lao tzu").name.should eql("lao tzu")
-        run_context.resource_collection.resources(:zen_master => "lao tzu").something.should eql(true)
+        expect(run_context.resource_collection.resources(:zen_master => "lao tzu").name).to eql("lao tzu")
+        expect(run_context.resource_collection.resources(:zen_master => "lao tzu").something).to eql(true)
       end
 
       it "should set the node on defined resources" do
@@ -337,7 +412,7 @@ describe Chef::Recipe do
         recipe.crow "mine" do
           something node[:foo]
         end
-        recipe.resources(:zen_master => "lao tzu").something.should eql(false)
+        expect(recipe.resources(:zen_master => "lao tzu").something).to eql(false)
       end
 
       it "should return the last statement in the definition as the retval" do
@@ -346,9 +421,10 @@ describe Chef::Recipe do
           "the return val"
         end
         run_context.definitions[:crow] = crow_define
-        recipe.crow "mine" do
+        crow_block = recipe.crow "mine" do
           peace true
-        end.should eql("the return val")
+        end
+        expect(crow_block).to eql("the return val")
       end
     end
 
@@ -361,8 +437,8 @@ describe Chef::Recipe do
     peace = true
   end
   CODE
-      lambda { recipe.instance_eval(code) }.should_not raise_error
-      recipe.resources(:zen_master => "gnome").name.should eql("gnome")
+      expect { recipe.instance_eval(code) }.not_to raise_error
+      expect(recipe.resources(:zen_master => "gnome").name).to eql("gnome")
     end
   end
 
@@ -371,7 +447,7 @@ describe Chef::Recipe do
       code = <<-CODE
       exec 'do_not_try_to_exec'
       CODE
-      lambda { recipe.instance_eval(code) }.should raise_error(Chef::Exceptions::ResourceNotFound)
+      expect { recipe.instance_eval(code) }.to raise_error(Chef::Exceptions::ResourceNotFound)
     end
   end
 
@@ -379,52 +455,80 @@ describe Chef::Recipe do
     it "should load a resource from a ruby file" do
       recipe.from_file(File.join(CHEF_SPEC_DATA, "recipes", "test.rb"))
       res = recipe.resources(:file => "/etc/nsswitch.conf")
-      res.name.should eql("/etc/nsswitch.conf")
-      res.action.should eql([:create])
-      res.owner.should eql("root")
-      res.group.should eql("root")
-      res.mode.should eql(0644)
+      expect(res.name).to eql("/etc/nsswitch.conf")
+      expect(res.action).to eql([:create])
+      expect(res.owner).to eql("root")
+      expect(res.group).to eql("root")
+      expect(res.mode).to eql(0644)
     end
 
     it "should raise an exception if the file cannot be found or read" do
-      lambda { recipe.from_file("/tmp/monkeydiving") }.should raise_error(IOError)
+      expect { recipe.from_file("/tmp/monkeydiving") }.to raise_error(IOError)
     end
   end
 
   describe "include_recipe" do
     it "should evaluate another recipe with include_recipe" do
-      node.should_receive(:loaded_recipe).with(:openldap, "gigantor")
-      run_context.stub(:unreachable_cookbook?).with(:openldap).and_return(false)
+      expect(node).to receive(:loaded_recipe).with(:openldap, "gigantor")
+      allow(run_context).to receive(:unreachable_cookbook?).with(:openldap).and_return(false)
       run_context.include_recipe "openldap::gigantor"
       res = run_context.resource_collection.resources(:cat => "blanket")
-      res.name.should eql("blanket")
-      res.pretty_kitty.should eql(false)
+      expect(res.name).to eql("blanket")
+      expect(res.pretty_kitty).to eql(false)
     end
 
     it "should load the default recipe for a cookbook if include_recipe is called without a ::" do
-      node.should_receive(:loaded_recipe).with(:openldap, "default")
-      run_context.stub(:unreachable_cookbook?).with(:openldap).and_return(false)
+      expect(node).to receive(:loaded_recipe).with(:openldap, "default")
+      allow(run_context).to receive(:unreachable_cookbook?).with(:openldap).and_return(false)
       run_context.include_recipe "openldap"
       res = run_context.resource_collection.resources(:cat => "blanket")
-      res.name.should eql("blanket")
-      res.pretty_kitty.should eql(true)
+      expect(res.name).to eql("blanket")
+      expect(res.pretty_kitty).to eql(true)
     end
 
     it "should store that it has seen a recipe in the run_context" do
-      node.should_receive(:loaded_recipe).with(:openldap, "default")
-      run_context.stub(:unreachable_cookbook?).with(:openldap).and_return(false)
+      expect(node).to receive(:loaded_recipe).with(:openldap, "default")
+      allow(run_context).to receive(:unreachable_cookbook?).with(:openldap).and_return(false)
       run_context.include_recipe "openldap"
-      run_context.loaded_recipe?("openldap").should be_true
+      expect(run_context.loaded_recipe?("openldap")).to be_truthy
     end
 
     it "should not include the same recipe twice" do
-      node.should_receive(:loaded_recipe).with(:openldap, "default").exactly(:once)
-      run_context.stub(:unreachable_cookbook?).with(:openldap).and_return(false)
-      cookbook_collection[:openldap].should_receive(:load_recipe).with("default", run_context)
+      expect(node).to receive(:loaded_recipe).with(:openldap, "default").exactly(:once)
+      allow(run_context).to receive(:unreachable_cookbook?).with(:openldap).and_return(false)
+      expect(cookbook_collection[:openldap]).to receive(:load_recipe).with("default", run_context)
       recipe.include_recipe "openldap"
-      cookbook_collection[:openldap].should_not_receive(:load_recipe).with("default", run_context)
+      expect(cookbook_collection[:openldap]).not_to receive(:load_recipe).with("default", run_context)
       recipe.include_recipe "openldap"
     end
+
+    it "will load a recipe out of the current cookbook when include_recipe is called with a leading ::" do
+      openldap_recipe = Chef::Recipe.new("openldap", "test", run_context)
+      expect(node).to receive(:loaded_recipe).with(:openldap, "default").exactly(:once)
+      allow(run_context).to receive(:unreachable_cookbook?).with(:openldap).and_return(false)
+      expect(cookbook_collection[:openldap]).to receive(:load_recipe).with("default", run_context)
+      openldap_recipe.include_recipe "::default"
+    end
+
+    it "will not include the same recipe twice when using leading :: syntax" do
+      openldap_recipe = Chef::Recipe.new("openldap", "test", run_context)
+      expect(node).to receive(:loaded_recipe).with(:openldap, "default").exactly(:once)
+      allow(run_context).to receive(:unreachable_cookbook?).with(:openldap).and_return(false)
+      expect(cookbook_collection[:openldap]).to receive(:load_recipe).with("default", run_context)
+      openldap_recipe.include_recipe "::default"
+      expect(cookbook_collection[:openldap]).not_to receive(:load_recipe).with("default", run_context)
+      openldap_recipe.include_recipe "openldap::default"
+    end
+
+    it "will not include the same recipe twice when using leading :: syntax (reversed order)" do
+      openldap_recipe = Chef::Recipe.new("openldap", "test", run_context)
+      expect(node).to receive(:loaded_recipe).with(:openldap, "default").exactly(:once)
+      allow(run_context).to receive(:unreachable_cookbook?).with(:openldap).and_return(false)
+      expect(cookbook_collection[:openldap]).to receive(:load_recipe).with("default", run_context)
+      openldap_recipe.include_recipe "openldap::default"
+      expect(cookbook_collection[:openldap]).not_to receive(:load_recipe).with("default", run_context)
+      openldap_recipe.include_recipe "::default"
+    end
   end
 
   describe "tags" do
@@ -432,55 +536,62 @@ describe Chef::Recipe do
       let(:node) { Chef::Node.new }
 
       it "should return false for any tags" do
-        recipe.tagged?("foo").should be(false)
+        expect(recipe.tagged?("foo")).to be(false)
       end
     end
 
     it "should set tags via tag" do
       recipe.tag "foo"
-      node[:tags].should include("foo")
+      expect(node[:tags]).to include("foo")
     end
 
     it "should set multiple tags via tag" do
       recipe.tag "foo", "bar"
-      node[:tags].should include("foo")
-      node[:tags].should 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"
-      node[:tags].should eql([ "foo" ])
+      expect(node[:tags]).to eql([ "foo" ])
     end
 
     it "should return the current list of tags from tag with no arguments" do
       recipe.tag "foo"
-      recipe.tag.should eql([ "foo" ])
+      expect(recipe.tag).to eql([ "foo" ])
     end
 
     it "should return true from tagged? if node is tagged" do
       recipe.tag "foo"
-      recipe.tagged?("foo").should be(true)
+      expect(recipe.tagged?("foo")).to be(true)
     end
 
     it "should return false from tagged? if node is not tagged" do
-      recipe.tagged?("foo").should be(false)
+      expect(recipe.tagged?("foo")).to be(false)
     end
 
     it "should return false from tagged? if node is not tagged" do
-      recipe.tagged?("foo").should be(false)
+      expect(recipe.tagged?("foo")).to be(false)
     end
 
     it "should remove a tag from the tag list via untag" do
       recipe.tag "foo"
       recipe.untag "foo"
-      node[:tags].should 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"
-      node[:tags].should eql([])
+      expect(node[:tags]).to eql([])
+    end
+  end
+
+  describe "included DSL" do
+    it "should include features from Chef::DSL::Audit" do
+      expect(recipe.singleton_class.included_modules).to include(Chef::DSL::Audit)
+      expect(recipe.respond_to?(:control_group)).to be true
     end
   end
 end