Merge branch 'master' of https://github.com/chef/chef

11 files changed, 621 insertions, 166 deletions

diff --git a/spec/unit/provider/group/groupadd_spec.rb b/spec/unit/provider/group/groupadd_spec.rb
index 93159dd16e..054d953414 100644
--- a/spec/unit/provider/group/groupadd_spec.rb
+++ b/spec/unit/provider/group/groupadd_spec.rb
@@ -18,156 +18,175 @@
 
 require "spec_helper"
 
-describe Chef::Provider::Group::Groupadd, "set_options" do
-  before do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-    @new_resource = Chef::Resource::Group.new("aj")
-    @new_resource.gid(50)
-    @new_resource.members(%w{root aj})
-    @new_resource.system false
-    @new_resource.non_unique false
-    @current_resource = Chef::Resource::Group.new("aj")
-    @current_resource.gid(50)
-    @current_resource.members(%w{root aj})
-    @current_resource.system false
-    @current_resource.non_unique false
-    @provider = Chef::Provider::Group::Groupadd.new(@new_resource, @run_context)
-    @provider.current_resource = @current_resource
-  end
-
-  field_list = {
-    :gid => "-g",
-  }
-
-  field_list.each do |attribute, option|
-    it "should check for differences in #{attribute} between the current and new resources" do
-      expect(@new_resource).to receive(attribute)
-      expect(@current_resource).to receive(attribute)
-      @provider.set_options
+describe Chef::Provider::Group::Groupadd do
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:new_resource) do
+    Chef::Resource::Group.new("aj").tap do |r|
+      r.gid 50
+      r.members %w{root aj}
+      r.system false
+      r.non_unique false
     end
-    it "should set the option for #{attribute} if the new resources #{attribute} is not null" do
-      allow(@new_resource).to receive(attribute).and_return("wowaweea")
-      expect(@provider.set_options).to eql(" #{option} '#{@new_resource.send(attribute)}' #{@new_resource.group_name}")
+  end
+  let(:current_resource) do
+    Chef::Resource::Group.new("aj").tap do |r|
+      r.gid 50
+      r.members %w{root aj}
+      r.system false
+      r.non_unique false
     end
   end
-
-  it "should combine all the possible options" do
-    match_string = ""
-    field_list.sort { |a, b| a[0] <=> b[0] }.each do |attribute, option|
-      allow(@new_resource).to receive(attribute).and_return("hola")
-      match_string << " #{option} 'hola'"
+  let(:provider) do
+    described_class.new(new_resource, run_context).tap do |p|
+      p.current_resource = current_resource
     end
-    match_string << " aj"
-    expect(@provider.set_options).to eql(match_string)
   end
 
-  describe "when we want to create a system group" do
-    it "should not set groupadd_options '-r' when system is false" do
-      @new_resource.system(false)
-      expect(@provider.groupadd_options).not_to match(/-r/)
+  describe "#set_options" do
+    field_list = {
+      :gid => "-g",
+    }
+
+    field_list.each do |attribute, option|
+      it "should check for differences in #{attribute} between the current and new resources" do
+        expect(new_resource).to receive(attribute)
+        expect(current_resource).to receive(attribute)
+        provider.set_options
+      end
+
+      it "should set the option for #{attribute} if the new resources #{attribute} is not null" do
+        allow(new_resource).to receive(attribute).and_return("wowaweea")
+        expect(provider.set_options).to eql(" #{option} '#{new_resource.send(attribute)}' #{new_resource.group_name}")
+      end
     end
 
-    it "should set groupadd -r if system is true" do
-      @new_resource.system(true)
-      expect(@provider.groupadd_options).to eq(" -r")
+    it "should combine all the possible options" do
+      match_string = ""
+      field_list.sort { |a, b| a[0] <=> b[0] }.each do |attribute, option|
+        allow(new_resource).to receive(attribute).and_return("hola")
+        match_string << " #{option} 'hola'"
+      end
+      match_string << " aj"
+      expect(provider.set_options).to eql(match_string)
     end
-  end
 
-  describe "when we want to create a non_unique gid group" do
-    it "should not set groupadd_options '-o' when non_unique is false" do
-      @new_resource.non_unique(false)
-      expect(@provider.groupadd_options).not_to match(/-o/)
+    describe "when we want to create a system group" do
+      it "should not set groupadd_options '-r' when system is false" do
+        new_resource.system(false)
+        expect(provider.groupadd_options).not_to match(/-r/)
+      end
+
+      it "should set groupadd -r if system is true" do
+        new_resource.system(true)
+        expect(provider.groupadd_options).to eq(" -r")
+      end
+
+      context "on Solaris" do
+        before { node.automatic["platform"] = "solaris2" }
+        it "should not set groupadd -r if system is true" do
+          new_resource.system(true)
+          expect(provider.groupadd_options).not_to match(/-r/)
+        end
+      end
     end
 
