chef 13.12.14-universal-mingw32 → 14.0.190-universal-mingw32

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

@@ -33,8 +33,10 @@ require "ostruct"
 describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
   include GemspecBackcompatCreator
 
+  let(:logger) { double("Mixlib::Log::Child").as_null_object }
   before do
     @gem_env = Chef::Provider::Package::Rubygems::CurrentGemEnvironment.new
+    allow(@gem_env).to receive(:logger).and_return(logger)
   end
 
   it "determines the gem paths from the in memory rubygems" do
@@ -43,7 +45,10 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
 
   it "determines the installed versions of gems from Gem.source_index" do
     gems = [gemspec("rspec-core", Gem::Version.new("1.2.9")), gemspec("rspec-core", Gem::Version.new("1.3.0"))]
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new("1.8.0")
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new("2.7")
+      expect(Gem::Specification).to receive(:dirs).and_return(["/path/to/gems/specifications", "/another/path/to/gems/specifications"])
+      expect(Gem::Specification).to receive(:installed_stubs).with(["/path/to/gems/specifications", "/another/path/to/gems/specifications"], "rspec-core-*.gemspec").and_return(gems)
+    elsif Gem::Version.new(Gem::VERSION) >= Gem::Version.new("1.8.0")
       expect(Gem::Specification).to receive(:find_all_by_name).with("rspec-core", Gem::Dependency.new("rspec-core").requirement).and_return(gems)
     else
       expect(Gem.source_index).to receive(:search).with(Gem::Dependency.new("rspec-core", nil)).and_return(gems)
@@ -219,7 +224,11 @@ describe Chef::Provider::Package::Rubygems::AlternateGemEnvironment do
   it "determines the installed versions of gems from the source index" do
     gems = [gemspec("rspec", Gem::Version.new("1.2.9")), gemspec("rspec", Gem::Version.new("1.3.0"))]
     rspec_dep = Gem::Dependency.new("rspec", nil)
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new("1.8.0")
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new("2.7")
+      allow(@gem_env).to receive(:gem_specification).and_return(Gem::Specification)
+      expect(Gem::Specification).to receive(:dirs).and_return(["/path/to/gems/specifications", "/another/path/to/gems/specifications"])
+      expect(Gem::Specification).to receive(:installed_stubs).with(["/path/to/gems/specifications", "/another/path/to/gems/specifications"], "rspec-*.gemspec").and_return(gems)
+    elsif Gem::Version.new(Gem::VERSION) >= Gem::Version.new("1.8.0")
       allow(@gem_env).to receive(:gem_specification).and_return(Gem::Specification)
       expect(@gem_env.gem_specification).to receive(:find_all_by_name).with(rspec_dep.name, rspec_dep.requirement).and_return(gems)
     else

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

@@ -394,25 +394,6 @@ describe Chef::Provider::Package::Windows, :windows_only do
         end
       end
     end
-
-    context "a missing local file is given" 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)
-        provider.load_current_resource
-      end
-
-      it "raises a Package error" do
-        expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
-      end
-
-      it "why_run mode doesn't raise an error" do
-        Chef::Config[:why_run] = true
-        expect { provider.run_action(:install) }.not_to raise_error
-        Chef::Config[:why_run] = false
-      end
-    end
   end
 
   shared_context "valid checksum" do

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

