ridley 4.0.0 → 4.3.0

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,46 @@ 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
+
+  describe "#file_specificity" do
+    let(:category) { :templates }
+    let(:relpath) { 'default.rb' }
+    let(:file) { subject.path.join(category.to_s, relpath) }
+    before(:each) { @specificity = subject.file_specificity(category, file) }
+
+    context "given a recipe file" do
+      let(:category) { :recipes }
+
+      it "has a specificity of 'default'" do
+        expect(@specificity).to eql("default")
+      end
+    end
+
+    context "given a template 'default/config.erb'" do
+      let(:relpath) { 'default/config.erb' }
+
+      it "has a specificity of 'default'" do
+        expect(@specificity).to eql("default")
+      end
+    end
+
+    context "given a template 'centos/config.erb'" do
+      let(:relpath) { 'centos/config.erb' }
+
+      it "has a specificity of 'centos'" do
+        expect(@specificity).to eql("centos")
+      end
+    end
+
+    context "given a template 'config.erb'" do
+      let(:relpath) { 'config.erb' }
+
+      it "has a specificity of 'root_default'" do
+        expect(@specificity).to eql("root_default")
       end
     end
   end
@@ -265,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
 
@@ -523,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

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

@@ -9,14 +9,14 @@ describe Ridley::Chef::Digester do
 
   describe "when computing checksums of cookbook files and templates" do
     it "proxies the class method checksum_for_file to the instance" do
-      @cache.should_receive(:checksum_for_file).with("a_file_or_a_fail")
+      expect(@cache).to receive(:checksum_for_file).with("a_file_or_a_fail")
       described_class.checksum_for_file("a_file_or_a_fail")
     end
 
     it "generates a checksum from a non-file IO object" do
       io = StringIO.new("riseofthemachines\nriseofthechefs\n")
       expected_md5 = '0e157ac1e2dd73191b76067fb6b4bceb'
-      @cache.generate_md5_checksum(io).should == expected_md5
+      expect(@cache.generate_md5_checksum(io)).to eq(expected_md5)
     end
   end
 end