ridley 4.2.0 → 4.3.0

data/spec/unit/ridley/chef/cookbook/metadata_spec.rb

@@ -17,36 +17,36 @@ describe Ridley::Chef::Cookbook::Metadata do
         :choice => [ "test1", "test2" ],
         :default => "test1"
       }
-      lambda {
+      expect {
         subject.attribute("test_cookbook/test", options)
-      }.should_not raise_error
+      }.not_to raise_error
   
       options = {
         :type => "boolean",
         :choice => [ true, false ],
         :default => true
       }
-      lambda {
+      expect {
         subject.attribute("test_cookbook/test", options)
-      }.should_not raise_error
+      }.not_to raise_error
 
       options = {
         :type => "numeric",
         :choice => [ 1337, 420 ],
         :default => 1337
       }
-      lambda {
+      expect {
         subject.attribute("test_cookbook/test", options)
-      }.should_not raise_error
+      }.not_to raise_error
 
       options = {
         :type => "numeric",
         :choice => [ true, "false" ],
         :default => false
       }
-      lambda {
+      expect {
         subject.attribute("test_cookbook/test", options)
-      }.should raise_error
+      }.to raise_error
     end
   end
 end

data/spec/unit/ridley/chef/cookbook/syntax_check_spec.rb

@@ -12,7 +12,7 @@ describe Ridley::Chef::Cookbook::SyntaxCheck do
   subject { syntax_check }
 
   before(:each) do
-    subject.stub(:chefignore) { chefignore }
+    allow(subject).to receive(:chefignore) { chefignore }
   end
 
   describe "#ruby_files" do
@@ -55,7 +55,7 @@ describe Ridley::Chef::Cookbook::SyntaxCheck do
     it "checks if a file has already been validated" do
       valid_template_file = cookbook_dir.join("templates/default/temp.txt.erb").to_s
       subject.validated(valid_template_file)
-      expect(subject.validated?(valid_template_file)).to be_true
+      expect(subject.validated?(valid_template_file)).to be_truthy
     end
   end
 
@@ -63,7 +63,7 @@ describe Ridley::Chef::Cookbook::SyntaxCheck do
     let(:validated_files) { double('validated_files') }
 
     before(:each) do
-      subject.stub(:validated_files) { validated_files }
+      allow(subject).to receive(:validated_files) { validated_files }
     end
 
     it "records a file as validated" do
@@ -77,35 +77,35 @@ describe Ridley::Chef::Cookbook::SyntaxCheck do
 
   describe "#validate_ruby_files" do
     it "asks #untested_ruby_files for a list of files and calls #validate_ruby_file on each" do
-      subject.stub(:validate_ruby_file).with(anything()).exactly(9).times { true }
-      expect(subject.validate_ruby_files).to be_true
+      allow(subject).to receive(:validate_ruby_file).with(anything()).exactly(9).times { true }
+      expect(subject.validate_ruby_files).to be_truthy
     end
 
     it "marks the successfully validated ruby files" do
-      subject.stub(:validated).with(anything()).exactly(9).times
-      expect(subject.validate_ruby_files).to be_true
+      allow(subject).to receive(:validated).with(anything()).exactly(9).times
+      expect(subject.validate_ruby_files).to be_truthy
     end
 
     it "returns false if any ruby file fails to validate" do
-      subject.stub(:validate_ruby_file).with(/\.rb$/) { false }
-      expect(subject.validate_ruby_files).to be_false
+      allow(subject).to receive(:validate_ruby_file).with(/\.rb$/) { false }
+      expect(subject.validate_ruby_files).to be_falsey
     end
   end
 
   describe "#validate_templates" do
     it "asks #untested_template_files for a list of erb files and calls #validate_template on each" do
-      subject.stub(:validate_template).with(anything()).exactly(9).times { true }
-      expect(subject.validate_templates).to be_true
+      allow(subject).to receive(:validate_template).with(anything()).exactly(9).times { true }
+      expect(subject.validate_templates).to be_truthy
     end
 
     it "marks the successfully validated erb files" do
