chef 15.17.4-universal-mingw32 → 16.0.257-universal-mingw32

data/spec/support/shared/integration/knife_support.rb

@@ -39,7 +39,10 @@ module KnifeSupport
 
     # Work on machines where we can't access /var
     Dir.mktmpdir("checksums") do |checksums_cache_dir|
-      Chef::Config[:syntax_check_cache_path] = checksums_cache_dir
+      Chef::Config[:cache_options] = {
+        path: checksums_cache_dir,
+        skip_expires: true,
+      }
 
       # This is Chef::Knife.run without load_commands--we'll load stuff
       # ourselves, thank you very much
@@ -114,7 +117,7 @@ module KnifeSupport
       ensure
         Chef::Log.use_log_devices(old_loggers)
         Chef::Log.level = old_log_level
-        Chef::Config.delete(:syntax_check_cache_path)
+        Chef::Config.delete(:cache_options)
         Chef::Config.delete(:concurrency)
       end
 
@@ -167,21 +170,24 @@ module KnifeSupport
 
     def should_result_in(expected)
       expected[:stdout] = "" unless expected[:stdout]
+      expected[:stdout] = expected[:stdout].is_a?(String) ? expected[:stdout].gsub(/[ \t\f\v]+$/, "") : expected[:stdout]
       expected[:stderr] = "" unless expected[:stderr]
+      expected[:stderr] = expected[:stderr].is_a?(String) ? expected[:stderr].gsub(/[ \t\f\v]+$/, "") : expected[:stderr]
       expected[:exit_code] = 0 unless expected[:exit_code]
       # TODO make this go away
       stderr_actual = @stderr.sub(/^WARNING: No knife configuration file found\n/, "")
-
-      if expected[:stderr].is_a?(Regexp)
-        expect(stderr_actual).to match(expected[:stderr])
-      else
-        expect(stderr_actual).to eq(expected[:stderr])
-      end
+      stderr_actual = stderr_actual.gsub(/[ \t\f\v]+$/, "")
       stdout_actual = @stdout
+      stdout_actual = stdout_actual.gsub(/[ \t\f\v]+$/, "")
       if ChefUtils.windows?
         stderr_actual = stderr_actual.gsub("\r\n", "\n")
         stdout_actual = stdout_actual.gsub("\r\n", "\n")
       end
+      if expected[:stderr].is_a?(Regexp)
+        expect(stderr_actual).to match(expected[:stderr])
+      else
+        expect(stderr_actual).to eq(expected[:stderr])
+      end
       expect(@exit_code).to eq(expected[:exit_code])
       if expected[:stdout].is_a?(Regexp)
         expect(stdout_actual).to match(expected[:stdout])

data/spec/unit/application/apply_spec.rb

@@ -46,6 +46,7 @@ describe Chef::Application::Apply do
     it "should read text properly" do
       expect(@app.read_recipe_file(@recipe_file_name)[0]).to eq(@recipe_text)
     end
+
     it "should return a file_handle" do
       expect(@app.read_recipe_file(@recipe_file_name)[1]).to be_instance_of(RSpec::Mocks::Double)
     end
@@ -57,6 +58,7 @@ describe Chef::Application::Apply do
         @app.read_recipe_file(nil)
       end
     end
+
     describe "when recipe doesn't exist" do
       before do
         allow(File).to receive(:exist?).with(@recipe_path).and_return(false)
@@ -68,6 +70,7 @@ describe Chef::Application::Apply do
       end
     end
   end
+
   describe "temp_recipe_file" do
     before do
       @app.instance_variable_set(:@recipe_text, @recipe_text)

data/spec/unit/application/client_spec.rb

@@ -303,8 +303,12 @@ describe Chef::Application::Client, "reconfigure" do
         context "when there is no new config" do
           let(:config_exists) { false }
 
-          it "does not updates the config" do
+          it "does not update the config" do
             expect(Chef::Config).not_to receive(:from_string)
