chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/unit/dsl/regsitry_helper_spec.rb

@@ -33,22 +33,22 @@ describe Chef::Resource::RegistryKey do
 
   context "tests registry dsl" do
     it "resource can access registry_helper method registry_key_exists" do
-      @resource.respond_to?('registry_key_exists?').should == true
+      expect(@resource.respond_to?('registry_key_exists?')).to eq(true)
     end
     it "resource can access registry_helper method registry_get_values" do
-      @resource.respond_to?('registry_get_values').should == true
+      expect(@resource.respond_to?('registry_get_values')).to eq(true)
     end
     it "resource can access registry_helper method registry_has_subkey" do
-      @resource.respond_to?('registry_has_subkeys?').should == true
+      expect(@resource.respond_to?('registry_has_subkeys?')).to eq(true)
     end
     it "resource can access registry_helper method registry_get_subkeys" do
-      @resource.respond_to?('registry_get_subkeys').should == true
+      expect(@resource.respond_to?('registry_get_subkeys')).to eq(true)
     end
     it "resource can access registry_helper method registry_value_exists" do
-      @resource.respond_to?('registry_value_exists?').should == true
+      expect(@resource.respond_to?('registry_value_exists?')).to eq(true)
     end
     it "resource can access registry_helper method data_value_exists" do
-      @resource.respond_to?('registry_data_exists?').should == true
+      expect(@resource.respond_to?('registry_data_exists?')).to eq(true)
     end
   end
 end

data/spec/unit/encrypted_data_bag_item_spec.rb

@@ -39,7 +39,7 @@ describe Chef::EncryptedDataBagItem::Encryptor  do
   let(:key) { "passwd" }
 
   it "encrypts to format version 1 by default" do
-    encryptor.should be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor)
+    expect(encryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor)
   end
 
   describe "generating a random IV" do
@@ -49,14 +49,14 @@ describe Chef::EncryptedDataBagItem::Encryptor  do
       # No API in ruby OpenSSL to get the iv is used for the encryption back
       # out. Instead we test if the encrypted data is the same. If it *is* the
       # same, we assume the IV was the same each time.
-      encryptor.encrypted_data.should_not eq encryptor2.encrypted_data
+      expect(encryptor.encrypted_data).not_to eq encryptor2.encrypted_data
     end
   end
 
   describe "when encrypting a non-hash non-array value" do
     let(:plaintext_data) { 5 }
     it "serializes the value in a de-serializable way" do
-      Chef::JSONCompat.from_json(encryptor.serialized_data)["json_wrapper"].should eq 5
+      expect(Chef::JSONCompat.from_json(encryptor.serialized_data)["json_wrapper"]).to eq 5
     end
 
   end
@@ -64,10 +64,10 @@ describe Chef::EncryptedDataBagItem::Encryptor  do
   describe "wrapping secret values in an envelope" do
     it "wraps the encrypted data in an envelope with the iv and version" do
       final_data = encryptor.for_encrypted_item
-      final_data["encrypted_data"].should eq encryptor.encrypted_data
-      final_data["iv"].should eq Base64.encode64(encryptor.iv)
-      final_data["version"].should eq 1
-      final_data["cipher"].should eq"aes-256-cbc"
+      expect(final_data["encrypted_data"]).to eq encryptor.encrypted_data
+      expect(final_data["iv"]).to eq Base64.encode64(encryptor.iv)
+      expect(final_data["version"]).to eq 1
+      expect(final_data["cipher"]).to eq"aes-256-cbc"
     end
   end
 
@@ -78,17 +78,17 @@ describe Chef::EncryptedDataBagItem::Encryptor  do
     end
 
     it "creates a version 2 encryptor" do
-      encryptor.should be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor)
+      expect(encryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor)
     end
 
     it "generates an hmac based on ciphertext with different iv" do
       encryptor2 = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, key)
-      encryptor.hmac.should_not eq(encryptor2.hmac)
+      expect(encryptor.hmac).not_to eq(encryptor2.hmac)
     end
 
     it "includes the hmac in the envelope" do
       final_data = encryptor.for_encrypted_item
-      final_data["hmac"].should eq(encryptor.hmac)
+      expect(final_data["hmac"]).to eq(encryptor.hmac)
     end
   end
 
@@ -100,23 +100,23 @@ describe Chef::EncryptedDataBagItem::Encryptor  do
     context "on supported platforms", :aes_256_gcm_only, :ruby_20_only do
 
       it "creates a version 3 encryptor" do
-        encryptor.should be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor)
+        expect(encryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor)
       end
 
       it "generates different authentication tags" do
         encryptor3 = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, key)
         encryptor.for_encrypted_item # required to generate the auth_tag
         encryptor3.for_encrypted_item
-        encryptor.auth_tag.should_not eq(encryptor3.auth_tag)
+        expect(encryptor.auth_tag).not_to eq(encryptor3.auth_tag)
       end
 
       it "includes the auth_tag in the envelope" do
         final_data = encryptor.for_encrypted_item
