chef 16.2.73 → 16.3.38

data/spec/unit/property_spec.rb

@@ -111,11 +111,11 @@ describe "Chef::Resource.property" do
 
   with_property ":Straße" do
     it "properties with UTF-8 in their name work" do
-      expect(resource.Straße).to eql(nil)
-      expect(resource.Straße "foo").to eql("foo")
-      expect(resource.Straße).to eql("foo")
-      expect(resource.Straße = "bar").to eql("bar")
-      expect(resource.Straße).to eql("bar")
+      expect(resource.Straße).to eql(nil) # rubocop: disable Naming/AsciiIdentifiers
+      expect(resource.Straße "foo").to eql("foo") # rubocop: disable Naming/AsciiIdentifiers
+      expect(resource.Straße).to eql("foo") # rubocop: disable Naming/AsciiIdentifiers
+      expect(resource.Straße = "bar").to eql("bar") # rubocop: disable Naming/AsciiIdentifiers
+      expect(resource.Straße).to eql("bar") # rubocop: disable Naming/AsciiIdentifiers
     end
   end
 

data/spec/unit/provider/execute_spec.rb

@@ -43,17 +43,10 @@ describe Chef::Provider::Execute do
   before do
     allow(Chef::EventDispatch::EventsOutputStream).to receive(:new) { @live_stream }
     allow(ChefUtils).to receive(:windows?) { false }
-    @original_log_level = Chef::Log.level
     Chef::Log.level = :info
     allow(STDOUT).to receive(:tty?).and_return(false)
   end
 
-  after do
-    Chef::Log.level = @original_log_level
-    Chef::Config[:always_stream_execute] = false
-    Chef::Config[:daemon] = false
-  end
-
   describe "#initialize" do
     it "should return a Chef::Provider::Execute provider" do
       expect(provider.class).to eql(Chef::Provider::Execute)

data/spec/unit/provider/ifconfig_spec.rb

@@ -16,7 +16,6 @@
 # limitations under the License.
 #
 
-# require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
 require "spec_helper"
 require "chef/exceptions"
 

data/spec/unit/provider/package/dnf/python_helper_spec.rb

@@ -22,7 +22,7 @@ require "spec_helper"
 describe Chef::Provider::Package::Dnf::PythonHelper do
   let(:helper) { Chef::Provider::Package::Dnf::PythonHelper.instance }
 
-  it "propagates stacktraces on stderr from the forked subprocess" do
+  it "propagates stacktraces on stderr from the forked subprocess", :rhel do
     allow(helper).to receive(:dnf_command).and_return("ruby -e 'raise \"your hands in the air\"'")
     expect { helper.package_query(:whatprovides, "tcpdump") }.to raise_error(/your hands in the air/)
   end

data/spec/unit/provider/package/rubygems_spec.rb

@@ -106,30 +106,25 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
   context "new default rubygems behavior" do
     before do
       Chef::Config[:rubygems_cache_enabled] = false
+
+      dep_installer = Gem::DependencyInstaller.new
+      expect(dep_installer).not_to receive(:find_gems_with_sources)
+      allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
     end
 
     it "finds a matching gem candidate version on rubygems 2.0.0+" do
       dep = Gem::Dependency.new("rspec", ">= 0")
-      dep_installer = Gem::DependencyInstaller.new
-      allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
-      expect(dep_installer).not_to receive(:find_gems_with_sources).with(dep).and_call_original
       expect(@gem_env.candidate_version_from_remote(dep)).to be_kind_of(Gem::Version)
     end
 
     it "gives the candidate version as nil if none is found" do
       dep = Gem::Dependency.new("lksdjflksdjflsdkfj", ">= 0")
-      dep_installer = Gem::DependencyInstaller.new
-      allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
-      expect(dep_installer).not_to receive(:find_gems_with_sources).with(dep).and_call_original
       expect(@gem_env.candidate_version_from_remote(dep)).to be_nil
     end
 
     it "finds a matching gem from a specific gemserver when explicit sources are given (to a server that doesn't respond to api requests)" do
       dep = Gem::Dependency.new("rspec", ">= 0")
-      dep_installer = Gem::DependencyInstaller.new
-      allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
-      expect(dep_installer).not_to receive(:find_gems_with_sources).with(dep).and_call_original
-      expect(@gem_env.candidate_version_from_remote(dep, "http://production.cf.rubygems.org")).to be_kind_of(Gem::Version)
+      expect(@gem_env.candidate_version_from_remote(dep, "https://rubygems.org")).to be_kind_of(Gem::Version)
     end
   end
 

data/spec/unit/provider/package/smartos_spec.rb

