chef 12.0.0.alpha.2 → 12.0.0.rc.0

data/spec/unit/cookbook/cookbook_version_loader_spec.rb

@@ -19,6 +19,9 @@
 require 'spec_helper'
 
 describe Chef::Cookbook::CookbookVersionLoader do
+  before do
+    Chef::Platform.stub(:windows?) { false }
+  end
 
   describe "loading a cookbook" do
 
@@ -54,6 +57,11 @@ describe Chef::Cookbook::CookbookVersionLoader do
       expect(loaded_cookbook.recipe_filenames).to include(full_path("/recipes/return.rb"))
     end
 
+    it "loads libraries" do
+      expect(loaded_cookbook.library_filenames).to include(full_path('/libraries/openldap.rb'))
+      expect(loaded_cookbook.library_filenames).to include(full_path('/libraries/openldap/version.rb'))
+    end
+
     it "loads static files in the files/ dir" do
       expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/remotedir/remotesubdir/remote_subdir_file1.txt"))
       expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/remotedir/remotesubdir/remote_subdir_file2.txt"))

data/spec/unit/cookbook/metadata_spec.rb

@@ -29,7 +29,8 @@ describe Chef::Cookbook::Metadata do
       @fields = [ :name, :description, :long_description, :maintainer,
                   :maintainer_email, :license, :platforms, :dependencies,
                   :recommendations, :suggestions, :conflicting, :providing,
-                  :replacing, :attributes, :groupings, :recipes, :version]
+                  :replacing, :attributes, :groupings, :recipes, :version,
+                  :source_url, :issues_url ]
     end
 
     it "does not depend on object identity for equality" do
@@ -140,6 +141,13 @@ describe Chef::Cookbook::Metadata do
       metadata.recipes.should eq(Mash.new)
     end
 
+    it "has an empty source_url string" do
+      metadata.source_url.should eq('')
+    end
+
+    it "has an empty issues_url string" do
+      metadata.issues_url.should eq('')
+    end
   end
 
   describe "validation" do
@@ -188,7 +196,9 @@ describe Chef::Cookbook::Metadata do
       :license => "Apache v2.0",
       :description => "Foobar!",
       :long_description => "Much Longer\nSeriously",
-      :version => "0.6.0"
+      :version => "0.6.0",
+      :source_url => "http://example.com",
+      :issues_url => "http://example.com/issues"
     }
     params.sort { |a,b| a.to_s <=> b.to_s }.each do |field, field_value|
       describe field do
@@ -333,7 +343,9 @@ describe Chef::Cookbook::Metadata do
         "type" => 'string',
         "required" => 'recommended',
         "recipes" => [ "mysql::server", "mysql::master" ],
-        "default" => [ ]
+        "default" => [ ],
+        "source_url" => "http://example.com",
+        "issues_url" => "http://example.com/issues"
       }
       metadata.attribute("/db/mysql/databases", attrs).should == attrs
     end
@@ -356,6 +368,24 @@ describe Chef::Cookbook::Metadata do
       }.should raise_error(ArgumentError)
     end
 
+    it "should not accept anything but a string for the source_url" do
+      lambda {
+        metadata.attribute("db/mysql/databases", :source_url => "foo")
+      }.should_not raise_error
+      lambda {
+        metadata.attribute("db/mysql/databases", :source_url => Hash.new)
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should not accept anything but a string for the issues_url" do
+      lambda {
+        metadata.attribute("db/mysql/databases", :issues_url => "foo")
+      }.should_not raise_error
+      lambda {
+        metadata.attribute("db/mysql/databases", :issues_url => Hash.new)
+      }.should raise_error(ArgumentError)
+    end
+
     it "should not accept anything but an array of strings for choice" do
       lambda {
         metadata.attribute("db/mysql/databases", :choice => ['dedicated', 'shared'])
@@ -623,9 +653,13 @@ describe Chef::Cookbook::Metadata do
       metadata.version "1.2.3"
     end
 
+    it "should produce the same output from to_json and Chef::JSONCompat" do
+      expect(metadata.to_json).to eq(Chef::JSONCompat.to_json(metadata))
+    end
+
     describe "serialize" do
 
-      let(:deserialized_metadata) { Chef::JSONCompat.from_json(metadata.to_json) }
+      let(:deserialized_metadata) { Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(metadata)) }
 
       it "should serialize to a json hash" do
         deserialized_metadata.should be_a_kind_of(Hash)
@@ -648,6 +682,8 @@ describe Chef::Cookbook::Metadata do
         attributes
         recipes
         version
+        source_url
+        issues_url
       }.each do |t|
         it "should include '#{t}'" do
           deserialized_metadata[t].should == metadata.send(t.to_sym)