-      subject.stub(:validated).with(anything()).exactly(9).times
-      expect(subject.validate_templates).to be_true
+      allow(subject).to receive(:validated).with(anything()).exactly(9).times
+      expect(subject.validate_templates).to be_truthy
     end
 
     it "returns false if any erb file fails to validate" do
-      subject.stub(:validate_template).with(/\.erb$/) { false }
-      expect(subject.validate_templates).to be_false
+      allow(subject).to receive(:validate_template).with(/\.erb$/) { false }
+      expect(subject.validate_templates).to be_falsey
     end
   end
 

data/spec/unit/ridley/chef/cookbook_spec.rb

@@ -8,18 +8,18 @@ describe Ridley::Chef::Cookbook do
       let(:cookbook_path) { fixtures_path.join("example_cookbook") }
 
       it "returns an instance of Ridley::Chef::Cookbook" do
-        subject.from_path(cookbook_path).should be_a(described_class)
+        expect(subject.from_path(cookbook_path)).to be_a(described_class)
       end
 
       it "has a cookbook_name attribute set to the value of the 'name' attribute in the metadata" do
-        subject.from_path(cookbook_path).cookbook_name.should eql("example_cookbook")
+        expect(subject.from_path(cookbook_path).cookbook_name).to eql("example_cookbook")
       end
 
       context "given a path that does not contain a metadata file" do
         it "raises an IOError" do
-          lambda {
+          expect {
             subject.from_path(Dir.mktmpdir)
-          }.should raise_error(IOError)
+          }.to raise_error(IOError)
         end
       end
 
@@ -51,7 +51,7 @@ describe Ridley::Chef::Cookbook do
         end
 
         it "sets the name of the cookbook from the metadata.rb" do
-          subject.from_path(cookbook_path).cookbook_name.should eql("rspec_test")
+          expect(subject.from_path(cookbook_path).cookbook_name).to eql("rspec_test")
         end
       end
 
@@ -73,7 +73,7 @@ describe Ridley::Chef::Cookbook do
         end
 
         it "prefers the metadata.json" do
-          subject.from_path(cookbook_path).cookbook_name.should eql("json_metadata")
+          expect(subject.from_path(cookbook_path).cookbook_name).to eql("json_metadata")
         end
       end
     end
@@ -81,7 +81,7 @@ describe Ridley::Chef::Cookbook do
     describe "::checksum" do
       it "delegates to Ridley::Chef::Digester.md5_checksum_for_file" do
         path = fixtures_path.join("example_cookbook", "metadata.rb")
-        Ridley::Chef::Digester.should_receive(:md5_checksum_for_file).with(path)
+        expect(Ridley::Chef::Digester).to receive(:md5_checksum_for_file).with(path)
 
         subject.checksum(path)
       end
@@ -96,11 +96,11 @@ describe Ridley::Chef::Cookbook do
 
   describe "#checksums" do
     it "returns a Hash" do
-      subject.checksums.should be_a(Hash)
+      expect(subject.checksums).to be_a(Hash)
     end
 
     it "has a key value for every cookbook file" do
-      subject.checksums.should have(subject.send(:files).length).items
+      expect(subject.checksums.size).to eq(subject.send(:files).length)
     end
   end
 
@@ -118,10 +118,10 @@ describe Ridley::Chef::Cookbook do
     end
 
     it "compiles the raw metadata.rb into a metadata.json file in the path of the cookbook" do
-      expect(subject.compiled_metadata?).to be_false
+      expect(subject.compiled_metadata?).to be_falsey
       subject.compile_metadata
       subject.reload
-      expect(subject.compiled_metadata?).to be_true
+      expect(subject.compiled_metadata?).to be_truthy
       expect(subject.cookbook_name).to eql("rspec_test")
       expect(subject.version).to eql("1.2.3")
     end
@@ -132,7 +132,7 @@ describe Ridley::Chef::Cookbook do
 
       it "writes the compiled metadata to a metadata.json file at the given out path" do
         subject.compile_metadata(out_path)
