chef 16.2.44-universal-mingw32 → 16.4.35-universal-mingw32

data/spec/unit/data_bag_spec.rb

@@ -240,20 +240,23 @@ describe Chef::DataBag do
 
       it "should raise an error if the configured data_bag_path is invalid" do
         file_dir_stub(@paths.first, false)
+        msg = "Data bag path '#{windows? ? "C:/var/chef" : "/var/chef"}/data_bags' not found. Please create this directory."
 
         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, msg
       end
 
     end
 
     describe "data bag with string path" do
-      it_should_behave_like "data bag in solo mode", "/var/chef/data_bags"
+      it_should_behave_like "data bag in solo mode", "#{windows? ? "C:/var/chef" : "/var/chef"}/data_bags"
     end
 
     describe "data bag with array path" do
-      it_should_behave_like "data bag in solo mode", ["/var/chef/data_bags", "/var/chef/data_bags_2"]
+      it_should_behave_like "data bag in solo mode", %w{data_bags data_bags_2}.map { |data_bag|
+        "#{windows? ? "C:/var/chef" : "/var/chef"}/#{data_bag}"
+      }
     end
   end
 

data/spec/unit/data_collector_spec.rb

@@ -15,7 +15,7 @@
 # limitations under the License.
 #
 
-require_relative "../spec_helper"
+require "spec_helper"
 require "chef/data_collector"
 require "socket"
 
@@ -39,6 +39,7 @@ describe Chef::DataCollector do
   let(:new_resource) do
     new_resource = Chef::Resource::File.new("/tmp/a-file.txt")
     new_resource.checksum nil
+    new_resource.path
     new_resource
   end
 
@@ -780,6 +781,13 @@ describe Chef::DataCollector do
         let(:resource_record) do
           rec = resource_record_for(new_resource, current_resource, nil, :create, "failed", "1234")
           rec["error_message"] = "imperial to metric conversion error"
+          rec["error"] = {
+            "class" => exception.class,
+            "message" => exception.message,
+            "backtrace" => exception.backtrace,
+            "description" => error_description,
+          }
+
           [ rec ]
         end
         let(:status) { "failure" }
@@ -808,6 +816,13 @@ describe Chef::DataCollector do
           rec = resource_record_for(new_resource, nil, nil, :create, "failed", "1234")
           rec["before"] = {}
           rec["error_message"] = "imperial to metric conversion error"
+          rec["error"] = {
+            "class" => exception.class,
+            "message" => exception.message,
+            "backtrace" => exception.backtrace,
+            "description" => error_description,
+          }
+
           [ rec ]
         end
         let(:status) { "failure" }
@@ -842,6 +857,13 @@ describe Chef::DataCollector do
         let(:resource_record) do
           rec1 = resource_record_for(new_resource, current_resource, nil, :create, "failed", "1234")
           rec1["error_message"] = "imperial to metric conversion error"
+          rec1["error"] = {
+            "class" => exception.class,
+            "message" => exception.message,
+            "backtrace" => exception.backtrace,
+            "description" => error_description,
+          }
+
           rec2 = resource_record_for(unprocessed_resource, nil, nil, :nothing, "unprocessed", "")
           [ rec1, rec2 ]
         end

data/spec/unit/decorator_spec.rb

@@ -18,37 +18,37 @@
 
 require "spec_helper"
 
-def impersonates_a(klass)
-  it "#is_a?(#{klass}) is true" do
-    expect(decorator.is_a?(klass)).to be true
-  end
+describe Chef::Decorator do
+  def self.impersonates_a(klass)
+    it "#is_a?(#{klass}) is true" do
+      expect(decorator.is_a?(klass)).to be true
+    end
 
-  it "#is_a?(Chef::Decorator) is true" do
-    expect(decorator.is_a?(Chef::Decorator)).to be true
-  end
+    it "#is_a?(Chef::Decorator) is true" do
+      expect(decorator.is_a?(Chef::Decorator)).to be true
+    end
 
-  it "#kind_of?(#{klass}) is true" do
-    expect(decorator.is_a?(klass)).to be true
-  end
+    it "#kind_of?(#{klass}) is true" do
+      expect(decorator.is_a?(klass)).to be true
+    end
 
-  it "#kind_of?(Chef::Decorator) is true" do
-    expect(decorator.is_a?(Chef::Decorator)).to be true
-  end
+    it "#kind_of?(Chef::Decorator) is true" do
+      expect(decorator.is_a?(Chef::Decorator)).to be true
+    end
 
