chef 16.13.16-universal-mingw32 → 17.3.48-universal-mingw32

data/spec/unit/lwrp_spec.rb

@@ -576,7 +576,7 @@ describe "LWRP" do
       @tmpdir = File.join(@tmpparent, "lwrp")
       Dir.mkdir(@tmpdir)
       resource_path = File.join(@tmpdir, "once.rb")
-      IO.write(resource_path, "default_action :create")
+      IO.write(resource_path, "unified_mode true\ndefault_action :create")
       @test_lwrp_class = Chef::Resource::LWRPBase.build_from_file("lwrp", resource_path, nil)
     end
 

data/spec/unit/mixin/params_validate_spec.rb

@@ -359,10 +359,11 @@ describe Chef::Mixin::ParamsValidate do
     expect(@vo.set_or_return(:test, nil, {}).object_id).to eq(value.object_id)
   end
 
-  it "should set and return a default value when the argument is nil, then return the same value" do
+  it "should set and return a default value when the argument is nil, then return a dup of the 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)
+    expect(@vo.set_or_return(:test, nil, { default: value }).object_id).not_to eq(value.object_id)
+    expect(@vo.set_or_return(:test, nil, {}).object_id).not_to eq(value.object_id)
+    expect(@vo.set_or_return(:test, nil, {})).to eql(value)
   end
 
   it "should raise an ArgumentError when argument is nil and required is true" do

data/spec/unit/node/attribute_spec.rb

@@ -898,7 +898,7 @@ describe Chef::Node::Attribute do
     end
   end
 
-  describe "index" do
+  describe "index", ruby: "< 3.0.0" do
     # Hash#index is deprecated and triggers warnings.
     def silence
       old_verbose = $VERBOSE

data/spec/unit/node_spec.rb

@@ -1951,4 +1951,82 @@ describe Chef::Node do
       expect(node["foo"]["bar"]["test"]).to eql("right")
     end
   end
+
+  describe "lazy values" do
+    it "supports lazy values in attributes" do
+      node.instance_eval do
+        default["foo"]["bar"] = lazy { node["fizz"]["buzz"] }
+        default["fizz"]["buzz"] = "works"
+      end
+      expect(node["foo"]["bar"]).to eql("works")
+    end
+
+    it "lazy values maintain laziness" do
+      node.instance_eval do
+        default["foo"]["bar"] = lazy { node["fizz"]["buzz"] }
+        default["fizz"]["buzz"] = "works"
+      end
+      expect(node["foo"]["bar"]).to eql("works")
+      node.default["fizz"]["buzz"] = "still works"
+      expect(node["foo"]["bar"]).to eql("still works")
+    end
+
+    it "supports recursive lazy values in attributes" do
+      node.instance_eval do
+        default["cool"]["beans"] = lazy { node["foo"]["bar"] }
+        default["foo"]["bar"] = lazy { node["fizz"]["buzz"] }
+        default["fizz"]["buzz"] = "works"
+      end
+      expect(node["cool"]["beans"]).to eql("works")
+      node.default["fizz"]["buzz"] = "still works"
+      expect(node["cool"]["beans"]).to eql("still works")
+    end
+
+    it "supports top level lazy values in attributes" do
+      # due to the top level deep merge cache these are special cases
+      node.instance_eval do
+        default["cool"] = lazy { node["foo"] }
+        default["foo"] = lazy { node["fizz"] }
+        default["fizz"] = "works"
+      end
+      expect(node["cool"]).to eql("works")
+      node.default["fizz"] = "still works"
+      expect(node["cool"]).to eql("still works")
+    end
+
+    it "supports deep merged values in attributes" do
+      node.instance_eval do
+        override["bar"]["cool"] = lazy { node["bar"]["foo"] }
+        override["bar"]["foo"] = lazy { node["bar"]["fizz"] }
+        override["bar"]["fizz"] = "works"
+      end
+      expect(node["bar"]["cool"]).to eql("works")
+      node.override["bar"]["fizz"] = "still works"
+      expect(node["bar"]["cool"]).to eql("still works")
+    end
+
+    it "supports overridden deep merged values in attributes (deep_merge)" do
+      node.instance_eval do
+        role_override["bar"] = { "cool" => "bad", "foo" => "bad", "fizz" => "bad" }
+        force_override["bar"]["cool"] = lazy { node["bar"]["foo"] }
+        force_override["bar"]["foo"] = lazy { node["bar"]["fizz"] }
+        force_override["bar"]["fizz"] = "works"
+      end
+      expect(node["bar"]["cool"]).to eql("works")
+      node.force_override["bar"]["fizz"] = "still works"
+      expect(node["bar"]["cool"]).to eql("still works")
+    end
+
+    it "supports overridden deep merged values in attributes (hash_only_merge)" do
+      node.instance_eval do
+        default["bar"] = { "cool" => "bad", "foo" => "bad", "fizz" => "bad" }
+        override["bar"]["cool"] = lazy { node["bar"]["foo"] }
+        override["bar"]["foo"] = lazy { node["bar"]["fizz"] }
+        override["bar"]["fizz"] = "works"
+      end
+      expect(node["bar"]["cool"]).to eql("works")
+      node.override["bar"]["fizz"] = "still works"
+      expect(node["bar"]["cool"]).to eql("still works")
+    end
+  end
 end

