chef 16.18.30 → 17.10.163

data/spec/unit/mixin/homebrew_user_spec.rb

@@ -47,6 +47,8 @@ describe Chef::Mixin::HomebrewUser do
     let(:user) { nil }
     let(:brew_owner) { 2001 }
     let(:default_brew_path) { "/usr/local/bin/brew" }
+    let(:default_brew_path_arm) { "/opt/homebrew/bin/brew" }
+    let(:default_brew_path_linux) { "/home/linuxbrew/.linuxbrew/bin/brew" }
     let(:stat_double) do
       d = double
       expect(d).to receive(:uid).and_return(brew_owner)
@@ -59,16 +61,38 @@ describe Chef::Mixin::HomebrewUser do
         expect(Etc).to receive(:getpwuid).with(brew_owner).and_return(OpenStruct.new(name: "name"))
       end
 
-      it "returns the owner of the brew executable when it is at a default location" do
-        expect(File).to receive(:exist?).with(default_brew_path).and_return(true)
-        expect(File).to receive(:stat).with(default_brew_path).and_return(stat_double)
+      def false_unless_specific_value(object, method, value)
+        allow(object).to receive(method).and_return(false)
+        allow(object).to receive(method).with(value).and_return(true)
+      end
+
+      it "returns the owner of the brew executable when it is at a default location for x86_64 machines" do
+        false_unless_specific_value(File, :exist?, default_brew_path)
+        false_unless_specific_value(File, :executable?, default_brew_path)
+        allow(File).to receive(:stat).with(default_brew_path).and_return(stat_double)
+        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
+      end
+
+      it "returns the owner of the brew executable when it is at a default location for arm machines" do
+        false_unless_specific_value(File, :exist?, default_brew_path_arm)
+        false_unless_specific_value(File, :executable?, default_brew_path_arm)
+        allow(File).to receive(:stat).with(default_brew_path_arm).and_return(stat_double)
+        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
+      end
+
+      it "returns the owner of the brew executable when it is at a default location for linux machines" do
+        false_unless_specific_value(File, :exist?, default_brew_path_linux)
+        false_unless_specific_value(File, :executable?, default_brew_path_linux)
+        allow(File).to receive(:stat).with(default_brew_path_linux).and_return(stat_double)
         expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
       end
 
       it "returns the owner of the brew executable when it is not at a default location" do
-        expect(File).to receive(:exist?).with(default_brew_path).and_return(false)
+        allow_any_instance_of(ExampleHomebrewUser).to receive(:which).and_return("/foo")
+        false_unless_specific_value(File, :exist?, "/foo")
+        false_unless_specific_value(File, :executable?, "/foo")
         allow(homebrew_user).to receive_message_chain(:shell_out, :stdout, :strip).and_return("/foo")
-        expect(File).to receive(:stat).with("/foo").and_return(stat_double)
+        allow(File).to receive(:stat).with("/foo").and_return(stat_double)
         expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
       end
 
@@ -78,8 +102,7 @@ describe Chef::Mixin::HomebrewUser do
   describe "when the homebrew user is not provided" do
 
     it "raises an error if no executable is found" do
-      expect(File).to receive(:exist?).with(default_brew_path).and_return(false)
-      allow(homebrew_user).to receive_message_chain(:shell_out, :stdout, :strip).and_return("")
+      expect(File).to receive(:exist?).and_return(nil).at_least(:once)
       expect { homebrew_user.find_homebrew_uid(user) }.to raise_error(Chef::Exceptions::CannotDetermineHomebrewOwner)
     end
 

data/spec/unit/mixin/openssl_helper_spec.rb

@@ -92,7 +92,7 @@ describe Chef::Mixin::OpenSSLHelper do
 
     context "When the dhparam.pem file does exist, and does contain a vaild dhparam key" do
       it "returns true" do