-        expect(File.exist?(File.join(out_path, "metadata.json"))).to be_true
+        expect(File.exist?(File.join(out_path, "metadata.json"))).to be_truthy
       end
     end
   end
@@ -152,7 +152,10 @@ describe Ridley::Chef::Cookbook do
         end
       end
 
-      its(:compiled_metadata?) { should be_true }
+      describe '#compiled_metadata?' do
+        subject { super().compiled_metadata? }
+        it { is_expected.to be_truthy }
+      end
     end
 
     context "when a metadata.json file is not present" do
@@ -164,7 +167,10 @@ describe Ridley::Chef::Cookbook do
         end
       end
 
-      its(:compiled_metadata?) { should be_false }
+      describe '#compiled_metadata?' do
+        subject { super().compiled_metadata? }
+        it { is_expected.to be_falsey }
+      end
     end
   end
 
@@ -181,7 +187,7 @@ describe Ridley::Chef::Cookbook do
         :providers,
         :root_files
       ].each do |category|
-        subject.manifest.should have_key(category)
+        expect(subject.manifest).to have_key(category)
       end
     end
   end
@@ -190,31 +196,31 @@ describe Ridley::Chef::Cookbook do
     let(:syntax_checker) { double('syntax_checker') }
 
     before(:each) do
-      subject.stub(:syntax_checker) { syntax_checker }
+      allow(subject).to receive(:syntax_checker) { syntax_checker }
     end
 
     it "asks the syntax_checker to validate the ruby and template files of the cookbook" do
-      syntax_checker.should_receive(:validate_ruby_files).and_return(true)
-      syntax_checker.should_receive(:validate_templates).and_return(true)
+      expect(syntax_checker).to receive(:validate_ruby_files).and_return(true)
+      expect(syntax_checker).to receive(:validate_templates).and_return(true)
 
       subject.validate
     end
 
     it "raises CookbookSyntaxError if the cookbook contains invalid ruby files" do
-      syntax_checker.should_receive(:validate_ruby_files).and_return(false)
+      expect(syntax_checker).to receive(:validate_ruby_files).and_return(false)
 
-      lambda {
+      expect {
         subject.validate
-      }.should raise_error(Ridley::Errors::CookbookSyntaxError)
+      }.to raise_error(Ridley::Errors::CookbookSyntaxError)
     end
 
     it "raises CookbookSyntaxError if the cookbook contains invalid template files" do
-      syntax_checker.should_receive(:validate_ruby_files).and_return(true)
-      syntax_checker.should_receive(:validate_templates).and_return(false)
+      expect(syntax_checker).to receive(:validate_ruby_files).and_return(true)
+      expect(syntax_checker).to receive(:validate_templates).and_return(false)
 
-      lambda {
+      expect {
         subject.validate
-      }.should raise_error(Ridley::Errors::CookbookSyntaxError)
+      }.to raise_error(Ridley::Errors::CookbookSyntaxError)
     end
   end
 
@@ -223,23 +229,23 @@ describe Ridley::Chef::Cookbook do
     before(:each) { @metadata = subject.file_metadata(:file, file) }
 
     it "has a :path key whose value is a relative path from the CachedCookbook's path" do
-      @metadata.should have_key(:path)
-      @metadata[:path].should be_relative_path
-      @metadata[:path].should eql("files/default/file.h")
+      expect(@metadata).to have_key(:path)
+      expect(@metadata[:path]).to be_relative_path
+      expect(@metadata[:path]).to eql("files/default/file.h")
     end
 
     it "has a :name key whose value is the basename of the target file" do
-      @metadata.should have_key(:name)
-      @metadata[:name].should eql("file.h")
+      expect(@metadata).to have_key(:name)
+      expect(@metadata[:name]).to eql("file.h")
     end
 
     it "has a :checksum key whose value is the checksum of the target file" do