-    it "should set groupadd -o if non_unique is true" do
-      @new_resource.non_unique(true)
-      expect(@provider.groupadd_options).to eq(" -o")
-    end
-  end
-end
+    describe "when we want to create a non_unique gid group" do
+      it "should not set groupadd_options '-o' when non_unique is false" do
+        new_resource.non_unique(false)
+        expect(provider.groupadd_options).not_to match(/-o/)
+      end
 
-describe Chef::Provider::Group::Groupadd, "create_group" do
-  before do
-    @node = Chef::Node.new
-    @new_resource = Chef::Resource::Group.new("aj")
-    @provider = Chef::Provider::Group::Groupadd.new(@node, @new_resource)
-    allow(@provider).to receive(:run_command).and_return(true)
-    allow(@provider).to receive(:set_options).and_return(" monkey")
-    allow(@provider).to receive(:groupadd_options).and_return("")
-    allow(@provider).to receive(:modify_group_members).and_return(true)
+      it "should set groupadd -o if non_unique is true" do
+        new_resource.non_unique(true)
+        expect(provider.groupadd_options).to eq(" -o")
+      end
+    end
   end
 
-  it "should run groupadd with the return of set_options" do
-    expect(@provider).to receive(:run_command).with({ :command => "groupadd monkey" }).and_return(true)
-    @provider.create_group
-  end
+  describe "#create_group" do
+    before do
+      allow(provider).to receive(:run_command).and_return(true)
+      allow(provider).to receive(:set_options).and_return(" monkey")
+      allow(provider).to receive(:groupadd_options).and_return("")
+      allow(provider).to receive(:modify_group_members).and_return(true)
+    end
 
-  it "should modify the group members" do
-    expect(@provider).to receive(:modify_group_members).and_return(true)
-    @provider.create_group
-  end
-end
+    it "should run groupadd with the return of set_options" do
+      expect(provider).to receive(:run_command).with({ :command => "groupadd monkey" }).and_return(true)
+      provider.create_group
+    end
 
-describe Chef::Provider::Group::Groupadd do
-  before do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-    @new_resource = Chef::Resource::Group.new("aj")
-    @provider = Chef::Provider::Group::Groupadd.new(@new_resource, @run_context)
-    allow(@provider).to receive(:run_command).and_return(true)
-    allow(@provider).to receive(:set_options).and_return(" monkey")
+    it "should modify the group members" do
+      expect(provider).to receive(:modify_group_members).and_return(true)
+      provider.create_group
+    end
   end
 
-  describe "manage group" do
+  describe "#manage_group" do
+    before do
+      allow(provider).to receive(:run_command).and_return(true)
+      allow(provider).to receive(:set_options).and_return(" monkey")
+    end
 
     it "should run groupmod with the return of set_options" do
-      allow(@provider).to receive(:modify_group_members).and_return(true)
-      expect(@provider).to receive(:run_command).with({ :command => "groupmod monkey" }).and_return(true)
-      @provider.manage_group
+      allow(provider).to receive(:modify_group_members).and_return(true)
+      expect(provider).to receive(:run_command).with({ :command => "groupmod monkey" }).and_return(true)
+      provider.manage_group
     end
 
     it "should modify the group members" do
-      expect(@provider).to receive(:modify_group_members).and_return(true)
-      @provider.manage_group
+      expect(provider).to receive(:modify_group_members).and_return(true)
+      provider.manage_group
     end
   end
 
-  describe "remove_group" do
+  describe "#remove_group" do
+    before do
+      allow(provider).to receive(:run_command).and_return(true)
+      allow(provider).to receive(:set_options).and_return(" monkey")
+    end
 
     it "should run groupdel with the new resources group name" do
-      expect(@provider).to receive(:run_command).with({ :command => "groupdel aj" }).and_return(true)
-      @provider.remove_group
+      expect(provider).to receive(:run_command).with({ :command => "groupdel aj" }).and_return(true)
+      provider.remove_group
     end
   end
 
   [:add_member, :remove_member, :set_members].each do |m|
     it "should raise an error when calling #{m}" do
-      expect { @provider.send(m, [ ]) }.to raise_error(Chef::Exceptions::Group, "you must override #{m} in #{@provider}")
+      expect { provider.send(m, [ ]) }.to raise_error(Chef::Exceptions::Group, "you must override #{m} in #{provider}")
     end
   end
 
-  describe "load_current_resource" do
+  describe "#load_current_resource" do
+    before do
+      allow(provider).to receive(:run_command).and_return(true)
+      allow(provider).to receive(:set_options).and_return(" monkey")
+    end
+
     before do
       allow(File).to receive(:exists?).and_return(false)
-      @provider.define_resource_requirements
+      provider.define_resource_requirements
     end
+
     it "should raise an error if the required binary /usr/sbin/groupadd doesn't exist" do
       expect(File).to receive(:exists?).with("/usr/sbin/groupadd").and_return(false)
-      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Group)
+      expect { provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Group)
     end