-        @dhparam_file.puts(::OpenSSL::PKey::DH.new(256).to_pem) # this is 256 to speed up specs
+        @dhparam_file.puts(::OpenSSL::PKey::DH.new(1024).to_pem)
         @dhparam_file.close
         expect(instance.dhparam_pem_valid?(@dhparam_file.path)).to be_truthy
       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/mixin/powershell_exec_spec.rb

@@ -25,8 +25,8 @@ describe Chef::Mixin::PowershellExec, :windows_only do
 
   describe "#powershell_exec" do
     context "not specifying an interpreter" do
-      it "runs a basic command and returns a ChefPowerShell::PowerShell object" do
-        expect(object.powershell_exec("$PSVersionTable")).to be_kind_of(ChefPowerShell::PowerShell)
+      it "runs a basic command and returns a Chef::PowerShell object" do
+        expect(object.powershell_exec("$PSVersionTable")).to be_kind_of(Chef::PowerShell)
       end
 
       it "uses less than version 6" do
@@ -36,8 +36,8 @@ describe Chef::Mixin::PowershellExec, :windows_only do
     end
 
     context "using pwsh interpreter" do
-      it "runs a basic command and returns a ChefPowerShell::Pwsh object" do
-        expect(object.powershell_exec("$PSVersionTable", :pwsh)).to be_kind_of(ChefPowerShell::Pwsh)
+      it "runs a basic command and returns a Chef::PowerShell object" do
+        expect(object.powershell_exec("$PSVersionTable", :pwsh)).to be_kind_of(Chef::Pwsh)
       end
 
       it "uses greater than version 6" do
@@ -47,8 +47,8 @@ describe Chef::Mixin::PowershellExec, :windows_only do
     end
 
     context "using powershell interpreter" do
-      it "runs a basic command and returns a ChefPowerShell::PowerShell object" do
-        expect(object.powershell_exec("$PSVersionTable", :powershell)).to be_kind_of(ChefPowerShell::PowerShell)
+      it "runs a basic command and returns a Chef::PowerShell object" do
+        expect(object.powershell_exec("$PSVersionTable", :powershell)).to be_kind_of(Chef::PowerShell)
       end
 
       it "uses less than version 6" do
@@ -75,12 +75,12 @@ describe Chef::Mixin::PowershellExec, :windows_only do
   end
 
   describe "#powershell_exec!" do
-    it "runs a basic command and returns a ChefPowerShell::PowerShell object" do
-      expect(object.powershell_exec!("$PSVersionTable")).to be_kind_of(ChefPowerShell::PowerShell)
+    it "runs a basic command and returns a Chef::PowerShell object" do
+      expect(object.powershell_exec!("$PSVersionTable")).to be_kind_of(Chef::PowerShell)
     end
 
     it "raises an error if the command fails" do
-      expect { object.powershell_exec!("this-should-error") }.to raise_error(ChefPowerShell::PowerShellExceptions::PowerShellCommandFailed)
+      expect { object.powershell_exec!("this-should-error") }.to raise_error(Chef::PowerShell::CommandFailed)
     end
 
     it "raises an error if the interpreter is invalid" do

data/spec/unit/mixin/powershell_out_spec.rb

@@ -30,7 +30,7 @@ describe Chef::Mixin::PowershellOut, :windows_only do
     it "runs a command and returns the shell_out object" do
       ret = double("Mixlib::ShellOut")
       expect(object).to receive(:shell_out).with(
-        "powershell.exe #{flags} -Command \"Get-Process\"", {}
+        "powershell.exe #{flags} -Command \"Get-Process\""
       ).and_return(ret)
       expect(object.powershell_out("Get-Process")).to eql(ret)
     end
@@ -75,7 +75,7 @@ describe Chef::Mixin::PowershellOut, :windows_only do
     it "runs a command and returns the shell_out object" do
       mixlib_shellout = double("Mixlib::ShellOut")
       expect(object).to receive(:shell_out).with(
-        "powershell.exe #{flags} -Command \"Get-Process\"", {}
+        "powershell.exe #{flags} -Command \"Get-Process\""
       ).and_return(mixlib_shellout)
       expect(mixlib_shellout).to receive(:error!)
       expect(object.powershell_out!("Get-Process")).to eql(mixlib_shellout)

