chef 12.0.0.alpha.0-x86-mingw32 → 12.0.0.alpha.1-x86-mingw32

data/spec/unit/cookbook/syntax_check_spec.rb

@@ -147,7 +147,8 @@ describe Chef::Cookbook::SyntaxCheck do
 
         it "does not remove the invalid file from the list of untested files" do
           syntax_check.untested_ruby_files.should include(File.join(cookbook_path, 'recipes', 'default.rb'))
-          lambda { syntax_check.validate_ruby_files }.should_not change(syntax_check, :untested_ruby_files)
+          syntax_check.validate_ruby_files
+          syntax_check.untested_ruby_files.should include(File.join(cookbook_path, 'recipes', 'default.rb'))
         end
 
         it "indicates that a template file has a syntax error" do
@@ -166,7 +167,7 @@ describe Chef::Cookbook::SyntaxCheck do
           cookbook_path = File.join(CHEF_SPEC_DATA, 'cookbooks', 'ignorken')
           Chef::Config[:cookbook_path] = File.dirname(cookbook_path)
           syntax_check.cookbook_path.replace(cookbook_path)
-          @ruby_files = [File.join(cookbook_path, 'recipes/default.rb')]
+          @ruby_files = [File.join(cookbook_path, 'metadata.rb'), File.join(cookbook_path, 'recipes/default.rb')]
         end
 
         it "shows that ignored ruby files do not require a syntax check" do

data/spec/unit/cookbook_loader_spec.rb

@@ -19,39 +19,61 @@
 require 'spec_helper'
 
 describe Chef::CookbookLoader do