-        final_data["auth_tag"].should eq(Base64::encode64(encryptor.auth_tag))
+        expect(final_data["auth_tag"]).to eq(Base64::encode64(encryptor.auth_tag))
       end
 
       it "throws an error if auth tag is read before encrypting the data" do
-        lambda { encryptor.auth_tag }.should raise_error(Chef::EncryptedDataBagItem::EncryptionFailure)
+        expect { encryptor.auth_tag }.to raise_error(Chef::EncryptedDataBagItem::EncryptionFailure)
       end
 
     end # context on supported platforms
@@ -124,34 +124,18 @@ describe Chef::EncryptedDataBagItem::Encryptor  do
     context "on unsupported platforms" do
       let(:aead_algorithm) { Chef::EncryptedDataBagItem::AEAD_ALGORITHM }
 
-      it "throws an error warning about the Ruby version if it has no GCM support" do
-        # Force OpenSSL with AEAD support
-        OpenSSL::Cipher.stub(:ciphers).and_return([ aead_algorithm ])
-        # Ruby without AEAD support
-        OpenSSL::Cipher.should_receive(:method_defined?).with(:auth_data=).and_return(false)
-        lambda { encryptor }.should raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires Ruby/)
-      end
-
       it "throws an error warning about the OpenSSL version if it has no GCM support" do
         # Force Ruby with AEAD support
-        OpenSSL::Cipher.stub(:method_defined?).with(:auth_data=).and_return(true)
+        allow(OpenSSL::Cipher).to receive(:method_defined?).with(:auth_data=).and_return(true)
         # OpenSSL without AEAD support
-        OpenSSL::Cipher.should_receive(:ciphers).and_return([])
-        lambda { encryptor }.should raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
+        expect(OpenSSL::Cipher).to receive(:ciphers).and_return([])
+        expect { encryptor }.to raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
       end
 
-      context "on platforms with old Ruby", :ruby_lt_20 do
-
-        it "throws an error warning about the Ruby version" do
-          lambda { encryptor }.should raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires Ruby/)
-        end
-
-      end # context on platforms with old Ruby
-
       context "on platforms with old OpenSSL", :openssl_lt_101 do
 
         it "throws an error warning about the OpenSSL version" do
-          lambda { encryptor }.should raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
+          expect { encryptor }.to raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
         end
 
       end # context on platforms with old OpenSSL
@@ -172,11 +156,11 @@ describe Chef::EncryptedDataBagItem::Decryptor do
 
   shared_examples "decryption examples" do
     it "decrypts the encrypted value" do
-      decryptor.decrypted_data.should eq(json_wrapped_data)
+      expect(decryptor.decrypted_data).to eq(json_wrapped_data)
     end
 
     it "unwraps the encrypted data and returns it" do
-      decryptor.for_decrypted_item.should eq plaintext_data
+      expect(decryptor.for_decrypted_item).to eq plaintext_data
     end
   end
 
@@ -194,12 +178,12 @@ describe Chef::EncryptedDataBagItem::Decryptor do
 
       it "rejects the data if the authentication tag is wrong" do
         encrypted_value["auth_tag"] = bogus_auth_tag
-        lambda { decryptor.for_decrypted_item }.should raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
       end
 
       it "rejects the data if the authentication tag is missing" do
         encrypted_value.delete("auth_tag")
-        lambda { decryptor.for_decrypted_item }.should raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
       end
 
     end # context on supported platforms
@@ -214,18 +198,10 @@ describe Chef::EncryptedDataBagItem::Decryptor do
         }
       end
 
-      context "on platforms with old Ruby", :ruby_lt_20 do
-
-        it "throws an error warning about the Ruby version" do
-          lambda { decryptor }.should raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires Ruby/)
-        end
-
-      end # context on platforms with old Ruby
-
       context "on platforms with old OpenSSL", :openssl_lt_101 do
 
         it "throws an error warning about the OpenSSL version" do
-          lambda { decryptor }.should raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
+          expect { decryptor }.to raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
         end
 
       end # context on unsupported platforms
@@ -249,12 +225,12 @@ describe Chef::EncryptedDataBagItem::Decryptor do
 
     it "rejects the data if the hmac is wrong" do
       encrypted_value["hmac"] = bogus_hmac
-      lambda { decryptor.for_decrypted_item }.should raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+      expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
     end
 
     it "rejects the data if the hmac is missing" do
       encrypted_value.delete("hmac")
-      lambda { decryptor.for_decrypted_item }.should raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+      expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
     end
 
   end
@@ -266,7 +242,7 @@ describe Chef::EncryptedDataBagItem::Decryptor do
     end
 
     it "selects the correct strategy for version 1" do
-      decryptor.should be_a_instance_of Chef::EncryptedDataBagItem::Decryptor::Version1Decryptor
+      expect(decryptor).to be_a_instance_of Chef::EncryptedDataBagItem::Decryptor::Version1Decryptor
     end
 
     include_examples "decryption examples"
@@ -276,8 +252,8 @@ describe Chef::EncryptedDataBagItem::Decryptor do
         # Over a large number of tests on a variety of systems, we occasionally
         # see the decryption step "succeed" but return invalid data (e.g., not
         # the original plain text) [CHEF-3858]