+
     it "should raise an error if the required binary /usr/sbin/groupmod doesn't exist" do
       expect(File).to receive(:exists?).with("/usr/sbin/groupadd").and_return(true)
       expect(File).to receive(:exists?).with("/usr/sbin/groupmod").and_return(false)
-      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Group)
+      expect { provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Group)
     end
+
     it "should raise an error if the required binary /usr/sbin/groupdel doesn't exist" do
       expect(File).to receive(:exists?).with("/usr/sbin/groupadd").and_return(true)
       expect(File).to receive(:exists?).with("/usr/sbin/groupmod").and_return(true)
       expect(File).to receive(:exists?).with("/usr/sbin/groupdel").and_return(false)
-      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Group)
+      expect { provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Group)
     end
 
   end
diff --git a/spec/unit/provider/log_spec.rb b/spec/unit/provider/log_spec.rb
index 2e4f9c4e52..ce7b1af55a 100644
--- a/spec/unit/provider/log_spec.rb
+++ b/spec/unit/provider/log_spec.rb
@@ -72,4 +72,18 @@ describe Chef::Provider::Log::ChefLog do
     expect(Chef::Log).to receive(:info).with(log_str).and_return(true)
     provider.run_action(:write)
   end
+
+  context "when count_log_resource_updates is passed in knife.rb" do
+    it "updates the resource count if count_log_resource_updates=true" do
+      Chef::Config[:count_log_resource_updates] = true
+      expect(new_resource).to receive(:updated_by_last_action)
+      provider.run_action(:write)
+    end
+
+    it "doesn't update the resource count if count_log_resource_updates=false" do
+      Chef::Config[:count_log_resource_updates] = false
+      expect(new_resource).not_to receive(:updated_by_last_action)
+      provider.run_action(:write)
+    end
+  end
 end