@@ -17,7 +17,7 @@
 # limitations under the License.
 #
 
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "spec_helper"))
+require "spec_helper"
 require "ostruct"
 
 describe Chef::Provider::Package::SmartOS, "load_current_resource" do

data/spec/unit/provider/package/windows_spec.rb

@@ -42,7 +42,7 @@ describe Chef::Provider::Package::Windows, :windows_only do
   let(:cache_path) { 'c:\\cache\\' }
 
   before(:each) do
-    allow(::File).to receive(:exist?).with(provider.new_resource.source).and_return(true)
+    allow(::File).to receive(:exist?).with(new_resource.source).and_return(true)
   end
 
   describe "load_current_resource" do
@@ -66,20 +66,22 @@ describe Chef::Provider::Package::Windows, :windows_only do
 
       it "sets the version to be installed" do
         provider.load_current_resource
-        expect(provider.new_resource.version).to eql("2.0")
+        expect(new_resource.version).to eql("2.0")
       end
     end
 
-    context "when the source is a uri" do
-      let(:resource_source) { "https://foo.bar/calculator.msi" }
-
-      context "when the source has not been downloaded" do
+    context "when the source is not present it loads from cache" do
+      context "when the package is not installed" do
         before(:each) do
-          allow(provider).to receive(:downloadable_file_missing?).and_return(true)
+          allow(provider).to receive(:uri_scheme?).and_return(false)
+          allow(provider.package_provider).to receive(:get_product_property).and_return(nil)
+          allow(provider.package_provider).to receive(:get_installed_version).and_return(nil)
+          allow(provider.package_provider).to receive(:package_version).and_return(nil)
         end
-        it "sets the current version to unknown" do
+
+        it "sets the current version nil" do
           provider.load_current_resource
-          expect(provider.current_resource.version).to eql("unknown")
+          expect(provider.current_resource.version).to eql(nil)
         end
       end
 
@@ -233,9 +235,9 @@ describe Chef::Provider::Package::Windows, :windows_only do
       end
     end
 
-    it "returns @installer_type if it is set" do
-      provider.new_resource.installer_type(:downeaster)
-      expect(provider.installer_type).to eql(:downeaster)
+    it "returns the resource's installer_type if it is set" do
+      new_resource.installer_type(:nsis)
+      expect(provider.installer_type).to eql(:nsis)
     end
 
     it "sets installer_type to inno if the source contains inno" do
@@ -275,7 +277,7 @@ describe Chef::Provider::Package::Windows, :windows_only do
 
       it "raises an error" do
         allow(::Kernel).to receive(:open).and_yield(StringIO.new(""))
-        provider.new_resource.installer_type(nil)
+        new_resource.installer_type(nil)
         expect { provider.installer_type }.to raise_error(Chef::Exceptions::CannotDetermineWindowsInstallerType)
       end
     end
@@ -312,7 +314,10 @@ describe Chef::Provider::Package::Windows, :windows_only do
       let(:resource_source) { "https://foo.bar/calculator.exe" }
 
       it "downloads the http resource" do
-        allow(File).to receive(:exist?).with('c:\cache\calculator.exe').and_return(false)
+        allow(provider).to receive(:uri_scheme?).and_return(true)
+        allow(provider).to receive(:installer_type).and_return(nil)
+        allow(File).to receive(:exist?).with("https\\foo.bar\\calculator.exe").and_return(false)
+        allow(provider).to receive(:compile_and_converge_action)
         expect(provider).to receive(:download_source_file)
         provider.run_action(:install)
       end
@@ -400,7 +405,7 @@ describe Chef::Provider::Package::Windows, :windows_only do
       let(:resource_source) { "C:/a_missing_file.exe" }
       let(:installer_type) { nil }
       before do
-        allow(::File).to receive(:exist?).with(provider.new_resource.source).and_return(false)
+        allow(::File).to receive(:exist?).with(new_resource.source).and_return(false)
         provider.load_current_resource
       end
 
@@ -414,51 +419,23 @@ describe Chef::Provider::Package::Windows, :windows_only do
         Chef::Config[:why_run] = false
       end
     end
-  end
 
-  shared_context "valid checksum" do
-    context "checksum is valid" do
-      before do
-        allow(provider).to receive(:checksum).and_return("jiie00u3bbs92vsbhvgvklb2lasgh20ah")
-      end
+    it "does not raise an error with a valid checksum" do
+      expect(Chef::Digester).to receive(:checksum_for_file).with(new_resource.source).and_return("abcdef1234567890")
+      expect(provider).to receive(:install_package)
 