+              .with(
+                "new_config",
+                File.join("the_path_to_the_repo", ".chef/config.rb")
+              )
 
             app.reconfigure
           end

data/spec/unit/application_spec.rb

@@ -94,13 +94,6 @@ describe Chef::Application do
           end
         end
 
-        describe "when enforce_license is set to false" do
-          it "should not check the license acceptance" do
-            expect(@app).to_not receive(:check_license_acceptance)
-            @app.run(enforce_license: false)
-          end
-        end
-
         it "should run the actual application" do
           expect(@app).to receive(:run_application).and_return(true)
           @app.run
@@ -201,7 +194,6 @@ describe Chef::Application do
       it "should initialise the chef logger" do
         allow(Chef::Log).to receive(:level=)
         @monologger = double("Monologger")
-        expect(MonoLogger).to receive(:new).with(Chef::Config[:log_location]).and_return(@monologger)
         allow(MonoLogger).to receive(:new).with(STDOUT).and_return(@monologger)
         allow(@monologger).to receive(:formatter=).with(Chef::Log.logger.formatter)
         expect(Chef::Log).to receive(:init).with(@monologger)
@@ -279,7 +271,7 @@ describe Chef::Application do
             it "it sets log_location to an instance of #{expected_class}" do
               expect(expected_class).to receive(:new).with no_args
               @app.configure_logging
-              expect(Chef::Config[:log_location]).to be logger_instance
+              expect(Chef::Config[:log_location]).to eq([ logger_instance, STDOUT ])
             end
           end
         end

data/spec/unit/chef_fs/file_system/operation_failed_error_spec.rb

@@ -25,9 +25,11 @@ describe Chef::ChefFS::FileSystem::OperationFailedError do
 
     context "has a cause attribute and HTTP result code is 400" do
       it "include error cause" do
+        allow_message_expectations_on_nil
         response_body = '{"error":["Invalid key test in request body"]}'
-        response = double(:response, code: "400", body: response_body)
-        exception = Net::HTTPClientException.new("(exception) unauthorized", response)
+        allow(@response).to receive(:code).and_return("400")
+        allow(@response).to receive(:body).and_return(response_body)
+        exception = Net::HTTPClientException.new("(exception) unauthorized", @response)
         expect do
           raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, exception), error_message
         end.to raise_error(Chef::ChefFS::FileSystem::OperationFailedError, "#{error_message} cause: #{response_body}")

data/spec/unit/client_spec.rb

@@ -308,13 +308,15 @@ describe Chef::Client do
   end
 
   describe "eol release warning" do
-    it "warns when the date is after April 30, 2021" do
+    it "warns when running an EOL release" do
+      stub_const("Chef::VERSION", 15)
       allow(Time).to receive(:now).and_return(Time.new(2021, 5, 1, 5))
       expect(logger).to receive(:warn).with(/This release of.*became end of life \(EOL\) on May 1st 2021/)
       client.warn_if_eol
     end
 
-    it "does not warn when date is before May 1st 2021" do
+    it "does not warn when running an non-EOL release" do
+      stub_const("Chef::VERSION", 15)
       allow(Time).to receive(:now).and_return(Time.new(2021, 4, 31))
       expect(logger).to_not receive(:warn).with(/became end of life/)
       client.warn_if_eol
@@ -349,7 +351,7 @@ describe Chef::Client do
   describe "configuring output formatters" do
     context "when no formatter has been configured" do
       it "configures the :doc formatter" do
-        expect(client.formatters_for_run).to eq([[:doc]])
+        expect(client.formatters_for_run).to eq([[:doc, nil]])
       end
 
       context "and force_logger is set" do
@@ -368,7 +370,7 @@ describe Chef::Client do
         end
 
         it "configures the :doc formatter" do
-          expect(client.formatters_for_run).to eq([[:doc]])
+          expect(client.formatters_for_run).to eq([[:doc, nil]])
         end
       end
 
@@ -379,7 +381,7 @@ describe Chef::Client do
         end
 
         it "configures the :doc formatter" do