diff --git a/spec/unit/provider/package/cab_spec.rb b/spec/unit/provider/package/cab_spec.rb
new file mode 100644
index 0000000000..5e16795aa8
--- /dev/null
+++ b/spec/unit/provider/package/cab_spec.rb
@@ -0,0 +1,218 @@
+#
+# Author:: Vasundhara Jagdale (<vasundhara.jagdale@msystechnologies.com>)
+# Copyright:: Copyright 2008-2016, 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"
+
+describe Chef::Provider::Package::Cab do
+  let(:timeout) {}
+
+  let(:new_resource) { Chef::Resource::CabPackage.new("windows_test_pkg") }
+
+  let(:provider) do
+    node = Chef::Node.new
+    events = Chef::EventDispatch::Dispatcher.new
+    run_context = Chef::RunContext.new(node, {}, events)
+    Chef::Provider::Package::Cab.new(new_resource, run_context)
+  end
+
+  let(:installed_package_list_stdout) do
+    <<-EOF
+Packages listing:
+Package Identity : Package_for_KB2999486~31bf3856ad364e35~amd64~~6.1.9768.0
+Package Identity : Package_for_KB2994825~31bf3856ad364e35~amd64~~6.1.7601.0
+    EOF
+  end
+
+  let(:package_version_stdout) do
+    <<-EOF
+Package information:
+Package Identity : Package_for_KB2664825~31bf3856ad364e35~amd64~~6.1.3.0
+State : Installed
+Dependency : Language Pack
+The operation completed successfully
+    EOF
+  end
+
+  before do
+    new_resource.source = "C:\\Temp\\Test6.1-KB2664825-v3-x64.cab"
+    installed_package_list_obj = double(stdout: installed_package_list_stdout)
+    allow(provider).to receive(:dism_command).with("/Get-Packages").and_return(installed_package_list_obj)
+    package_version_obj = double(stdout: package_version_stdout)
+    allow(provider).to receive(:dism_command).with("/Get-PackageInfo /PackagePath:\"#{new_resource.source}\"").and_return(package_version_obj)
+  end
+
+  def allow_package_info(package_path = nil, package_name = nil)
+    get_package_info_stdout = <<-EOF
+Deployment Image Servicing and Management tool
+Version: 6.1.7600.16385
+
+Image Version: 6.1.7600.16385
+
+Package information:
+Package Identity : Package_for_KB2664825~31bf3856ad364e35~amd64~~6.1.3.0
+Applicable : Yes
+Copyright : Microsoft Corporation
+Company : Microsoft Corporation
+State : Installed
+Dependency : Language Pack
+The operation completed successfully
+    EOF
+    get_package_info_obj = double(stdout: get_package_info_stdout)
+    if package_path
+      allow(provider).to receive(:dism_command).with("/Get-PackageInfo /PackagePath:\"#{package_path}\"").and_return(get_package_info_obj)
+    else
+      allow(provider).to receive(:dism_command).with("/Get-PackageInfo /PackageName:\"#{package_name}\"").and_return(get_package_info_obj)
+    end
+  end
+
+  def allow_get_packages
+    get_packages_stdout = <<-EOF
+Deployment Image Servicing and Management tool
+Version: 6.1.7600.16385
+
+Image Version: 6.1.7600.16385
+
+Packages listing:
+
+Package Identity : Package_for_KB2999486~31bf3856ad364e35~amd64~~6.1.9768.0
+State : Installed
+Release Type : Language Pack
+Install Time : 2/11/2015 11:33 PM
+
+Package Identity : Package_for_KB2994825~31bf3856ad364e35~amd64~~6.1.7601.0
+State : Installed
+Release Type : Language Pack
+Install Time : 2/11/2015 11:33 PM
+
+Package Identity : Package_for_KB2664825~31bf3856ad364e35~amd64~~6.1.3.0
+State : Installed
+Release Type : Feature Pack
+Install Time : 11/21/2010 3:40 AM
+
+The operation completed successfully.
+    EOF
+    get_packages_obj = double(stdout: get_packages_stdout)
+    allow(provider).to receive(:dism_command).with("/Get-Packages").and_return(get_packages_obj)
+  end
+
+  describe "#load_current_resource" do
+    it "returns a current_resource" do
+      expect(provider.load_current_resource).to be_kind_of(Chef::Resource::CabPackage)
+    end
+
+    it "sets the current_resource.version to nil when the package is not installed" do
+      provider.load_current_resource
+      expect(provider.current_resource.version).to eql(nil)
+    end
+
+    it "sets the new resource package version" do
+      provider.load_current_resource
+      expect(provider.new_resource.version).to eql("6.1.3.0")
+    end
+  end
+
+  describe "#initialize" do
+    it "returns the correct class" do
+      expect(provider).to be_kind_of(Chef::Provider::Package::Cab)
+    end
+  end
+
+  describe "#package_version" do
+    it "returns the new package version" do
+      allow_package_info(new_resource.source, nil)
+      expect(provider.package_version).to eql("6.1.3.0")
+    end
+  end
+
+  describe "#installed_version" do
+    it "returns the current installed version of package" do
+      allow_package_info(new_resource.source, nil)
+      allow_get_packages
+      allow_package_info(nil, "Package_for_KB2664825~31bf3856ad364e35~amd64~~6.1.3.0")
+      expect(provider.installed_version).to eql("6.1.3.0")
+    end
+  end
+
+  describe "#action_remove" do
+    it "does nothing when the package is already removed" do
+      provider.load_current_resource
+      expect(provider).not_to receive(:remove_package)
+      provider.run_action(:remove)
+      expect(new_resource).not_to be_updated_by_last_action
+    end
+
+    it "removes packages if package is installed" do
+      allow_package_info(new_resource.source, nil)
+      allow_get_packages
+      allow_package_info(nil, "Package_for_KB2664825~31bf3856ad364e35~amd64~~6.1.3.0")
+      provider.load_current_resource
+      expect(provider.installed_version).not_to eql(nil)
+      expect(provider).to receive(:remove_package)
+      provider.run_action(:remove)
+      expect(new_resource).to be_updated_by_last_action
+    end
+  end
+
+  describe "#action_install" do
+    it "installs package if already not installed" do
+      provider.load_current_resource
+      expect(provider.installed_version).to eql(nil)
+      expect(provider).to receive(:install_package)
+      provider.run_action(:install)
+      expect(new_resource).to be_updated_by_last_action
+    end
+
+    it "does not install package if already installed" do
+      allow_package_info(new_resource.source, nil)
+      allow_get_packages
+      allow_package_info(nil, "Package_for_KB2664825~31bf3856ad364e35~amd64~~6.1.3.0")
+      provider.load_current_resource
+      expect(provider.installed_version).not_to eql(nil)
+      expect(provider).not_to receive(:install_package)
+      provider.run_action(:install)
+      expect(new_resource).not_to be_updated_by_last_action
+    end
+  end
+
+  context "Invalid package source" do
+    def package_version_stdout
+      package_version_stdout = <<-EOF
+
+Deployment Image Servicing and Management tool
+Version: 6.1.7600.16385
+
+Image Version: 6.1.7600.16385
+
+An error occurred trying to open - c:\\temp\\test6.1-KB2664825-v3-x64.cab Error: 0x80070003
+Error: 3
+The system cannot find the path specified.
+The DISM log file can be found at C:\\Windows\\Logs\\DISM\\dism.log.
+      EOF
+    end
+
+    before do
+      new_resource.source = "C:\\Temp\\Test6.1-KB2664825-v3-x64.cab"
+      installed_package_list_obj = double(stdout: installed_package_list_stdout)
+      allow(provider).to receive(:dism_command).with("/Get-Packages").and_return(installed_package_list_obj)
+    end
+
+    it "raises error for invalid source path or file" do
+      expect { provider.load_current_resource }.to raise_error(Chef::Exceptions::Package, "DISM: The system cannot find the path or file specified.")
+    end
+  end
+end
diff --git a/spec/unit/provider/package/rubygems_spec.rb b/spec/unit/provider/package/rubygems_spec.rb
index 4934505583..548204df75 100644
--- a/spec/unit/provider/package/rubygems_spec.rb
+++ b/spec/unit/provider/package/rubygems_spec.rb
@@ -735,10 +735,9 @@ describe Chef::Provider::Package::Rubygems do
         context "when source is a path" do
           let(:source) { CHEF_SPEC_DATA + "/gems/chef-integration-test-0.1.0.gem" }
           let(:target_version) { ">= 0" }