-      @metadata.should have_key(:checksum)
-      @metadata[:checksum].should eql("7b1ebd2ff580ca9dc46fb27ec1653bf2")
+      expect(@metadata).to have_key(:checksum)
+      expect(@metadata[:checksum]).to eql("7b1ebd2ff580ca9dc46fb27ec1653bf2")
     end
 
     it "has a :specificity key" do
-      @metadata.should have_key(:specificity)
+      expect(@metadata).to have_key(:specificity)
     end
 
     context "given a file or template in a 'default' directory" do
@@ -247,7 +253,7 @@ describe Ridley::Chef::Cookbook do
       before(:each) { @metadata = subject.file_metadata(:files, file) }
 
       it "has a specificity of 'default'" do
-        @metadata[:specificity].should eql("default")
+        expect(@metadata[:specificity]).to eql("default")
       end
     end
 
@@ -256,7 +262,7 @@ describe Ridley::Chef::Cookbook do
       before(:each) { @metadata = subject.file_metadata(:files, file) }
 
       it "has a specificity of 'ubuntu'" do
-        @metadata[:specificity].should eql("ubuntu")
+        expect(@metadata[:specificity]).to eql("ubuntu")
       end
     end
   end
@@ -271,7 +277,7 @@ describe Ridley::Chef::Cookbook do
       let(:category) { :recipes }
 
       it "has a specificity of 'default'" do
-        @specificity.should eql("default")
+        expect(@specificity).to eql("default")
       end
     end
 
@@ -279,7 +285,7 @@ describe Ridley::Chef::Cookbook do
       let(:relpath) { 'default/config.erb' }
 
       it "has a specificity of 'default'" do
-        @specificity.should eql("default")
+        expect(@specificity).to eql("default")
       end
     end
 
@@ -287,7 +293,7 @@ describe Ridley::Chef::Cookbook do
       let(:relpath) { 'centos/config.erb' }
 
       it "has a specificity of 'centos'" do
-        @specificity.should eql("centos")
+        expect(@specificity).to eql("centos")
       end
     end
 
@@ -295,7 +301,7 @@ describe Ridley::Chef::Cookbook do
       let(:relpath) { 'config.erb' }
 
       it "has a specificity of 'root_default'" do
-        @specificity.should eql("root_default")
+        expect(@specificity).to eql("root_default")
       end
     end
   end
@@ -304,255 +310,255 @@ describe Ridley::Chef::Cookbook do
     subject { cookbook.to_hash }
 
     it "has a :frozen? flag" do
-      subject.should have_key(:frozen?)
+      expect(subject).to have_key(:frozen?)
     end
 
     it "has a :recipes key with a value of an Array Hashes" do
-      subject.should have_key(:recipes)
-      subject[:recipes].should be_a(Array)
+      expect(subject).to have_key(:recipes)
+      expect(subject[:recipes]).to be_a(Array)
       subject[:recipes].each do |item|
-        item.should be_a(Hash)
+        expect(item).to be_a(Hash)
       end
     end
 
     it "has a :name key value pair in a Hash of the :recipes Array of Hashes" do
-      subject[:recipes].first.should have_key(:name)
+      expect(subject[:recipes].first).to have_key(:name)
     end
 
     it "has a :path key value pair in a Hash of the :recipes Array of Hashes" do
-      subject[:recipes].first.should have_key(:path)
+      expect(subject[:recipes].first).to have_key(:path)
     end
 
     it "has a :checksum key value pair in a Hash of the :recipes Array of Hashes" do
-      subject[:recipes].first.should have_key(:checksum)
+      expect(subject[:recipes].first).to have_key(:checksum)
     end
 
     it "has a :specificity key value pair in a Hash of the :recipes Array of Hashes" do
-      subject[:recipes].first.should have_key(:specificity)
+      expect(subject[:recipes].first).to have_key(:specificity)
     end
 
     it "has a :definitions key with a value of an Array Hashes" do
-      subject.should have_key(:definitions)
-      subject[:definitions].should be_a(Array)
+      expect(subject).to have_key(:definitions)
+      expect(subject[:definitions]).to be_a(Array)
       subject[:definitions].each do |item|
