chef 16.1.16 → 16.18.30

data/spec/unit/util/diff_spec.rb

@@ -61,10 +61,6 @@ shared_examples_for "a diff util" do
       Chef::Config[:diff_disabled] = true
     end
 
-    after do
-      Chef::Config[:diff_disabled] = false
-    end
-
     it "calling for_output should return the error message" do
       expect(differ.for_output).to eql( [ "(diff output suppressed by config)" ] )
     end
@@ -300,14 +296,9 @@ shared_examples_for "a diff util" do
 
   describe "when testing the diff_filesize_threshold" do
     before do
-      @diff_filesize_threshold_saved = Chef::Config[:diff_filesize_threshold]
       Chef::Config[:diff_filesize_threshold] = 10
     end
 
-    after do
-      Chef::Config[:diff_filesize_threshold] = @diff_filesize_threshold_saved
-    end
-
     describe "when the old_file goes over the threshold" do
       before do
         old_tempfile.write("But thats what you get when Wu-Tang raised you")
@@ -359,14 +350,9 @@ shared_examples_for "a diff util" do
     describe "when the diff output is too long" do
 
       before do
-        @diff_output_threshold_saved = Chef::Config[:diff_output_threshold]
         Chef::Config[:diff_output_threshold] = 10
       end
 
-      after do
-        Chef::Config[:diff_output_threshold] = @diff_output_threshold_saved
-      end
-
       it "calling for_output should return the error message" do
         expect(differ.for_output).to eql(["(long diff of over 10 characters, diff output suppressed)"])
       end
@@ -546,7 +532,7 @@ shared_examples_for "a diff util" do
 
 end
 
-describe Chef::Util::Diff, uses_diff: true do
+describe Chef::Util::Diff do
   let!(:old_file) { old_tempfile.path }
   let!(:new_file) { new_tempfile.path }
 

data/spec/unit/util/dsc/configuration_generator_spec.rb

@@ -25,6 +25,85 @@ describe Chef::Util::DSC::ConfigurationGenerator do
     Chef::Util::DSC::ConfigurationGenerator.new(node, "tmp")
   end
 