-      it "does not raise the checksum mismatch exception" do
-        expect { provider.send(:validate_content!) }.to_not raise_error
-      end
-    end
-  end
-
-  shared_context "invalid checksum" do
-    context "checksum is invalid" do
-      before do
-        allow(provider).to receive(:checksum).and_return("kiie30u3bbs92vsbhvgvklb2lasgh20ah")
-      end
+      new_resource.checksum("abcdef1234567890")
 
-      it "raises the checksum mismatch exception" do
-        expect { provider.send(:validate_content!) }.to raise_error(
-          Chef::Exceptions::ChecksumMismatch
-        )
-      end
+      provider.run_action(:install)
     end
-  end
 
-  describe "validate_content!" do
-    before(:each) do
-      new_resource.checksum("jiie00u3bbs92vsbhvgvklb2lasgh20ah")
-    end
-
-    context "checksum is in lowercase" do
-      include_context "valid checksum"
-      include_context "invalid checksum"
-    end
+    it "raises an error with an invalid checksum" do
+      expect(Chef::Digester).to receive(:checksum_for_file).with(new_resource.source).and_return("abcdef1234567890")
+      expect(provider).not_to receive(:install_package)
 
-    context "checksum is in uppercase" do
-      before do
-        new_resource.checksum = new_resource.checksum.upcase
-      end
+      new_resource.checksum("ffffffffffffffff")
 
-      include_context "valid checksum"
-      include_context "invalid checksum"
+      expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
     end
   end
 end

data/spec/unit/provider/service/redhat_spec.rb

@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "spec_helper"))
+require "spec_helper"
 require "ostruct"
 
 shared_examples_for "define_resource_requirements_common" do

data/spec/unit/provider/service/windows_spec.rb

@@ -22,12 +22,8 @@ require "spec_helper"
 describe Chef::Provider::Service::Windows, "load_current_resource" do
   include_context "Win32"
 
-  before(:all) do
-    Chef::ReservedNames::Win32::Security = Class.new unless windows?
-  end
-
-  after(:all) do
-    Chef::ReservedNames::Win32.send(:remove_const, :Security) unless windows?
+  before do
+    stub_const("Chef::ReservedNames::Win32::Security", Class.new) unless windows?
   end
 
   let(:logger) { double("Mixlib::Log::Child").as_null_object }

data/spec/unit/provider/systemd_unit_spec.rb

@@ -220,31 +220,35 @@ describe Chef::Provider::SystemdUnit do
       expect(current_resource.content).to eq(nil)
     end
 
-    it "loads the user unit content if the file exists and user is set" do
-      new_resource.user("joe")
-      allow(File).to receive(:exist?)
-        .with(unit_path_user)
-        .and_return(true)
-      allow(File).to receive(:read)
-        .with(unit_path_user)
-        .and_return(unit_content_string)
-      expect(File).to receive(:exist?)
-        .with(unit_path_user)
-      expect(File).to receive(:read)
-        .with(unit_path_user)
-      provider.load_current_resource
-      expect(current_resource.content).to eq(unit_content_string)
-    end
+    # A password is required when specifying a user on Windows. Since systemd resources
+    # won't actually run on Windows, skip these tests rather than code a workaround.
+    unless windows?
+      it "loads the user unit content if the file exists and user is set" do
+        new_resource.user("joe")
+        allow(File).to receive(:exist?)
+          .with(unit_path_user)
+          .and_return(true)
+        allow(File).to receive(:read)
+          .with(unit_path_user)
+          .and_return(unit_content_string)
+        expect(File).to receive(:exist?)
+          .with(unit_path_user)
+        expect(File).to receive(:read)
+          .with(unit_path_user)
+        provider.load_current_resource
+        expect(current_resource.content).to eq(unit_content_string)
+      end
 
-    it "does not load the user unit if the file does not exist and user is set" do
-      new_resource.user("joe")
-      allow(File).to receive(:exist?)
-        .with(unit_path_user)
-        .and_return(false)
-      expect(File).to_not receive(:read)
-        .with(unit_path_user)
-      provider.load_current_resource
-      expect(current_resource.content).to eq(nil)
+      it "does not load the user unit if the file does not exist and user is set" do
+        new_resource.user("joe")
+        allow(File).to receive(:exist?)
+          .with(unit_path_user)
+          .and_return(false)
+        expect(File).to_not receive(:read)
+          .with(unit_path_user)
+        provider.load_current_resource
+        expect(current_resource.content).to eq(nil)
+      end
     end
   end
 

data/spec/unit/provider_spec.rb

@@ -20,6 +20,7 @@ require "spec_helper"
 
 class NoWhyrunDemonstrator < Chef::Provider
   attr_reader :system_state_altered