-        item.should be_a(Hash)
+        expect(item).to be_a(Hash)
       end
     end
 
     it "has a :name key value pair in a Hash of the :definitions Array of Hashes" do
-      subject[:definitions].first.should have_key(:name)
+      expect(subject[:definitions].first).to have_key(:name)
     end
 
     it "has a :path key value pair in a Hash of the :definitions Array of Hashes" do
-      subject[:definitions].first.should have_key(:path)
+      expect(subject[:definitions].first).to have_key(:path)
     end
 
     it "has a :checksum key value pair in a Hash of the :definitions Array of Hashes" do
-      subject[:definitions].first.should have_key(:checksum)
+      expect(subject[:definitions].first).to have_key(:checksum)
     end
 
     it "has a :specificity key value pair in a Hash of the :definitions Array of Hashes" do
-      subject[:definitions].first.should have_key(:specificity)
+      expect(subject[:definitions].first).to have_key(:specificity)
     end
 
     it "has a :libraries key with a value of an Array Hashes" do
-      subject.should have_key(:libraries)
-      subject[:libraries].should be_a(Array)
+      expect(subject).to have_key(:libraries)
+      expect(subject[:libraries]).to be_a(Array)
       subject[:libraries].each do |item|
-        item.should be_a(Hash)
+        expect(item).to be_a(Hash)
       end
     end
 
     it "has a :name key value pair in a Hash of the :libraries Array of Hashes" do
-      subject[:libraries].first.should have_key(:name)
+      expect(subject[:libraries].first).to have_key(:name)
     end
 
     it "has a :path key value pair in a Hash of the :libraries Array of Hashes" do
-      subject[:libraries].first.should have_key(:path)
+      expect(subject[:libraries].first).to have_key(:path)
     end
 
     it "has a :checksum key value pair in a Hash of the :libraries Array of Hashes" do
-      subject[:libraries].first.should have_key(:checksum)
+      expect(subject[:libraries].first).to have_key(:checksum)
     end
 
     it "has a :specificity key value pair in a Hash of the :libraries Array of Hashes" do
-      subject[:libraries].first.should have_key(:specificity)
+      expect(subject[:libraries].first).to have_key(:specificity)
     end
 
     it "has a :attributes key with a value of an Array Hashes" do
-      subject.should have_key(:attributes)
-      subject[:attributes].should be_a(Array)
+      expect(subject).to have_key(:attributes)
+      expect(subject[:attributes]).to be_a(Array)
       subject[:attributes].each do |item|
-        item.should be_a(Hash)
+        expect(item).to be_a(Hash)
       end
     end
 
     it "has a :name key value pair in a Hash of the :attributes Array of Hashes" do
-      subject[:attributes].first.should have_key(:name)
+      expect(subject[:attributes].first).to have_key(:name)
     end
 
     it "has a :path key value pair in a Hash of the :attributes Array of Hashes" do
-      subject[:attributes].first.should have_key(:path)
+      expect(subject[:attributes].first).to have_key(:path)
     end
 
     it "has a :checksum key value pair in a Hash of the :attributes Array of Hashes" do
-      subject[:attributes].first.should have_key(:checksum)
+      expect(subject[:attributes].first).to have_key(:checksum)
     end
 
     it "has a :specificity key value pair in a Hash of the :attributes Array of Hashes" do
-      subject[:attributes].first.should have_key(:specificity)
+      expect(subject[:attributes].first).to have_key(:specificity)
     end
 
     it "has a :files key with a value of an Array Hashes" do
-      subject.should have_key(:files)
-      subject[:files].should be_a(Array)
+      expect(subject).to have_key(:files)
+      expect(subject[:files]).to be_a(Array)
       subject[:files].each do |item|
-        item.should be_a(Hash)
+        expect(item).to be_a(Hash)
       end
     end
 
     it "has a :name key value pair in a Hash of the :files Array of Hashes" do