-          let(:domain) { " --local" }
 
           it "installs the gem by shelling out to gem install" do
-            expect(provider).to receive(:shell_out!).with("#{gem_binary} install #{source} -q --no-rdoc --no-ri -v \"#{target_version}\"#{domain}", env: nil, timeout: 900)
+            expect(provider).to receive(:shell_out!).with("#{gem_binary} install #{source} -q --no-rdoc --no-ri -v \"#{target_version}\"", env: nil, timeout: 900)
             provider.run_action(:install)
             expect(new_resource).to be_updated_by_last_action
           end
@@ -747,11 +746,10 @@ describe Chef::Provider::Package::Rubygems do
         context "when the package is a path and source is nil" do
           let(:gem_name) { CHEF_SPEC_DATA + "/gems/chef-integration-test-0.1.0.gem" }
           let(:target_version) { ">= 0" }
-          let(:domain) { " --local" }
 
           it "installs the gem from file by shelling out to gem install when the package is a path and the source is nil" do
             expect(new_resource.source).to eq(gem_name)
-            expect(provider).to receive(:shell_out!).with("#{gem_binary} install #{gem_name} -q --no-rdoc --no-ri -v \"#{target_version}\"#{domain}", env: nil, timeout: 900)
+            expect(provider).to receive(:shell_out!).with("#{gem_binary} install #{gem_name} -q --no-rdoc --no-ri -v \"#{target_version}\"", env: nil, timeout: 900)
             provider.run_action(:install)
             expect(new_resource).to be_updated_by_last_action
           end
diff --git a/spec/unit/provider/package/windows_spec.rb b/spec/unit/provider/package/windows_spec.rb
index e26662ac75..d1d717bdbe 100644
--- a/spec/unit/provider/package/windows_spec.rb
+++ b/spec/unit/provider/package/windows_spec.rb
@@ -394,4 +394,49 @@ describe Chef::Provider::Package::Windows, :windows_only do
       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 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
+
+      it "raises the checksum mismatch exception" do
+        expect { provider.send(:validate_content!) }.to raise_error(
+          Chef::Exceptions::ChecksumMismatch)
+      end
+    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
+
+    context "checksum is in uppercase" do
+      before do
+        new_resource.checksum = new_resource.checksum.upcase
+      end
+
+      include_context "valid checksum"
+      include_context "invalid checksum"
+    end
+  end
 end
diff --git a/spec/unit/provider/registry_key_spec.rb b/spec/unit/provider/registry_key_spec.rb
index 41bc5b33d3..3fb9468f5d 100644
--- a/spec/unit/provider/registry_key_spec.rb
+++ b/spec/unit/provider/registry_key_spec.rb
@@ -19,23 +19,6 @@
 require "spec_helper"
 
 shared_examples_for "a registry key" do
-  before(:each) do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-
-    @new_resource = Chef::Resource::RegistryKey.new("windows is fun", @run_context)
-    @new_resource.key keyname
-    @new_resource.values( testval1 )
-    @new_resource.recursive false
-
-    @provider = Chef::Provider::RegistryKey.new(@new_resource, @run_context)
-
-    allow(@provider).to receive(:running_on_windows!).and_return(true)
-    @double_registry = double(Chef::Win32::Registry)
-    allow(@provider).to receive(:registry).and_return(@double_registry)
-  end
-
   describe "when first created" do
   end
 
@@ -273,6 +256,23 @@ shared_examples_for "a registry key" do
 end
 
 describe Chef::Provider::RegistryKey do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::RegistryKey.new("windows is fun", @run_context)
+    @new_resource.key keyname
+    @new_resource.values( testval1 )
+    @new_resource.recursive false
+
+    @provider = Chef::Provider::RegistryKey.new(@new_resource, @run_context)
+
+    allow(@provider).to receive(:running_on_windows!).and_return(true)
+    @double_registry = double(Chef::Win32::Registry)
+    allow(@provider).to receive(:registry).and_return(@double_registry)
+  end
+
   context "when the key data is safe" do
     let(:keyname) { 'HKLM\Software\Opscode\Testing\Safe' }
     let(:testval1) { { :name => "one", :type => :string, :data => "1" } }
@@ -292,4 +292,116 @@ describe Chef::Provider::RegistryKey do
 
     it_should_behave_like "a registry key"
   end