-        decryptor.should_receive(:decrypted_data).and_return("lksajdf")
-        lambda { decryptor.for_decrypted_item }.should raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+        expect(decryptor).to receive(:decrypted_data).and_return("lksajdf")
+        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
       end
     end
 
@@ -285,7 +261,7 @@ describe Chef::EncryptedDataBagItem::Decryptor do
       let(:decryption_key) { "wrong-passwd" }
 
       it "raises a sensible error" do
-        lambda { decryptor.for_decrypted_item }.should raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
       end
     end
 
@@ -297,7 +273,7 @@ describe Chef::EncryptedDataBagItem::Decryptor do
       end
 
       it "raises a sensible error" do
-        lambda { decryptor.for_decrypted_item }.should raise_error(Chef::EncryptedDataBagItem::UnsupportedCipher)
+        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::UnsupportedCipher)
       end
     end
 
@@ -307,7 +283,7 @@ describe Chef::EncryptedDataBagItem::Decryptor do
       end
 
       it "raises an error attempting to decrypt" do
-        lambda { decryptor }.should raise_error(Chef::EncryptedDataBagItem::UnacceptableEncryptedDataBagItemFormat)
+        expect { decryptor }.to raise_error(Chef::EncryptedDataBagItem::UnacceptableEncryptedDataBagItemFormat)
       end
 
     end
@@ -320,11 +296,11 @@ describe Chef::EncryptedDataBagItem::Decryptor do
     end
 
     it "selects the correct strategy for version 0" do
-      decryptor.should be_a_instance_of(Chef::EncryptedDataBagItem::Decryptor::Version0Decryptor)
+      expect(decryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Decryptor::Version0Decryptor)
     end
 
     it "decrypts the encrypted value" do
-      decryptor.for_decrypted_item.should eq plaintext_data
+      expect(decryptor.for_decrypted_item).to eq plaintext_data
     end
 
     context "and version 1 format is required" do
@@ -333,7 +309,7 @@ describe Chef::EncryptedDataBagItem::Decryptor do
       end
 
       it "raises an error attempting to decrypt" do
-        lambda { decryptor }.should raise_error(Chef::EncryptedDataBagItem::UnacceptableEncryptedDataBagItemFormat)
+        expect { decryptor }.to raise_error(Chef::EncryptedDataBagItem::UnacceptableEncryptedDataBagItemFormat)
       end
 
     end
@@ -355,27 +331,27 @@ describe Chef::EncryptedDataBagItem do
   describe "encrypting" do
 
     it "doesn't encrypt the 'id' key" do
-      encoded_data["id"].should eq "item_name"
+      expect(encoded_data["id"]).to eq "item_name"
     end
 
     it "encrypts non-collection objects" do
-      encoded_data["greeting"]["version"].should eq 1
-      encoded_data["greeting"].should have_key("iv")
+      expect(encoded_data["greeting"]["version"]).to eq 1
+      expect(encoded_data["greeting"]).to have_key("iv")
 
       iv = encoded_data["greeting"]["iv"]
       encryptor = Chef::EncryptedDataBagItem::Encryptor.new("hello", secret, iv)
 
-      encoded_data["greeting"]["encrypted_data"].should eq(encryptor.for_encrypted_item["encrypted_data"])
+      expect(encoded_data["greeting"]["encrypted_data"]).to eq(encryptor.for_encrypted_item["encrypted_data"])
     end
 
     it "encrypts nested values" do
-      encoded_data["nested"]["version"].should eq 1
-      encoded_data["nested"].should have_key("iv")
+      expect(encoded_data["nested"]["version"]).to eq 1
+      expect(encoded_data["nested"]).to have_key("iv")
 
       iv = encoded_data["nested"]["iv"]
       encryptor = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data["nested"], secret, iv)
 
-      encoded_data["nested"]["encrypted_data"].should eq(encryptor.for_encrypted_item["encrypted_data"])
+      expect(encoded_data["nested"]["encrypted_data"]).to eq(encryptor.for_encrypted_item["encrypted_data"])
     end
 
   end
@@ -383,31 +359,31 @@ describe Chef::EncryptedDataBagItem do
   describe "decrypting" do
 
     it "doesn't try to decrypt 'id'" do
-      encrypted_data_bag_item["id"].should eq(plaintext_data["id"])
+      expect(encrypted_data_bag_item["id"]).to eq(plaintext_data["id"])
     end
 
     it "decrypts 'greeting'" do
-      encrypted_data_bag_item["greeting"].should eq(plaintext_data["greeting"])
+      expect(encrypted_data_bag_item["greeting"]).to eq(plaintext_data["greeting"])
     end
 
     it "decrypts 'nested'" do
-      encrypted_data_bag_item["nested"].should eq(plaintext_data["nested"])
+      expect(encrypted_data_bag_item["nested"]).to eq(plaintext_data["nested"])
     end
 
     it "decrypts everyting via to_hash" do