+
   def whyrun_supported?
     false
   end

data/spec/unit/resource/execute_spec.rb

@@ -63,6 +63,16 @@ describe Chef::Resource::Execute do
         expect(identity[:user]).to eq("user")
       end
     end
+
+    context "when username is passed as an integer" do
+      let(:username) { 499 }
+
+      it "correctly parses the user and domain" do
+        identity = resource.qualify_user(username, password, domain)
+        expect(identity[:domain]).to eq(nil)
+        expect(identity[:user]).to eq(499)
+      end
+    end
   end
 
   shared_examples_for "it received valid credentials" do

data/spec/unit/resource/macos_user_defaults_spec.rb

@@ -20,16 +20,117 @@ require "spec_helper"
 describe Chef::Resource::MacosUserDefaults do
 
   let(:resource) { Chef::Resource::MacosUserDefaults.new("foo") }
+  let(:provider) { resource.provider_for_action(:write) }
 
   it "has a resource name of :macos_userdefaults" do
-    expect(resource.resource_name).to eql(:macos_userdefaults)
+    expect(resource.resource_name).to eq(:macos_userdefaults)
+  end
+
+  it "the domain property defaults to NSGlobalDomain" do
+    expect(resource.domain).to eq("NSGlobalDomain")
+  end
+
+  it "the value property coerces keys in hashes to strings so we can compare them with plist data" do
+    resource.value "User": "/Library/Managed Installs/way_fake.log"
+    expect(resource.value).to eq({ "User" => "/Library/Managed Installs/way_fake.log" })
+  end
+
+  it "the host property defaults to nil" do
+    expect(resource.host).to be_nil
+  end
+
+  it "the sudo property defaults to false" do
+    expect(resource.sudo).to be false
   end
 
   it "sets the default action as :write" do
-    expect(resource.action).to eql([:write])
+    expect(resource.action).to eq([:write])
   end
 
   it "supports :write action" do
     expect { resource.action :write }.not_to raise_error
   end
+
+  describe "#defaults_export_cmd" do
+    it "exports NSGlobalDomain if no domain is set" do
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "export", "NSGlobalDomain", "-"])
+    end
+
+    it "exports a provided domain" do
+      resource.domain "com.tim"
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "export", "com.tim", "-"])
+    end
+
+    it "sets -currentHost if host is 'current'" do
+      resource.host "current"
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "-currentHost", "export", "NSGlobalDomain", "-"])
+    end
+
+    it "sets -host 'tim-laptop if host is 'tim-laptop'" do
+      resource.host "tim-laptop"
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "-host", "tim-laptop", "export", "NSGlobalDomain", "-"])
+    end
+  end
+
+  describe "#defaults_modify_cmd" do
+    # avoid needing to set these required values over and over. We'll overwrite them where necessary
+    before do
+      resource.key = "foo"
+      resource.value = "bar"
+    end
+
+    it "writes to NSGlobalDomain if domain isn't specified" do
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-string", "bar"])
+    end
+
+    it "uses the domain property if set" do
+      resource.domain = "MyCustomDomain"
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "MyCustomDomain", "foo", "-string", "bar"])
+    end
+
+    it "sets host specific values using host property" do
+      resource.host = "tims_laptop"
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "-host", "tims_laptop", "write", "NSGlobalDomain", "foo", "-string", "bar"])
+    end
+
+    it "if host is set to :current it passes CurrentHost" do
+      resource.host = :current
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "-currentHost", "write", "NSGlobalDomain", "foo", "-string", "bar"])
+    end
+
+    it "raises ArgumentError if bool is specified, but the value can't be made into a bool" do
+      resource.type "bool"
+      expect { provider.defaults_modify_cmd }.to raise_error(ArgumentError)
+    end
+
+    it "autodetects array type and passes individual values" do
+      resource.value = %w{one two three}
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-array", "one", "two", "three"])
+    end
+
+    it "autodetects string type and passes a single value" do
+      resource.value = "one"
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-string", "one"])
+    end
+
+    it "autodetects integer type and passes a single value" do
+      resource.value = 1
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-int", 1])
+    end
+
+    it "autodetects boolean type from TrueClass value and passes a 'TRUE' string" do
+      resource.value = true
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-bool", "TRUE"])
+    end
+
+    it "autodetects boolean type from FalseClass value and passes a 'FALSE' string" do
+      resource.value = false
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-bool", "FALSE"])
+    end
+
+    it "autodetects dict type from Hash value and flattens keys & values" do
+      resource.value = { "foo" => "bar" }
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-dict", "foo", "bar"])
+    end
+  end
 end