+
+  describe "action_create" do
+    context "when key exists and type matches" do
+      let(:keyname) { 'hklm\\software\\opscode\\testing\\dword' }
+      let(:dword_passed_as_integer) { { :name => "one", :type => :dword, :data => 12345 } }
+      let(:testval1) { { :name => "one", :type => :dword, :data => "12345" } }
+      before do
+        expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(true)
+      end
+
+      it "does not make a change for datatype of data value differing" do
+        expect(@double_registry).to receive(:get_values).with(keyname).and_return( dword_passed_as_integer )
+        expect(@double_registry).not_to receive(:set_value)
+        @provider.load_current_resource
+        @provider.action_create
+      end
+    end
+  end
+end
+
+describe Chef::Provider::RegistryKey, "key_missing?" do
+  let(:provider) { Chef::Provider::RegistryKey.new(nil, nil) }
+  let(:all_keys_present_in_all_hash) do
+    [ { :name => "input1_value1", :type => :string, :data => "my_value1" },
+      { :name => "input1_value2", :type => :string, :data => "my_value2" },
+    ]
+  end
+  let(:type_key_not_present_in_any_hash) do
+    [ { :name => "input2_value1", :data => "my_value1" },
+      { :name => "input2_value2", :data => "my_value2" },
+    ]
+  end
+  let(:type_key_not_present_in_some_hash) do
+    [ { :name => "input3_value1", :data => "my_value1" },
+      { :name => "input3_value2", :type => :string, :data => "my_value2" },
+    ]
+  end
+  let(:data_key_not_present_in_any_hash) do
+    [ { :name => "input4_value1", :type => :string },
+      { :name => "input4_value2", :type => :string },
+    ]
+  end
+  let(:data_key_not_present_in_some_hash) do
+    [ { :name => "input5_value1", :type => :string, :data => "my_value1" },
+      { :name => "input5_value2", :type => :string },
+    ]
+  end
+  let(:only_name_key_present_in_all_hash) do
+    [ { :name => "input6_value1" },
+      { :name => "input6_value2" },
+    ]
+  end
+
+  context "type key" do
+    context "when type key is present in all the values hash of registry_key resource" do
+      it "returns false" do
+        response = provider.key_missing?(all_keys_present_in_all_hash, :type)
+        expect(response).to be == false
+      end
+    end
+
+    context "when type key is not present in any of the values hash of registry_key resource" do
+      it "returns true" do
+        response = provider.key_missing?(type_key_not_present_in_any_hash, :type)
+        expect(response).to be == true
+      end
+    end
+
+    context "when type key is not present only in some of the values hash of registry_key resource" do
+      it "returns true" do
+        response = provider.key_missing?(type_key_not_present_in_some_hash, :type)
+        expect(response).to be == true
+      end
+    end
+
+    context "when only name key is present in all the values hash of registry_key resource" do
+      it "returns true" do
+        response = provider.key_missing?(only_name_key_present_in_all_hash, :type)
+        expect(response).to be == true
+      end
+    end
+  end
+
+  context "data key" do
+    context "when data key is present in all the values hash of registry_key resource" do
+      it "returns false" do
+        response = provider.key_missing?(all_keys_present_in_all_hash, :data)
+        expect(response).to be == false
+      end
+    end
+
+    context "when data key is not present in any of the values hash of registry_key resource" do
+      it "returns true" do
+        response = provider.key_missing?(data_key_not_present_in_any_hash, :data)
+        expect(response).to be == true
+      end
+    end
+
+    context "when data key is not present only in some of the values hash of registry_key resource" do
+      it "returns true" do
+        response = provider.key_missing?(data_key_not_present_in_some_hash, :data)
+        expect(response).to be == true
+      end
+    end
+
+    context "when only name key is present in all the values hash of registry_key resource" do
+      it "returns true" do
+        response = provider.key_missing?(only_name_key_present_in_all_hash, :data)
+        expect(response).to be == true
+      end
+    end
+  end
 end
diff --git a/spec/unit/provider/remote_file/content_spec.rb b/spec/unit/provider/remote_file/content_spec.rb
index c6a560b123..db9a75458d 100644
--- a/spec/unit/provider/remote_file/content_spec.rb
+++ b/spec/unit/provider/remote_file/content_spec.rb
@@ -180,6 +180,7 @@ describe Chef::Provider::RemoteFile::Content do
       Net::HTTPServerException,
       Net::HTTPFatalError,
       Net::FTPError,
+      Errno::ETIMEDOUT,
     ].each do |exception|
       describe "with an exception of #{exception}" do
         before do
diff --git a/spec/unit/provider/user/dscl_spec.rb b/spec/unit/provider/user/dscl_spec.rb
index dfaaa377d3..7b8be02f3a 100644
--- a/spec/unit/provider/user/dscl_spec.rb
+++ b/spec/unit/provider/user/dscl_spec.rb
@@ -219,6 +219,8 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
     end
 
     before do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
       new_resource.supports({ :manage_home => true })
       new_resource.home("/Users/toor")
 
@@ -237,6 +239,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
     end
 
     it "moves the users home to the new location if it exists and the target location is different" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
       new_resource.supports(:manage_home => true)
 
       current_home = CHEF_SPEC_DATA + "/old_home_dir"
