chef 12.2.0.rc.1-x86-mingw32 → 12.2.0.rc.2-x86-mingw32

data/lib/chef/resource/macports_package.rb

@@ -21,6 +21,7 @@ class Chef
     class MacportsPackage < Chef::Resource::Package
 
       provides :macports_package
+      provides :package, os: "darwin"
 
       def initialize(name, run_context=nil)
         super

data/lib/chef/version.rb

@@ -17,7 +17,7 @@
 
 class Chef
   CHEF_ROOT = File.dirname(File.expand_path(File.dirname(__FILE__)))
-  VERSION = '12.2.0.rc.1'
+  VERSION = '12.2.0.rc.2'
 end
 
 #

data/spec/functional/resource/deploy_revision_spec.rb

@@ -201,41 +201,6 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       end
     end
 
-    describe "setting default parameters to nil" do
-      before do
-        FileUtils.mkdir_p(rel_path("releases"))
-        FileUtils.mkdir_p(rel_path("shared"))
-      end
-
-      it "supports setting symlink_before_migrate to nil" do
-        deploy_to_latest_rev.symlink_before_migrate(nil)
-        expect(deploy_to_latest_rev.symlink_before_migrate).to eql(nil)
-        deploy_to_latest_rev.run_action(:deploy)
-        expect(deploy_to_latest_rev).to be_updated_by_last_action
-      end
-
-      it "supports setting symlinks to nil" do
-        deploy_to_latest_rev.symlinks(nil)
-        expect(deploy_to_latest_rev.symlinks).to eql(nil)
-        deploy_to_latest_rev.run_action(:deploy)
-        expect(deploy_to_latest_rev).to be_updated_by_last_action
-      end
-
-      it "supports setting purge_before_symlink to nil" do
-        deploy_to_latest_rev.purge_before_symlink(nil)
-        expect(deploy_to_latest_rev.purge_before_symlink).to eql(nil)
-        deploy_to_latest_rev.run_action(:deploy)
-        expect(deploy_to_latest_rev).to be_updated_by_last_action
-      end
-
-      it "supports setting create_dirs_before_symlink to nil" do
-        deploy_to_latest_rev.create_dirs_before_symlink(nil)
-        expect(deploy_to_latest_rev.create_dirs_before_symlink).to eql(nil)
-        deploy_to_latest_rev.run_action(:deploy)
-        expect(deploy_to_latest_rev).to be_updated_by_last_action
-      end
-    end
-
     describe "back to a previously deployed revision, with the directory structure precreated" do
       before do
         FileUtils.mkdir_p(rel_path("releases"))

data/spec/unit/cookbook/file_vendor_spec.rb

@@ -21,9 +21,6 @@ describe Chef::Cookbook::FileVendor do
 
   let(:file_vendor_class) { Class.new(described_class) }
 
-  # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
-  let(:manifest) { {:cookbook_name => "bob"} }
-
   context "when configured to fetch files over http" do
 
     let(:http) { double("Chef::REST") }
@@ -40,19 +37,42 @@ describe Chef::Cookbook::FileVendor do
       expect(file_vendor_class.initialization_options).to eq(http)
     end
 
-    it "creates a RemoteFileVendor for a given manifest" do
-      file_vendor = file_vendor_class.create_from_manifest(manifest)
-      expect(file_vendor).to be_a_kind_of(Chef::Cookbook::RemoteFileVendor)
-      expect(file_vendor.rest).to eq(http)
-      expect(file_vendor.cookbook_name).to eq("bob")
+    context "with a manifest from a cookbook version" do
+
+      # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
+      let(:manifest) { {:cookbook_name => "bob", :name => "bob-1.2.3"} }
+
+      it "creates a RemoteFileVendor for a given manifest" do
+        file_vendor = file_vendor_class.create_from_manifest(manifest)
+        expect(file_vendor).to be_a_kind_of(Chef::Cookbook::RemoteFileVendor)
+        expect(file_vendor.rest).to eq(http)
+        expect(file_vendor.cookbook_name).to eq("bob")
+      end
+
     end
 