data/spec/unit/org_group_spec.rb

@@ -0,0 +1,45 @@
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+require "chef/org"
+
+describe Chef::Org do
+  let(:org) { Chef::Org.new("myorg") }
+
+  describe "API Interactions" do
+    before(:each) do
+      Chef::Config[:chef_server_root] = "http://www.example.com"
+      @rest = double("rest")
+      allow(Chef::ServerAPI).to receive(:new).and_return(@rest)
+    end
+
+    describe "group" do
+      it "should load group data when it's not loaded." do
+        expect(@rest).to receive(:get_rest).with("organizations/myorg/groups/admins").and_return({})
+        org.group("admins")
+      end
+
+      it "should not load group data a second time when it's already loaded." do
+        expect(@rest).to receive(:get_rest)
+          .with("organizations/myorg/groups/admins")
+          .and_return({ anything: "goes" })
+          .exactly(:once)
+        admin1 = org.group("admins")
+        admin2 = org.group("admins")
+        expect(admin1).to eq admin2
+      end
+    end
+  end
+end

data/spec/unit/policy_builder/dynamic_spec.rb

@@ -55,11 +55,6 @@ describe Chef::PolicyBuilder::Dynamic do
         expect(policy_builder).to respond_to(:load_node)
       end
 
-      it "forwards #original_runlist" do
-        expect(implementation).to receive(:original_runlist)
-        policy_builder.original_runlist
-      end
-
       it "forwards #run_context" do
         expect(implementation).to receive(:run_context)
         policy_builder.run_context

data/spec/unit/policy_builder/policyfile_spec.rb

@@ -72,40 +72,40 @@ describe Chef::PolicyBuilder::Policyfile do
 
   let(:policyfile_default_attributes) do
     {
-        "policyfile_default_attr" => "policyfile_default_value",
-        "top_level_attr" => "hat",
-        "baseline_attr" => {
-          "one" => 1,
-          "two" => 2,
-          "deep" => {
-              "three" => 3,
-              "four" => [4],
-              "five" => [5],
-          },
+      "policyfile_default_attr" => "policyfile_default_value",
+      "top_level_attr" => "hat",
+      "baseline_attr" => {
+        "one" => 1,
+        "two" => 2,
+        "deep" => {
+          "three" => 3,
+          "four" => [4],
+          "five" => [5],
         },
-        "policy_group_value" => {
-          "baseline_attr" => {
-            "one" => 111,
-          },
+      },
+      "policy_group_value" => {
+        "baseline_attr" => {
+          "one" => 111,
         },
-      }
+      },
+    }
   end
 
   let(:policyfile_override_attributes) do
     {
-       "policyfile_override_attr" => "policyfile_override_value",
-       "baseline_attr" => {
-         "deep" => {
-           "three" => 333 },
-       },
-       "policy_group_value" => {
-         "top_level_attr" => "cat",
-         "baseline_attr" => {
-           "deep" => {
-             "four" => [444],
-           },
-         },
-       },
+      "policyfile_override_attr" => "policyfile_override_value",
+      "baseline_attr" => {
+        "deep" => {
+          "three" => 333 },
+      },
+      "policy_group_value" => {
+        "top_level_attr" => "cat",
+        "baseline_attr" => {
+          "deep" => {
+            "four" => [444],
+          },
+        },
+      },
     }
   end
 
@@ -146,10 +146,6 @@ describe Chef::PolicyBuilder::Policyfile do
       Chef::PolicyBuilder::Policyfile.new(node_name, ohai_data, json_attribs, override_runlist, events)
     end
 
-    it "always gives `false` for #temporary_policy?" do
-      expect(initialize_pb.temporary_policy?).to be_falsey
-    end
-
     context "chef-solo" do
       before { Chef::Config[:solo_legacy_mode] = true }
 
@@ -161,16 +157,8 @@ describe Chef::PolicyBuilder::Policyfile do
     context "when given an override run_list" do
       let(:override_runlist) { "recipe[foo],recipe[bar]" }
 
-      it "errors on create" do
-        expect { initialize_pb }.to raise_error(err_namespace::UnsupportedFeature)
-      end
-    end
-
-    context "when json_attribs contains a run_list" do
-      let(:json_attribs) { { "run_list" => [] } }
-
-      it "errors on create" do
-        expect { initialize_pb }.to raise_error(err_namespace::UnsupportedFeature)
+      it "does not error" do
+        expect { initialize_pb }.not_to raise_error
       end
     end
 
@@ -206,7 +194,7 @@ describe Chef::PolicyBuilder::Policyfile do
     end
 
     before do
-      Chef::Config[:policy_document_native_api] = false
+      Chef::Config[:policy_document_native_api] = true
       Chef::Config[:deployment_group] = "example-policy-stage"
       allow(policy_builder).to receive(:api_service).and_return(api_service)
     end
@@ -214,6 +202,8 @@ describe Chef::PolicyBuilder::Policyfile do
     describe "when using compatibility mode (policy_document_native_api == false)" do
 
       before do
+        Chef::Config[:policy_document_native_api] = false
+        Chef::Config[:treat_deprecation_warnings_as_errors] = false
         Chef::Config[:deployment_group] = "example-policy-stage"
       end
 
@@ -323,7 +313,7 @@ describe Chef::PolicyBuilder::Policyfile do
           "example2::server@4.2.0 (feab40e)",
         ]
 