-          expect(client.formatters_for_run).to eq([[:doc]])
+          expect(client.formatters_for_run).to eq([[:doc, nil]])
         end
       end
     end

data/spec/unit/cookbook/gem_installer_spec.rb

@@ -78,7 +78,7 @@ describe Chef::Cookbook::GemInstaller do
 
   it "generates a valid Gemfile when Chef::Config[:rubygems_url] is set to a String" do
     expect(gem_installer).to receive(:shell_out!).and_return(shell_out)
-    Chef::Config[:rubygems_url] = "https://www.rubygems.org"
+    Chef::Config[:rubygems_url] = "https://rubygems.org"
     expect { gem_installer.install }.to_not raise_error
 
     expect(bundler_dsl.dependencies.find { |d| d.name == "httpclient" }.requirements_list.length).to eql(2)
@@ -86,7 +86,7 @@ describe Chef::Cookbook::GemInstaller do
 
   it "generates a valid Gemfile when Chef::Config[:rubygems_url] is set to an Array" do
     expect(gem_installer).to receive(:shell_out!).and_return(shell_out)
-    Chef::Config[:rubygems_url] = [ "https://www.rubygems.org" ]
+    Chef::Config[:rubygems_url] = [ "https://rubygems.org" ]
 
     expect { gem_installer.install }.to_not raise_error
 
@@ -95,8 +95,7 @@ describe Chef::Cookbook::GemInstaller do
 
   it "skip metadata installation when Chef::Config[:skip_gem_metadata_installation] is set to true" do
     Chef::Config[:skip_gem_metadata_installation] = true
-    expect(gem_installer).to_not receive(:shell_out!)
-    expect(gem_installer.install).to be_nil
+    expect(gem_installer.install).to_not receive(:shell_out!)
   end
 
   it "install metadata when Chef::Config[:skip_gem_metadata_installation] is not true" do

data/spec/unit/cookbook/metadata_spec.rb

@@ -29,7 +29,7 @@ describe Chef::Cookbook::Metadata do
       @fields = %i{name description long_description maintainer
                   maintainer_email license platforms dependencies
                   providing recipes version source_url issues_url
-                  privacy ohai_versions chef_versions gems}
+                  privacy ohai_versions chef_versions gems eager_load_libraries}
     end
 
     it "does not depend on object identity for equality" do
@@ -127,6 +127,10 @@ describe Chef::Cookbook::Metadata do
     it "is not private" do
       expect(metadata.privacy).to eq(false)
     end
+
+    it "has eager_load_libraries set to true" do
+      expect(metadata.eager_load_libraries).to eq(true)
+    end
   end
 
   describe "validation" do
@@ -179,6 +183,7 @@ describe Chef::Cookbook::Metadata do
       source_url: "http://example.com",
       issues_url: "http://example.com/issues",
       privacy: true,
+      eager_load_libraries: false,
     }
     params.sort_by(&:to_s).each do |field, field_value|
       describe field do
@@ -269,8 +274,33 @@ describe Chef::Cookbook::Metadata do
 
     it "errors on self-dependencies" do
       metadata.name("foo")
-      expect { metadata.depends("foo") }.to raise_error
-      # FIXME: add the error type
+      expect { metadata.depends("foo") }.to raise_error(RuntimeError, /Cookbook depends on itself/)
+    end
+  end
+
+  describe "eager_load_libraries" do
+    it "can be set to true" do
+      metadata.send(:eager_load_libraries, true)
+      expect(metadata.send(:eager_load_libraries)).to eql(true)
+    end
+
+    it "can be set to false" do
+      metadata.send(:eager_load_libraries, false)
+      expect(metadata.send(:eager_load_libraries)).to eql(false)
+    end
+
+    it "can be set to a string" do
+      metadata.send(:eager_load_libraries, "default.rb")
+      expect(metadata.send(:eager_load_libraries)).to eql("default.rb")
+    end
+
+    it "can be set to an array" do
+      metadata.send(:eager_load_libraries, [ "default.rb", "foo/*/**.rb" ])
+      expect(metadata.send(:eager_load_libraries)).to eql([ "default.rb", "foo/*/**.rb" ])
+    end
+
+    it "cannot be set to a number" do
+      expect { metadata.send(:eager_load_libraries, 1) }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
   end
 
