chef 15.12.22-universal-mingw32 → 15.16.4-universal-mingw32

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/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.query(:whatprovides, "tcpdump") }.to raise_error(/your hands in the air/)
   end

data/spec/unit/provider/package/freebsd/pkgng_spec.rb

@@ -66,7 +66,7 @@ describe Chef::Provider::Package::Freebsd::Port do
     end
 
     it "should query pkg database" do
-      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "zsh", env: nil, returns: [0, 70], timeout: 900).and_return(@pkg_info)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "zsh", env: nil, returns: [0, 1, 70], timeout: 900).and_return(@pkg_info)
       expect(@provider.current_installed_version).to eq("3.1.7")
     end
   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/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/arch_service_spec.rb

@@ -37,7 +37,8 @@ describe Chef::Provider::Service::Arch, "load_current_resource" do
 
     @provider = Chef::Provider::Service::Arch.new(@new_resource, @run_context)
 
-    allow(::File).to receive(:exists?).with("/etc/rc.conf").and_return(true)
+    allow(::File).to receive(:exist?).with("/etc/rc.d/chef").and_return(false)
+    allow(::File).to receive(:exist?).with("/etc/rc.conf").and_return(true)
     allow(::File).to receive(:read).with("/etc/rc.conf").and_return("DAEMONS=(network apache sshd)")
   end
 
@@ -106,7 +107,7 @@ describe Chef::Provider::Service::Arch, "load_current_resource" do
   end
 
   it "should fail if file /etc/rc.conf does not exist" do
-    allow(::File).to receive(:exists?).with("/etc/rc.conf").and_return(false)
+    allow(::File).to receive(:exist?).with("/etc/rc.conf").and_return(false)
     expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Service)
   end
 

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

@@ -47,7 +47,7 @@ describe Chef::Provider::Service::Debian do
 
   describe "load_current_resource" do
     it "ensures /usr/sbin/update-rc.d is available" do
-      expect(File).to receive(:exists?).with("/usr/sbin/update-rc.d") .and_return(false)
+      expect(File).to receive(:exist?).with("/usr/sbin/update-rc.d").and_return(false)
 
       @provider.define_resource_requirements
       expect do

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

@@ -32,16 +32,16 @@ describe Chef::Provider::Service::Gentoo do
     allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
     @status = double("Status", exitstatus: 0, stdout: @stdout)
     allow(@provider).to receive(:shell_out).and_return(@status)
-    allow(File).to receive(:exists?).with("/etc/init.d/chef").and_return(true)
-    allow(File).to receive(:exists?).with("/sbin/rc-update").and_return(true)
-    allow(File).to receive(:exists?).with("/etc/runlevels/default/chef").and_return(false)
+    allow(File).to receive(:exist?).with("/etc/init.d/chef").and_return(true)
+    allow(File).to receive(:exist?).with("/sbin/rc-update").and_return(true)
+    allow(File).to receive(:exist?).with("/etc/runlevels/default/chef").and_return(false)
     allow(File).to receive(:readable?).with("/etc/runlevels/default/chef").and_return(false)
   end
   # new test: found_enabled state
   #
   describe "load_current_resource" do
     it "should raise Chef::Exceptions::Service if /sbin/rc-update does not exist" do
-      expect(File).to receive(:exists?).with("/sbin/rc-update").and_return(false)
+      expect(File).to receive(:exist?).with("/sbin/rc-update").and_return(false)
       @provider.define_resource_requirements
       expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
     end
@@ -65,7 +65,7 @@ describe Chef::Provider::Service::Gentoo do
 
         describe "and the file exists and is readable" do
           before do
-            allow(File).to receive(:exists?).with("/etc/runlevels/default/chef").and_return(true)
+            allow(File).to receive(:exist?).with("/etc/runlevels/default/chef").and_return(true)
             allow(File).to receive(:readable?).with("/etc/runlevels/default/chef").and_return(true)
           end
           it "should set enabled to true" do
@@ -76,7 +76,7 @@ describe Chef::Provider::Service::Gentoo do
 
         describe "and the file exists but is not readable" do
           before do
-            allow(File).to receive(:exists?).with("/etc/runlevels/default/chef").and_return(true)
+            allow(File).to receive(:exist?).with("/etc/runlevels/default/chef").and_return(true)
             allow(File).to receive(:readable?).with("/etc/runlevels/default/chef").and_return(false)
           end
 