@@ -0,0 +1,29 @@
+#
+# Copyright:: Copyright 2017-2017, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+
+# NOTE: most of the tests of this functionality are baked into the func tests for the yum package provider
+
+describe Chef::Provider::Package::Yum::PythonHelper do
+  let(:helper) { Chef::Provider::Package::Yum::PythonHelper.instance }
+
+  it "propagates stacktraces on stderr from the forked subprocess", :rhel do
+    allow(helper).to receive(:yum_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
+end

data/spec/unit/provider/package/yum/yum_cache_spec.rb

@@ -1,6 +1,5 @@
 #
-# Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# Copyright:: Copyright 2018-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,9 +18,92 @@
 require "spec_helper"
 
 describe Chef::Provider::Package::Yum::YumCache do
+  let(:yum_cache) { Chef::Provider::Package::Yum::YumCache.instance }
 
-  it "can find yum-dump.py" do
-    expect(File.exist?(Chef::Provider::Package::Yum::YumCache.instance.yum_dump_path)).to be true
+  let(:python_helper) { instance_double(Chef::Provider::Package::Yum::PythonHelper) }
+
+  def yum_version(name, version, arch)
+    Chef::Provider::Package::Yum::Version.new(name, version, arch)
+  end
+
+  before(:each) do
+    allow( yum_cache ).to receive(:python_helper).and_return(python_helper)
+  end
+
+  it "package_available? returns false if the helper reports the available version is nil" do
+    expect( python_helper ).to receive(:package_query).with(:whatavailable, "foo", arch: nil).and_return( yum_version("foo", nil, nil) )
+    expect( yum_cache.package_available?("foo") ).to be false
+  end
+
+  it "package_available? returns true if the helper returns an available version" do
+    expect( python_helper ).to receive(:package_query).with(:whatavailable, "foo", arch: nil).and_return( yum_version("foo", "1.2.3-1", "x86_64") )
+    expect( yum_cache.package_available?("foo") ).to be true
+  end
+
+  it "version_available? returns false if the helper reports the available version is nil" do
+    expect( python_helper ).to receive(:package_query).with(:whatavailable, "foo", version: "1.2.3", arch: nil).and_return( yum_version("foo", nil, nil) )
+    expect( yum_cache.version_available?("foo", "1.2.3") ).to be false
+  end
+
+  it "version_available? returns true if the helper returns an available version" do
+    expect( python_helper ).to receive(:package_query).with(:whatavailable, "foo", version: "1.2.3", arch: nil).and_return( yum_version("foo", "1.2.3-1", "x86_64") )
+    expect( yum_cache.version_available?("foo", "1.2.3") ).to be true
+  end
+
+  it "version_available? with an arch returns false if the helper reports the available version is nil" do
+    expect( python_helper ).to receive(:package_query).with(:whatavailable, "foo", version: "1.2.3", arch: "x86_64").and_return( yum_version("foo", nil, nil) )
+    expect( yum_cache.version_available?("foo", "1.2.3", "x86_64") ).to be false
+  end
+
+  it "version_available? with an arch returns true if the helper returns an available version" do
+    expect( python_helper ).to receive(:package_query).with(:whatavailable, "foo", version: "1.2.3", arch: "x86_64").and_return( yum_version("foo", "1.2.3-1", "x86_64") )
+    expect( yum_cache.version_available?("foo", "1.2.3", "x86_64") ).to be true
+  end
+
+  [ :refresh, :reload, :reload_installed, :reload_provides, :reset, :reset_installed ].each do |method|
+    it "restarts the python helper when #{method} is called" do
+      expect( python_helper ).to receive(:restart)
+      yum_cache.send(method)
+    end
+  end
+
+  it "installed_version? returns nil if the helper reports the installed version is nil" do
+    expect( python_helper ).to receive(:package_query).with(:whatinstalled, "foo", arch: nil).and_return( yum_version("foo", nil, nil) )
+    expect( yum_cache.installed_version("foo") ).to be nil
+  end
+
+  it "installed_version? returns version string if the helper returns an installed version" do
+    expect( python_helper ).to receive(:package_query).with(:whatinstalled, "foo", arch: nil).and_return( yum_version("foo", "1.2.3-1", "x86_64") )
+    expect( yum_cache.installed_version("foo") ).to eql("1.2.3-1.x86_64")
+  end
+
+  it "installed_version? returns nil if the helper reports the installed version is nil" do
+    expect( python_helper ).to receive(:package_query).with(:whatinstalled, "foo", arch: "x86_64").and_return( yum_version("foo", nil, nil) )
+    expect( yum_cache.installed_version("foo", "x86_64") ).to be nil
+  end
+
+  it "installed_version? returns version string if the helper returns an installed version" do
+    expect( python_helper ).to receive(:package_query).with(:whatinstalled, "foo", arch: "x86_64").and_return( yum_version("foo", "1.2.3-1", "x86_64") )
+    expect( yum_cache.installed_version("foo", "x86_64") ).to eql("1.2.3-1.x86_64")
+  end
+
+  it "available_version? returns nil if the helper reports the available version is nil" do
+    expect( python_helper ).to receive(:package_query).with(:whatavailable, "foo", arch: nil).and_return( yum_version("foo", nil, nil) )
+    expect( yum_cache.available_version("foo") ).to be nil
+  end
+
+  it "available_version? returns version string if the helper returns an available version" do
+    expect( python_helper ).to receive(:package_query).with(:whatavailable, "foo", arch: nil).and_return( yum_version("foo", "1.2.3-1", "x86_64") )
+    expect( yum_cache.available_version("foo") ).to eql("1.2.3-1.x86_64")
+  end
+
+  it "available_version? returns nil if the helper reports the available version is nil" do
+    expect( python_helper ).to receive(:package_query).with(:whatavailable, "foo", arch: "x86_64").and_return( yum_version("foo", nil, nil) )
+    expect( yum_cache.available_version("foo", "x86_64") ).to be nil
   end
 
+  it "available_version? returns version string if the helper returns an available version" do
+    expect( python_helper ).to receive(:package_query).with(:whatavailable, "foo", arch: "x86_64").and_return( yum_version("foo", "1.2.3-1", "x86_64") )
+    expect( yum_cache.available_version("foo", "x86_64") ).to eql("1.2.3-1.x86_64")
+  end
 end

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

@@ -88,6 +88,14 @@ describe Chef::Provider::Package::Zypper do
       provider.load_current_resource
     end
 
+    it "should set the installed version if zypper info has one (zypper version >= 1.13.17)" do
+      status = double(:stdout => "Version        : 1.0\nInstalled      : Yes (automatically)\n", :exitstatus => 0)
+
+      allow(provider).to receive(:shell_out!).and_return(status)
+      expect(current_resource).to receive(:version).with(["1.0"]).and_return(true)
+      provider.load_current_resource
+    end
+
     it "should set the candidate version if zypper info has one (zypper version < 1.13.0)" do
       status = double(:stdout => "Version: 1.0\nInstalled: No\nStatus: out-of-date (version 0.9 installed)", :exitstatus => 0)
 

data/spec/unit/provider/package_spec.rb

@@ -26,17 +26,24 @@ describe Chef::Provider::Package do
     node
   end
   let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:logger) { double("Mixlib::Log::Child").as_null_object }
   let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:new_resource) { Chef::Resource::Package.new("emacs") }