@@ -856,6 +859,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
 
     describe "when Chef is removing the user" do
       it "removes the user from the groups and deletes home directory when the resource is configured to manage home" do
+        Chef::Config[:treat_deprecation_warnings_as_errors] = false
         new_resource.supports({ :manage_home => true })
         expect(provider).to receive(:run_dscl).with("list /Groups").and_return("my_group\nyour_group\nreal_group\n")
         expect(provider).to receive(:run_dscl).with("read /Groups/my_group").and_raise(Chef::Exceptions::DsclCommandFailed) # Empty group
diff --git a/spec/unit/provider/user/linux_spec.rb b/spec/unit/provider/user/linux_spec.rb
index ac94592859..1c487c0de9 100644
--- a/spec/unit/provider/user/linux_spec.rb
+++ b/spec/unit/provider/user/linux_spec.rb
@@ -45,20 +45,50 @@ describe Chef::Provider::User::Linux do
       @current_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
     end
 
-    it "sets supports manage_home to true" do
-      Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      expect( @new_resource.supports[:manage_home] ).to be true
+    it "supports manage_home does not exist", chef: ">= 13" do
+      expect( @new_resource.supports.key?(:manage_home) ).to be false
+    end
+
+    it "supports non_unique does not exist", chef: ">= 13" do
+      expect( @new_resource.supports.key?(:non_unique) ).to be false
+    end
+
+    # supports is a method on the superclass so can't totally be removed, but we should aggressively NOP it to decisively break it
+    it "disables the supports API", chef: ">= 13" do
+      @new_resource.supports( { manage_home: true } )
+      expect( @new_resource.supports.key?(:manage_home) ).to be false
+    end
+
+    it "sets supports manage_home to false" do
+      expect( @new_resource.supports[:manage_home] ).to be false
+    end
+
+    it "sets supports non-unique to false" do
+      expect( @new_resource.supports[:non_unique] ).to be false
     end
 
-    it "sets supports non-unique to true" do
+    it "throws a deprecation warning on setting supports[:manage_home]" do
       Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      expect( @new_resource.supports[:non_unique] ).to be true
+      expect(Chef).to receive(:log_deprecation).with("supports { manage_home: true } on the user resource is deprecated and will be removed in Chef 13, set manage_home: true instead")
+      @new_resource.supports( { :manage_home => true } )
     end
 
-    it "defaults manage_home to true" do
+    it "defaults manage_home to false" do
       expect( @new_resource.manage_home ).to be false
     end
 
+    it "supports[:manage_home] (incorectly) acts like manage_home" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      @new_resource.supports({ manage_home: true })
+      expect( provider.useradd_options ).to eql(["-m"])
+    end
+
+    it "supports[:manage_home] does not change behavior of manage_home: false", chef: ">= 13" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      @new_resource.supports({ manage_home: true })
+      expect( provider.useradd_options ).to eql(["-M"])
+    end
+
     it "by default manage_home is false and we use -M" do
       expect( provider.useradd_options ).to eql(["-M"])
     end
diff --git a/spec/unit/provider/user/pw_spec.rb b/spec/unit/provider/user/pw_spec.rb
index 624bcfc67d..fb7c9211a1 100644
--- a/spec/unit/provider/user/pw_spec.rb
+++ b/spec/unit/provider/user/pw_spec.rb
@@ -32,6 +32,8 @@ describe Chef::Provider::User::Pw do
     @new_resource.shell     "/usr/bin/zsh"
     @new_resource.password  "abracadabra"
 
+    # XXX: rip out in Chef-13
+    Chef::Config[:treat_deprecation_warnings_as_errors] = false
     @new_resource.supports :manage_home => true
 
     @current_resource = Chef::Resource::User::PwUser.new("adam")
diff --git a/spec/unit/provider/user/solaris_spec.rb b/spec/unit/provider/user/solaris_spec.rb
index 860c9e41dd..8a5e654a0d 100644
--- a/spec/unit/provider/user/solaris_spec.rb
+++ b/spec/unit/provider/user/solaris_spec.rb
@@ -29,26 +29,31 @@ describe Chef::Provider::User::Solaris do
     Struct.new(:stdout, :stderr, :exitstatus)
   end
 
-  subject(:provider) do
-    p = described_class.new(@new_resource, @run_context)
-    p.current_resource = @current_resource
+  let(:node) do
+    Chef::Node.new.tap do |node|
+      node.automatic["platform"] = "solaris2"
+    end
+  end
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:new_resource) do
+    Chef::Resource::User::SolarisUser.new("adam", @run_context)
+  end
+  let(:current_resource) do
+    Chef::Resource::User::SolarisUser.new("adam", @run_context)
+  end
 
-    # Prevent the useradd-based provider tests from trying to write /etc/shadow
-    allow(p).to receive(:write_shadow_file)
-    p
+  subject(:provider) do
+    described_class.new(new_resource, run_context).tap do |p|
+      p.current_resource = current_resource
+      # Prevent the useradd-based provider tests from trying to write /etc/shadow
+      allow(p).to receive(:write_shadow_file)
+    end
   end
 
   describe "when we want to set a password" do
     before(:each) do