@@ -657,7 +693,7 @@ describe Chef::Cookbook::Metadata do
 
     describe "deserialize" do
 
-      let(:deserialized_metadata) { Chef::Cookbook::Metadata.from_json(metadata.to_json) }
+      let(:deserialized_metadata) { Chef::Cookbook::Metadata.from_json(Chef::JSONCompat.to_json(metadata)) }
 
 
       it "should deserialize to a Chef::Cookbook::Metadata object" do
@@ -681,6 +717,8 @@ describe Chef::Cookbook::Metadata do
         attributes
         recipes
         version
+        source_url
+        issues_url
       }.each do |t|
         it "should match '#{t}'" do
           deserialized_metadata.send(t.to_sym).should == metadata.send(t.to_sym)
@@ -731,5 +769,4 @@ describe Chef::Cookbook::Metadata do
     end
 
   end
-
 end

data/spec/unit/cookbook/syntax_check_spec.rb

@@ -20,15 +20,20 @@ require 'spec_helper'
 require "chef/cookbook/syntax_check"
 
 describe Chef::Cookbook::SyntaxCheck do
+  before do
+    Chef::Platform.stub(:windows?) { false }
+  end
 
   let(:cookbook_path) { File.join(CHEF_SPEC_DATA, 'cookbooks', 'openldap') }
   let(:syntax_check) { Chef::Cookbook::SyntaxCheck.new(cookbook_path) }
 
   let(:open_ldap_cookbook_files) do