-  before(:each) do
-    @repo_paths = [ File.expand_path(File.join(CHEF_SPEC_DATA, "kitchen")),
-                    File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks")) ]
-    @cookbook_loader = Chef::CookbookLoader.new(@repo_paths)
+
+  let(:repo_paths) do
+    [
+      File.expand_path(File.join(CHEF_SPEC_DATA, "kitchen")),
+      File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
+    ]
   end
 
-  describe "loading all cookbooks" do
+  let(:cookbook_loader) { Chef::CookbookLoader.new(repo_paths) }
+
+  it "checks each directory only once when loading (CHEF-3487)" do
+    cookbook_paths = []
+    repo_paths.each do |repo_path|
+      cookbook_paths |= Dir[File.join(repo_path, "*")]
+    end
+
+    cookbook_paths.delete_if { |path| File.basename(path) == "chefignore" }
+
+    cookbook_paths.each do |cookbook_path|
+      Chef::Cookbook::CookbookVersionLoader.should_receive(:new).
+        with(cookbook_path, anything).
+        once.
+        and_call_original
+    end
+    cookbook_loader.load_cookbooks
+  end
+
+
+  context "after loading all cookbooks" do
     before(:each) do
-      @cookbook_loader.load_cookbooks
+      cookbook_loader.load_cookbooks
     end
 
     describe "[]" do
       it "should return cookbook objects with []" do
-        @cookbook_loader[:openldap].should be_a_kind_of(Chef::CookbookVersion)
+        cookbook_loader[:openldap].should be_a_kind_of(Chef::CookbookVersion)
       end
 
       it "should raise an exception if it cannot find a cookbook with []" do
-        lambda { @cookbook_loader[:monkeypoop] }.should raise_error(Chef::Exceptions::CookbookNotFoundInRepo)
+        lambda { cookbook_loader[:monkeypoop] }.should raise_error(Chef::Exceptions::CookbookNotFoundInRepo)
       end
 
       it "should allow you to look up available cookbooks with [] and a symbol" do
-        @cookbook_loader[:openldap].name.should eql(:openldap)
+        cookbook_loader[:openldap].name.should eql(:openldap)
       end
 
       it "should allow you to look up available cookbooks with [] and a string" do
-        @cookbook_loader["openldap"].name.should eql(:openldap)
+        cookbook_loader["openldap"].name.should eql(:openldap)
       end
     end
 
     describe "each" do
       it "should allow you to iterate over cookbooks with each" do
         seen = Hash.new
-        @cookbook_loader.each do |cookbook_name, cookbook|
+        cookbook_loader.each do |cookbook_name, cookbook|
           seen[cookbook_name] = true
         end
         seen.should have_key("openldap")
@@ -60,7 +82,7 @@ describe Chef::CookbookLoader do
 
       it "should iterate in alphabetical order" do
         seen = Array.new
-        @cookbook_loader.each do |cookbook_name, cookbook|
+        cookbook_loader.each do |cookbook_name, cookbook|
           seen << cookbook_name
           end
         seen[0].should == "angrybash"
@@ -68,106 +90,111 @@ describe Chef::CookbookLoader do
         seen[2].should == "borken"
         seen[3].should == "ignorken"
         seen[4].should == "java"
-        seen[5].should == "openldap"
+        seen[5].should == "name-mismatch"
+        seen[6].should == "openldap"
       end
     end
 
-    describe "load_cookbooks" do
+    describe "referencing cookbook files" do
       it "should find all the cookbooks in the cookbook path" do
-        Chef::Config.cookbook_path << File.expand_path(File.join(CHEF_SPEC_DATA, "hidden-cookbooks"))
-        @cookbook_loader.load_cookbooks
-        @cookbook_loader.should have_key(:openldap)
-        @cookbook_loader.should have_key(:apache2)
+        cookbook_loader.load_cookbooks
+        cookbook_loader.should have_key(:openldap)
+        cookbook_loader.should have_key(:apache2)
       end
 
       it "should allow you to override an attribute file via cookbook_path" do
-        @cookbook_loader[:openldap].attribute_filenames.detect { |f|
+        cookbook_loader[:openldap].attribute_filenames.detect { |f|
           f =~ /cookbooks\/openldap\/attributes\/default.rb/
         }.should_not eql(nil)
-        @cookbook_loader[:openldap].attribute_filenames.detect { |f|
+        cookbook_loader[:openldap].attribute_filenames.detect { |f|
           f =~ /kitchen\/openldap\/attributes\/default.rb/
         }.should eql(nil)
       end
 
       it "should load different attribute files from deeper paths" do
-        @cookbook_loader[:openldap].attribute_filenames.detect { |f|
+        cookbook_loader[:openldap].attribute_filenames.detect { |f|
           f =~ /kitchen\/openldap\/attributes\/robinson.rb/
         }.should_not eql(nil)
       end
 
       it "should allow you to override a definition file via cookbook_path" do
-        @cookbook_loader[:openldap].definition_filenames.detect { |f|
+        cookbook_loader[:openldap].definition_filenames.detect { |f|
           f =~ /cookbooks\/openldap\/definitions\/client.rb/
         }.should_not eql(nil)
-        @cookbook_loader[:openldap].definition_filenames.detect { |f|
+        cookbook_loader[:openldap].definition_filenames.detect { |f|
           f =~ /kitchen\/openldap\/definitions\/client.rb/
         }.should eql(nil)
       end
 
       it "should load definition files from deeper paths" do
-        @cookbook_loader[:openldap].definition_filenames.detect { |f|
+        cookbook_loader[:openldap].definition_filenames.detect { |f|
           f =~ /kitchen\/openldap\/definitions\/drewbarrymore.rb/
         }.should_not eql(nil)
       end
 
       it "should allow you to override a recipe file via cookbook_path" do
-        @cookbook_loader[:openldap].recipe_filenames.detect { |f|
+        cookbook_loader[:openldap].recipe_filenames.detect { |f|
           f =~ /cookbooks\/openldap\/recipes\/gigantor.rb/
         }.should_not eql(nil)
-        @cookbook_loader[:openldap].recipe_filenames.detect { |f|
+        cookbook_loader[:openldap].recipe_filenames.detect { |f|
           f =~ /kitchen\/openldap\/recipes\/gigantor.rb/
         }.should eql(nil)
       end
 
       it "should load recipe files from deeper paths" do
-        @cookbook_loader[:openldap].recipe_filenames.detect { |f|
+        cookbook_loader[:openldap].recipe_filenames.detect { |f|
           f =~ /kitchen\/openldap\/recipes\/woot.rb/
         }.should_not eql(nil)
       end
 
       it "should allow you to have an 'ignore' file, which skips loading files in later cookbooks" do
-        @cookbook_loader[:openldap].recipe_filenames.detect { |f|
+        cookbook_loader[:openldap].recipe_filenames.detect { |f|
           f =~ /kitchen\/openldap\/recipes\/ignoreme.rb/
         }.should eql(nil)
       end
 
       it "should find files that start with a ." do
-        @cookbook_loader[:openldap].file_filenames.detect { |f|
+        cookbook_loader[:openldap].file_filenames.detect { |f|
           f =~ /\.dotfile$/
         }.should =~ /\.dotfile$/
-        @cookbook_loader[:openldap].file_filenames.detect { |f|
+        cookbook_loader[:openldap].file_filenames.detect { |f|
           f =~ /\.ssh\/id_rsa$/
         }.should =~ /\.ssh\/id_rsa$/
       end
 
       it "should load the metadata for the cookbook" do
-        @cookbook_loader.metadata[:openldap].name.to_s.should == "openldap"
-        @cookbook_loader.metadata[:openldap].should be_a_kind_of(Chef::Cookbook::Metadata)
+        cookbook_loader.metadata[:openldap].name.to_s.should == "openldap"
+        cookbook_loader.metadata[:openldap].should be_a_kind_of(Chef::Cookbook::Metadata)
       end
 
-      it "should check each cookbook directory only once (CHEF-3487)" do
-        cookbooks = []
-        @repo_paths.each do |repo_path|
-          cookbooks |= Dir[File.join(repo_path, "*")]
-        end
-        cookbooks.each do |cookbook|
-            File.should_receive(:directory?).with(cookbook).once;
-        end
-        @cookbook_loader.load_cookbooks
-      end
-    end # load_cookbooks
+    end # referencing cookbook files
 
   end # loading all cookbooks
 
+  context "loading all cookbooks when one has invalid metadata" do
+
+    let(:repo_paths) do
+      [
+        File.join(CHEF_SPEC_DATA, "kitchen"),
+        File.join(CHEF_SPEC_DATA, "cookbooks"),
+        File.join(CHEF_SPEC_DATA, "invalid-metadata-chef-repo")
+      ]
+    end
+
+    it "does not squelch the exception" do
+      expect { cookbook_loader.load_cookbooks }.to raise_error("THIS METADATA HAS A BUG")
+    end
+
+  end
+
   describe "loading only one cookbook" do
     before(:each) do
-      @cookbook_loader = Chef::CookbookLoader.new(@repo_paths)
-      @cookbook_loader.load_cookbook("openldap")
+      cookbook_loader.load_cookbook("openldap")
     end
 
     it "should have loaded the correct cookbook" do
       seen = Hash.new
-      @cookbook_loader.each do |cookbook_name, cookbook|
+      cookbook_loader.each do |cookbook_name, cookbook|
         seen[cookbook_name] = true
       end
       seen.should have_key("openldap")
@@ -176,7 +203,7 @@ describe Chef::CookbookLoader do
     it "should not duplicate keys when serialized to JSON" do
       # Chef JSON serialization will generate duplicate keys if given
       # a Hash containing matching string and symbol keys. See CHEF-4571.
-      aa = @cookbook_loader["openldap"]
+      aa = cookbook_loader["openldap"]
       aa.to_hash["metadata"].recipes.keys.should_not include(:openldap)
       aa.to_hash["metadata"].recipes.keys.should include("openldap")
       expected_desc = "Main Open LDAP configuration"
@@ -190,30 +217,50 @@ describe Chef::CookbookLoader do
     end
 
     it "should not load the cookbook again when accessed" do
-      @cookbook_loader.should_not_receive('load_cookbook')
-      @cookbook_loader["openldap"]
+      cookbook_loader.should_not_receive('load_cookbook')
+      cookbook_loader["openldap"]
     end
 
     it "should not load the other cookbooks" do
       seen = Hash.new
-      @cookbook_loader.each do |cookbook_name, cookbook|
+      cookbook_loader.each do |cookbook_name, cookbook|
         seen[cookbook_name] = true
       end
       seen.should_not have_key("apache2")
     end
 
     it "should load another cookbook lazily with []" do
-      @cookbook_loader["apache2"].should be_a_kind_of(Chef::CookbookVersion)
+      cookbook_loader["apache2"].should be_a_kind_of(Chef::CookbookVersion)
+    end
+
+    context "when an unrelated cookbook has invalid metadata" do
+
+      let(:repo_paths) do
+        [
+          File.join(CHEF_SPEC_DATA, "kitchen"),
+          File.join(CHEF_SPEC_DATA, "cookbooks"),
+          File.join(CHEF_SPEC_DATA, "invalid-metadata-chef-repo")
+        ]
+      end
+
+      it "ignores the invalid cookbook" do
+        expect { cookbook_loader["openldap"] }.to_not raise_error
+      end
+
+      it "surfaces the exception if the cookbook is loaded later" do
+        expect { cookbook_loader["invalid-metadata"] }.to raise_error("THIS METADATA HAS A BUG")
+      end
+
     end
 
     describe "loading all cookbooks after loading only one cookbook" do
       before(:each) do
-        @cookbook_loader.load_cookbooks
+        cookbook_loader.load_cookbooks
       end
 
       it "should load all cookbooks" do
         seen = Hash.new
-        @cookbook_loader.each do |cookbook_name, cookbook|
+        cookbook_loader.each do |cookbook_name, cookbook|
           seen[cookbook_name] = true
         end
         seen.should have_key("openldap")
@@ -221,4 +268,18 @@ describe Chef::CookbookLoader do
       end
     end
   end # loading only one cookbook
+
+  describe "loading a single cookbook with a different name than basename" do
+
+    before(:each) do
+      cookbook_loader.load_cookbook("name-mismatch")
+    end
+
+    it "loads the correct cookbook" do
+      cookbook_version = cookbook_loader["name-mismatch"]
+      cookbook_version.should be_a_kind_of(Chef::CookbookVersion)
+      cookbook_version.name.should == :"name-mismatch"
+    end
+
+  end
 end

data/spec/unit/{cookbook_site_streaming_uploader.rb → cookbook_site_streaming_uploader_spec.rb}

@@ -121,6 +121,27 @@ describe Chef::CookbookSiteStreamingUploader do
       })
     end
 
+    describe "http verify mode" do
+      before do
+        @uri = "https://cookbooks.dummy.com/api/v1/cookbooks"
+        uri_info = URI.parse(@uri)
+        @http = Net::HTTP.new(uri_info.host, uri_info.port)
+        Net::HTTP.should_receive(:new).with(uri_info.host, uri_info.port).and_return(@http)
+      end
+
+      it "should be VERIFY_NONE when ssl_verify_mode is :verify_none" do
+        Chef::Config[:ssl_verify_mode] = :verify_none
+        Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, 'bill', @secret_filename)
+        @http.verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+      end
+
+      it "should be VERIFY_PEER when ssl_verify_mode is :verify_peer" do
+        Chef::Config[:ssl_verify_mode] = :verify_peer
+        Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, 'bill', @secret_filename)
+        @http.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+      end
+    end
+
   end # make_request
 
   describe "StreamPart" do
@@ -197,4 +218,3 @@ describe Chef::CookbookSiteStreamingUploader do
   end # MultipartStream
 
 end
-

data/spec/unit/data_bag_spec.rb

@@ -128,10 +128,19 @@ describe Chef::DataBag do
       end
     end
 
-    describe "in solo mode" do
+    def file_dir_stub(path, returns = true)
+      File.should_receive(:directory?).with(path).and_return(returns)
+    end
+
+    def dir_glob_stub(path, returns = [])
+      Dir.should_receive(:glob).with(File.join(path, 'foo/*.json')).and_return(returns)
+    end
+
+    shared_examples_for "data bag in solo mode" do |data_bag_path|
       before do
         Chef::Config[:solo] = true
-        Chef::Config[:data_bag_path] = '/var/chef/data_bags'
+        Chef::Config[:data_bag_path] = data_bag_path
+        @paths = Array(data_bag_path)
       end
 
       after do
@@ -139,35 +148,93 @@ describe Chef::DataBag do
       end
 
       it "should get the data bag from the data_bag_path" do
-        File.should_receive(:directory?).with('/var/chef/data_bags').and_return(true)
-        Dir.should_receive(:glob).with('/var/chef/data_bags/foo/*.json').and_return([])
+        @paths.each do |path|
+          file_dir_stub(path)
+          dir_glob_stub(path)
+        end
         Chef::DataBag.load('foo')
       end
 
       it "should get the data bag from the data_bag_path by symbolic name" do
-        File.should_receive(:directory?).with('/var/chef/data_bags').and_return(true)
-        Dir.should_receive(:glob).with('/var/chef/data_bags/foo/*.json').and_return([])
+        @paths.each do |path|
+          file_dir_stub(path)
+          dir_glob_stub(path)
+        end
         Chef::DataBag.load(:foo)
       end
 
       it "should return the data bag" do
-        File.should_receive(:directory?).with('/var/chef/data_bags').and_return(true)
-        Dir.stub(:glob).and_return(["/var/chef/data_bags/foo/bar.json", "/var/chef/data_bags/foo/baz.json"])
-        IO.should_receive(:read).with('/var/chef/data_bags/foo/bar.json').and_return('{"id": "bar", "name": "Bob Bar" }')
-        IO.should_receive(:read).with('/var/chef/data_bags/foo/baz.json').and_return('{"id": "baz", "name": "John Baz" }')
+        @paths.each do |path|
+          file_dir_stub(path)
+          if path == @paths.first
+            dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
+          else
+            dir_glob_stub(path)
+          end
+        end
+        IO.should_receive(:read).with(File.join(@paths.first, 'foo/bar.json')).and_return('{"id": "bar", "name": "Bob Bar" }')
+        IO.should_receive(:read).with(File.join(@paths.first, 'foo/baz.json')).and_return('{"id": "baz", "name": "John Baz" }')
         data_bag = Chef::DataBag.load('foo')
         data_bag.should == { 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar' }, 'baz' => { 'id' => 'baz', 'name' => 'John Baz' }}
       end
 
+      it "should raise if data bag has items with similar names but different content" do
+        @paths.each do |path|
+          file_dir_stub(path)
+          item_with_different_content = "{\"id\": \"bar\", \"name\": \"Bob Bar\", \"path\": \"#{path}\"}"
+          IO.should_receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_different_content)
+          if data_bag_path.is_a?(String)
+            dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
+            item_2_with_different_content = '{"id": "bar", "name": "John Baz"}'
+            IO.should_receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_2_with_different_content)
+          else
+            dir_glob_stub(path, [File.join(path, 'foo/bar.json')])
+          end
+        end
+        expect { Chef::DataBag.load('foo') }.to raise_error(Chef::Exceptions::DuplicateDataBagItem)
+      end
+
+      it "should return data bag if it has items with similar names and the same content" do
+        @paths.each do |path|
+          file_dir_stub(path)
+          dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
+          item_with_same_content = '{"id": "bar", "name": "Bob Bar"}'
+          IO.should_receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_same_content)
+          IO.should_receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_with_same_content)
+        end
+        data_bag = Chef::DataBag.load('foo')
+        test_data_bag = { 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar'} }
+        data_bag.should == test_data_bag
+      end
+
+      it "should merge data bag items if there are no conflicts" do
+        @paths.each_with_index do |path, index|
+          file_dir_stub(path)
+          dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
+          test_item_with_same_content = '{"id": "bar", "name": "Bob Bar"}'
+          IO.should_receive(:read).with(File.join(path, 'foo/bar.json')).and_return(test_item_with_same_content)
+          test_uniq_item = "{\"id\": \"baz_#{index}\", \"name\": \"John Baz\", \"path\": \"#{path}\"}"
+          IO.should_receive(:read).with(File.join(path, 'foo/baz.json')).and_return(test_uniq_item)
+        end
+        data_bag = Chef::DataBag.load('foo')
+        test_data_bag = { 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar'} }
+        @paths.each_with_index do |path, index|
+          test_data_bag["baz_#{index}"] = { "id" => "baz_#{index}", "name" => "John Baz", "path" => path }
+        end
+        data_bag.should == test_data_bag
+      end
+
       it "should return the data bag list" do
-        File.should_receive(:directory?).with('/var/chef/data_bags').and_return(true)
-        Dir.should_receive(:glob).and_return(["/var/chef/data_bags/foo", "/var/chef/data_bags/bar"])
+        @paths.each do |path|
+          file_dir_stub(path)
+          Dir.should_receive(:glob).and_return([File.join(path, 'foo'), File.join(path, 'bar')])
+        end
         data_bag_list = Chef::DataBag.list
         data_bag_list.should == { 'bar' => 'bar', 'foo' => 'foo' }
       end
 
       it 'should raise an error if the configured data_bag_path is invalid' do
-        File.should_receive(:directory?).with('/var/chef/data_bags').and_return(false)
+        file_dir_stub(@paths.first, false)
 
         lambda {
           Chef::DataBag.load('foo')
@@ -175,6 +242,14 @@ describe Chef::DataBag do
       end
 
     end
+
+    describe "data bag with string path" do
+      it_should_behave_like "data bag in solo mode", "/var/chef/data_bags"
+    end
+
+    describe "data bag with array path" do
+      it_should_behave_like "data bag in solo mode", ["/var/chef/data_bags", "/var/chef/data_bags_2"]
+    end
   end
 
 end