-  let(:current_resource) { Chef::Resource::Package.new("emacs") }
+  let(:new_resource) { Chef::Resource::Package.new("install emacs") }
+  let(:current_resource) { Chef::Resource::Package.new("install emacs") }
   let(:candidate_version) { "1.0" }
   let(:provider) do
+    new_resource.package_name = "emacs"
+    current_resource.package_name = "emacs"
     provider = Chef::Provider::Package.new(new_resource, run_context)
     provider.current_resource = current_resource
     provider.candidate_version = candidate_version
     provider
   end
 
+  before do
+    allow(run_context).to receive(:logger).and_return(logger)
+  end
+
   describe "when installing a package" do
     before(:each) do
       provider.current_resource = current_resource
@@ -57,7 +64,7 @@ describe Chef::Provider::Package do
     it "should call preseed_package if a response_file is given" do
       new_resource.response_file("foo")
       expect(provider).to receive(:get_preseed_file).with(
-        new_resource.name,
+        new_resource.package_name,
         provider.candidate_version
       ).and_return("/var/cache/preseed-test")
 
@@ -74,7 +81,7 @@ describe Chef::Provider::Package do
 
     it "should install the package at the candidate_version if it is not already installed" do
       expect(provider).to receive(:install_package).with(
-        new_resource.name,
+        new_resource.package_name,
         provider.candidate_version
       ).and_return(true)
       provider.run_action(:install)
@@ -84,7 +91,7 @@ describe Chef::Provider::Package do
     it "should install the package at the version specified if it is not already installed" do
       new_resource.version("1.0")
       expect(provider).to receive(:install_package).with(
-        new_resource.name,
+        new_resource.package_name,
         new_resource.version
       ).and_return(true)
       provider.run_action(:install)
@@ -95,7 +102,7 @@ describe Chef::Provider::Package do
       new_resource.version("1.0")
       allow(current_resource).to receive(:version).and_return("0.99")
       expect(provider).to receive(:install_package).with(
-        new_resource.name,
+        new_resource.package_name,
         new_resource.version
       ).and_return(true)
       provider.run_action(:install)
@@ -143,7 +150,7 @@ describe Chef::Provider::Package do
 
     it "should upgrade the package if the current version is not the candidate version" do
       expect(provider).to receive(:upgrade_package).with(
-        new_resource.name,
+        new_resource.package_name,
         provider.candidate_version
       ).and_return(true)
       provider.run_action(:upgrade)
@@ -164,7 +171,7 @@ describe Chef::Provider::Package do
 
     it "should print the word 'uninstalled' if there was no original version" do
       allow(current_resource).to receive(:version).and_return(nil)
