chef 16.18.30 → 17.10.163

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
 
@@ -325,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
@@ -351,9 +339,9 @@ describe Chef::PolicyBuilder::Policyfile do
           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
@@ -401,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
@@ -583,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
@@ -670,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
@@ -836,6 +833,7 @@ describe Chef::PolicyBuilder::Policyfile do
             end
 
             include_examples "fetching cookbooks when they exist"
+
           end
         end
 
@@ -873,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

data/spec/unit/property_spec.rb

@@ -541,13 +541,16 @@ describe "Chef::Resource.property" do
         it "when x is not set, it returns ''" do
           expect(resource.x).to eq ""
         end
-        it "x is immutable" do
-          expect { resource.x << "foo" }.to raise_error(FrozenError, /can't modify frozen String/)
+        it "setting x does not mutate the default" do
+          expect(resource.x).to eq ""
+          resource.x << "foo"
+          expect(resource.x).to eq "foo"
+          expect(resource_class.new("other").x).to eq ""
         end
       end
 
       with_property ":x, default: lazy { '' }" do
-        it "x is immutable" do
+        it "setting x does not mutate the default" do
           expect(resource.x).to eq ""
           resource.x << "foo"
           expect(resource.x).to eq "foo"
@@ -561,16 +564,14 @@ describe "Chef::Resource.property" do
         it "when x is not set, it returns {}" do
           expect(resource.x).to eq({})
         end
-        it "x is immutable" do
-          expect { resource.x["foo"] = "bar" }.to raise_error(FrozenError, /can't modify frozen Hash/)
-        end
-        it "The same exact value is returned multiple times in a row" do
-          value = resource.x
-          expect(value).to eq({})
-          expect(resource.x.object_id).to eq(value.object_id)
+        it "setting x does not mutate the default" do
+          expect(resource.x).to eq({})
+          resource.x["plants"] = "zombies"
+          expect(resource.x).to eq({ "plants" => "zombies" })
+          expect(resource_class.new("other").x).to eq({})
         end
-        it "Multiple instances of x receive the exact same value" do
-          expect(resource.x.object_id).to eq(resource_class.new("blah2").x.object_id)
+        it "Multiple instances of x receive different values" do
+          expect(resource.x.object_id).not_to eq(resource_class.new("blah2").x.object_id)
         end
       end
 
@@ -594,14 +595,14 @@ describe "Chef::Resource.property" do
         it "when x is not set, it returns [{foo: 'bar'}]" do
           expect(resource.x).to eq([{ foo: "bar" }])
         end
-        it "x is immutable" do
-          expect { resource.x << :other }.to raise_error(FrozenError, /can't modify frozen Array/)
-        end
-        it "x.first is immutable" do
-          expect { resource.x.first[:foo] = "other" }.to raise_error(FrozenError, /can't modify frozen Hash/)
+        it "setting x does not mutate the default" do
+          expect(resource.x).to eq([{ foo: "bar" }])
+          resource.x[0][:foo] << "baz"
+          expect(resource.x).to eq([{ foo: "barbaz" }])
+          expect(resource_class.new("other").x).to eq([{ foo: "bar" }])
         end
-        it "x.first[:foo] is immutable" do
-          expect { resource.x.first[:foo] << "other" }.to raise_error(FrozenError, /can't modify frozen String/)
+        it "Multiple instances of x receive different values" do
+          expect(resource.x.object_id).not_to eq(resource_class.new("blah2").x.object_id)
         end
       end
     end
@@ -708,10 +709,10 @@ describe "Chef::Resource.property" do
           expect(resource.x).to eq "hi1"
           expect(Namer.current_index).to eq 1
         end
-        it "when x is retrieved, coercion is run each time" do
+        it "when x is retrieved, coercion is run exactly once" do
           expect(resource.x).to eq "101"
-          expect(resource.x).to eq "102"
-          expect(Namer.current_index).to eq 2
+          expect(resource.x).to eq "101"
+          expect(Namer.current_index).to eq 1
         end
       end
 

data/spec/unit/provider/apt_update_spec.rb

@@ -75,7 +75,9 @@ describe "Chef::Provider::AptUpdate" do
 
   describe "#action_periodic" do
     before do
-      allow(File).to receive(:exist?)
+      allow(File).to receive(:exist?).with(config_file).and_return(true)
+      allow(File).to receive(:exist?).with(config_dir).and_return(true)
+      allow(File).to receive(:exist?).with(stamp_dir).and_return(true)
       allow(File).to receive(:exist?).with(Dir.tmpdir).and_return(true)
       expect(File).to receive(:exist?).with("#{stamp_dir}/update-success-stamp").and_return(true)
     end

data/spec/unit/provider/cron_spec.rb

@@ -392,6 +392,27 @@ describe Chef::Provider::Cron do
         expect(cron.command).to eq("/bin/true")
       end
     end
+
+    context "with a matching entry with a commented crontab line" do
+      it "should set cron_exists" do
+        allow(@provider).to receive(:read_crontab).and_return(<<~CRONTAB)
+          0 2 * * * /some/other/command
+
+          # Chef Name: cronhole some stuff
+          #* * * * * /bin/true
+        CRONTAB
+        cron = @provider.load_current_resource
+        expect(@provider.cron_exists).to eq(true)
+        expect(@provider.cron_empty).to eq(false)
+        expect(cron.minute).to eq("*")
+        expect(cron.hour).to eq("*")
+        expect(cron.day).to eq("*")
+        expect(cron.month).to eq("*")
+        expect(cron.weekday).to eq("*")
+        expect(cron.time).to eq(nil)
+        expect(cron.property_is_set?(:command)).to eq(false)
+      end
+    end
   end
 
   describe "cron_different?" do
@@ -691,6 +712,30 @@ describe Chef::Provider::Cron do
       end
     end
 
+    context "when there is a crontab with a matching section with a commented crontab line in it" do
+      before :each do
+        @provider.cron_exists = true
+      end
+
+      it "should add the crontab to the entry" do
+        allow(@provider).to receive(:read_crontab).and_return(<<~CRONTAB)
+          0 2 * * * /some/other/command
+
+          # Chef Name: cronhole some stuff
+          # * * * * * /bin/true
+        CRONTAB
+        expect(@provider).to receive(:write_crontab).with(<<~ENDCRON)
+          0 2 * * * /some/other/command
+
+          # Chef Name: cronhole some stuff
+          * * * * * /bin/true
+          # * * * * * /bin/true
+        ENDCRON
+        @new_resource.minute "*"
+        @provider.run_action(:create)
+      end
+    end
+
     context "when there is a crontab with a matching and identical section" do
       context "when environment variable is not used" do
         before :each do
@@ -719,7 +764,7 @@ describe Chef::Provider::Cron do
 
         it "should log nothing changed" do
           expect(logger).to receive(:trace).with("Found cron '#{@new_resource.name}'")
-          expect(logger).to receive(:trace).with("Skipping existing cron entry '#{@new_resource.name}'")
+          expect(logger).to receive(:debug).with("#{@new_resource}: Skipping existing cron entry")
           @provider.run_action(:create)
         end
       end

data/spec/unit/provider/dsc_script_spec.rb

@@ -39,21 +39,21 @@ describe Chef::Provider::DscScript do
       it "describes the resource as converged if there were 0 DSC resources" do
         allow(provider).to receive(:run_configuration).with(:test).and_return([])
         provider.load_current_resource
-        expect(provider.instance_variable_get("@resource_converged")).to be_truthy
+        expect(provider.instance_variable_get(:@resource_converged)).to be_truthy
       end
 
       it "describes the resource as not converged if there is 1 DSC resources that is converged" do
         dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resource", false, ["nothing will change something"])
         allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
         provider.load_current_resource
-        expect(provider.instance_variable_get("@resource_converged")).to be_truthy
+        expect(provider.instance_variable_get(:@resource_converged)).to be_truthy
       end
 
       it "describes the resource as not converged if there is 1 DSC resources that is not converged" do
         dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resource", true, ["will change something"])
         allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
         provider.load_current_resource
-        expect(provider.instance_variable_get("@resource_converged")).to be_falsey
+        expect(provider.instance_variable_get(:@resource_converged)).to be_falsey
       end
 
       it "describes the resource as not converged if there are any DSC resources that are not converged" do
@@ -62,7 +62,7 @@ describe Chef::Provider::DscScript do
 
         allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
         provider.load_current_resource
-        expect(provider.instance_variable_get("@resource_converged")).to be_falsey
+        expect(provider.instance_variable_get(:@resource_converged)).to be_falsey
       end
 
       it "describes the resource as converged if all DSC resources that are converged" do
@@ -71,7 +71,7 @@ describe Chef::Provider::DscScript do
 
         allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
         provider.load_current_resource
-        expect(provider.instance_variable_get("@resource_converged")).to be_truthy
+        expect(provider.instance_variable_get(:@resource_converged)).to be_truthy
       end
     end
 
@@ -126,19 +126,19 @@ describe Chef::Provider::DscScript do
     describe "#generate_description" do
       it "removes the resource name from the beginning of any log line from the LCM" do
         dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resourcename", true, ["resourcename doing something", "lastline"])
-        provider.instance_variable_set("@dsc_resources_info", [dsc_resource_info])
+        provider.instance_variable_set(:@dsc_resources_info, [dsc_resource_info])
         expect(provider.send(:generate_description)[1]).to match(/converge DSC resource resourcename by doing something/)
       end
 
       it "ignores the last line" do
         dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resourcename", true, ["resourcename doing something", "lastline"])
-        provider.instance_variable_set("@dsc_resources_info", [dsc_resource_info])
+        provider.instance_variable_set(:@dsc_resources_info, [dsc_resource_info])
         expect(provider.send(:generate_description)[1]).not_to match(/lastline/)
       end
 
       it "reports a dsc resource has not been changed if the LCM reported no change was required" do
         dsc_resource_info = Chef::Util::DSC::ResourceInfo.new("resourcename", false, ["resourcename does nothing", "lastline"])
-        provider.instance_variable_set("@dsc_resources_info", [dsc_resource_info])
+        provider.instance_variable_set(:@dsc_resources_info, [dsc_resource_info])
         expect(provider.send(:generate_description)[1]).to match(/converge DSC resource resourcename by doing nothing/)
       end
     end

data/spec/unit/provider/group/gpasswd_spec.rb

@@ -68,7 +68,7 @@ describe Chef::Provider::Group::Gpasswd, "modify_group_members" do
       end
 
       it "logs a message and sets group's members to 'none'" do
-        expect(logger).to receive(:trace).with("group[wheel] setting group members to: none")
+        expect(logger).to receive(:debug).with("group[wheel] setting group members to: none")
         expect(@provider).to receive(:shell_out_compacted!).with("gpasswd", "-M", "", "wheel")
         @provider.modify_group_members
       end
@@ -88,7 +88,7 @@ describe Chef::Provider::Group::Gpasswd, "modify_group_members" do
 
     describe "when the resource specifies group members" do
       it "should log an appropriate debug message" do
-        expect(logger).to receive(:trace).with("group[wheel] setting group members to: lobster, rage, fist")
+        expect(logger).to receive(:debug).with("group[wheel] setting group members to: lobster, rage, fist")
         allow(@provider).to receive(:shell_out_compacted!)
         @provider.modify_group_members
       end

data/spec/unit/provider/group/groupadd_spec.rb

@@ -169,6 +169,7 @@ describe Chef::Provider::Group::Groupadd do
 
     before do
       allow(File).to receive(:exist?).and_return(false)
+      provider.action = :modify
       provider.define_resource_requirements
     end
 

data/spec/unit/provider/group/groupmod_spec.rb

@@ -64,7 +64,7 @@ describe Chef::Provider::Group::Groupmod do
         end
 
         it "logs a message and sets group's members to 'none', then removes existing group members" do
-          expect(logger).to receive(:trace).with("group[wheel] setting group members to: none")
+          expect(logger).to receive(:debug).with("group[wheel] setting group members to: none")
           expect(@provider).to receive(:shell_out_compacted!).with("group", "mod", "-n", "wheel_bak", "wheel")
           expect(@provider).to receive(:shell_out_compacted!).with("group", "add", "-g", "123", "-o", "wheel")
           expect(@provider).to receive(:shell_out_compacted!).with("group", "del", "wheel_bak")
@@ -79,7 +79,7 @@ describe Chef::Provider::Group::Groupmod do
         end
 
         it "logs a message and does not modify group membership" do
-          expect(logger).to receive(:trace).with("group[wheel] not changing group members, the group has no members to add")
+          expect(logger).to receive(:debug).with("group[wheel] not changing group members, the group has no members to add")
           expect(@provider).not_to receive(:shell_out_compacted!)
           @provider.manage_group
         end

data/spec/unit/provider/group/pw_spec.rb

@@ -96,7 +96,7 @@ describe Chef::Provider::Group::Pw do
       end
 
       it "should log an appropriate message" do
-        expect(logger).to receive(:trace).with("group[wheel] removing group members: all,your,base")
+        expect(logger).to receive(:debug).with("group[wheel] removing group members: all,your,base")
         @provider.set_members_options
       end
 
@@ -112,7 +112,7 @@ describe Chef::Provider::Group::Pw do
       end
 
       it "should log an appropriate debug message" do
-        expect(logger).to receive(:trace).with("group[wheel] adding group members: all,your,base")
+        expect(logger).to receive(:debug).with("group[wheel] adding group members: all,your,base")
         @provider.set_members_options
       end
 

data/spec/unit/provider/group/usermod_spec.rb

@@ -58,18 +58,18 @@ describe Chef::Provider::Group::Usermod do
       end
 
       it "should raise an error when setting the entire group directly" do
+        @provider.action = :modify
         @provider.define_resource_requirements
         @provider.load_current_resource
-        @provider.instance_variable_set("@group_exists", true)
-        @provider.action = :modify
+        @provider.instance_variable_set(:@group_exists, true)
         expect { @provider.run_action(@provider.process_resource_requirements) }.to raise_error(Chef::Exceptions::Group, "setting group members directly is not supported by #{@provider}, must set append true in group")
       end
 
       it "should raise an error when excluded_members are set" do
+        @provider.action = :modify
         @provider.define_resource_requirements
         @provider.load_current_resource
-        @provider.instance_variable_set("@group_exists", true)
-        @provider.action = :modify
+        @provider.instance_variable_set(:@group_exists, true)
         @new_resource.append(true)
         @new_resource.excluded_members(["someone"])
         expect { @provider.run_action(@provider.process_resource_requirements) }.to raise_error(Chef::Exceptions::Group, "excluded_members is not supported by #{@provider}")

data/spec/unit/provider/group_spec.rb

@@ -119,7 +119,7 @@ describe Chef::Provider::User do
     end
 
     it "should return true if the append is true and excluded_members include an existing user" do
-      @new_resource.members.each { |m| @new_resource.excluded_members << m }
+      @new_resource.excluded_members += @new_resource.members
       @new_resource.members.clear
       @new_resource.append(true)
       expect(@provider.compare_group).to be_truthy