-      subject[:files].first.should have_key(:name)
+      expect(subject[:files].first).to have_key(:name)
     end
 
     it "has a :path key value pair in a Hash of the :files Array of Hashes" do
-      subject[:files].first.should have_key(:path)
+      expect(subject[:files].first).to have_key(:path)
     end
 
     it "has a :checksum key value pair in a Hash of the :files Array of Hashes" do
-      subject[:files].first.should have_key(:checksum)
+      expect(subject[:files].first).to have_key(:checksum)
     end
 
     it "has a :specificity key value pair in a Hash of the :files Array of Hashes" do
-      subject[:files].first.should have_key(:specificity)
+      expect(subject[:files].first).to have_key(:specificity)
     end
 
     it "has a :templates key with a value of an Array Hashes" do
-      subject.should have_key(:templates)
-      subject[:templates].should be_a(Array)
+      expect(subject).to have_key(:templates)
+      expect(subject[:templates]).to be_a(Array)
       subject[:templates].each do |item|
-        item.should be_a(Hash)
+        expect(item).to be_a(Hash)
       end
     end
 
     it "has a :name key value pair in a Hash of the :templates Array of Hashes" do
-      subject[:templates].first.should have_key(:name)
+      expect(subject[:templates].first).to have_key(:name)
     end
 
     it "has a :path key value pair in a Hash of the :templates Array of Hashes" do
-      subject[:templates].first.should have_key(:path)
+      expect(subject[:templates].first).to have_key(:path)
     end
 
     it "has a :checksum key value pair in a Hash of the :templates Array of Hashes" do
-      subject[:templates].first.should have_key(:checksum)
+      expect(subject[:templates].first).to have_key(:checksum)
     end
 
     it "has a :specificity key value pair in a Hash of the :templates Array of Hashes" do
-      subject[:templates].first.should have_key(:specificity)
+      expect(subject[:templates].first).to have_key(:specificity)
     end
 
     it "has a :resources key with a value of an Array Hashes" do
-      subject.should have_key(:resources)
-      subject[:resources].should be_a(Array)
+      expect(subject).to have_key(:resources)
+      expect(subject[:resources]).to be_a(Array)
       subject[:resources].each do |item|
-        item.should be_a(Hash)
+        expect(item).to be_a(Hash)
       end
     end
 
     it "has a :name key value pair in a Hash of the :resources Array of Hashes" do
-      subject[:resources].first.should have_key(:name)
+      expect(subject[:resources].first).to have_key(:name)
     end
 
     it "has a :path key value pair in a Hash of the :resources Array of Hashes" do
-      subject[:resources].first.should have_key(:path)
+      expect(subject[:resources].first).to have_key(:path)
     end
 
     it "has a :checksum key value pair in a Hash of the :resources Array of Hashes" do
-      subject[:resources].first.should have_key(:checksum)
+      expect(subject[:resources].first).to have_key(:checksum)
     end
 
     it "has a :specificity key value pair in a Hash of the :resources Array of Hashes" do
-      subject[:resources].first.should have_key(:specificity)
+      expect(subject[:resources].first).to have_key(:specificity)
     end
 
     it "has a :providers key with a value of an Array Hashes" do
-      subject.should have_key(:providers)
-      subject[:providers].should be_a(Array)
+      expect(subject).to have_key(:providers)
+      expect(subject[:providers]).to be_a(Array)
       subject[:providers].each do |item|
-        item.should be_a(Hash)
+        expect(item).to be_a(Hash)
       end
     end
 
     it "has a :name key value pair in a Hash of the :providers Array of Hashes" do
-      subject[:providers].first.should have_key(:name)
+      expect(subject[:providers].first).to have_key(:name)
     end
 
     it "has a :path key value pair in a Hash of the :providers Array of Hashes" do
-      subject[:providers].first.should have_key(:path)
+      expect(subject[:providers].first).to have_key(:path)
     end
 
     it "has a :checksum key value pair in a Hash of the :providers Array of Hashes" do