-    %w{ attributes/default.rb 
+    %w{ attributes/default.rb
         attributes/smokey.rb
         definitions/client.rb
         definitions/server.rb
+        libraries/openldap.rb
+        libraries/openldap/version.rb
         metadata.rb
         recipes/default.rb
         recipes/gigantor.rb
@@ -41,9 +46,10 @@ describe Chef::Cookbook::SyntaxCheck do
     Chef::Log.level = :warn # suppress "Syntax OK" messages
 
     @attr_files = %w{default.rb smokey.rb}.map { |f| File.join(cookbook_path, 'attributes', f) }
+    @libr_files = %w{openldap.rb openldap/version.rb}.map { |f| File.join(cookbook_path, 'libraries', f) }
     @defn_files = %w{client.rb server.rb}.map { |f| File.join(cookbook_path, 'definitions', f)}
     @recipes = %w{default.rb gigantor.rb one.rb return.rb}.map { |f| File.join(cookbook_path, 'recipes', f) }
-    @ruby_files = @attr_files + @defn_files + @recipes + [File.join(cookbook_path, "metadata.rb")]
+    @ruby_files = @attr_files + @libr_files + @defn_files + @recipes + [File.join(cookbook_path, "metadata.rb")]
     basenames = %w{ helpers_via_partial_test.erb
                     helper_test.erb
                     openldap_stuff.conf.erb

data/spec/unit/cookbook_loader_spec.rb

@@ -19,7 +19,9 @@
 require 'spec_helper'
 
 describe Chef::CookbookLoader do
-
+  before do
+    Chef::Platform.stub(:windows?) {false}
+  end
   let(:repo_paths) do
     [
       File.expand_path(File.join(CHEF_SPEC_DATA, "kitchen")),
@@ -208,7 +210,7 @@ describe Chef::CookbookLoader do
       aa.to_hash["metadata"].recipes.keys.should include("openldap")
       expected_desc = "Main Open LDAP configuration"
       aa.to_hash["metadata"].recipes["openldap"].should == expected_desc
-      raw = aa.to_hash["metadata"].recipes.to_json
+      raw = Chef::JSONCompat.to_json(aa.to_hash["metadata"].recipes)
       search_str = "\"openldap\":\""
       key_idx = raw.index(search_str)
       key_idx.should be > 0

data/spec/unit/cookbook_version_spec.rb

@@ -115,14 +115,13 @@ describe Chef::CookbookVersion do
       @cookbook[:provider_filenames]    = Dir[File.join(@cookbook_root, 'providers', '**', '*.rb')]
       @cookbook[:root_filenames]        = Array(File.join(@cookbook_root, 'README.rdoc'))
       @cookbook[:metadata_filenames]    = Array(File.join(@cookbook_root, 'metadata.json'))
-
     end
 
     describe "and a cookbook with the same name" do
       before do
         # Currently the cookbook loader finds all the files then tells CookbookVersion
         # where they are.
-        @cookbook_version = Chef::CookbookVersion.new("tatft", @cookbook_root)
+        @cookbook_version = Chef::CookbookVersion.new('tatft', @cookbook_root)
 
         @cookbook_version.attribute_filenames  = @cookbook[:attribute_filenames]
         @cookbook_version.definition_filenames = @cookbook[:definition_filenames]
@@ -350,6 +349,84 @@ describe Chef::CookbookVersion do
         readme["specificity"].should == "default"
       end
     end
+  end
+
+  describe 'with a cookbook directory named cookbook2 that has unscoped files' do
+    before do
+      @cookbook = Hash.new { |hash, key| hash[key] = [] }
+
+      @cookbook_root = File.join(CHEF_SPEC_DATA, 'cb_version_cookbooks', 'cookbook2')
+
+      # Dunno if the paths here are representitive of what is set by CookbookLoader...
+      @cookbook[:attribute_filenames]   = Dir[File.join(@cookbook_root, 'attributes', '**', '*.rb')]
+      @cookbook[:definition_filenames]  = Dir[File.join(@cookbook_root, 'definitions', '**', '*.rb')]
+      @cookbook[:file_filenames]        = Dir[File.join(@cookbook_root, 'files', '**', '*.*')]
+      @cookbook[:recipe_filenames]      = Dir[File.join(@cookbook_root, 'recipes', '**', '*.rb')]
+      @cookbook[:template_filenames]    = Dir[File.join(@cookbook_root, 'templates', '**', '*.*')]
+      @cookbook[:library_filenames]     = Dir[File.join(@cookbook_root, 'libraries', '**', '*.rb')]
+      @cookbook[:resource_filenames]    = Dir[File.join(@cookbook_root, 'resources', '**', '*.rb')]
+      @cookbook[:provider_filenames]    = Dir[File.join(@cookbook_root, 'providers', '**', '*.rb')]
+      @cookbook[:root_filenames]        = Array(File.join(@cookbook_root, 'README.rdoc'))
+      @cookbook[:metadata_filenames]    = Array(File.join(@cookbook_root, 'metadata.json'))
+
+      @cookbook_version = Chef::CookbookVersion.new('cookbook2', @cookbook_root)
+      @cookbook_version.attribute_filenames  = @cookbook[:attribute_filenames]
+      @cookbook_version.definition_filenames = @cookbook[:definition_filenames]
+      @cookbook_version.recipe_filenames     = @cookbook[:recipe_filenames]
+      @cookbook_version.template_filenames   = @cookbook[:template_filenames]
+      @cookbook_version.file_filenames       = @cookbook[:file_filenames]
+      @cookbook_version.library_filenames    = @cookbook[:library_filenames]
+      @cookbook_version.resource_filenames   = @cookbook[:resource_filenames]
+      @cookbook_version.provider_filenames   = @cookbook[:provider_filenames]
+      @cookbook_version.root_filenames       = @cookbook[:root_filenames]
+      @cookbook_version.metadata_filenames   = @cookbook[:metadata_filenames]
+
+      # Used to test file-specificity related file lookups
+      @node = Chef::Node.new
+      @node.set[:platform] = "ubuntu"
+      @node.set[:platform_version] = "13.04"
+      @node.name("testing")
+    end
+
+    it "should see a template" do
+      @cookbook_version.should have_template_for_node(@node, "test.erb")
+    end
+
+    it "should see a template using an array lookup" do
+      @cookbook_version.should have_template_for_node(@node, ["test.erb"])
+    end
+
+    it "should see a template using an array lookup with non-existant elements" do
+      @cookbook_version.should have_template_for_node(@node, ["missing.txt", "test.erb"])
+    end
+
+    it "should see a file" do
+      @cookbook_version.should have_cookbook_file_for_node(@node, "test.txt")
+    end
+
+    it "should see a file using an array lookup" do
+      @cookbook_version.should have_cookbook_file_for_node(@node, ["test.txt"])
+    end
+
+    it "should see a file using an array lookup with non-existant elements" do
+      @cookbook_version.should have_cookbook_file_for_node(@node, ["missing.txt", "test.txt"])
+    end
+
+    it "should not see a non-existant template" do
+      @cookbook_version.should_not have_template_for_node(@node, "missing.erb")
+    end
+
+    it "should not see a non-existant template using an array lookup" do
+      @cookbook_version.should_not have_template_for_node(@node, ["missing.erb"])
+    end
+
+    it "should not see a non-existant file" do
+      @cookbook_version.should_not have_cookbook_file_for_node(@node, "missing.txt")
+    end
+
+    it "should not see a non-existant file using an array lookup" do
+      @cookbook_version.should_not have_cookbook_file_for_node(@node, ["missing.txt"])
+    end
 
   end
 
@@ -422,4 +499,8 @@ describe Chef::CookbookVersion do
 
   end
 
+  include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+    let(:jsonable) { Chef::CookbookVersion.new("tatft", '/tmp/blah') }
+  end
+
 end

data/spec/unit/data_bag_item_spec.rb

@@ -166,7 +166,7 @@ describe Chef::DataBagItem do
     before(:each) do
       @data_bag_item.data_bag('mars_volta')
       @data_bag_item.raw_data = { "id" => "octahedron", "snooze" => { "finally" => :world_will }}
-      @deserial = Chef::JSONCompat.from_json(@data_bag_item.to_json)
+      @deserial = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@data_bag_item))
     end
 
     it "should deserialize to a Chef::DataBagItem object" do
@@ -184,6 +184,10 @@ describe Chef::DataBagItem do
     it "should have a matching 'snooze' key" do
       @deserial["snooze"].should == { "finally" => "world_will" }
     end
+
+    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+      let(:jsonable) { @data_bag_item }
+    end
   end
 
   describe "when converting to a string" do

data/spec/unit/data_bag_spec.rb

@@ -22,6 +22,7 @@ require 'chef/data_bag'
 describe Chef::DataBag do
   before(:each) do
     @data_bag = Chef::DataBag.new
+    Chef::Platform::stub(:windows?) { false }
   end
 
   describe "initialize" do
@@ -58,7 +59,7 @@ describe Chef::DataBag do
   describe "deserialize" do
     before(:each) do
       @data_bag.name('mars_volta')
-      @deserial = Chef::JSONCompat.from_json(@data_bag.to_json)
+      @deserial = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@data_bag))
     end
 
     it "should deserialize to a Chef::DataBag object" do