-      encrypted_data_bag_item.to_hash.should eq(plaintext_data)
+      expect(encrypted_data_bag_item.to_hash).to eq(plaintext_data)
     end
 
     it "handles missing keys gracefully" do
-      encrypted_data_bag_item["no-such-key"].should be_nil
+      expect(encrypted_data_bag_item["no-such-key"]).to be_nil
     end
   end
 
   describe "loading" do
     it "should defer to Chef::DataBagItem.load" do
-      Chef::DataBagItem.stub(:load).with(:the_bag, "my_codes").and_return(encoded_data)
+      allow(Chef::DataBagItem).to receive(:load).with(:the_bag, "my_codes").and_return(encoded_data)
       edbi = Chef::EncryptedDataBagItem.load(:the_bag, "my_codes", secret)
-      edbi["greeting"].should eq(plaintext_data["greeting"])
+      expect(edbi["greeting"]).to eq(plaintext_data["greeting"])
     end
   end
 
@@ -416,45 +392,45 @@ describe Chef::EncryptedDataBagItem do
 
     context "when /var/mysecret exists" do
       before do
-        ::File.stub(:exist?).with("/var/mysecret").and_return(true)
-        IO.stub(:read).with("/var/mysecret").and_return(secret)
+        allow(::File).to receive(:exist?).with("/var/mysecret").and_return(true)
+        allow(IO).to receive(:read).with("/var/mysecret").and_return(secret)
       end
 
       it "load_secret('/var/mysecret') reads the secret" do
-        Chef::EncryptedDataBagItem.load_secret("/var/mysecret").should eq secret
+        expect(Chef::EncryptedDataBagItem.load_secret("/var/mysecret")).to eq secret
       end
     end
 
     context "when /etc/chef/encrypted_data_bag_secret exists" do
       before do
         path = Chef::Config.platform_specific_path("/etc/chef/encrypted_data_bag_secret")
-        ::File.stub(:exist?).with(path).and_return(true)
-        IO.stub(:read).with(path).and_return(secret)
+        allow(::File).to receive(:exist?).with(path).and_return(true)
+        allow(IO).to receive(:read).with(path).and_return(secret)
       end
 
       it "load_secret(nil) reads the secret" do
-        Chef::EncryptedDataBagItem.load_secret(nil).should eq secret
+        expect(Chef::EncryptedDataBagItem.load_secret(nil)).to eq secret
       end
     end
 
     context "when /etc/chef/encrypted_data_bag_secret does not exist" do
       before do
         path = Chef::Config.platform_specific_path("/etc/chef/encrypted_data_bag_secret")
-        ::File.stub(:exist?).with(path).and_return(false)
+        allow(::File).to receive(:exist?).with(path).and_return(false)
       end
 
       it "load_secret(nil) emits a reasonable error message" do