-      @node = Chef::Node.new
-      @events = Chef::EventDispatch::Dispatcher.new
-      @run_context = Chef::RunContext.new(@node, {}, @events)
-
-      @new_resource = Chef::Resource::User::SolarisUser.new("adam", @run_context)
-      @current_resource = Chef::Resource::User::SolarisUser.new("adam", @run_context)
-
-      @new_resource.password "hocus-pocus"
-
+      new_resource.password "hocus-pocus"
     end
 
     it "should use its own shadow file writer to set the password" do
@@ -68,53 +73,60 @@ describe Chef::Provider::User::Solaris do
       # may not be able to write to /etc for tests...
       temp_file = Tempfile.new("shadow")
       allow(Tempfile).to receive(:new).with("shadow", "/etc").and_return(temp_file)
-      @new_resource.password "verysecurepassword"
+      new_resource.password "verysecurepassword"
       provider.manage_user
       expect(::File.open(password_file.path, "r").read).to match(/adam:verysecurepassword:/)
       password_file.unlink
     end
   end
 
-  describe "when managing user locked status" do
-    before(:each) do
-      @node = Chef::Node.new
-      @events = Chef::EventDispatch::Dispatcher.new
-      @run_context = Chef::RunContext.new(@node, {}, @events)
-
-      @new_resource = Chef::Resource::User::SolarisUser.new("dave")
-      @current_resource = @new_resource.dup
+  describe "#create_user" do
+    context "with a system user" do
+      before { new_resource.system(true) }
+      it "should not pass -r" do
+        expect(provider).to receive(:shell_out!).with("useradd", "adam")
+        provider.create_user
+      end
+    end
 
-      @provider = Chef::Provider::User::Solaris.new(@new_resource, @run_context)
-      @provider.current_resource = @current_resource
+    context "with manage_home" do
+      before { new_resource.manage_home(true) }
+      it "should not pass -r" do
+        expect(provider).to receive(:shell_out!).with("useradd", "-m", "adam")
+        provider.create_user
+      end
     end
+  end
+
+  describe "when managing user locked status" do
     describe "when determining if the user is locked" do
 
       # locked shadow lines
       [
-        "dave:LK:::::::",
-        "dave:*LK*:::::::",
-        "dave:*LK*foobar:::::::",
-        "dave:*LK*bahamas10:::::::",
-        "dave:*LK*L....:::::::",
+        "adam:LK:::::::",
+        "adam:*LK*:::::::",
+        "adam:*LK*foobar:::::::",
+        "adam:*LK*bahamas10:::::::",
+        "adam:*LK*L....:::::::",
       ].each do |shadow|
         it "should return true if user is locked with #{shadow}" do
           shell_return = shellcmdresult.new(shadow + "\n", "", 0)
-          expect(provider).to receive(:shell_out!).with("getent", "shadow", @new_resource.username).and_return(shell_return)
+          expect(provider).to receive(:shell_out!).with("getent", "shadow", "adam").and_return(shell_return)
           expect(provider.check_lock).to eql(true)
         end
       end
 
       # unlocked shadow lines
       [
-        "dave:NP:::::::",
-        "dave:*NP*:::::::",
-        "dave:foobar:::::::",
-        "dave:bahamas10:::::::",
-        "dave:L...:::::::",
+        "adam:NP:::::::",
+        "adam:*NP*:::::::",
+        "adam:foobar:::::::",
+        "adam:bahamas10:::::::",
+        "adam:L...:::::::",
       ].each do |shadow|
         it "should return false if user is unlocked with #{shadow}" do
           shell_return = shellcmdresult.new(shadow + "\n", "", 0)
-          expect(provider).to receive(:shell_out!).with("getent", "shadow", @new_resource.username).and_return(shell_return)
+          expect(provider).to receive(:shell_out!).with("getent", "shadow", "adam").and_return(shell_return)
           expect(provider.check_lock).to eql(false)
         end
       end
@@ -123,7 +135,7 @@ describe Chef::Provider::User::Solaris do
     describe "when locking the user" do
       it "should run passwd -l with the new resources username" do
         shell_return = shellcmdresult.new("", "", 0)
-        expect(provider).to receive(:shell_out!).with("passwd", "-l", @new_resource.username).and_return(shell_return)
+        expect(provider).to receive(:shell_out!).with("passwd", "-l", "adam").and_return(shell_return)
         provider.lock_user
       end
     end
@@ -131,7 +143,7 @@ describe Chef::Provider::User::Solaris do
     describe "when unlocking the user" do
       it "should run passwd -u with the new resources username" do
         shell_return = shellcmdresult.new("", "", 0)
-        expect(provider).to receive(:shell_out!).with("passwd", "-u", @new_resource.username).and_return(shell_return)
+        expect(provider).to receive(:shell_out!).with("passwd", "-u", "adam").and_return(shell_return)
         provider.unlock_user
       end
     end