-        expect(policy_builder.run_list_with_versions_for_display).to eq(expected)
+        expect(policy_builder.run_list_with_versions_for_display(policy_builder.run_list)).to eq(expected)
       end
 
       it "generates a RunListExpansion-alike object for feeding to the CookbookCompiler" do
@@ -339,15 +329,19 @@ describe Chef::PolicyBuilder::Policyfile do
       end
 
       describe "validating the Policyfile.lock" do
+        before do
+          Chef::Config[:policy_group] = "policy-stage"
+          Chef::Config[:policy_name] = "example"
+        end
 
         it "errors if the policyfile json contains any non-recipe items" do
           parsed_policyfile_json["run_list"] = ["role[foo]"]
           expect { policy_builder.validate_policyfile }.to raise_error(err_namespace::PolicyfileError)
         end
 
-        it "errors if the policyfile json contains non-fully qualified recipe items" do
+        it "does not error if the policyfile json contains non-fully qualified recipe items" do
           parsed_policyfile_json["run_list"] = ["recipe[foo]"]
-          expect { policy_builder.validate_policyfile }.to raise_error(err_namespace::PolicyfileError)
+          expect { policy_builder.validate_policyfile }.not_to raise_error
         end
 
         it "errors if the policyfile doesn't have a run_list key" do
@@ -395,8 +389,8 @@ describe Chef::PolicyBuilder::Policyfile do
             {
               id: "_policy_node",
               run_list: [
-               { type: "recipe", name: "test::default", skipped: false, version: nil },
-               { type: "recipe", name: "test::other", skipped: false, version: nil },
+                { type: "recipe", name: "test::default", skipped: false, version: nil },
+                { type: "recipe", name: "test::other", skipped: false, version: nil },
               ],
             }
           end
@@ -577,11 +571,9 @@ describe Chef::PolicyBuilder::Policyfile do
               expect(node.automatic_attrs[:policy_name]).to eq("policy_name_from_node_json")
               expect(node.automatic_attrs[:policy_group]).to eq("policy_group_from_node_json")
               expect(node.automatic_attrs[:chef_environment]).to eq("policy_group_from_node_json")
-
             end
 
           end
-
         end
 
         it "resets default and override data" do
@@ -664,18 +656,29 @@ describe Chef::PolicyBuilder::Policyfile do
               expect(policy_builder.run_list).to eq([ "recipe[example1::default]" ])
               expected_expansion = Chef::PolicyBuilder::Policyfile::RunListExpansionIsh.new([ "example1::default" ], [])
               expect(policy_builder.run_list_expansion).to eq(expected_expansion)
-              expect(policy_builder.run_list_with_versions_for_display).to eq(["example1::default@2.3.5 (168d210)"])
+              expect(policy_builder.run_list_with_versions_for_display(policy_builder.run_list)).to eq(["example1::default@2.3.5 (168d210)"])
               expect(node.run_list).to eq([ Chef::RunList::RunListItem.new("recipe[example1::default]") ])
               expect(node[:roles]).to eq( [] )
               expect(node[:recipes]).to eq( ["example1::default"] )
             end
 