@@ -448,10 +478,11 @@ describe Chef::Cookbook::Metadata do
       metadata.version "1.2.3"
       metadata.gem "foo", "~> 1.2"
       metadata.gem "bar", ">= 2.2", "< 4.0"
-      metadata.chef_version ">= 11.14.2", "< 11.18.10"
-      metadata.chef_version ">= 12.2.1", "< 12.5.1"
-      metadata.ohai_version ">= 7.1.0", "< 7.5.0"
-      metadata.ohai_version ">= 8.0.1", "< 8.6.0"
+      metadata.chef_version "< 11.18.10", ">= 11.14.2"
+      metadata.chef_version "< 12.5.1", ">= 12.2.1"
+      metadata.ohai_version "< 7.5.0", ">= 7.1.0"
+      metadata.ohai_version "< 8.6.0", ">= 8.0.1"
+      metadata.eager_load_libraries [ "default.rb", "foo/*/**.rb" ]
     end
 
     it "should produce the same output from to_json and Chef::JSONCompat" do
@@ -537,18 +568,6 @@ describe Chef::Cookbook::Metadata do
         @hash = metadata.to_hash
       end
 
-      it "should transform deprecated greater than syntax for :dependencies" do
-        @hash[:dependencies.to_s]["foo::bar"] = ">> 0.2"
-        deserial = Chef::Cookbook::Metadata.from_hash(@hash)
-        expect(deserial.send(:dependencies)["foo::bar"]).to eq("> 0.2")
-      end
-
-      it "should transform deprecated less than syntax for :dependencies" do
-        @hash[:dependencies.to_s]["foo::bar"] = "<< 0.2"
-        deserial = Chef::Cookbook::Metadata.from_hash(@hash)
-        expect(deserial.send(:dependencies)["foo::bar"]).to eq("< 0.2")
-      end
-
       it "should ignore multiple dependency constraints for :dependencies" do
         @hash[:dependencies.to_s]["foo::bar"] = [ ">= 1.0", "<= 5.2" ]
         deserial = Chef::Cookbook::Metadata.from_hash(@hash)

data/spec/unit/data_bag_spec.rb

@@ -243,7 +243,7 @@ describe Chef::DataBag do
 
         expect do
           Chef::DataBag.load("foo")
-        end.to raise_error Chef::Exceptions::InvalidDataBagPath, "Data bag path '/var/chef/data_bags' not found. Please create this directory."
+        end.to raise_error Chef::Exceptions::InvalidDataBagPath, "Data bag path '/var/chef/data_bags' is invalid"
       end
 
     end

data/spec/unit/data_collector_spec.rb

@@ -19,6 +19,12 @@ require_relative "../spec_helper"
 require "chef/data_collector"
 require "socket"
 
+#
+# FIXME FIXME FIXME:  What we need to do here is have the ability to construct a real resource collection
+# with some test resources that will correctly be up-to-date/updated/skipped/failed/unprocessed and really
+# converge a client with them (sort of chefspec-like construction of a Chef::Client but with the actions
+# actually running -- another testing requirement similar to the integration testing framework in cheffish as well)
+#
 describe Chef::DataCollector do
   before(:each) do
     Chef::Config[:enable_reporting] = true
@@ -30,9 +36,23 @@ describe Chef::DataCollector do
 
   let(:data_collector) { Chef::DataCollector::Reporter.new(events) }
 
-  let(:new_resource) { Chef::Resource::File.new("/tmp/a-file.txt") }
+  let(:new_resource) do
+    new_resource = Chef::Resource::File.new("/tmp/a-file.txt")
+    new_resource.checksum nil
+    new_resource
+  end
+
+  let(:current_resource) do
+    current_resource = Chef::Resource::File.new("/tmp/a-file.txt")
+    current_resource.checksum "1234123412341234123412341234123412341234123412341234123412341234"
+    current_resource
+  end
 