@@ -71,6 +72,10 @@ describe Chef::DataBag do
       it "should match '#{t}'" do
         @deserial.send(t.to_sym).should == @data_bag.send(t.to_sym)
       end
+
+      include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+        let(:jsonable) { @data_bag }
+      end
     end
 
   end

data/spec/unit/dsl/data_query_spec.rb

@@ -86,123 +86,21 @@ describe Chef::DSL::DataQuery do
     end
 
     context "when the item is encrypted" do
-      let(:default_secret) { "abc123SECRET" }
-
-      let(:encoded_data) { Chef::EncryptedDataBagItem.encrypt_data_bag_item(raw_data, default_secret) }
-
-      let(:item) do
-        item = Chef::DataBagItem.new
-        item.data_bag(bag_name)
-        item.raw_data = encoded_data
-        item
-      end
+      let(:secret) { "abc123SECRET" }
+      let(:enc_data_bag) { double("Chef::EncryptedDataBagItem") }
 
       before do
         allow( Chef::DataBagItem ).to receive(:load).with(bag_name, item_name).and_return(item)
+        expect(language).to receive(:encrypted?).and_return(true)
+        expect( Chef::EncryptedDataBagItem ).to receive(:load_secret).and_return(secret)
       end
 
-      shared_examples_for "encryption detected" do
-        let(:encoded_data) do
-          Chef::Config[:data_bag_encrypt_version] = version
-          Chef::EncryptedDataBagItem.encrypt_data_bag_item(raw_data, default_secret)
-        end
-
-        before do
-          allow( Chef::EncryptedDataBagItem ).to receive(:load_secret).and_return(default_secret)
-        end
-
-        it "detects encrypted data bag" do
-          expect( encryptor ).to receive(:encryptor_keys).at_least(:once).and_call_original
-          expect( Chef::Log ).to receive(:debug).with(/Data bag item looks encrypted/)
-          language.data_bag_item(bag_name, item_name)
-        end
-      end
-
-      context "when encryption version is 1" do
-        include_examples "encryption detected" do
-          let(:version) { 1 }
-          let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor }
-        end
-      end
-
-      context "when encryption version is 2" do
-        include_examples "encryption detected" do
-          let(:version) { 2 }
-          let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor }
-        end
+      it "detects encrypted data bag" do
+        expect( Chef::EncryptedDataBagItem ).to receive(:new).with(raw_data, secret).and_return(enc_data_bag)
+        expect( Chef::Log ).to receive(:debug).with(/Data bag item looks encrypted/)
+        expect(language.data_bag_item(bag_name, item_name)).to eq(enc_data_bag)
       end
 