-            it "disables the cookbook cache cleaner" do
-              expect(Chef::CookbookCacheCleaner.instance.skip_removal).to be(true)
-            end
+          end
+        end
+
+        context "when an override run_list is given" do
+          let(:override_runlist) { [ "recipe[example2::server]" ] }
 
+          before do
+            policy_builder.build_node
           end
 
+          it "gives `true` for #temporary_policy?" do
+            expect(policy_builder.temporary_policy?).to be true
+          end
+
+          it "returns the override_runlist for the run_list" do
+            expect(policy_builder.run_list).to eql override_runlist
+          end
         end
 
         describe "hoisting attribute values" do
@@ -806,6 +809,10 @@ describe Chef::PolicyBuilder::Policyfile do
         context "when using compatibility mode (policy_document_native_api == false)" do
           let(:cookbook1_url) { "cookbooks/example1/#{example1_xyz_version}" }
           let(:cookbook2_url) { "cookbooks/example2/#{example2_xyz_version}" }
+          before do
+            Chef::Config[:policy_document_native_api] = false
+            Chef::Config[:treat_deprecation_warnings_as_errors] = false
+          end
 
           context "when the cookbooks don't exist on the server" do
             include_examples "fetching cookbooks when they don't exist"
@@ -826,6 +833,7 @@ describe Chef::PolicyBuilder::Policyfile do
             end
 
             include_examples "fetching cookbooks when they exist"
+
           end
         end
 
@@ -863,10 +871,90 @@ describe Chef::PolicyBuilder::Policyfile do
           end
 
         end
+      end
 
+      describe "selecting the run_list" do
+        let(:node) do
+          node = Chef::Node.new
+          node.name(node_name)
+          node
+        end
+
+        before do
+          allow(policy_builder).to receive(:node).and_return(node)
+        end
+
+        context "when json_attribs contains a run_list" do
+          let(:json_attribs) { { "run_list" => [ "recipe[something::default]" ] } }
+
+          it "reads the run_list from the json_attribs" do
+            expect(policy_builder.run_list).to eql(json_attribs["run_list"])
+          end
+
+          it "ignores the node.run_list" do
+            node.run_list.reset!("recipe[incorrect::incorrect]")
+            expect(policy_builder.run_list).to eql(json_attribs["run_list"])
+          end
+
+          it "ignores the node.run_list if the Chef::Config value is set" do
+            Chef::Config[:policy_persist_run_list] = true
+            node.run_list.reset!("recipe[incorrect::incorrect]")
+            expect(policy_builder.run_list).to eql(json_attribs["run_list"])
+          end
+        end
+
+        it "reads the run_list from the policyfile" do
+          expect(policy_builder.run_list).to eql(policyfile_run_list)
+        end
+
+        it "ignores the node.run_list by default" do
+          node.run_list.reset!("recipe[incorrect::incorrect]")
+          expect(policy_builder.run_list).to eql(policyfile_run_list)
+        end
+
+        it "uses the node.run_list if the Chef::Config value is set" do
+          Chef::Config[:policy_persist_run_list] = true
+          node.run_list.reset!("recipe[correct::default]")
+          expect(policy_builder.run_list).to eql(node.run_list)
+        end
+
+        it "does not use an empty node.run_list" do
+          Chef::Config[:policy_persist_run_list] = true
+          node.run_list.reset!
+          expect(policy_builder.run_list).to eql(policyfile_run_list)
+        end
+
+        context "with a valid named_run_list" do
+          let(:parsed_policyfile_json) do
+            basic_valid_policy_data.dup.tap do |p|
+              p["named_run_lists"] = {
+                "deploy-app" => [ "recipe[example1::default]" ],
+              }
+            end
+          end
+
+          it "uses the named_run_list over the policyfile" do
+            Chef::Config[:named_run_list] = "deploy-app"
+            expect(policy_builder.run_list).to eq([ "recipe[example1::default]" ])
+          end
+
+          it "is overridden if the run_list is persistent" do
+            Chef::Config[:named_run_list] = "deploy-app"
+            Chef::Config[:policy_persist_run_list] = true
+            node.run_list.reset!("recipe[correct::default]")
+            expect(policy_builder.run_list).to eql(node.run_list)
+          end
+
+          context "when json_attribs contains a run_list" do
+            let(:json_attribs) { { "run_list" => [ "recipe[something::default]" ] } }
+
+            it "overrides the named_run_list" do
+              expect(policy_builder.run_list).to eql(json_attribs["run_list"])
+            end
+          end
+
+        end
       end
     end
-
   end
-
 end