-  it "#instance_of?(#{klass}) is false" do
-    expect(decorator.instance_of?(klass)).to be false
-  end
+    it "#instance_of?(#{klass}) is false" do
+      expect(decorator.instance_of?(klass)).to be false
+    end
 
-  it "#instance_of?(Chef::Decorator) is true" do
-    expect(decorator.instance_of?(Chef::Decorator)).to be true
-  end
+    it "#instance_of?(Chef::Decorator) is true" do
+      expect(decorator.instance_of?(Chef::Decorator)).to be true
+    end
 
-  it "#class is Chef::Decorator" do
-    expect(decorator.class).to eql(Chef::Decorator)
+    it "#class is Chef::Decorator" do
+      expect(decorator.class).to eql(Chef::Decorator)
+    end
   end
-end
 
-describe Chef::Decorator do
   let(:obj) {}
   let(:decorator) { Chef::Decorator.new(obj) }
 

data/spec/unit/dsl/platform_introspection_spec.rb

@@ -21,6 +21,7 @@ require "chef/dsl/platform_introspection"
 
 class LanguageTester
   attr_reader :node
+
   def initialize(node)
     @node = node
   end

data/spec/unit/environment_spec.rb

@@ -402,8 +402,8 @@ describe Chef::Environment do
 
       it "should get the environment from the environment_path" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.rb")).exactly(1).times.and_return(true)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.rb")).exactly(1).times.and_return(true)
         expect(File).to receive(:readable?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         expect(File).to receive(:file?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         role_dsl = "name \"foo\"\ndescription \"desc\"\n"
@@ -413,7 +413,7 @@ describe Chef::Environment do
 
       it "should return a Chef::Environment object from JSON" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(true)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(true)
         environment_hash = {
           "name" => "foo",
           "default_attributes" => {
@@ -436,8 +436,8 @@ describe Chef::Environment do
 
       it "should return a Chef::Environment object from Ruby DSL" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.rb")).exactly(1).times.and_return(true)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.rb")).exactly(1).times.and_return(true)
         expect(File).to receive(:readable?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         expect(File).to receive(:file?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         role_dsl = "name \"foo\"\ndescription \"desc\"\n"
@@ -454,13 +454,17 @@ describe Chef::Environment do
 
         expect do
           Chef::Environment.load("foo")
-        end.to raise_error Chef::Exceptions::InvalidEnvironmentPath, "Environment path '/var/chef/environments' is invalid"
+        end.to raise_error(
+          an_instance_of(Chef::Exceptions::InvalidEnvironmentPath).and having_attributes(
+            message: "Environment path '#{windows? ? "C:/var/chef/environments" : "/var/chef/environments"}' is invalid"
+          )
+        )
       end
 
       it "should raise an error if the file does not exist" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(false)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(false)
 
         expect do
           Chef::Environment.load("foo")

data/spec/unit/event_dispatch/dispatcher_spec.rb

@@ -61,6 +61,7 @@ describe Chef::EventDispatch::Dispatcher do
       let(:event_sink) do
         Class.new(Chef::EventDispatch::Base) do
           attr_reader :synchronized_cookbook_args
+
           def synchronized_cookbook(cookbook_name)
             @synchronized_cookbook_args = [cookbook_name]
           end
@@ -79,6 +80,7 @@ describe Chef::EventDispatch::Dispatcher do
     let(:event_sink_1) do
       Class.new(Chef::EventDispatch::Base) do
         attr_reader :synchronized_cookbook_args
+
         def synchronized_cookbook(cookbook_name)
           @synchronized_cookbook_args = [cookbook_name]
         end
@@ -87,6 +89,7 @@ describe Chef::EventDispatch::Dispatcher do
     let(:event_sink_2) do
       Class.new(Chef::EventDispatch::Base) do
         attr_reader :synchronized_cookbook_args
+
         def synchronized_cookbook(cookbook_name, cookbook)
           @synchronized_cookbook_args = [cookbook_name, cookbook]
         end

data/spec/unit/guard_interpreter_spec.rb

@@ -20,7 +20,7 @@ require "spec_helper"
 
 describe Chef::GuardInterpreter do
   describe "#for_resource" do
-    let (:resource) { Chef::Resource.new("foo") }
+    let(:resource) { Chef::Resource.new("foo") }
 
     it "returns a DefaultGuardInterpreter if the resource has guard_interpreter set to :default" do
       resource.guard_interpreter :default

data/spec/unit/http/api_versions_spec.rb

@@ -53,8 +53,26 @@ describe Chef::HTTP::APIVersions do
     m
   end
 
+  let(:version_class) do
+    Class.new do
+      extend Chef::Mixin::VersionedAPIFactory
+
+      version_class_v0 = Class.new do
+        extend Chef::Mixin::VersionedAPI
+        minimum_api_version 0
+      end
+      add_versioned_api_class version_class_v0
+
+      version_class_v2 = Class.new do
+        extend Chef::Mixin::VersionedAPI
+        minimum_api_version 2
+      end
+      add_versioned_api_class version_class_v2
+    end
+  end
+
   let(:client) do
-    TestVersionClient.new(url, { version_class: VersionedClassVersions })
+    TestVersionClient.new(url, { version_class: version_class })
   end
 
   let(:middleware) do
@@ -72,7 +90,7 @@ describe Chef::HTTP::APIVersions do
   end
 
   context "with an unacceptable api version" do
-    let (:return_value) { "406" }
+    let(:return_value) { "406" }
     it "resets the list of supported versions" do
       Chef::ServerAPIVersions.instance.set_versions({ "min_version" => 1, "max_version" => 3 })
       run_api_version_handler

data/spec/unit/json_compat_spec.rb

@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require_relative "../spec_helper"
+require "spec_helper"
 require "chef/json_compat"
 
 describe Chef::JSONCompat do

data/spec/unit/knife/bootstrap_spec.rb

@@ -206,7 +206,7 @@ describe Chef::Knife::Bootstrap do
       end
 
       before(:each) do
-        expect(File).to receive(:exists?).with(bootstrap_template).and_return(false)
+        expect(File).to receive(:exist?).with(bootstrap_template).and_return(false)
       end
 
       context "when file is available everywhere" do
@@ -215,7 +215,7 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exists?).with(builtin_template_path).and_return(true)
+          expect(File).to receive(:exist?).with(builtin_template_path).and_return(true)
         end
 
         it "should load the template from built-in templates" do
@@ -229,8 +229,8 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(true)
+          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(true)
 
           it "should load the template from chef_config_dir" do
             knife.find_template.should eq(chef_config_dir_template_path)
@@ -244,9 +244,9 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(env_home_template_path).and_return(true)
+          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(env_home_template_path).and_return(true)
         end
 
         it "should load the template from chef_config_dir" do
@@ -260,10 +260,10 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(env_home_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(gem_files_template_path).and_return(true)
+          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(env_home_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(gem_files_template_path).and_return(true)
         end
 
         it "should load the template from Gem files" do
@@ -277,9 +277,9 @@ describe Chef::Knife::Bootstrap do
           configure_gem_files
           allow(Chef::Util::PathHelper).to receive(:home).with(".chef", "bootstrap", "example.erb").and_return(nil)
 
-          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(gem_files_template_path).and_return(true)
+          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(gem_files_template_path).and_return(true)
         end
 
         it "should load the template from Gem files" do
@@ -1861,12 +1861,10 @@ describe Chef::Knife::Bootstrap do
           let(:connection_protocol) { "ssh" }
 
           it "warns, prompts for password, then reconnects with a password-enabled configuration using the new password" do
-            question_mock = double("question")
             expect(knife).to receive(:do_connect).and_raise(expected_error_password_prompt)
             expect(knife.ui).to receive(:warn).with(/Failed to auth.*/)
-            expect(knife.ui).to receive(:ask).and_yield(question_mock).and_return("newpassword")
+            expect(knife.ui).to receive(:ask).and_return("newpassword")
             # Ensure that we set echo off to prevent showing password on the screen
-            expect(question_mock).to receive(:echo=).with false
             expect(knife).to receive(:do_connect) do |opts|
               expect(opts[:password]).to eq "newpassword"
             end
@@ -1878,12 +1876,10 @@ describe Chef::Knife::Bootstrap do
           let(:connection_protocol) { "winrm" }
 
           it "warns, prompts for password, then reconnects with a password-enabled configuration using the new password for" do
-            question_mock = double("question")
             expect(knife).to receive(:do_connect).and_raise(expected_error_password_prompt_winrm)
             expect(knife.ui).to receive(:warn).with(/Failed to auth.*/)
-            expect(knife.ui).to receive(:ask).and_yield(question_mock).and_return("newpassword")
+            expect(knife.ui).to receive(:ask).and_return("newpassword")
             # Ensure that we set echo off to prevent showing password on the screen
-            expect(question_mock).to receive(:echo=).with false
             expect(knife).to receive(:do_connect) do |opts|
               expect(opts[:password]).to eq "newpassword"
             end
@@ -1927,6 +1923,7 @@ describe Chef::Knife::Bootstrap do
       Chef::Config[:knife][:test_key_c] = "c from Chef::Config"
       Chef::Config[:knife][:alt_test_key_c] = "alt c from Chef::Config"
       knife.merge_configs
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
     end
 
     it "returns the Chef::Config value from the cli when the CLI key is set" do

data/spec/unit/knife/cookbook_download_spec.rb

@@ -83,7 +83,7 @@ describe Chef::Knife::CookbookDownload do
         }
       end
 
-      let (:cookbook) do
+      let(:cookbook) do
         cb = Chef::CookbookVersion.new("foobar")
         cb.version = "1.0.0"
         cb.manifest = manifest_data
@@ -91,10 +91,10 @@ describe Chef::Knife::CookbookDownload do
       end
 
       describe "and no version" do
-        let (:manifest_data) { { all_files: [] } }
+        let(:manifest_data) { { all_files: [] } }
         it "should determine which version to download" do
           expect(@knife).to receive(:determine_version).and_return("1.0.0")
-          expect(File).to receive(:exists?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
+          expect(File).to receive(:exist?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
           @knife.run
         end
       end
@@ -111,7 +111,7 @@ describe Chef::Knife::CookbookDownload do
         end
 
         it "should print an error and exit if the cookbook download directory already exists" do
-          expect(File).to receive(:exists?).with("/var/tmp/chef/foobar-1.0.0").and_return(true)
+          expect(File).to receive(:exist?).with("/var/tmp/chef/foobar-1.0.0").and_return(true)
           expect(@knife.ui).to receive(:fatal).with(%r{/var/tmp/chef/foobar-1\.0\.0 exists}i)
           expect { @knife.run }.to raise_error(SystemExit)
         end
@@ -135,7 +135,7 @@ describe Chef::Knife::CookbookDownload do
           end
 
           it "should download the cookbook when the cookbook download directory doesn't exist" do
-            expect(File).to receive(:exists?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
+            expect(File).to receive(:exist?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
             @knife.run
             %w{attributes recipes templates}.each do |segment|
               expect(@stderr.string).to match /downloading #{segment}/im
@@ -147,7 +147,7 @@ describe Chef::Knife::CookbookDownload do
           describe "with -f or --force" do
             it "should remove the existing the cookbook download directory if it exists" do
               @knife.config[:force] = true
-              expect(File).to receive(:exists?).with("/var/tmp/chef/foobar-1.0.0").and_return(true)
+              expect(File).to receive(:exist?).with("/var/tmp/chef/foobar-1.0.0").and_return(true)
               expect(FileUtils).to receive(:rm_rf).with("/var/tmp/chef/foobar-1.0.0")
               @knife.run
             end

data/spec/unit/knife/cookbook_metadata_from_file_spec.rb

@@ -34,7 +34,7 @@ describe Chef::Knife::CookbookMetadataFromFile do
   end
 
   after do
-    if File.exists?(@tgt)
+    if File.exist?(@tgt)
       File.unlink(@tgt)
     end
   end

data/spec/unit/knife/cookbook_show_spec.rb

@@ -16,7 +16,6 @@
 # limitations under the License.
 #
 
-# rename to cookbook not coookbook
 require "spec_helper"
 
 describe Chef::Knife::CookbookShow do
@@ -28,24 +27,24 @@ describe Chef::Knife::CookbookShow do
     allow(Chef::CookbookVersion).to receive(:load).and_return(cb)
   end
 
-  let (:knife) do
+  let(:knife) do
     knife = Chef::Knife::CookbookShow.new
     knife.config = {}
     knife.name_args = [ "cookbook_name" ]
     knife
   end
 
-  let (:cb) do
+  let(:cb) do
     cb = Chef::CookbookVersion.new("cookbook_name")
     cb.manifest = manifest
     cb
   end
 
-  let (:rest) { double(Chef::ServerAPI) }
+  let(:rest) { double(Chef::ServerAPI) }
 
-  let (:content) { "Example recipe text" }
+  let(:content) { "Example recipe text" }
 
-  let (:manifest) do
+  let(:manifest) do
     {
       "all_files" => [
         {
@@ -69,7 +68,7 @@ describe Chef::Knife::CookbookShow do
     end
 
     describe "with 1 argument: versions" do
-      let (:response) do
+      let(:response) do
         {
           "cookbook_name" => {
             "url" => "http://url/cookbooks/cookbook_name",