+    context "with a manifest from a cookbook artifact" do
+
+      # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
+      let(:manifest) { {:name => "bob"} }
+
+      it "creates a RemoteFileVendor for a given manifest" do
+        file_vendor = file_vendor_class.create_from_manifest(manifest)
+        expect(file_vendor).to be_a_kind_of(Chef::Cookbook::RemoteFileVendor)
+        expect(file_vendor.rest).to eq(http)
+        expect(file_vendor.cookbook_name).to eq("bob")
+      end
+
+    end
   end
 
   context "when configured to load files from disk" do
 
     let(:cookbook_path) { %w[/var/chef/cookbooks /var/chef/other_cookbooks] }
 
+    # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
+    let(:manifest) { {:cookbook_name => "bob"} }
+
     before do
       file_vendor_class.fetch_from_disk(cookbook_path)
     end

data/spec/unit/cookbook_manifest_spec.rb

@@ -24,6 +24,8 @@ describe Chef::CookbookManifest do
 
   let(:version) { "1.2.3" }
 
+  let(:identifier) { "9e10455ce2b4a4e29424b7064b1d67a1a25c9d3b" }
+
   let(:metadata) do
     Chef::Cookbook::Metadata.new.tap do |m|
       m.version(version)
@@ -35,6 +37,7 @@ describe Chef::CookbookManifest do
   let(:cookbook_version) do
     Chef::CookbookVersion.new("tatft", cookbook_root).tap do |c|
       c.metadata = metadata
+      c.identifier = identifier
     end
   end
 
@@ -212,12 +215,26 @@ describe Chef::CookbookManifest do
 
       let(:policy_mode) { true }
 
+      let(:cookbook_manifest_hash) { cookbook_manifest.to_hash }
+
+      it "sets the identifier in the manifest data" do
+        expect(cookbook_manifest_hash["identifier"]).to eq("9e10455ce2b4a4e29424b7064b1d67a1a25c9d3b")
+      end
+
+      it "sets the name to just the name" do
+        expect(cookbook_manifest_hash["name"]).to eq("tatft")
+      end
+
+      it "does not set a 'cookbook_name' field" do
+        expect(cookbook_manifest_hash).to_not have_key("cookbook_name")
+      end
+
       it "gives the save URL" do
-        expect(cookbook_manifest.save_url).to eq("cookbook_artifacts/tatft/1.2.3")
+        expect(cookbook_manifest.save_url).to eq("cookbook_artifacts/tatft/9e10455ce2b4a4e29424b7064b1d67a1a25c9d3b")
       end
 
       it "gives the force save URL" do
-        expect(cookbook_manifest.force_save_url).to eq("cookbook_artifacts/tatft/1.2.3?force=true")
+        expect(cookbook_manifest.force_save_url).to eq("cookbook_artifacts/tatft/9e10455ce2b4a4e29424b7064b1d67a1a25c9d3b?force=true")
       end
 
     end

data/spec/unit/cookbook_uploader_spec.rb

@@ -25,11 +25,17 @@ describe Chef::CookbookUploader do
   let(:cookbook_loader) do
     loader = Chef::CookbookLoader.new(File.join(CHEF_SPEC_DATA, "cookbooks"))
     loader.load_cookbooks
+    loader.cookbooks_by_name["apache2"].identifier = apache2_identifier
+    loader.cookbooks_by_name["java"].identifier = java_identifier
     loader
   end
 
+  let(:apache2_identifier) { "6644e6cb2ade90b8aff2ebb44728958fbc939ebf" }
+
   let(:apache2_cookbook) { cookbook_loader.cookbooks_by_name["apache2"] }
 
+  let(:java_identifier) { "edd40c30c4e0ebb3658abde4620597597d2e9c17" }
+
   let(:java_cookbook) { cookbook_loader.cookbooks_by_name["java"] }
 
   let(:cookbooks_to_upload) { [apache2_cookbook, java_cookbook] }
@@ -175,7 +181,7 @@ describe Chef::CookbookUploader do
       let(:policy_mode) { true }
 
       def expected_save_url(cookbook)
-        "cookbook_artifacts/#{cookbook.name}/#{cookbook.version}"
+        "cookbook_artifacts/#{cookbook.name}/#{cookbook.identifier}"
       end
 
       it "uploads all files in a sandbox transaction, then creates cookbooks on the server using cookbook_artifacts API" do