-  let(:current_resource) { Chef::Resource::File.new("/tmp/a-file.txt") }
+  let(:after_resource) do
+    after_resource = Chef::Resource::File.new("/tmp/a-file.txt")
+    after_resource.checksum "6789678967896789678967896789678967896789678967896789678967896789"
+    after_resource
+  end
 
   let(:events) { Chef::EventDispatch::Dispatcher.new }
 
@@ -130,10 +150,10 @@ describe Chef::DataCollector do
     new_resource.respond_to?(:diff) && %w{updated failed}.include?(status)
   end
 
-  def resource_record_for(current_resource, new_resource, action, status, duration)
+  def resource_record_for(new_resource, before_resource, after_resource, action, status, duration)
     {
-      "after" => new_resource.state_for_resource_reporter,
-      "before" => current_resource&.state_for_resource_reporter,
+      "after" => after_resource&.state_for_resource_reporter || {},
+      "before" => before_resource&.state_for_resource_reporter || {},
       "cookbook_name" => cookbook_name,
       "cookbook_version" => cookbook_version.version,
       "delta" => resource_has_diff(new_resource, status) ? new_resource.diff : "",
@@ -634,13 +654,14 @@ describe Chef::DataCollector do
       context "when the run contains a file resource that is up-to-date" do
         let(:total_resource_count) { 1 }
         let(:updated_resource_count) { 0 }
-        let(:resource_record) { [ resource_record_for(current_resource, new_resource, :create, "up-to-date", "1234") ] }
+        let(:resource_record) { [ resource_record_for(new_resource, current_resource, after_resource, :create, "up-to-date", "1234") ] }
         let(:status) { "success" }
 
         before do
           events.resource_action_start(new_resource, :create)
           events.resource_current_state_loaded(new_resource, :create, current_resource)
           events.resource_up_to_date(new_resource, :create)
+          events.resource_after_state_loaded(new_resource, :create, after_resource)
           new_resource.instance_variable_set(:@elapsed_time, 1.2345)
           events.resource_completed(new_resource)
           events.converge_complete
@@ -653,13 +674,14 @@ describe Chef::DataCollector do
       context "when the run contains a file resource that is updated" do
         let(:total_resource_count) { 1 }
         let(:updated_resource_count) { 1 }
-        let(:resource_record) { [ resource_record_for(current_resource, new_resource, :create, "updated", "1234") ] }
+        let(:resource_record) { [ resource_record_for(new_resource, current_resource, after_resource, :create, "updated", "1234") ] }
         let(:status) { "success" }
 
         before do
           events.resource_action_start(new_resource, :create)
           events.resource_current_state_loaded(new_resource, :create, current_resource)
           events.resource_updated(new_resource, :create)
+          events.resource_after_state_loaded(new_resource, :create, after_resource)
           new_resource.instance_variable_set(:@elapsed_time, 1.2345)
           events.resource_completed(new_resource)
           events.converge_complete
@@ -679,7 +701,7 @@ describe Chef::DataCollector do
           allow(r).to receive(:cookbook_version).and_return(cookbook_version)
           r
         end
-        let(:resource_record) { [ resource_record_for(implementation_resource, implementation_resource, :create, "updated", "2345"), resource_record_for(current_resource, new_resource, :create, "updated", "1234") ] }
+        let(:resource_record) { [ resource_record_for(implementation_resource, implementation_resource, implementation_resource, :create, "updated", "2345"), resource_record_for(new_resource, current_resource, after_resource, :create, "updated", "1234") ] }
         let(:status) { "success" }
 
         before do
@@ -689,10 +711,12 @@ describe Chef::DataCollector do
           events.resource_action_start(implementation_resource , :create)
           events.resource_current_state_loaded(implementation_resource, :create, implementation_resource)
           events.resource_updated(implementation_resource, :create)
+          events.resource_after_state_loaded(implementation_resource, :create, implementation_resource)
           implementation_resource.instance_variable_set(:@elapsed_time, 2.3456)
           events.resource_completed(implementation_resource)
 
           events.resource_updated(new_resource, :create)
+          events.resource_after_state_loaded(new_resource, :create, after_resource)
           new_resource.instance_variable_set(:@elapsed_time, 1.2345)
           events.resource_completed(new_resource)
           events.converge_complete
@@ -706,7 +730,7 @@ describe Chef::DataCollector do
         let(:total_resource_count) { 1 }
         let(:updated_resource_count) { 0 }
         let(:resource_record) do
-          rec = resource_record_for(current_resource, new_resource, :create, "skipped", "1234")
+          rec = resource_record_for(new_resource, nil, nil, :create, "skipped", "1234")
           rec["conditional"] = "not_if { #code block }" # FIXME: "#code block" is poor, is there some way to fix this?
           [ rec ]
         end
@@ -715,7 +739,6 @@ describe Chef::DataCollector do
         before do
           conditional = (new_resource.not_if { true }).first
           events.resource_action_start(new_resource, :create)
-          events.resource_current_state_loaded(new_resource, :create, current_resource)
           events.resource_skipped(new_resource, :create, conditional)
           new_resource.instance_variable_set(:@elapsed_time, 1.2345)
           events.resource_completed(new_resource)
@@ -730,7 +753,7 @@ describe Chef::DataCollector do
         let(:total_resource_count) { 1 }
         let(:updated_resource_count) { 0 }
         let(:resource_record) do
-          rec = resource_record_for(current_resource, new_resource, :create, "skipped", "1234")
+          rec = resource_record_for(new_resource, nil, nil, :create, "skipped", "1234")
           rec["conditional"] = 'not_if "true"'
           [ rec ]
         end
@@ -739,7 +762,6 @@ describe Chef::DataCollector do
         before do
           conditional = (new_resource.not_if "true").first
           events.resource_action_start(new_resource, :create)
-          events.resource_current_state_loaded(new_resource, :create, current_resource)
           events.resource_skipped(new_resource, :create, conditional)
           new_resource.instance_variable_set(:@elapsed_time, 1.2345)
           events.resource_completed(new_resource)
@@ -756,7 +778,7 @@ describe Chef::DataCollector do
         let(:total_resource_count) { 1 }
         let(:updated_resource_count) { 0 }
         let(:resource_record) do
-          rec = resource_record_for(current_resource, new_resource, :create, "failed", "1234")
+          rec = resource_record_for(new_resource, current_resource, nil, :create, "failed", "1234")
           rec["error_message"] = "imperial to metric conversion error"
           [ rec ]
         end
@@ -783,7 +805,7 @@ describe Chef::DataCollector do
         let(:total_resource_count) { 1 }
         let(:updated_resource_count) { 0 }
         let(:resource_record) do
-          rec = resource_record_for(current_resource, new_resource, :create, "failed", "1234")
+          rec = resource_record_for(new_resource, nil, nil, :create, "failed", "1234")
           rec["before"] = {}
           rec["error_message"] = "imperial to metric conversion error"
           [ rec ]
@@ -818,10 +840,9 @@ describe Chef::DataCollector do
           res
         end
         let(:resource_record) do
-          rec1 = resource_record_for(current_resource, new_resource, :create, "failed", "1234")
+          rec1 = resource_record_for(new_resource, current_resource, nil, :create, "failed", "1234")
           rec1["error_message"] = "imperial to metric conversion error"
-          rec2 = resource_record_for(nil, unprocessed_resource, :nothing, "unprocessed", "")
-          rec2["before"] = {}
+          rec2 = resource_record_for(unprocessed_resource, nil, nil, :nothing, "unprocessed", "")
           [ rec1, rec2 ]
         end
         let(:status) { "failure" }