-      expect(Chef::Log).to receive(:info).with("package[emacs] upgraded emacs to 1.0")
+      expect(logger).to receive(:info).with("package[install emacs] upgraded emacs to 1.0")
       provider.run_action(:upgrade)
       expect(new_resource).to be_updated_by_last_action
     end
@@ -285,7 +292,7 @@ describe Chef::Provider::Package do
       expect(provider).to receive(:get_preseed_file).and_return("/var/cache/preseed-test")
       allow(provider).to receive(:preseed_package).and_return(true)
       allow(provider).to receive(:reconfig_package).and_return(true)
-      expect(Chef::Log).to receive(:info).with("package[emacs] reconfigured")
+      expect(logger).to receive(:info).with("package[install emacs] reconfigured")
       expect(provider).to receive(:reconfig_package)
       provider.run_action(:reconfig)
       expect(new_resource).to be_updated
@@ -294,7 +301,7 @@ describe Chef::Provider::Package do
 
     it "should debug log and not reconfigure the package if the package is not installed" do
       allow(current_resource).to receive(:version).and_return(nil)
-      expect(Chef::Log).to receive(:debug).with("package[emacs] is NOT installed - nothing to do")
+      expect(logger).to receive(:trace).with("package[install emacs] is NOT installed - nothing to do")
       expect(provider).not_to receive(:reconfig_package)
       provider.run_action(:reconfig)
       expect(new_resource).not_to be_updated_by_last_action
@@ -303,7 +310,7 @@ describe Chef::Provider::Package do
     it "should debug log and not reconfigure the package if no response_file is given" do
       allow(current_resource).to receive(:version).and_return("1.0")
       allow(new_resource).to receive(:response_file).and_return(nil)
-      expect(Chef::Log).to receive(:debug).with("package[emacs] no response_file provided - nothing to do")
+      expect(logger).to receive(:trace).with("package[install emacs] no response_file provided - nothing to do")
       expect(provider).not_to receive(:reconfig_package)
       provider.run_action(:reconfig)
       expect(new_resource).not_to be_updated_by_last_action
@@ -314,7 +321,7 @@ describe Chef::Provider::Package do
       allow(new_resource).to receive(:response_file).and_return(true)
       expect(provider).to receive(:get_preseed_file).and_return(false)
       allow(provider).to receive(:preseed_package).and_return(false)
-      expect(Chef::Log).to receive(:debug).with("package[emacs] preseeding has not changed - nothing to do")
+      expect(logger).to receive(:trace).with("package[install emacs] preseeding has not changed - nothing to do")
       expect(provider).not_to receive(:reconfig_package)
       provider.run_action(:reconfig)
       expect(new_resource).not_to be_updated_by_last_action
@@ -323,24 +330,35 @@ describe Chef::Provider::Package do
 
   describe "When locking the package" do
     before(:each) do
-      allow(provider).to receive(:lock_package).and_return(true)
+      allow(provider).to receive(:lock_package).with(
+        new_resource.package_name,
+        nil
+      ).and_return(true)
     end
 
     it "should lock the package if it is unlocked" do
-      allow(provider).to receive(:package_locked).and_return(false)
-      expect(provider).to receive(:lock_package)
+      allow(provider).to receive(:package_locked).with(
+        new_resource.package_name,
+        nil
+      ).and_return(false)
       provider.run_action(:lock)
     end
 
     it "should not lock the package if it is already locked" do
-      allow(provider).to receive(:package_locked).and_return(true)
+      allow(provider).to receive(:package_locked).with(
+        new_resource.package_name,
+        nil
+      ).and_return(true)
       expect(provider).not_to receive(:lock_package)
       provider.run_action(:lock)
       expect(new_resource).not_to be_updated_by_last_action
     end
 
     it "should set the resource to updated if it locks the package" do
-      allow(provider).to receive(:package_locked).and_return(false)
+      allow(provider).to receive(:package_locked).with(
+        new_resource.package_name,
+        nil
+      ).and_return(false)
       provider.run_action(:lock)
       expect(new_resource).to be_updated
     end
@@ -352,20 +370,29 @@ describe Chef::Provider::Package do
     end
 
     it "should unlock the package if it is locked" do
-      allow(provider).to receive(:package_locked).and_return(true)
+      allow(provider).to receive(:package_locked).with(
+        new_resource.package_name,
+        nil
+      ).and_return(true)
       expect(provider).to receive(:unlock_package)
       provider.run_action(:unlock)
     end
 
     it "should not unlock the package if it is already unlocked" do