data/spec/unit/mixin/params_validate_spec.rb

@@ -339,83 +339,69 @@ describe Chef::Mixin::ParamsValidate do
     end.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 
-  def self.test_set_or_return_method(method)
-    # caller is responsible for passing in the right arg to get 'return' behavior
-    return_arg = method == :nillable_set_or_return ? TinyClass::NULL_ARG : nil
-
-    it "#{method} should set and return a value, then return the same value" do
-      value = "meow"
-      expect(@vo.send(method,:test, value, {}).object_id).to eq(value.object_id)
-      expect(@vo.send(method,:test, return_arg, {}).object_id).to eq(value.object_id)
-    end
-
-    it "#{method} should set and return a default value when the argument is nil, then return the same value" do
-      value = "meow"
-      expect(@vo.send(method,:test, return_arg, { :default => value }).object_id).to eq(value.object_id)
-      expect(@vo.send(method,:test, return_arg, {}).object_id).to eq(value.object_id)
-    end
-
-    it "#{method} should raise an ArgumentError when argument is nil and required is true" do
-      expect {
-        @vo.send(method,:test, return_arg, { :required => true })
-      }.to raise_error(ArgumentError)
-    end
-
-    it "#{method} should not raise an error when argument is nil and required is false" do
-      expect {
-        @vo.send(method,:test, return_arg, { :required => false })
-      }.not_to raise_error
-    end
-
-    it "#{method} should set and return @name, then return @name for foo when argument is nil" do
-      value = "meow"
-      expect(@vo.send(method,:name, value, { }).object_id).to eq(value.object_id)
-      expect(@vo.send(method,:foo, return_arg, { :name_attribute => true }).object_id).to eq(value.object_id)
-    end
-
-    it "#{method} should allow DelayedEvaluator instance to be set for value regardless of restriction" do
-      value = Chef::DelayedEvaluator.new{ 'test' }
-      @vo.send(method,:test, value, {:kind_of => Numeric})
-    end
-
-    it "#{method} should raise an error when delayed evaluated attribute is not valid" do
-      value = Chef::DelayedEvaluator.new{ 'test' }
-      @vo.send(method,:test, value, {:kind_of => Numeric})
-      expect do
-        @vo.send(method,:test, return_arg, {:kind_of => Numeric})
-      end.to raise_error(Chef::Exceptions::ValidationFailed)
-    end
-
-    it "#{method} should create DelayedEvaluator instance when #lazy is used" do
-      @vo.send(method,:delayed, @vo.lazy{ 'test' }, {})
-      expect(@vo.instance_variable_get(:@delayed)).to be_a(Chef::DelayedEvaluator)
-    end
-
-    it "#{method} should execute block on each call when DelayedEvaluator" do
-      value = 'fubar'
-      @vo.send(method,:test, @vo.lazy{ value }, {})
-      expect(@vo.send(method,:test, return_arg, {})).to eq('fubar')
-      value = 'foobar'
-      expect(@vo.send(method,:test, return_arg, {})).to eq('foobar')
-      value = 'fauxbar'
-      expect(@vo.send(method,:test, return_arg, {})).to eq('fauxbar')
-    end
-
-    it "#{method} should not evaluate non DelayedEvaluator instances" do
-      value = lambda{ 'test' }
-      @vo.send(method,:test, value, {})
-      expect(@vo.send(method,:test, return_arg, {}).object_id).to eq(value.object_id)
-      expect(@vo.send(method,:test, return_arg, {})).to be_a(Proc)
-    end
+  it "should set and return a value, then return the same value" do
+    value = "meow"
+    expect(@vo.set_or_return(:test, value, {}).object_id).to eq(value.object_id)
+    expect(@vo.set_or_return(:test, nil, {}).object_id).to eq(value.object_id)
   end
 