-      context "when encryption version is 3", :ruby_20_only do
-        include_examples "encryption detected" do
-          let(:version) { 3 }
-          let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor }
-        end
-      end
-
-      shared_examples_for "an encrypted data bag item" do
-        it "returns an encrypted data bag item" do
-          expect( language.data_bag_item(bag_name, item_name, secret) ).to be_a_kind_of(Chef::EncryptedDataBagItem)
-        end
-
-        it "decrypts the contents of the data bag item" do
-          expect( language.data_bag_item(bag_name, item_name, secret).to_hash ).to eql raw_data
-        end
-      end
-
-      context "when a secret is supplied" do
-        include_examples "an encrypted data bag item" do
-          let(:secret) { default_secret }
-        end
-      end
-
-      context "when a secret is not supplied" do
-        before do
-          allow( Chef::Config ).to receive(:[]).and_call_original
-          expect( Chef::Config ).to receive(:[]).with(:encrypted_data_bag_secret).and_return(path)
-          expect( Chef::EncryptedDataBagItem ).to receive(:load_secret).and_call_original
-        end
-
-        context "when a secret is located at Chef::Config[:encrypted_data_bag_secret]" do
-          let(:path) { "/tmp/my_secret" }
-
-          before do
-            expect( File ).to receive(:exist?).with(path).and_return(true)
-            expect( IO ).to receive(:read).with(path).and_return(default_secret)
-          end
-
-          include_examples "an encrypted data bag item" do
-            let(:secret) { nil }
-          end
-        end
-
-        shared_examples_for "no secret file" do
-          it "should fail to load the data bag item" do
-            expect( Chef::Log ).to receive(:error).with(/Failed to load secret for encrypted data bag item/)
-            expect( Chef::Log ).to receive(:error).with(/Failed to load data bag item/)
-            expect{ language.data_bag_item(bag_name, item_name) }.to raise_error(error_type, error_message)
-          end
-        end
-
-        context "when Chef::Config[:encrypted_data_bag_secret] is not configured" do
-          include_examples "no secret file" do
-            let(:path) { nil }
-            let(:error_type) { ArgumentError }
-            let(:error_message) { /No secret specified and no secret found/ }
-          end
-        end
-
-        context "when Chef::Config[:encrypted_data_bag_secret] does not exist" do
-          include_examples "no secret file" do
-            before do
-              expect( File ).to receive(:exist?).with(path).and_return(false)
-            end
-
-            let(:path) { "/tmp/my_secret" }
-            let(:error_type) { Errno::ENOENT }
-            let(:error_message) { /file not found/ }
-          end
-        end
-      end
     end
   end
 end