-      subject[:providers].first.should have_key(:checksum)
+      expect(subject[:providers].first).to have_key(:checksum)
     end
 
     it "has a :specificity key value pair in a Hash of the :providers Array of Hashes" do
-      subject[:providers].first.should have_key(:specificity)
+      expect(subject[:providers].first).to have_key(:specificity)
     end
 
     it "has a :root_files key with a value of an Array Hashes" do
-      subject.should have_key(:root_files)
-      subject[:root_files].should be_a(Array)
+      expect(subject).to have_key(:root_files)
+      expect(subject[:root_files]).to be_a(Array)
       subject[:root_files].each do |item|
-        item.should be_a(Hash)
+        expect(item).to be_a(Hash)
       end
     end
 
     it "has a :name key value pair in a Hash of the :root_files Array of Hashes" do
-      subject[:root_files].first.should have_key(:name)
+      expect(subject[:root_files].first).to have_key(:name)
     end
 
     it "has a :path key value pair in a Hash of the :root_files Array of Hashes" do
-      subject[:root_files].first.should have_key(:path)
+      expect(subject[:root_files].first).to have_key(:path)
     end
 
     it "has a :checksum key value pair in a Hash of the :root_files Array of Hashes" do
-      subject[:root_files].first.should have_key(:checksum)
+      expect(subject[:root_files].first).to have_key(:checksum)
     end
 
     it "has a :specificity key value pair in a Hash of the :root_files Array of Hashes" do
-      subject[:root_files].first.should have_key(:specificity)
+      expect(subject[:root_files].first).to have_key(:specificity)
     end
 
     it "has a :cookbook_name key with a String value" do
-      subject.should have_key(:cookbook_name)
-      subject[:cookbook_name].should be_a(String)
+      expect(subject).to have_key(:cookbook_name)
+      expect(subject[:cookbook_name]).to be_a(String)
     end
 
     it "has a :metadata key with a Hashie::Mash value" do
-      subject.should have_key(:metadata)
-      subject[:metadata].should be_a(Hashie::Mash)
+      expect(subject).to have_key(:metadata)
+      expect(subject[:metadata]).to be_a(Hashie::Mash)
     end
 
     it "has a :version key with a String value" do
-      subject.should have_key(:version)
-      subject[:version].should be_a(String)
+      expect(subject).to have_key(:version)
+      expect(subject[:version]).to be_a(String)
     end
 
     it "has a :name key with a String value" do
-      subject.should have_key(:name)
-      subject[:name].should be_a(String)
+      expect(subject).to have_key(:name)
+      expect(subject[:name]).to be_a(String)
     end
 
     it "has a value containing the cookbook name and version separated by a dash for :name" do
       name, version = subject[:name].split('-')
 
-      name.should eql(cookbook.cookbook_name)
-      version.should eql(cookbook.version)
+      expect(name).to eql(cookbook.cookbook_name)
+      expect(version).to eql(cookbook.version)
     end
 
     it "has a :chef_type key with Cookbook::CHEF_TYPE as the value" do
-      subject.should have_key(:chef_type)
-      subject[:chef_type].should eql(Ridley::Chef::Cookbook::CHEF_TYPE)
+      expect(subject).to have_key(:chef_type)
+      expect(subject[:chef_type]).to eql(Ridley::Chef::Cookbook::CHEF_TYPE)
     end
   end
 
@@ -562,12 +568,12 @@ describe Ridley::Chef::Cookbook do
     end
 
     it "has a 'json_class' key with Cookbook::CHEF_JSON_CLASS  as the value" do
-      @json.should have_json_path('json_class')
-      parse_json(@json)['json_class'].should eql(Ridley::Chef::Cookbook::CHEF_JSON_CLASS)
+      expect(@json).to have_json_path('json_class')
+      expect(parse_json(@json)['json_class']).to eql(Ridley::Chef::Cookbook::CHEF_JSON_CLASS)
     end
 
     it "has a 'frozen?' flag" do
-      @json.should have_json_path('frozen?')
+      expect(@json).to have_json_path('frozen?')
     end
   end
 end