-  test_set_or_return_method(:set_or_return)
-  test_set_or_return_method(:nillable_set_or_return)
+  it "should set and return a default value when the argument is nil, then return the same value" do
+    value = "meow"
+    expect(@vo.set_or_return(:test, nil, { :default => value }).object_id).to eq(value.object_id)
+    expect(@vo.set_or_return(:test, nil, {}).object_id).to eq(value.object_id)
+  end
+
+  it "should raise an ArgumentError when argument is nil and required is true" do
+    expect {
+      @vo.set_or_return(:test, nil, { :required => true })
+    }.to raise_error(ArgumentError)
+  end
+
+  it "should not raise an error when argument is nil and required is false" do
+    expect {
+      @vo.set_or_return(:test, nil, { :required => false })
+    }.not_to raise_error
+  end
+
+  it "should set and return @name, then return @name for foo when argument is nil" do
+    value = "meow"
+    expect(@vo.set_or_return(:name, value, { }).object_id).to eq(value.object_id)
+    expect(@vo.set_or_return(:foo, nil, { :name_attribute => true }).object_id).to eq(value.object_id)
+  end
 
-  it "nillable_set_or_return supports nilling values" do
-    expect(@vo.nillable_set_or_return(:test, "meow", {})).to eq("meow")
-    expect(@vo.nillable_set_or_return(:test, TinyClass::NULL_ARG, {})).to eq("meow")
-    expect(@vo.nillable_set_or_return(:test, nil, {})).to be_nil
-    expect(@vo.nillable_set_or_return(:test, TinyClass::NULL_ARG, {})).to be_nil
+  it "should allow DelayedEvaluator instance to be set for value regardless of restriction" do
+    value = Chef::DelayedEvaluator.new{ 'test' }
+    @vo.set_or_return(:test, value, {:kind_of => Numeric})
   end
+
+  it "should raise an error when delayed evaluated attribute is not valid" do
+    value = Chef::DelayedEvaluator.new{ 'test' }
+    @vo.set_or_return(:test, value, {:kind_of => Numeric})
+    expect do
+      @vo.set_or_return(:test, nil, {:kind_of => Numeric})
+    end.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "should create DelayedEvaluator instance when #lazy is used" do
+    @vo.set_or_return(:delayed, @vo.lazy{ 'test' }, {})
+    expect(@vo.instance_variable_get(:@delayed)).to be_a(Chef::DelayedEvaluator)
+  end
+
+  it "should execute block on each call when DelayedEvaluator" do
+    value = 'fubar'
+    @vo.set_or_return(:test, @vo.lazy{ value }, {})
+    expect(@vo.set_or_return(:test, nil, {})).to eq('fubar')
+    value = 'foobar'
+    expect(@vo.set_or_return(:test, nil, {})).to eq('foobar')
+    value = 'fauxbar'
+    expect(@vo.set_or_return(:test, nil, {})).to eq('fauxbar')
+  end
+
+  it "should not evaluate non DelayedEvaluator instances" do
+    value = lambda{ 'test' }
+    @vo.set_or_return(:test, value, {})
+    expect(@vo.set_or_return(:test, nil, {}).object_id).to eq(value.object_id)
+    expect(@vo.set_or_return(:test, nil, {})).to be_a(Proc)
+  end
+
 end

data/spec/unit/policy_builder/policyfile_spec.rb

@@ -256,7 +256,7 @@ describe Chef::PolicyBuilder::Policyfile do
 
       context "and policy_name and policy_group are configured" do
 
-        let(:policy_relative_url) { "policies/policy-stage/example" }
+        let(:policy_relative_url) { "policy_groups/policy-stage/policies/example" }
 
         before do
           expect(http_api).to receive(:get).with(policy_relative_url).and_return(parsed_policyfile_json)
@@ -386,6 +386,9 @@ describe Chef::PolicyBuilder::Policyfile do
 
       describe "fetching the desired cookbook set" do
 
+        let(:example1_cookbook_data) { double("CookbookVersion Hash for example1 cookbook") }
+        let(:example2_cookbook_data) { double("CookbookVersion Hash for example2 cookbook") }
+
         let(:example1_cookbook_object) { double("Chef::CookbookVersion for example1 cookbook") }
         let(:example2_cookbook_object) { double("Chef::CookbookVersion for example2 cookbook") }
 