-        lambda { Chef::EncryptedDataBagItem.load_secret(nil) }.should raise_error(ArgumentError, /No secret specified and no secret found at #{Chef::Config[:encrypted_data_bag_secret]}/)
+        expect { Chef::EncryptedDataBagItem.load_secret(nil) }.to raise_error(ArgumentError, /No secret specified and no secret found at #{Chef::Config[:encrypted_data_bag_secret]}/)
       end
     end
 
     context "path argument is a URL" do
       before do
-        Kernel.stub(:open).with("http://www.opscode.com/").and_return(StringIO.new(secret))
+        allow(Kernel).to receive(:open).with("http://www.opscode.com/").and_return(StringIO.new(secret))
       end
 
       it "reads from the URL" do
-        Chef::EncryptedDataBagItem.load_secret("http://www.opscode.com/").should eq secret
+        expect(Chef::EncryptedDataBagItem.load_secret("http://www.opscode.com/")).to eq secret
       end
     end
   end

data/spec/unit/environment_spec.rb

@@ -29,75 +29,75 @@ describe Chef::Environment do
 
   describe "initialize" do
     it "should be a Chef::Environment" do
-      @environment.should be_a_kind_of(Chef::Environment)
+      expect(@environment).to be_a_kind_of(Chef::Environment)
     end
   end
 
   describe "name" do
     it "should let you set the name to a string" do
-      @environment.name("production").should == "production"
+      expect(@environment.name("production")).to eq("production")
     end
 
     it "should return the current name" do
       @environment.name("production")
-      @environment.name.should == "production"
+      expect(@environment.name).to eq("production")
     end
 
     it "should not accept spaces" do
-      lambda { @environment.name("production environment") }.should raise_error(ArgumentError)
+      expect { @environment.name("production environment") }.to raise_error(ArgumentError)
     end
 
     it "should not accept anything but strings" do
-      lambda { @environment.name(Array.new) }.should raise_error(ArgumentError)
-      lambda { @environment.name(Hash.new) }.should raise_error(ArgumentError)
-      lambda { @environment.name(2) }.should raise_error(ArgumentError)
+      expect { @environment.name(Array.new) }.to raise_error(ArgumentError)
+      expect { @environment.name(Hash.new) }.to raise_error(ArgumentError)
+      expect { @environment.name(2) }.to raise_error(ArgumentError)
     end
   end
 
   describe "description" do
     it "should let you set the description to a string" do
-      @environment.description("this is my test environment").should == "this is my test environment"
+      expect(@environment.description("this is my test environment")).to eq("this is my test environment")
     end
 
     it "should return the correct description" do
       @environment.description("I like running tests")
-      @environment.description.should == "I like running tests"
+      expect(@environment.description).to eq("I like running tests")
     end
 
     it "should not accept anything but strings" do
-      lambda { @environment.description(Array.new) }.should raise_error(ArgumentError)
-      lambda { @environment.description(Hash.new) }.should raise_error(ArgumentError)
-      lambda { @environment.description(42) }.should raise_error(ArgumentError)
+      expect { @environment.description(Array.new) }.to raise_error(ArgumentError)
+      expect { @environment.description(Hash.new) }.to raise_error(ArgumentError)
+      expect { @environment.description(42) }.to raise_error(ArgumentError)
     end
   end
 
   describe "default attributes" do
     it "should let you set the attributes hash explicitly" do
-      @environment.default_attributes({ :one => 'two' }).should == { :one => 'two' }
+      expect(@environment.default_attributes({ :one => 'two' })).to eq({ :one => 'two' })
     end
 
     it "should let you return the attributes hash" do
       @environment.default_attributes({ :one => 'two' })
-      @environment.default_attributes.should == { :one => 'two' }
+      expect(@environment.default_attributes).to eq({ :one => 'two' })
     end
 
     it "should throw an ArgumentError if we aren't a kind of hash" do
-      lambda { @environment.default_attributes(Array.new) }.should raise_error(ArgumentError)
+      expect { @environment.default_attributes(Array.new) }.to raise_error(ArgumentError)
     end
   end
 
   describe "override attributes" do
     it "should let you set the attributes hash explicitly" do
-      @environment.override_attributes({ :one => 'two' }).should == { :one => 'two' }
+      expect(@environment.override_attributes({ :one => 'two' })).to eq({ :one => 'two' })
     end
 
     it "should let you return the attributes hash" do
       @environment.override_attributes({ :one => 'two' })
-      @environment.override_attributes.should == { :one => 'two' }
+      expect(@environment.override_attributes).to eq({ :one => 'two' })
     end
 
     it "should throw an ArgumentError if we aren't a kind of hash" do
-      lambda { @environment.override_attributes(Array.new) }.should raise_error(ArgumentError)
+      expect { @environment.override_attributes(Array.new) }.to raise_error(ArgumentError)
     end
   end
 
@@ -111,22 +111,22 @@ describe Chef::Environment do
     end
 
     it "should let you set the cookbook versions in a hash" do
-      @environment.cookbook_versions(@cookbook_versions).should == @cookbook_versions
+      expect(@environment.cookbook_versions(@cookbook_versions)).to eq(@cookbook_versions)
     end
 
     it "should return the cookbook versions" do
       @environment.cookbook_versions(@cookbook_versions)
-      @environment.cookbook_versions.should == @cookbook_versions
+      expect(@environment.cookbook_versions).to eq(@cookbook_versions)
     end
 
     it "should not accept anything but a hash" do
-      lambda { @environment.cookbook_versions("I am a string!") }.should raise_error(ArgumentError)
-      lambda { @environment.cookbook_versions(Array.new) }.should raise_error(ArgumentError)
-      lambda { @environment.cookbook_versions(42) }.should raise_error(ArgumentError)
+      expect { @environment.cookbook_versions("I am a string!") }.to raise_error(ArgumentError)
+      expect { @environment.cookbook_versions(Array.new) }.to raise_error(ArgumentError)
+      expect { @environment.cookbook_versions(42) }.to raise_error(ArgumentError)
     end
 
     it "should validate the hash" do
-      Chef::Environment.should_receive(:validate_cookbook_versions).with(@cookbook_versions).and_return true
+      expect(Chef::Environment).to receive(:validate_cookbook_versions).with(@cookbook_versions).and_return true
       @environment.cookbook_versions(@cookbook_versions)
     end
   end
@@ -134,11 +134,11 @@ describe Chef::Environment do
   describe "cookbook" do
     it "should set the version of the cookbook in the cookbook_versions hash" do
       @environment.cookbook("apt", "~> 1.2.3")
-      @environment.cookbook_versions["apt"].should == "~> 1.2.3"
+      expect(@environment.cookbook_versions["apt"]).to eq("~> 1.2.3")
     end
 
     it "should validate the cookbook version it is passed" do
-      Chef::Environment.should_receive(:validate_cookbook_version).with(">= 1.2.3").and_return true
+      expect(Chef::Environment).to receive(:validate_cookbook_version).with(">= 1.2.3").and_return true
       @environment.cookbook("apt", ">= 1.2.3")
     end
   end
@@ -157,9 +157,9 @@ describe Chef::Environment do
 
     it "should update everything but name" do
       @environment.update_from!(@example)
-      @environment.name.should == "prod"
-      @environment.description.should == @example.description
-      @environment.cookbook_versions.should == @example.cookbook_versions
+      expect(@environment.name).to eq("prod")
+      expect(@environment.description).to eq(@example.description)
+      expect(@environment.cookbook_versions).to eq(@example.cookbook_versions)
     end
   end
 
@@ -173,16 +173,16 @@ describe Chef::Environment do
 
     %w{name description cookbook_versions}.each do |t|
       it "should include '#{t}'" do
-        @hash[t].should == @environment.send(t.to_sym)
+        expect(@hash[t]).to eq(@environment.send(t.to_sym))
       end
     end
 
     it "should include 'json_class'" do
-      @hash["json_class"].should == "Chef::Environment"
+      expect(@hash["json_class"]).to eq("Chef::Environment")
     end
 
     it "should include 'chef_type'" do
-      @hash["chef_type"].should == "environment"
+      expect(@hash["chef_type"]).to eq("environment")
     end
   end
 
@@ -196,16 +196,16 @@ describe Chef::Environment do
 
     %w{name description cookbook_versions}.each do |t|
       it "should include '#{t}'" do
-        @json.should =~ /"#{t}":#{Regexp.escape(Chef::JSONCompat.to_json(@environment.send(t.to_sym)))}/
+        expect(@json).to match(/"#{t}":#{Regexp.escape(Chef::JSONCompat.to_json(@environment.send(t.to_sym)))}/)
       end
     end
 
     it "should include 'json_class'" do
-      @json.should =~ /"json_class":"Chef::Environment"/
+      expect(@json).to match(/"json_class":"Chef::Environment"/)
     end
 
     it "should include 'chef_type'" do
-      @json.should =~ /"chef_type":"environment"/
+      expect(@json).to match(/"chef_type":"environment"/)
     end
 
     include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
@@ -230,12 +230,12 @@ describe Chef::Environment do
     end
 
     it "should return a Chef::Environment" do
-      @environment.should be_a_kind_of(Chef::Environment)
+      expect(@environment).to be_a_kind_of(Chef::Environment)
     end
 
     %w{name description cookbook_versions}.each do |t|
       it "should match '#{t}'" do
-        @environment.send(t.to_sym).should == @data[t]
+        expect(@environment.send(t.to_sym)).to eq(@data[t])
       end
     end
   end
@@ -251,39 +251,39 @@ describe Chef::Environment do
 
     it "should validate the version string of each cookbook" do
       @cookbook_versions.each do |cookbook, version|
-        Chef::Environment.should_receive(:validate_cookbook_version).with(version).and_return true
+        expect(Chef::Environment).to receive(:validate_cookbook_version).with(version).and_return true
       end
       Chef::Environment.validate_cookbook_versions(@cookbook_versions)
     end
 
     it "should return false if anything other than a hash is passed as the argument" do
-      Chef::Environment.validate_cookbook_versions(Array.new).should == false
-      Chef::Environment.validate_cookbook_versions(42).should == false
-      Chef::Environment.validate_cookbook_versions(Chef::CookbookVersion.new("meta")).should == false
-      Chef::Environment.validate_cookbook_versions("cookbook => 1.2.3").should == false
+      expect(Chef::Environment.validate_cookbook_versions(Array.new)).to eq(false)
+      expect(Chef::Environment.validate_cookbook_versions(42)).to eq(false)
+      expect(Chef::Environment.validate_cookbook_versions(Chef::CookbookVersion.new("meta"))).to eq(false)
+      expect(Chef::Environment.validate_cookbook_versions("cookbook => 1.2.3")).to eq(false)
     end
   end
 
   describe "self.validate_cookbook_version" do
     it "should validate correct version numbers" do
-      Chef::Environment.validate_cookbook_version("= 1.2.3").should == true
-      Chef::Environment.validate_cookbook_version("=1.2.3").should == true
-      Chef::Environment.validate_cookbook_version(">= 0.0.3").should == true
-      Chef::Environment.validate_cookbook_version(">=0.0.3").should == true
+      expect(Chef::Environment.validate_cookbook_version("= 1.2.3")).to eq(true)
+      expect(Chef::Environment.validate_cookbook_version("=1.2.3")).to eq(true)
+      expect(Chef::Environment.validate_cookbook_version(">= 0.0.3")).to eq(true)
+      expect(Chef::Environment.validate_cookbook_version(">=0.0.3")).to eq(true)
       # A lone version is allowed, interpreted as implicit '='
-      Chef::Environment.validate_cookbook_version("1.2.3").should == true
+      expect(Chef::Environment.validate_cookbook_version("1.2.3")).to eq(true)
     end
 
     it "should return false when an invalid version is given" do
-      Chef::Environment.validate_cookbook_version(Chef::CookbookVersion.new("meta")).should == false
-      Chef::Environment.validate_cookbook_version("= 1.2.3a").should == false
-      Chef::Environment.validate_cookbook_version("=1.2.3a").should == false
-      Chef::Environment.validate_cookbook_version("= 1").should == false
-      Chef::Environment.validate_cookbook_version("=1").should == false
-      Chef::Environment.validate_cookbook_version("= a").should == false
-      Chef::Environment.validate_cookbook_version("=a").should == false
-      Chef::Environment.validate_cookbook_version("= 1.2.3.4").should == false
-      Chef::Environment.validate_cookbook_version("=1.2.3.4").should == false
+      expect(Chef::Environment.validate_cookbook_version(Chef::CookbookVersion.new("meta"))).to eq(false)
+      expect(Chef::Environment.validate_cookbook_version("= 1.2.3a")).to eq(false)
+      expect(Chef::Environment.validate_cookbook_version("=1.2.3a")).to eq(false)
+      expect(Chef::Environment.validate_cookbook_version("= 1")).to eq(false)
+      expect(Chef::Environment.validate_cookbook_version("=1")).to eq(false)
+      expect(Chef::Environment.validate_cookbook_version("= a")).to eq(false)
+      expect(Chef::Environment.validate_cookbook_version("=a")).to eq(false)
+      expect(Chef::Environment.validate_cookbook_version("= 1.2.3.4")).to eq(false)
+      expect(Chef::Environment.validate_cookbook_version("=1.2.3.4")).to eq(false)
     end
 
     describe "in solo mode" do
@@ -296,9 +296,9 @@ describe Chef::Environment do
       end
 
       it "should raise and exception" do
-        lambda {
+        expect {
           Chef::Environment.validate_cookbook_version("= 1.2.3.4")
-        }.should raise_error Chef::Exceptions::IllegalVersionConstraint,
+        }.to raise_error Chef::Exceptions::IllegalVersionConstraint,
                              "Environment cookbook version constraints not allowed in chef-solo"
       end
     end
@@ -312,17 +312,17 @@ describe Chef::Environment do
 
     it "updates the name from parameters[:name]" do
       @environment.update_from_params(:name => "kurrupt")
-      @environment.name.should == "kurrupt"
+      expect(@environment.name).to eq("kurrupt")
     end
 
     it "validates the name given in the params" do
-      @environment.update_from_params(:name => "@$%^&*()").should be_false
-      @environment.invalid_fields[:name].should == %q|Option name's value @$%^&*() does not match regular expression /^[\-[:alnum:]_]+$/|
+      expect(@environment.update_from_params(:name => "@$%^&*()")).to be_falsey
+      expect(@environment.invalid_fields[:name]).to eq(%q|Option name's value @$%^&*() does not match regular expression /^[\-[:alnum:]_]+$/|)
     end
 
     it "updates the description from parameters[:description]" do
       @environment.update_from_params(:description => "wow, writing your own object mapper is kinda painful")
-      @environment.description.should == "wow, writing your own object mapper is kinda painful"
+      expect(@environment.description).to eq("wow, writing your own object mapper is kinda painful")
     end
 
     it "updates cookbook version constraints from the hash in parameters[:cookbook_version_constraints]" do
@@ -331,34 +331,34 @@ describe Chef::Environment do
       # the way merb does params
       params = {:name=>"superbowl", :cookbook_version => {"0" => "apache2 ~> 1.0.0", "1" => "nginx < 2.0.0"}}
       @environment.update_from_params(params)
-      @environment.cookbook_versions.should == {"apache2" => "~> 1.0.0", "nginx" => "< 2.0.0"}
+      expect(@environment.cookbook_versions).to eq({"apache2" => "~> 1.0.0", "nginx" => "< 2.0.0"})
     end
 
     it "validates the cookbook constraints" do
       params = {:cookbook_version => {"0" => "apache2 >>> 1.0.0"}}
-      @environment.update_from_params(params).should be_false
+      expect(@environment.update_from_params(params)).to be_falsey
       err_msg = @environment.invalid_fields[:cookbook_version]["0"]
-      err_msg.should == "apache2 >>> 1.0.0 is not a valid cookbook constraint"
+      expect(err_msg).to eq("apache2 >>> 1.0.0 is not a valid cookbook constraint")
     end
 
     it "is not valid if the name is not present" do
-      @environment.validate_required_attrs_present.should be_false
-      @environment.invalid_fields[:name].should == "name cannot be empty"
+      expect(@environment.validate_required_attrs_present).to be_falsey
+      expect(@environment.invalid_fields[:name]).to eq("name cannot be empty")
     end
 
     it "is not valid after updating from params if the name is not present" do
-      @environment.update_from_params({}).should be_false
-      @environment.invalid_fields[:name].should == "name cannot be empty"
+      expect(@environment.update_from_params({})).to be_falsey
+      expect(@environment.invalid_fields[:name]).to eq("name cannot be empty")
     end
 
     it "updates default attributes from a JSON string in params[:attributes]" do
       @environment.update_from_params(:name => "fuuu", :default_attributes => %q|{"fuuu":"RAGE"}|)
-      @environment.default_attributes.should == {"fuuu" => "RAGE"}
+      expect(@environment.default_attributes).to eq({"fuuu" => "RAGE"})
     end
 
     it "updates override attributes from a JSON string in params[:attributes]" do
       @environment.update_from_params(:name => "fuuu", :override_attributes => %q|{"foo":"override"}|)
-      @environment.override_attributes.should == {"foo" => "override"}
+      expect(@environment.override_attributes).to eq({"foo" => "override"})
     end
 
   end
@@ -366,25 +366,25 @@ describe Chef::Environment do
   describe "api model" do
     before(:each) do
       @rest = double("Chef::REST")
-      Chef::REST.stub(:new).and_return(@rest)
+      allow(Chef::REST).to receive(:new).and_return(@rest)
       @query = double("Chef::Search::Query")
-      Chef::Search::Query.stub(:new).and_return(@query)
+      allow(Chef::Search::Query).to receive(:new).and_return(@query)
     end
 
     describe "list" do
       describe "inflated" do
         it "should return a hash of environment names and objects" do
           e1 = double("Chef::Environment", :name => "one")
-          @query.should_receive(:search).with(:environment).and_yield(e1)
+          expect(@query).to receive(:search).with(:environment).and_yield(e1)
           r = Chef::Environment.list(true)
-          r["one"].should == e1
+          expect(r["one"]).to eq(e1)
         end
       end
 
       it "should return a hash of environment names and urls" do
-        @rest.should_receive(:get_rest).and_return({ "one" => "http://foo" })
+        expect(@rest).to receive(:get_rest).and_return({ "one" => "http://foo" })
         r = Chef::Environment.list
-        r["one"].should == "http://foo"
+        expect(r["one"]).to eq("http://foo")
       end
     end
   end
@@ -401,18 +401,18 @@ describe Chef::Environment do
       end
 
       it "should get the environment from the environment_path" do
-        File.should_receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(false)
-        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).exactly(2).times.and_return(true)
-        File.should_receive(:readable?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(true)
+        expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
+        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(false)
+        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).exactly(2).times.and_return(true)
+        expect(File).to receive(:readable?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(true)
         role_dsl="name \"foo\"\ndescription \"desc\"\n"
-        IO.should_receive(:read).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(role_dsl)
+        expect(IO).to receive(:read).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(role_dsl)
         Chef::Environment.load('foo')
       end
 
       it "should return a Chef::Environment object from JSON" do
-        File.should_receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(true)
+        expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
+        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(true)
         environment_hash = {
           "name" => "foo",
           "default_attributes" => {
@@ -424,45 +424,45 @@ describe Chef::Environment do
           "description" => "desc",
           "chef_type" => "environment"
         }
-        IO.should_receive(:read).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(Chef::JSONCompat.to_json(environment_hash))
+        expect(IO).to receive(:read).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(Chef::JSONCompat.to_json(environment_hash))
         environment = Chef::Environment.load('foo')
 
-        environment.should be_a_kind_of(Chef::Environment)
-        environment.name.should == environment_hash['name']
-        environment.description.should == environment_hash['description']
-        environment.default_attributes.should == environment_hash['default_attributes']
+        expect(environment).to be_a_kind_of(Chef::Environment)
+        expect(environment.name).to eq(environment_hash['name'])
+        expect(environment.description).to eq(environment_hash['description'])
+        expect(environment.default_attributes).to eq(environment_hash['default_attributes'])
       end
 
       it "should return a Chef::Environment object from Ruby DSL" do
-        File.should_receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(false)
-        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).exactly(2).times.and_return(true)
-        File.should_receive(:readable?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(true)
+        expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
+        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(false)
+        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).exactly(2).times.and_return(true)
+        expect(File).to receive(:readable?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(true)
         role_dsl="name \"foo\"\ndescription \"desc\"\n"
-        IO.should_receive(:read).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(role_dsl)
+        expect(IO).to receive(:read).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(role_dsl)
         environment = Chef::Environment.load('foo')
 
-        environment.should be_a_kind_of(Chef::Environment)
-        environment.name.should == 'foo'
-        environment.description.should == 'desc'
+        expect(environment).to be_a_kind_of(Chef::Environment)
+        expect(environment.name).to eq('foo')
+        expect(environment.description).to eq('desc')
       end
 
       it 'should raise an error if the configured environment_path is invalid' do
-        File.should_receive(:directory?).with(Chef::Config[:environment_path]).and_return(false)
+        expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(false)
 
-        lambda {
+        expect {
           Chef::Environment.load('foo')
-        }.should raise_error Chef::Exceptions::InvalidEnvironmentPath, "Environment path '/var/chef/environments' is invalid"
+        }.to raise_error Chef::Exceptions::InvalidEnvironmentPath, "Environment path '/var/chef/environments' is invalid"
       end
 
       it 'should raise an error if the file does not exist' do
-        File.should_receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(false)
-        File.should_receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(false)
+        expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
+        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.json')).and_return(false)
+        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], 'foo.rb')).and_return(false)
 
-        lambda {
+        expect {
           Chef::Environment.load('foo')
-        }.should raise_error Chef::Exceptions::EnvironmentNotFound, "Environment 'foo' could not be loaded from disk"
+        }.to raise_error Chef::Exceptions::EnvironmentNotFound, "Environment 'foo' could not be loaded from disk"
       end
     end
   end