data/spec/unit/mixin/securable_spec.rb

@@ -53,8 +53,8 @@ describe Chef::Mixin::Securable do
     end
 
     it "should accept group/owner names with spaces and backslashes" do
-      expect { @securable.group 'test\ group' }.not_to raise_error
-      expect { @securable.owner 'test\ group' }.not_to raise_error
+      expect { @securable.group "test\\ group" }.not_to raise_error
+      expect { @securable.owner "test\\ group" }.not_to raise_error
     end
 
     it "should accept group/owner names that are a single character or digit" do
@@ -186,7 +186,7 @@ describe Chef::Mixin::Securable do
     end
 
     it "should not accept a group name or id for group with spaces and multiple backslashes" do
-      expect { @securable.group 'test\ \group' }.to raise_error(ArgumentError)
+      expect { @securable.group "test\\ \\group" }.to raise_error(ArgumentError)
     end
 
     it "should accept a unix file mode in string form as an octal number" do

data/spec/unit/mixin/why_run_spec.rb

@@ -0,0 +1,53 @@
+#
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# 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"
+
+describe Chef::Mixin::WhyRun::ResourceRequirements do
+  class TestResource < Chef::Resource
+    action_class do
+      def define_resource_requirements
+        requirements.assert(:boom) do |a|
+          a.assertion { raise "boom1" }
+          a.failure_message("#{raise "boom2"}")
+          a.whyrun("#{raise "boom3"}")
+        end
+      end
+    end
+
+    action :boom do
+      # nothing
+    end
+
+    action :noboom do
+      # nothing
+    end
+  end
+
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { TestResource.new("name", run_context) }
+
+  it "raises an exception for an action where the assertions raise exceptions" do
+    expect { resource.run_action(:boom) }.to raise_error(StandardError, /boom2/)
+  end
+
+  it "does not raise an exception for an action which has no assertions" do
+    resource.run_action(:noboom)
+  end
+end

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/platform/query_helpers_spec.rb

@@ -18,7 +18,7 @@
 
 require "spec_helper"
 
-describe "Chef::Platform#supports_dsc_invoke_resource?", :windows_only do
+describe "Chef::Platform#supports_dsc_invoke_resource?" do
   it "returns false if powershell is not present" do
     node = Chef::Node.new
     expect(Chef::Platform.supports_dsc_invoke_resource?(node)).to be_falsey
@@ -39,12 +39,12 @@ describe "Chef::Platform#supports_dsc_invoke_resource?", :windows_only do
   end
 end
 
-describe "Chef::Platform#dsc_refresh_mode_disabled?", :windows_only do
+describe "Chef::Platform#dsc_refresh_mode_disabled?" do
   let(:node) { instance_double("Chef::Node") }
-  let(:powershell) { instance_double("ChefPowerShell::PowerShell") }
+  let(:powershell) { instance_double("Chef::PowerShell") }
 
   it "returns true when RefreshMode is Disabled" do
-    expect(ChefPowerShell::PowerShell).to receive(:new)
+    expect(Chef::PowerShell).to receive(:new)
       .with("Get-DscLocalConfigurationManager")
       .and_return(powershell)
     expect(powershell).to receive(:error!)
@@ -53,7 +53,7 @@ describe "Chef::Platform#dsc_refresh_mode_disabled?", :windows_only do
   end
 
   it "returns false when RefreshMode is not Disabled" do
-    expect(ChefPowerShell::PowerShell).to receive(:new)
+    expect(Chef::PowerShell).to receive(:new)
       .with("Get-DscLocalConfigurationManager")
       .and_return(powershell)
     expect(powershell).to receive(:error!)

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