@@ -396,9 +399,12 @@ describe Chef::PolicyBuilder::Policyfile do
         let(:example1_xyz_version) { example1_lock_data["dotted_decimal_identifier"] }
         let(:example2_xyz_version) { example2_lock_data["dotted_decimal_identifier"] }
 
+        let(:example1_identifier) { example1_lock_data["identifier"] }
+        let(:example2_identifier) { example2_lock_data["identifier"] }
+
         let(:cookbook_synchronizer) { double("Chef::CookbookSynchronizer") }
 
-        shared_examples_for "fetching cookbooks" do
+        shared_examples "fetching cookbooks when they don't exist" do
           context "and a cookbook is missing" do
 
             let(:error404) { Net::HTTPServerException.new("404 message", :body) }
@@ -418,7 +424,9 @@ describe Chef::PolicyBuilder::Policyfile do
             end
 
           end
+        end
 
+        shared_examples_for "fetching cookbooks when they exist" do
           context "and the cookbooks can be fetched" do
             before do
               expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
@@ -426,11 +434,6 @@ describe Chef::PolicyBuilder::Policyfile do
               policy_builder.load_node
               policy_builder.build_node
 
-              expect(http_api).to receive(:get).with(cookbook1_url).
-                and_return(example1_cookbook_object)
-              expect(http_api).to receive(:get).with(cookbook2_url).
-                and_return(example2_cookbook_object)
-
               allow(Chef::CookbookSynchronizer).to receive(:new).
                 with(expected_cookbook_hash, events).
                 and_return(cookbook_synchronizer)
@@ -457,11 +460,23 @@ describe Chef::PolicyBuilder::Policyfile do
         end # shared_examples_for "fetching cookbooks"
 
         context "when using compatibility mode (policy_document_native_api == false)" do
-          include_examples "fetching cookbooks" do
+          let(:cookbook1_url) { "cookbooks/example1/#{example1_xyz_version}" }
+          let(:cookbook2_url) { "cookbooks/example2/#{example2_xyz_version}" }
 
-            let(:cookbook1_url) { "cookbooks/example1/#{example1_xyz_version}" }
-            let(:cookbook2_url) { "cookbooks/example2/#{example2_xyz_version}" }
+          context "when the cookbooks don't exist on the server" do
+            include_examples "fetching cookbooks when they don't exist"
+          end
+
+          context "when the cookbooks exist on the server" do
+
+            before do
+              expect(http_api).to receive(:get).with(cookbook1_url).
+                and_return(example1_cookbook_object)
+              expect(http_api).to receive(:get).with(cookbook2_url).
+                and_return(example2_cookbook_object)
+            end
 
+            include_examples "fetching cookbooks when they exist"
           end
 
         end
@@ -474,13 +489,33 @@ describe Chef::PolicyBuilder::Policyfile do
             Chef::Config[:policy_name] = "example"
           end
 
-          include_examples "fetching cookbooks" do
+          let(:cookbook1_url) { "cookbook_artifacts/example1/#{example1_identifier}" }
+          let(:cookbook2_url) { "cookbook_artifacts/example2/#{example2_identifier}" }
+
+          context "when the cookbooks don't exist on the server" do
+            include_examples "fetching cookbooks when they don't exist"
+          end
+
 
-            let(:cookbook1_url) { "cookbook_artifacts/example1/#{example1_xyz_version}" }
-            let(:cookbook2_url) { "cookbook_artifacts/example2/#{example2_xyz_version}" }
+          context "when the cookbooks exist on the server" do
+
+            before do
+              expect(http_api).to receive(:get).with(cookbook1_url).
+                and_return(example1_cookbook_data)
+              expect(http_api).to receive(:get).with(cookbook2_url).
+                and_return(example2_cookbook_data)
+
+              expect(Chef::CookbookVersion).to receive(:from_cb_artifact_data).with(example1_cookbook_data).
+                and_return(example1_cookbook_object)
+              expect(Chef::CookbookVersion).to receive(:from_cb_artifact_data).with(example2_cookbook_data).
+                and_return(example2_cookbook_object)
+            end
+
+            include_examples "fetching cookbooks when they exist"
 
           end
 
+
         end
 
       end