@@ -88,7 +88,7 @@ describe Chef::Provider::Service::Gentoo do
 
         describe "and the file does not exist" do
           before do
-            allow(File).to receive(:exists?).with("/etc/runlevels/default/chef").and_return(false)
+            allow(File).to receive(:exist?).with("/etc/runlevels/default/chef").and_return(false)
             allow(File).to receive(:readable?).with("/etc/runlevels/default/chef").and_return("foobarbaz")
           end
 

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

@@ -86,7 +86,7 @@ describe Chef::Provider::Service::Macosx do
               .with(/(#{su_cmd} '#{cmd}'|#{cmd})/, default_env: false)
               .and_return(double("Status",
                 stdout: launchctl_stdout, exitstatus: 0))
-            allow(File).to receive(:exists?).and_return([true], [])
+            allow(File).to receive(:exist?).and_return([true], [])
             allow(provider).to receive(:shell_out!)
               .with(/plutil -convert xml1 -o/, default_env: false)
               .and_return(double("Status", stdout: plutil_stdout))
@@ -112,7 +112,7 @@ describe Chef::Provider::Service::Macosx do
 
                 before do
                   allow(Dir).to receive(:glob).and_return([])
-                  allow(File).to receive(:exists?).and_return([true], [])
+                  allow(File).to receive(:exist?).and_return([true], [])
                   allow(provider).to receive(:shell_out!)
                     .with(/plutil -convert xml1 -o/)
                     .and_raise(Mixlib::ShellOut::ShellCommandFailed)
@@ -168,7 +168,7 @@ describe Chef::Provider::Service::Macosx do
               describe "running unsupported actions" do
                 before do
                   allow(Dir).to receive(:glob).and_return([(plist).to_s], [])
-                  allow(File).to receive(:exists?).and_return([true], [])
+                  allow(File).to receive(:exist?).and_return([true], [])
                 end
                 it "should throw an exception when reload action is attempted" do
                   expect { provider.run_action(:reload) }.to raise_error(Chef::Exceptions::UnsupportedAction)

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

@@ -21,7 +21,7 @@ require "ostruct"
 
 shared_examples_for "define_resource_requirements_common" do
   it "should raise an error if /sbin/chkconfig does not exist" do
-    allow(File).to receive(:exists?).with("/sbin/chkconfig").and_return(false)
+    allow(File).to receive(:exist?).with("/sbin/chkconfig").and_return(false)
     allow(@provider).to receive(:shell_out).with("/sbin/service chef status").and_raise(Errno::ENOENT)
     allow(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_raise(Errno::ENOENT)
     @provider.load_current_resource
@@ -55,7 +55,7 @@ describe "Chef::Provider::Service::Redhat" do
     @provider = Chef::Provider::Service::Redhat.new(@new_resource, @run_context)
     @provider.action = :start
     allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
-    allow(File).to receive(:exists?).with("/sbin/chkconfig").and_return(true)
+    allow(File).to receive(:exist?).with("/sbin/chkconfig").and_return(true)
   end
 
   describe "while not in why run mode" do

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

@@ -74,7 +74,7 @@ describe Chef::Provider::Service::Upstart do
       @status = double("Status", exitstatus: 0, stdout: "", stderr: "")
       allow(@provider).to receive(:shell_out).and_return(@status)
 
-      allow(::File).to receive(:exists?).and_return(true)
+      allow(::File).to receive(:exist?).and_return(true)
       allow(::File).to receive(:open).and_return(true)
     end
 
@@ -181,13 +181,13 @@ describe Chef::Provider::Service::Upstart do
     end
 
     it "should assume disable when no job configuration file is found" do
-      allow(::File).to receive(:exists?).and_return(false)
+      allow(::File).to receive(:exist?).and_return(false)
       expect(@current_resource).to receive(:running).with(false)
       @provider.load_current_resource
     end
 
     it "should track state when the upstart configuration file fails to load" do
-      expect(File).to receive(:exists?).and_return false
+      expect(File).to receive(:exist?).and_return false
       @provider.load_current_resource
       expect(@provider.instance_variable_get("@config_file_found")).to eq(false)
     end

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