+  describe "#validate_switch_name!" do
+    it "should not raise an error if a name contains all upper case letters" do
+      conf_man.send(:validate_switch_name!, "HELLO")
+    end
+
+    it "should not raise an error if the name contains all lower case letters" do
+      conf_man.send(:validate_switch_name!, "hello")
+    end
+
+    it "should not raise an error if no special characters are used except _" do
+      conf_man.send(:validate_switch_name!, "hello_world")
+    end
+
+    %w{! @ # $ % ^ & * & * ( ) - = + \{ \} . ? < > \\ /}.each do |sym|
+      it "raises an ArgumentError if configuration name contains #{sym}" do
+        expect do
+          conf_man.send(:validate_switch_name!, "Hello#{sym}")
+        end.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#escape_parameter_value" do
+    # Is this list really complete?
+    %w{` " # '}.each do |c|
+      it "escapes #{c}" do
+        expect(conf_man.send(:escape_parameter_value, "stuff #{c}")).to eql("stuff `#{c}")
+      end
+    end
+
+    it "does not do anything to a string without special characters" do
+      expect(conf_man.send(:escape_parameter_value, "stuff")).to eql("stuff")
+    end
+  end
+
+  describe "#escape_string_parameter_value" do
+    it "surrounds a string with ''" do
+      expect(conf_man.send(:escape_string_parameter_value, "stuff")).to eql("'stuff'")
+    end
+  end
+
+  describe "#command_switches_string" do
+    it "raises an ArgumentError if the key is not a symbol" do
+      expect do
+        conf_man.send(:command_switches_string, { "foo" => "bar" })
+      end.to raise_error(ArgumentError)
+    end
+
+    it "does not allow invalid switch names" do
+      expect do
+        conf_man.send(:command_switches_string, { foo!: "bar" })
+      end.to raise_error(ArgumentError)
+    end
+
+    it "ignores switches with a false value" do
+      expect(conf_man.send(:command_switches_string, { foo: false })).to eql("")
+    end
+
+    it "should correctly handle a value type of string" do
+      expect(conf_man.send(:command_switches_string, { foo: "bar" })).to eql("-foo 'bar'")
+    end
+
+    it "should correctly handle a value type of string even when it is 0 length" do
+      expect(conf_man.send(:command_switches_string, { foo: "" })).to eql("-foo ''")
+    end
+
+    it "should not quote integers" do
+      expect(conf_man.send(:command_switches_string, { foo: 1 })).to eql("-foo 1")
+    end
+
+    it "should not quote floats" do
+      expect(conf_man.send(:command_switches_string, { foo: 1.0 })).to eql("-foo 1.0")
+    end
+
+    it "has just the switch when the value is true" do
+      expect(conf_man.send(:command_switches_string, { foo: true })).to eql("-foo")
+    end
+  end
+
   describe "#validate_configuration_name!" do
     it "should not raise an error if a name contains all upper case letters" do
       conf_man.send(:validate_configuration_name!, "HELLO")
@@ -161,7 +240,7 @@ describe Chef::Util::DSC::ConfigurationGenerator do
       dsc = conf_man.send(:configuration_code, "archive{}", "hello", {})
       found_configuration = false
       dsc.split(";").each do |command|
-        if command.downcase =~ /\s*configuration\s+'hello'\s*\{\s*node\s+'localhost'\s*\{\s*archive\s*\{\s*\}\s*\}\s*\}\s*/
+        if /\s*configuration\s+'hello'\s*\{\s*node\s+'localhost'\s*\{\s*archive\s*\{\s*\}\s*\}\s*\}\s*/.match?(command.downcase)
           found_configuration = true
         end
       end

data/spec/unit/util/dsc/local_configuration_manager_spec.rb

@@ -49,23 +49,22 @@ describe Chef::Util::DSC::LocalConfigurationManager do
     EOH
   end
 
-  let(:lcm_status) do
-    double("LCM cmdlet status", stderr: lcm_standard_error, return_value: lcm_standard_output, succeeded?: lcm_cmdlet_success)
+  let(:powershell) do
+    double("ChefPowerShell::PowerShell", errors: lcm_errors, error?: !lcm_errors.empty?, result: lcm_result)
   end
 
   describe "test_configuration method invocation" do
     context "when interacting with the LCM using a PowerShell cmdlet" do
       before(:each) do
-        allow(lcm).to receive(:run_configuration_cmdlet).and_return(lcm_status)
+        allow(lcm).to receive(:run_configuration_cmdlet).and_return(powershell)
         allow(lcm).to receive(:ps_version_gte_5?).and_return(false)
       end
       context "that returns successfully" do
-        let(:lcm_standard_output) { normal_lcm_output }
-        let(:lcm_standard_error) { nil }
-        let(:lcm_cmdlet_success) { true }
+        let(:lcm_result) { normal_lcm_output }
+        let(:lcm_errors) { [] }
 
         it "successfully returns resource information for normally formatted output when cmdlet the cmdlet succeeds" do
-          test_configuration_result = lcm.test_configuration("config", {})
+          test_configuration_result = lcm.test_configuration("config")
           expect(test_configuration_result.class).to be(Array)
           expect(test_configuration_result.length).to be > 0
           expect(Chef::Log).not_to receive(:warn)
@@ -73,13 +72,12 @@ describe Chef::Util::DSC::LocalConfigurationManager do
       end
 
       context "when running on PowerShell version 5" do
-        let(:lcm_standard_output) { normal_lcm_output }
-        let(:lcm_standard_error) { nil }
-        let(:lcm_cmdlet_success) { true }
+        let(:lcm_result) { normal_lcm_output }
+        let(:lcm_errors) { [] }
 
         it "successfully returns resource information for normally formatted output when cmdlet the cmdlet succeeds" do
           allow(lcm).to receive(:ps_version_gte_5?).and_return(true)
-          test_configuration_result = lcm.test_configuration("config", {})
+          test_configuration_result = lcm.test_configuration("config")
           expect(test_configuration_result.class).to be(Array)
           expect(test_configuration_result.length).to be > 0
           expect(Chef::Log).not_to receive(:warn)
@@ -87,13 +85,12 @@ describe Chef::Util::DSC::LocalConfigurationManager do
       end
 
       context "when running on PowerShell version less than 5" do
-        let(:lcm_standard_output) { normal_lcm_output }
-        let(:lcm_standard_error) { nil }
-        let(:lcm_cmdlet_success) { true }
+        let(:lcm_result) { normal_lcm_output }
+        let(:lcm_errors) { [] }
 
         it "successfully returns resource information for normally formatted output when cmdlet the cmdlet succeeds" do
           allow(lcm).to receive(:ps_version_gte_5?).and_return(false)
-          test_configuration_result = lcm.test_configuration("config", {})
+          test_configuration_result = lcm.test_configuration("config")
           expect(test_configuration_result.class).to be(Array)
           expect(test_configuration_result.length).to be > 0
           expect(Chef::Log).not_to receive(:warn)
@@ -104,10 +101,9 @@ describe Chef::Util::DSC::LocalConfigurationManager do
         let(:common_command_prefix) { "$ProgressPreference = 'SilentlyContinue';" }
         let(:ps4_base_command) { "#{common_command_prefix} Start-DscConfiguration -path tmp -wait -erroraction 'stop' -force" }
         let(:lcm_command_ps4) { ps4_base_command + " -whatif; if (! $?) { exit 1 }" }
-        let(:lcm_command_ps5) { "#{common_command_prefix} Test-DscConfiguration -path tmp | format-list" }
-        let(:lcm_standard_output) { normal_lcm_output }
-        let(:lcm_standard_error) { nil }
-        let(:lcm_cmdlet_success) { true }
+        let(:lcm_command_ps5) { "#{common_command_prefix} Test-DscConfiguration -path tmp | format-list | Out-String" }
+        let(:lcm_result) { normal_lcm_output }
+        let(:lcm_errors) { [] }
 
         it "successfully returns command when apply_configuration true" do
           expect(lcm.send(:lcm_command, true)).to eq(ps4_base_command)
@@ -125,9 +121,8 @@ describe Chef::Util::DSC::LocalConfigurationManager do
       end
 
       context "that fails due to missing what-if switch in DSC resource cmdlet implementation" do
-        let(:lcm_standard_output) { "" }
-        let(:lcm_standard_error) { no_whatif_lcm_output }
-        let(:lcm_cmdlet_success) { false }
+        let(:lcm_result) { "" }
+        let(:lcm_errors) { [no_whatif_lcm_output] }
 
         it "returns true when passed to #whatif_not_supported?" do
           expect(lcm.send(:whatif_not_supported?, no_whatif_lcm_output)).to be_truthy
@@ -137,40 +132,38 @@ describe Chef::Util::DSC::LocalConfigurationManager do
           expect(Chef::Log).to receive(:warn).at_least(:once)
           expect(lcm).to receive(:whatif_not_supported?).and_call_original
           test_configuration_result = nil
-          expect { test_configuration_result = lcm.test_configuration("config", {}) }.not_to raise_error
+          expect { test_configuration_result = lcm.test_configuration("config") }.not_to raise_error
           expect(test_configuration_result.class).to be(Array)
         end
       end
 
       context "that fails due to a DSC resource not being imported before StartDSCConfiguration -whatif is executed" do
-        let(:lcm_standard_output) { "" }
-        let(:lcm_standard_error) { dsc_resource_import_failure_output }
-        let(:lcm_cmdlet_success) { false }
+        let(:lcm_result) { "" }
+        let(:lcm_errors) { [dsc_resource_import_failure_output] }
 
         it "logs a warning if the message is formatted as expected when a resource import failure occurs" do
           expect(Chef::Log).to receive(:warn).at_least(:once)
           expect(lcm).to receive(:dsc_module_import_failure?).and_call_original
           test_configuration_result = nil
-          expect { test_configuration_result = lcm.test_configuration("config", {}) }.not_to raise_error
+          expect { test_configuration_result = lcm.test_configuration("config") }.not_to raise_error
         end
 
         it "returns a (possibly empty) array of ResourceInfo instances" do
           expect(Chef::Log).to receive(:warn).at_least(:once)
           test_configuration_result = nil
-          expect { test_configuration_result = lcm.test_configuration("config", {}) }.not_to raise_error
+          expect { test_configuration_result = lcm.test_configuration("config") }.not_to raise_error
           expect(test_configuration_result.class).to be(Array)
         end
       end
 
       context "that fails due to an unknown PowerShell cmdlet error" do
-        let(:lcm_standard_output) { "some output" }
-        let(:lcm_standard_error) { "Abort, Retry, Fail?" }
-        let(:lcm_cmdlet_success) { false }
+        let(:lcm_result) { "some output" }
+        let(:lcm_errors) { ["Abort, Retry, Fail?"] }
 
         it "logs a warning" do
           expect(Chef::Log).to receive(:warn).at_least(:once)
           expect(lcm).to receive(:dsc_module_import_failure?).and_call_original
-          expect { lcm.test_configuration("config", {}) }.not_to raise_error
+          expect { lcm.test_configuration("config") }.not_to raise_error
         end
       end
     end
@@ -188,12 +181,11 @@ describe Chef::Util::DSC::LocalConfigurationManager do
     end
   end
 
-  describe "#run_configuration_cmdlet" do
+  describe "#run_configuration_cmdlet", :windows_powershell_dsc_only do
     context "when invalid dsc script is given" do
       it "raises exception" do
         configuration_document = "invalid-config"
-        shellout_flags = { cwd: nil, environment: nil, timeout: nil }
-        expect { lcm.send(:run_configuration_cmdlet, configuration_document, true, shellout_flags) }.to raise_error(Chef::Exceptions::PowershellCmdletException)
+        expect { lcm.send(:run_configuration_cmdlet, configuration_document, true) }.to raise_error(ChefPowerShell::PowerShellExceptions::PowerShellCommandFailed)
       end
     end
   end

data/spec/unit/util/powershell/ps_credential_spec.rb

@@ -20,8 +20,8 @@ require "chef"
 require "chef/util/powershell/ps_credential"
 
 describe Chef::Util::Powershell::PSCredential do
-  let (:username) { "foo" }
-  let (:password) { "ThIsIsThEpAsSwOrD" }
+  let(:username) { "foo" }
+  let(:password) { "ThIsIsThEpAsSwOrD" }
 
   context "when username and password are provided" do
     let(:ps_credential) { Chef::Util::Powershell::PSCredential.new(username, password) }

data/spec/unit/util/selinux_spec.rb

@@ -30,6 +30,9 @@ describe Chef::Util::Selinux do
   end
 
   before do
+    allow(ChefUtils).to receive(:windows?).and_return(false)
+    allow(ENV).to receive(:[]).with("PATHEXT").and_return(nil)
+    allow(ENV).to receive(:[]).with("PATH").and_call_original
     TestClass.reset_state
     @test_instance = TestClass.new
   end
@@ -113,7 +116,7 @@ describe Chef::Util::Selinux do
   end
 
   describe "when restorecon binary exists on the system" do
-    let (:path) { "/path/to/awesome directory" }
+    let(:path) { "/path/to/awesome directory" }
 
     before do
       @restorecon_enabled_path = File.join("/sbin", "restorecon")

data/spec/unit/util/threaded_job_queue_spec.rb

@@ -21,6 +21,15 @@ end
 describe Chef::Util::ThreadedJobQueue do
   let(:queue) { Chef::Util::ThreadedJobQueue.new }
 
+  around(:example) do |example|
+    old_value = Thread.report_on_exception
+    Thread.report_on_exception = false
+
+    example.run
+
+    Thread.report_on_exception = old_value
+  end
+
   it "should pass mutex to jobs with an arity of 1" do
     job = double
     expect(job).to receive(:arity).at_least(:once).and_return(1)

data/spec/unit/win32/security_spec.rb

@@ -81,9 +81,10 @@ describe "Chef::Win32::Security", :windows_only do
 
     context "when the user has admin privileges" do
       it "returns true" do
-        allow(Chef::ReservedNames::Win32::Security).to receive(:open_current_process_token)
-        token = Chef::ReservedNames::Win32::Security.open_current_process_token
+        token = double(:process_token)
         allow(token).to receive_message_chain(:handle, :handle)
+
+        allow(Chef::ReservedNames::Win32::Security).to receive(:open_current_process_token).and_return(token)
         allow(Chef::ReservedNames::Win32::Security).to receive(:get_token_information_elevation_type)
         allow(Chef::ReservedNames::Win32::Security).to receive(:GetTokenInformation).and_return(true)
         allow_any_instance_of(FFI::Buffer).to receive(:read_ulong).and_return(1)
@@ -128,7 +129,7 @@ describe "Chef::Win32::Security", :windows_only do
     context "when FFI::LastError.error result is not ERROR_INSUFFICIENT_BUFFER and not NO_ERROR" do
       it "raises Chef::ReservedNames::Win32::Error.raise! exception" do
         expect(FFI::LastError).to receive(:error).and_return(123).at_least(:once)
-        expect { security_class.lookup_account_name "system" }.to raise_error
+        expect { security_class.lookup_account_name "system" }.to raise_error(Chef::Exceptions::Win32APIError)
       end
     end
   end

data/tasks/rspec.rb

@@ -20,17 +20,15 @@
 require "rubygems"
 require "rake"
 
-CHEF_ROOT = File.join(File.dirname(__FILE__), "..")
-
 begin
   require "rspec/core/rake_task"
 
-  desc "Run specs for Chef's Components"
+  desc "Run specs for Chef's Gem Components"
   task :component_specs do
     %w{chef-utils chef-config}.each do |gem|
       Dir.chdir(gem) do
         Bundler.with_unbundled_env do
-          sh("bundle install")
+          sh("bundle install --jobs=3 --retry=3 --path=../vendor/bundle")
           sh("bundle exec rake spec")
         end
       end