-      allow(provider).to receive(:package_locked).and_return(false)
+      allow(provider).to receive(:package_locked).with(
+        new_resource.package_name,
+        nil
+      ).and_return(false)
       expect(provider).not_to receive(:unlock_package)
       provider.run_action(:unlock)
       expect(new_resource).not_to be_updated_by_last_action
     end
 
     it "should set the resource to updated if it unlocks the package" do
-      allow(provider).to receive(:package_locked).and_return(true)
+      allow(provider).to receive(:package_locked).with(
+        new_resource.package_name,
+        nil
+      ).and_return(true)
       provider.run_action(:unlock)
       expect(new_resource).to be_updated
     end

data/spec/unit/provider/registry_key_spec.rb

@@ -313,7 +313,13 @@ describe Chef::Provider::RegistryKey do
 end
 
 describe Chef::Provider::RegistryKey, "key_missing?" do
-  let(:provider) { Chef::Provider::RegistryKey.new(nil, nil) }
+  let(:node) { Chef::Node.new }
+  let(:events) { double("Chef::Events").as_null_object }
+  let(:logger) { double("Mixlib::Log::Child").as_null_object }
+  let(:run_context) { double("Chef::RunContext", node: node, events: events, logger: logger) }
+  let(:new_resource) { Chef::Resource::RegistryKey.new("emacs") }
+  let(:provider) { Chef::Provider::RegistryKey.new(new_resource, run_context) }
+
   let(:all_keys_present_in_all_hash) do
     [ { :name => "input1_value1", :type => :string, :data => "my_value1" },
       { :name => "input1_value2", :type => :string, :data => "my_value2" },

data/spec/unit/provider/remote_directory_spec.rb

@@ -193,7 +193,7 @@ describe Chef::Provider::RemoteDirectory do
         expect(::File.exist?(@destination_dir + "/a/multiply/nested/directory/qux.txt")).to be_falsey
       end
 
-      it "removes directory symlinks properly", :not_supported_on_win2k3 do
+      it "removes directory symlinks properly" do
         symlinked_dir_path = @destination_dir + "/symlinked_dir"
         @provider.action = :create
         @provider.run_action

data/spec/unit/provider/remote_file_spec.rb

@@ -36,7 +36,8 @@ describe Chef::Provider::RemoteFile do
 
   let(:node) { double("Chef::Node") }
   let(:events) { double("Chef::Events").as_null_object } # mock all the methods
-  let(:run_context) { double("Chef::RunContext", :node => node, :events => events) }
+  let(:logger) { double("Mixlib::Log::Child").as_null_object }
+  let(:run_context) { double("Chef::RunContext", :node => node, :events => events, :logger => logger) }
   let(:enclosing_directory) do
     canonicalize_path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates")))
   end

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

@@ -44,6 +44,7 @@ describe Chef::Provider::Service::Macosx do
   context "when service name is given as" do
     let(:node) { Chef::Node.new }
     let(:events) { Chef::EventDispatch::Dispatcher.new }
+    let(:logger) { double("Mixlib::Log::Child").as_null_object }
     let(:run_context) { Chef::RunContext.new(node, {}, events) }
     let(:provider) { described_class.new(new_resource, run_context) }
     let(:launchctl_stdout) { StringIO.new }
@@ -73,6 +74,7 @@ XML
           end
           let(:service_label) { "io.redis.redis-server" }
           before do
+            allow(run_context).to receive(:logger).and_return(logger)
             allow(Dir).to receive(:glob).and_return([plist], [])
             @stat = double("File::Stat", { :uid => 501 })
             allow(File).to receive(:stat).and_return(@stat)
@@ -260,7 +262,7 @@ SVC_LIST
 
               it "shows warning message if service is already running" do
                 allow(current_resource).to receive(:running).and_return(true)
-                expect(Chef::Log).to receive(:debug).with("macosx_service[#{service_name}] already running, not starting")
+                expect(logger).to receive(:trace).with("macosx_service[#{service_name}] already running, not starting")
 
                 provider.start_service
               end
@@ -292,7 +294,7 @@ SVC_LIST
 
               it "shows warning message if service is not running" do
                 allow(current_resource).to receive(:running).and_return(false)
-                expect(Chef::Log).to receive(:debug).with("macosx_service[#{service_name}] not running, not stopping")
+                expect(logger).to receive(:trace).with("macosx_service[#{service_name}] not running, not stopping")
 
                 provider.stop_service
               end