chef 12.6.0-universal-mingw32 → 12.7.2-universal-mingw32

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

@@ -1,6 +1,6 @@
 #
 # Author:: David Balatero (<dbalatero@gmail.com>)
-# Copyright:: Copyright (c) 2009 Opscode, Inc.
+# Copyright:: Copyright 2009-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::Provider::Package::Macports do
   before(:each) do
@@ -70,7 +70,7 @@ describe Chef::Provider::Package::Macports do
 
   describe "current_installed_version" do
     it "should return the current version if the package is installed" do
-      stdout =  <<EOF
+      stdout = <<EOF
 The following ports are currently installed:
   openssl @0.9.8k_0 (active)
 EOF

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

@@ -1,6 +1,6 @@
 #
 # Author:: Scott Bonds (scott@ggr.com)
-# Copyright:: Copyright (c) 2014 Scott Bonds
+# Copyright:: Copyright 2014-2016, Scott Bonds
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,14 +16,14 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'ostruct'
+require "spec_helper"
+require "ostruct"
 
 describe Chef::Provider::Package::Openbsd do
 
   let(:node) do
     node = Chef::Node.new
-    node.default['kernel'] = {'name' => 'OpenBSD', 'release' => '5.5', 'machine' => 'amd64'}
+    node.default["kernel"] = { "name" => "OpenBSD", "release" => "5.5", "machine" => "amd64" }
     node
   end
 
@@ -33,79 +33,79 @@ describe Chef::Provider::Package::Openbsd do
     Chef::Provider::Package::Openbsd.new(new_resource, run_context)
   end
 
-  let(:new_resource) { Chef::Resource::Package.new(name)}
+  let(:new_resource) { Chef::Resource::Package.new(name) }
 
   before(:each) do
-    ENV['PKG_PATH'] = nil
+    ENV["PKG_PATH"] = nil
   end
 
   describe "install a package" do
-    let(:name) { 'ihavetoes' }
-    let(:version) {'0.0'}
+    let(:name) { "ihavetoes" }
+    let(:version) { "0.0" }
 
-    context 'when not already installed' do
+    context "when not already installed" do
       before do
-        allow(provider).to receive(:shell_out!).with("pkg_info -e \"#{name}->0\"", anything()).and_return(instance_double('shellout', :stdout => ''))
+        allow(provider).to receive(:shell_out!).with("pkg_info -e \"#{name}->0\"", anything()).and_return(instance_double("shellout", :stdout => ""))
       end
 
-      context 'when there is a single candidate' do
+      context "when there is a single candidate" do
 
-        context 'when source is not provided' do
-          it 'should run the installation command' do
+        context "when source is not provided" do
+          it "should run the installation command" do
             expect(provider).to receive(:shell_out!).with("pkg_info -I \"#{name}\"", anything()).and_return(
-              instance_double('shellout', :stdout => "#{name}-#{version}\n"))
+              instance_double("shellout", :stdout => "#{name}-#{version}\n"))
             expect(provider).to receive(:shell_out!).with(
               "pkg_add -r #{name}-#{version}",
-              {:env => {"PKG_PATH" => "http://ftp.OpenBSD.org/pub/OpenBSD/5.5/packages/amd64/"}, timeout: 900}
-            ) {OpenStruct.new :status => true}
+              { :env => { "PKG_PATH" => "http://ftp.OpenBSD.org/pub/OpenBSD/5.5/packages/amd64/" }, timeout: 900 }
+            ) { OpenStruct.new :status => true }
             provider.run_action(:install)
           end
         end
       end
 
-      context 'when there are multiple candidates' do
-        let(:flavor_a) { 'flavora' }
-        let(:flavor_b) { 'flavorb' }
+      context "when there are multiple candidates" do
+        let(:flavor_a) { "flavora" }
+        let(:flavor_b) { "flavorb" }
 
-        context 'if no version is specified' do
-          it 'should raise an exception' do
+        context "if no version is specified" do
+          it "should raise an exception" do
             expect(provider).to receive(:shell_out!).with("pkg_info -I \"#{name}\"", anything()).and_return(
-              instance_double('shellout', :stdout => "#{name}-#{version}-#{flavor_a}\n#{name}-#{version}-#{flavor_b}\n"))
+              instance_double("shellout", :stdout => "#{name}-#{version}-#{flavor_a}\n#{name}-#{version}-#{flavor_b}\n"))
             expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /multiple matching candidates/)
           end
         end
 
-        context 'if a flavor is specified' do
+        context "if a flavor is specified" do
 
-          let(:flavor) { 'flavora' }
-          let(:package_name) {'ihavetoes' }
+          let(:flavor) { "flavora" }
+          let(:package_name) { "ihavetoes" }
           let(:name) { "#{package_name}--#{flavor}" }
 
-          context 'if no version is specified' do
-            it 'should run the installation command' do
-              expect(provider).to receive(:shell_out!).with("pkg_info -e \"#{package_name}->0\"", anything()).and_return(instance_double('shellout', :stdout => ''))
+          context "if no version is specified" do
+            it "should run the installation command" do
+              expect(provider).to receive(:shell_out!).with("pkg_info -e \"#{package_name}->0\"", anything()).and_return(instance_double("shellout", :stdout => ""))
               expect(provider).to receive(:shell_out!).with("pkg_info -I \"#{name}\"", anything()).and_return(
-                instance_double('shellout', :stdout => "#{name}-#{version}-#{flavor}\n"))
+                instance_double("shellout", :stdout => "#{name}-#{version}-#{flavor}\n"))
               expect(provider).to receive(:shell_out!).with(
                 "pkg_add -r #{name}-#{version}-#{flavor}",
-                {env: {"PKG_PATH" => "http://ftp.OpenBSD.org/pub/OpenBSD/5.5/packages/amd64/"}, timeout: 900}
-              ) {OpenStruct.new :status => true}
+                { env: { "PKG_PATH" => "http://ftp.OpenBSD.org/pub/OpenBSD/5.5/packages/amd64/" }, timeout: 900 }
+              ) { OpenStruct.new :status => true }
               provider.run_action(:install)
             end
           end
 
         end
 
-        context 'if a version is specified' do
-          it 'should use the flavor from the version' do
+        context "if a version is specified" do
+          it "should use the flavor from the version" do
             expect(provider).to receive(:shell_out!).with("pkg_info -I \"#{name}-#{version}-#{flavor_b}\"", anything()).and_return(
-              instance_double('shellout', :stdout => "#{name}-#{version}-#{flavor_a}\n"))
+              instance_double("shellout", :stdout => "#{name}-#{version}-#{flavor_a}\n"))
 
             new_resource.version("#{version}-#{flavor_b}")
             expect(provider).to receive(:shell_out!).with(
               "pkg_add -r #{name}-#{version}-#{flavor_b}",
-              {env: {"PKG_PATH" => "http://ftp.OpenBSD.org/pub/OpenBSD/5.5/packages/amd64/"}, timeout: 900}
-            ) {OpenStruct.new :status => true}
+              { env: { "PKG_PATH" => "http://ftp.OpenBSD.org/pub/OpenBSD/5.5/packages/amd64/" }, timeout: 900 }
+            ) { OpenStruct.new :status => true }
             provider.run_action(:install)
           end
         end
@@ -115,7 +115,7 @@ describe Chef::Provider::Package::Openbsd do
 
   describe "delete a package" do
     before do
-      @name = 'ihavetoes'
+      @name = "ihavetoes"
       @new_resource     = Chef::Resource::Package.new(@name)
       @current_resource = Chef::Resource::Package.new(@name)
       @provider = Chef::Provider::Package::Openbsd.new(@new_resource, @run_context)
@@ -124,7 +124,7 @@ describe Chef::Provider::Package::Openbsd do
     it "should run the command to delete the installed package" do
       expect(@provider).to receive(:shell_out!).with(
         "pkg_delete #{@name}", env: nil, timeout: 900
-      ) {OpenStruct.new :status => true}
+      ) { OpenStruct.new :status => true }
       @provider.remove_package(@name, nil)
     end
   end

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

@@ -1,6 +1,6 @@
 #
 # Author:: Jan Zimmek (<jan.zimmek@web.de>)
-# Copyright:: Copyright (c) 2010 Jan Zimmek
+# Copyright:: Copyright 2010-2016, Jan Zimmek
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::Provider::Package::Pacman do
   before(:each) do
@@ -51,7 +51,7 @@ ERR
     end
 
     it "should run pacman query with the package name" do
-      expect(@provider).to receive(:shell_out).with("pacman -Qi #{@new_resource.package_name}", {timeout: 900}).and_return(@status)
+      expect(@provider).to receive(:shell_out).with("pacman -Qi #{@new_resource.package_name}", { timeout: 900 }).and_return(@status)
       @provider.load_current_resource
     end
 
@@ -62,7 +62,6 @@ ERR
 
     it "should set the installed version to nil on the current resource if pacman installed version not exists" do
       allow(@provider).to receive(:shell_out).and_return(@status)
-      expect(@current_resource).to receive(:version).with(nil).and_return(true)
       @provider.load_current_resource
     end
 
@@ -103,7 +102,7 @@ PACMAN
     end
 
     it "should use pacman.conf to determine valid repo names for package versions" do
-     @pacman_conf = <<-PACMAN_CONF
+      @pacman_conf = <<-PACMAN_CONF
 [options]
 HoldPkg      = pacman glibc
 Architecture = auto
@@ -152,12 +151,12 @@ PACMAN_CONF
 
   describe Chef::Provider::Package::Pacman, "install_package" do
     it "should run pacman install with the package name and version" do
-      expect(@provider).to receive(:shell_out!).with("pacman --sync --noconfirm --noprogressbar nano", {timeout: 900})
+      expect(@provider).to receive(:shell_out!).with("pacman --sync --noconfirm --noprogressbar nano", { timeout: 900 })
       @provider.install_package("nano", "1.0")
     end
 
     it "should run pacman install with the package name and version and options if specified" do
-      expect(@provider).to receive(:shell_out!).with("pacman --sync --noconfirm --noprogressbar --debug nano", {timeout: 900})
+      expect(@provider).to receive(:shell_out!).with("pacman --sync --noconfirm --noprogressbar --debug nano", { timeout: 900 })
       allow(@new_resource).to receive(:options).and_return("--debug")
 
       @provider.install_package("nano", "1.0")
@@ -173,12 +172,12 @@ PACMAN_CONF
 
   describe Chef::Provider::Package::Pacman, "remove_package" do
     it "should run pacman remove with the package name" do
-      expect(@provider).to receive(:shell_out!).with("pacman --remove --noconfirm --noprogressbar nano", {timeout: 900})
+      expect(@provider).to receive(:shell_out!).with("pacman --remove --noconfirm --noprogressbar nano", { timeout: 900 })
       @provider.remove_package("nano", "1.0")
     end
 
     it "should run pacman remove with the package name and options if specified" do
-      expect(@provider).to receive(:shell_out!).with("pacman --remove --noconfirm --noprogressbar --debug nano", {timeout: 900})
+      expect(@provider).to receive(:shell_out!).with("pacman --remove --noconfirm --noprogressbar --debug nano", { timeout: 900 })
       allow(@new_resource).to receive(:options).and_return("--debug")
 
       @provider.remove_package("nano", "1.0")

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

@@ -1,6 +1,6 @@
 #
 # Author:: Vasiliy Tolstov <v.tolstov@selfip.ru>
-# Copyright:: Copyright (c) 2014 Opscode, Inc.
+# Copyright:: Copyright 2014-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'ostruct'
+require "spec_helper"
+require "ostruct"
 
 # based on the ips specs
 
@@ -33,7 +33,7 @@ describe Chef::Provider::Package::Paludis do
 
     @stdin = StringIO.new
     @stderr = StringIO.new
-    @stdout =<<-PKG_STATUS
+    @stdout = <<-PKG_STATUS
 group/ntp 0 accounts
 group/ntp 0 installed-accounts
 net/ntp 4.2.6_p5-r2 arbor
@@ -42,7 +42,7 @@ user/ntp 0 installed-accounts
 net/ntp 4.2.6_p5-r1 installed
 PKG_STATUS
     @pid = 12345
-    @shell_out = OpenStruct.new(:stdout => @stdout,:stdin => @stdin,:stderr => @stderr,:status => @status,:exitstatus => 0)
+    @shell_out = OpenStruct.new(:stdout => @stdout, :stdin => @stdin, :stderr => @stderr, :status => @status, :exitstatus => 0)
   end
 
   context "when loading current resource" do
@@ -86,13 +86,12 @@ INSTALLED
 
   context "when installing a package" do
     it "should run pkg install with the package name and version" do
-      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x \"=net/ntp-4.2.6_p5-r2\"", {:timeout=>@new_resource.timeout})
+      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x \"=net/ntp-4.2.6_p5-r2\"", { :timeout => @new_resource.timeout })
       @provider.install_package("net/ntp", "4.2.6_p5-r2")
     end
 
-
     it "should run pkg install with the package name and version and options if specified" do
-      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x --preserve-world \"=net/ntp-4.2.6_p5-r2\"", {:timeout=>@new_resource.timeout})
+      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x --preserve-world \"=net/ntp-4.2.6_p5-r2\"", { :timeout => @new_resource.timeout })
       allow(@new_resource).to receive(:options).and_return("--preserve-world")
       @provider.install_package("net/ntp", "4.2.6_p5-r2")
     end
@@ -102,7 +101,7 @@ INSTALLED
 sys-process/lsof 4.87 arbor
 sys-process/lsof 4.87 x86_64
 PKG_STATUS
-      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x \"=sys-process/lsof-4.87\"", {:timeout=>@new_resource.timeout})
+      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x \"=sys-process/lsof-4.87\"", { :timeout => @new_resource.timeout })
       @provider.install_package("sys-process/lsof", "4.87")
     end
 
@@ -120,7 +119,7 @@ PKG_STATUS
 
   context "when upgrading a package" do
     it "should run pkg install with the package name and version" do
-      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x \"=net/ntp-4.2.6_p5-r2\"", {:timeout=>@new_resource.timeout})
+      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x \"=net/ntp-4.2.6_p5-r2\"", { :timeout => @new_resource.timeout })
       @provider.upgrade_package("net/ntp", "4.2.6_p5-r2")
     end
   end

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

@@ -1,6 +1,6 @@
 #
 # Author:: Caleb Tennis (<caleb.tennis@gmail.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::Provider::Package::Portage, "load_current_resource" do
   before(:each) do

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

@@ -1,7 +1,7 @@
 #
-# Author:: Joshua Timberman (<joshua@opscode.com>)
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2008, 2010 Opscode, Inc.
+# Author:: Joshua Timberman (<joshua@chef.io>)
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::Provider::Package::Rpm do
   let(:provider) { Chef::Provider::Package::Rpm.new(new_resource, run_context) }
@@ -35,10 +35,10 @@ describe Chef::Provider::Package::Rpm do
   end
 
   # `rpm -qp [stuff] $source`
-  let(:rpm_qp_status) { instance_double('Mixlib::ShellOut', exitstatus: rpm_qp_exitstatus, stdout: rpm_qp_stdout) }
+  let(:rpm_qp_status) { instance_double("Mixlib::ShellOut", exitstatus: rpm_qp_exitstatus, stdout: rpm_qp_stdout) }
 
   # `rpm -q [stuff] $package_name`
-  let(:rpm_q_status) { instance_double('Mixlib::ShellOut', exitstatus: rpm_q_exitstatus, stdout: rpm_q_stdout) }
+  let(:rpm_q_status) { instance_double("Mixlib::ShellOut", exitstatus: rpm_q_exitstatus, stdout: rpm_q_stdout) }
 
   before(:each) do
     allow(::File).to receive(:exists?).with("PLEASE STUB File.exists? EXACTLY").and_return(true)
@@ -116,7 +116,6 @@ describe Chef::Provider::Package::Rpm do
       end
     end
 
-
     context "when the package is installed" do
 
       let(:rpm_qp_stdout) { "ImageMagick-c++ 6.5.4.7-7.el6_5" }
@@ -237,7 +236,6 @@ describe Chef::Provider::Package::Rpm do
           end
         end
 
-
         context "when the package name contains a tilde (chef#3503)" do
 
           let(:package_name) { "supermarket" }
@@ -287,7 +285,7 @@ describe Chef::Provider::Package::Rpm do
           provider.process_resource_requirements
         end
 
-        %w(http HTTP https HTTPS ftp FTP file FILE).each do |scheme|
+        %w{http HTTP https HTTPS ftp FTP file FILE}.each do |scheme|
 
           context "when the source URI uses protocol scheme '#{scheme}'" do
 
@@ -396,7 +394,6 @@ describe Chef::Provider::Package::Rpm do
 
       end
 
-
     end
   end
 
@@ -429,5 +426,4 @@ describe Chef::Provider::Package::Rpm do
     end
   end
 
-
 end

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

@@ -1,7 +1,7 @@
 #
 # Author:: David Balatero (dbalatero@gmail.com)
 #
-# Copyright:: Copyright (c) 2009 David Balatero
+# Copyright:: Copyright 2009-2016, David Balatero
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require 'pp'
+require "pp"
 
 module GemspecBackcompatCreator
   def gemspec(name, version)
@@ -28,8 +28,8 @@ module GemspecBackcompatCreator
   end
 end
 
-require 'spec_helper'
-require 'ostruct'
+require "spec_helper"
+require "ostruct"
 
 describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
   include GemspecBackcompatCreator
@@ -43,18 +43,18 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
   end
 
   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')
-      expect(Gem::Specification).to receive(:find_all_by_name).with('rspec-core', Gem::Dependency.new('rspec-core').requirement).and_return(gems)
+    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")
+      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)
+      expect(Gem.source_index).to receive(:search).with(Gem::Dependency.new("rspec-core", nil)).and_return(gems)
     end
-    expect(@gem_env.installed_versions(Gem::Dependency.new('rspec-core', nil))).to eq(gems)
+    expect(@gem_env.installed_versions(Gem::Dependency.new("rspec-core", nil))).to eq(gems)
   end
 
   it "determines the installed versions of gems from the source index (part2: the unmockening)" do
-    expected = ['rspec-core', Gem::Version.new(RSpec::Core::Version::STRING)]
-    actual = @gem_env.installed_versions(Gem::Dependency.new('rspec-core', nil)).map { |spec| [spec.name, spec.version] }
+    expected = ["rspec-core", Gem::Version.new(RSpec::Core::Version::STRING)]
+    actual = @gem_env.installed_versions(Gem::Dependency.new("rspec-core", nil)).map { |spec| [spec.name, spec.version] }
     expect(actual).to include(expected)
   end
 
@@ -87,16 +87,16 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
   end
 
   it "finds a matching gem candidate version" do
-    dep = Gem::Dependency.new('rspec', '>= 0')
+    dep = Gem::Dependency.new("rspec", ">= 0")
     dep_installer = Gem::DependencyInstaller.new
     allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
     latest = [[gemspec("rspec", Gem::Version.new("1.3.0")), "https://rubygems.org/"]]
     expect(dep_installer).to receive(:find_gems_with_sources).with(dep).and_return(latest)
-    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>= 0'))).to eq(Gem::Version.new('1.3.0'))
+    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new("rspec", ">= 0"))).to eq(Gem::Version.new("1.3.0"))
   end
 
   it "finds a matching gem candidate version on rubygems 2.0.0+" do
-    dep = Gem::Dependency.new('rspec', '>= 0')
+    dep = Gem::Dependency.new("rspec", ">= 0")
     dep_installer = Gem::DependencyInstaller.new
     allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
     best_gem = double("best gem match", :spec => gemspec("rspec", Gem::Version.new("1.3.0")), :source => "https://rubygems.org")
@@ -104,62 +104,62 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
     expect(available_set).to receive(:pick_best!)
     expect(available_set).to receive(:set).and_return([best_gem])
     expect(dep_installer).to receive(:find_gems_with_sources).with(dep).and_return(available_set)
-    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>= 0'))).to eq(Gem::Version.new('1.3.0'))
+    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new("rspec", ">= 0"))).to eq(Gem::Version.new("1.3.0"))
   end
 
   it "gives the candidate version as nil if none is found" do
-    dep = Gem::Dependency.new('rspec', '>= 0')
+    dep = Gem::Dependency.new("rspec", ">= 0")
     latest = []
     dep_installer = Gem::DependencyInstaller.new
     allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
     expect(dep_installer).to receive(:find_gems_with_sources).with(dep).and_return(latest)
-    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>= 0'))).to be_nil
+    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new("rspec", ">= 0"))).to be_nil
   end
 
   it "finds a matching candidate version from a .gem file when the path to the gem is supplied" do
-    location = CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem'
-    expect(@gem_env.candidate_version_from_file(Gem::Dependency.new('chef-integration-test', '>= 0'), location)).to eq(Gem::Version.new('0.1.0'))
-    expect(@gem_env.candidate_version_from_file(Gem::Dependency.new('chef-integration-test', '>= 0.2.0'), location)).to be_nil
+    location = CHEF_SPEC_DATA + "/gems/chef-integration-test-0.1.0.gem"
+    expect(@gem_env.candidate_version_from_file(Gem::Dependency.new("chef-integration-test", ">= 0"), location)).to eq(Gem::Version.new("0.1.0"))
+    expect(@gem_env.candidate_version_from_file(Gem::Dependency.new("chef-integration-test", ">= 0.2.0"), location)).to be_nil
   end
 
   it "finds a matching gem from a specific gemserver when explicit sources are given" do
-    dep = Gem::Dependency.new('rspec', '>= 0')
+    dep = Gem::Dependency.new("rspec", ">= 0")
     latest = [[gemspec("rspec", Gem::Version.new("1.3.0")), "https://rubygems.org/"]]
 
-    expect(@gem_env).to receive(:with_gem_sources).with('http://gems.example.com').and_yield
+    expect(@gem_env).to receive(:with_gem_sources).with("http://gems.example.com").and_yield
     dep_installer = Gem::DependencyInstaller.new
     allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
     expect(dep_installer).to receive(:find_gems_with_sources).with(dep).and_return(latest)
-    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>=0'), 'http://gems.example.com')).to eq(Gem::Version.new('1.3.0'))
+    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new("rspec", ">=0"), "http://gems.example.com")).to eq(Gem::Version.new("1.3.0"))
   end
 
   it "installs a gem with a hash of options for the dependency installer" do
     dep_installer = Gem::DependencyInstaller.new
-    expect(@gem_env).to receive(:dependency_installer).with(:install_dir => '/foo/bar').and_return(dep_installer)
-    expect(@gem_env).to receive(:with_gem_sources).with('http://gems.example.com').and_yield
-    expect(dep_installer).to receive(:install).with(Gem::Dependency.new('rspec', '>= 0'))
-    @gem_env.install(Gem::Dependency.new('rspec', '>= 0'), :install_dir => '/foo/bar', :sources => ['http://gems.example.com'])
+    expect(@gem_env).to receive(:dependency_installer).with(:install_dir => "/foo/bar").and_return(dep_installer)
+    expect(@gem_env).to receive(:with_gem_sources).with("http://gems.example.com").and_yield
+    expect(dep_installer).to receive(:install).with(Gem::Dependency.new("rspec", ">= 0"))
+    @gem_env.install(Gem::Dependency.new("rspec", ">= 0"), :install_dir => "/foo/bar", :sources => ["http://gems.example.com"])
   end
 
   it "builds an uninstaller for a gem with options set to avoid requiring user input" do
     # default options for uninstaller should be:
     # :ignore => true, :executables => true
-    expect(Gem::Uninstaller).to receive(:new).with('rspec', :ignore => true, :executables => true)
-    @gem_env.uninstaller('rspec')
+    expect(Gem::Uninstaller).to receive(:new).with("rspec", :ignore => true, :executables => true)
+    @gem_env.uninstaller("rspec")
   end
 
   it "uninstalls all versions of a gem" do
-    uninstaller = double('gem uninstaller')
+    uninstaller = double("gem uninstaller")
     expect(uninstaller).to receive(:uninstall)
-    expect(@gem_env).to receive(:uninstaller).with('rspec', :all => true).and_return(uninstaller)
-    @gem_env.uninstall('rspec')
+    expect(@gem_env).to receive(:uninstaller).with("rspec", :all => true).and_return(uninstaller)
+    @gem_env.uninstall("rspec")
   end
 
   it "uninstalls a specific version of a gem" do
-    uninstaller = double('gem uninstaller')
+    uninstaller = double("gem uninstaller")
     expect(uninstaller).to receive(:uninstall)
-    expect(@gem_env).to receive(:uninstaller).with('rspec', :version => '1.2.3').and_return(uninstaller)
-    @gem_env.uninstall('rspec', '1.2.3')
+    expect(@gem_env).to receive(:uninstaller).with("rspec", :version => "1.2.3").and_return(uninstaller)
+    @gem_env.uninstall("rspec", "1.2.3")
   end
 
 end
@@ -170,72 +170,72 @@ describe Chef::Provider::Package::Rubygems::AlternateGemEnvironment do
   before do
     Chef::Provider::Package::Rubygems::AlternateGemEnvironment.gempath_cache.clear
     Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache.clear
-    @gem_env = Chef::Provider::Package::Rubygems::AlternateGemEnvironment.new('/usr/weird/bin/gem')
+    @gem_env = Chef::Provider::Package::Rubygems::AlternateGemEnvironment.new("/usr/weird/bin/gem")
   end
 
   it "determines the gem paths from shelling out to gem env" do
-    gem_env_output = ['/path/to/gems', '/another/path/to/gems'].join(File::PATH_SEPARATOR)
+    gem_env_output = ["/path/to/gems", "/another/path/to/gems"].join(File::PATH_SEPARATOR)
     shell_out_result = OpenStruct.new(:stdout => gem_env_output)
-    expect(@gem_env).to receive(:shell_out!).with('/usr/weird/bin/gem env gempath').and_return(shell_out_result)
-    expect(@gem_env.gem_paths).to eq(['/path/to/gems', '/another/path/to/gems'])
+    expect(@gem_env).to receive(:shell_out!).with("/usr/weird/bin/gem env gempath").and_return(shell_out_result)
+    expect(@gem_env.gem_paths).to eq(["/path/to/gems", "/another/path/to/gems"])
   end
 
   it "caches the gempaths by gem_binary" do
-    gem_env_output = ['/path/to/gems', '/another/path/to/gems'].join(File::PATH_SEPARATOR)
+    gem_env_output = ["/path/to/gems", "/another/path/to/gems"].join(File::PATH_SEPARATOR)
     shell_out_result = OpenStruct.new(:stdout => gem_env_output)
-    expect(@gem_env).to receive(:shell_out!).with('/usr/weird/bin/gem env gempath').and_return(shell_out_result)
-    expected = ['/path/to/gems', '/another/path/to/gems']
-    expect(@gem_env.gem_paths).to eq(['/path/to/gems', '/another/path/to/gems'])
-    expect(Chef::Provider::Package::Rubygems::AlternateGemEnvironment.gempath_cache['/usr/weird/bin/gem']).to eq(expected)
+    expect(@gem_env).to receive(:shell_out!).with("/usr/weird/bin/gem env gempath").and_return(shell_out_result)
+    expected = ["/path/to/gems", "/another/path/to/gems"]
+    expect(@gem_env.gem_paths).to eq(["/path/to/gems", "/another/path/to/gems"])
+    expect(Chef::Provider::Package::Rubygems::AlternateGemEnvironment.gempath_cache["/usr/weird/bin/gem"]).to eq(expected)
   end
 
   it "uses the cached result for gem paths when available" do
     expect(@gem_env).not_to receive(:shell_out!)
-    expected = ['/path/to/gems', '/another/path/to/gems']
-    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.gempath_cache['/usr/weird/bin/gem']= expected
-    expect(@gem_env.gem_paths).to eq(['/path/to/gems', '/another/path/to/gems'])
+    expected = ["/path/to/gems", "/another/path/to/gems"]
+    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.gempath_cache["/usr/weird/bin/gem"] = expected
+    expect(@gem_env.gem_paths).to eq(["/path/to/gems", "/another/path/to/gems"])
   end
 
   it "builds the gems source index from the gem paths" do
-    allow(@gem_env).to receive(:gem_paths).and_return(['/path/to/gems', '/another/path/to/gems'])
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0')
+    allow(@gem_env).to receive(:gem_paths).and_return(["/path/to/gems", "/another/path/to/gems"])
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new("1.8.0")
       @gem_env.gem_specification
-      expect(Gem::Specification.dirs).to eq([ '/path/to/gems/specifications', '/another/path/to/gems/specifications' ])
+      expect(Gem::Specification.dirs).to eq([ "/path/to/gems/specifications", "/another/path/to/gems/specifications" ])
     else
-      expect(Gem::SourceIndex).to receive(:from_gems_in).with('/path/to/gems/specifications', '/another/path/to/gems/specifications')
+      expect(Gem::SourceIndex).to receive(:from_gems_in).with("/path/to/gems/specifications", "/another/path/to/gems/specifications")
       @gem_env.gem_source_index
     end
   end
 
   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')
+    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")
       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
       allow(@gem_env).to receive(:gem_source_index).and_return(Gem.source_index)
       expect(@gem_env.gem_source_index).to receive(:search).with(rspec_dep).and_return(gems)
     end
-    expect(@gem_env.installed_versions(Gem::Dependency.new('rspec', nil))).to eq(gems)
+    expect(@gem_env.installed_versions(Gem::Dependency.new("rspec", nil))).to eq(gems)
   end
 
   it "determines the installed versions of gems from the source index (part2: the unmockening)" do
     allow($stdout).to receive(:write)
     path_to_gem = if windows?
-      `where gem`.split[1]
-    else
-      `which gem`.strip
-    end
+                    `where gem`.split[1]
+                  else
+                    `which gem`.strip
+                  end
     skip("cant find your gem executable") if path_to_gem.empty?
     gem_env = Chef::Provider::Package::Rubygems::AlternateGemEnvironment.new(path_to_gem)
-    expected = ['rspec-core', Gem::Version.new(RSpec::Core::Version::STRING)]
-    actual = gem_env.installed_versions(Gem::Dependency.new('rspec-core', nil)).map { |s| [s.name, s.version] }
+    expected = ["rspec-core", Gem::Version.new(RSpec::Core::Version::STRING)]
+    actual = gem_env.installed_versions(Gem::Dependency.new("rspec-core", nil)).map { |s| [s.name, s.version] }
     expect(actual).to include(expected)
   end
 
   it "detects when the target gem environment is the jruby platform" do
-    gem_env_out=<<-JRUBY_GEM_ENV
+    gem_env_out = <<-JRUBY_GEM_ENV
 RubyGems Environment:
   - RUBYGEMS VERSION: 1.3.6
   - RUBY VERSION: 1.8.7 (2010-05-12 patchlevel 249) [java]
@@ -261,23 +261,23 @@ RubyGems Environment:
   - REMOTE SOURCES:
      - https://rubygems.org/
      - http://gems.github.com/
-JRUBY_GEM_ENV
-    expect(@gem_env).to receive(:shell_out!).with('/usr/weird/bin/gem env').and_return(double('jruby_gem_env', :stdout => gem_env_out))
-    expected = ['ruby', Gem::Platform.new('universal-java-1.6')]
+    JRUBY_GEM_ENV
+    expect(@gem_env).to receive(:shell_out!).with("/usr/weird/bin/gem env").and_return(double("jruby_gem_env", :stdout => gem_env_out))
+    expected = ["ruby", Gem::Platform.new("universal-java-1.6")]
     expect(@gem_env.gem_platforms).to eq(expected)
     # it should also cache the result
-    expect(Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache['/usr/weird/bin/gem']).to eq(expected)
+    expect(Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache["/usr/weird/bin/gem"]).to eq(expected)
   end
 
   it "uses the cached result for gem platforms if available" do
     expect(@gem_env).not_to receive(:shell_out!)
-    expected = ['ruby', Gem::Platform.new('universal-java-1.6')]
-    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache['/usr/weird/bin/gem']= expected
+    expected = ["ruby", Gem::Platform.new("universal-java-1.6")]
+    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache["/usr/weird/bin/gem"] = expected
     expect(@gem_env.gem_platforms).to eq(expected)
   end
 
   it "uses the current gem platforms when the target env is not jruby" do
-    gem_env_out=<<-RBX_GEM_ENV
+    gem_env_out = <<-RBX_GEM_ENV
 RubyGems Environment:
   - RUBYGEMS VERSION: 1.3.6
   - RUBY VERSION: 1.8.7 (2010-05-14 patchlevel 174) [x86_64-apple-darwin10.3.0]
@@ -303,23 +303,23 @@ RubyGems Environment:
   - REMOTE SOURCES:
      - https://rubygems.org/
      - http://gems.github.com/
-RBX_GEM_ENV
-    expect(@gem_env).to receive(:shell_out!).with('/usr/weird/bin/gem env').and_return(double('rbx_gem_env', :stdout => gem_env_out))
+    RBX_GEM_ENV
+    expect(@gem_env).to receive(:shell_out!).with("/usr/weird/bin/gem env").and_return(double("rbx_gem_env", :stdout => gem_env_out))
     expect(@gem_env.gem_platforms).to eq(Gem.platforms)
-    expect(Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache['/usr/weird/bin/gem']).to eq(Gem.platforms)
+    expect(Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache["/usr/weird/bin/gem"]).to eq(Gem.platforms)
   end
 
   it "yields to a block while masquerading as a different gems platform" do
     original_platforms = Gem.platforms
     platforms_in_block = nil
     begin
-      @gem_env.with_gem_platforms(['ruby', Gem::Platform.new('sparc64-java-1.7')]) do
+      @gem_env.with_gem_platforms(["ruby", Gem::Platform.new("sparc64-java-1.7")]) do
         platforms_in_block = Gem.platforms
         raise "gem platforms should get set to the correct value even when an error occurs"
       end
     rescue RuntimeError
     end
-    expect(platforms_in_block).to eq(['ruby', Gem::Platform.new('sparc64-java-1.7')])
+    expect(platforms_in_block).to eq(["ruby", Gem::Platform.new("sparc64-java-1.7")])
     expect(Gem.platforms).to eq(original_platforms)
   end
 
@@ -327,357 +327,454 @@ end
 
 describe Chef::Provider::Package::Rubygems do
   let(:target_version) { nil }
+  let(:gem_name) { "rspec-core" }
+  let(:gem_binary) { nil }
+  let(:bindir) { "/usr/bin/ruby" }
+  let(:options) { nil }
+  let(:source) { nil }
+
+  let(:new_resource) do
+    new_resource = Chef::Resource::GemPackage.new(gem_name)
+    new_resource.version(target_version)
+    new_resource.gem_binary(gem_binary) if gem_binary
+    new_resource.options(options) if options
+    new_resource.source(source) if source
+    new_resource
+  end
 
-  before(:each) do
-    @node = Chef::Node.new
-    @new_resource = Chef::Resource::GemPackage.new("rspec-core")
-    @spec_version = @new_resource.version(target_version)
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
+  let (:current_resource) { nil }
+
+  let(:provider) do
+    run_context = Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
+    provider = Chef::Provider::Package::Rubygems.new(new_resource, run_context)
+    if current_resource
+      allow(provider).to receive(:load_current_resource)
+      provider.current_resource = current_resource
+    end
+    provider
+  end
+
+  let(:gem_dep) { Gem::Dependency.new(gem_name, target_version) }
 
+  before(:each) do
     # We choose detect omnibus via RbConfig::CONFIG['bindir'] in Chef::Provider::Package::Rubygems.new
-    allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return("/usr/bin/ruby")
+    allow(RbConfig::CONFIG).to receive(:[]).with("bindir").and_return(bindir)
     # Rubygems uses this interally
-    allow(RbConfig::CONFIG).to receive(:[]).with('arch').and_call_original
-    @provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+    allow(RbConfig::CONFIG).to receive(:[]).with("arch").and_call_original
   end
 
   describe "when new_resource version is nil" do
     let(:target_version) { nil }
 
     it "target_version_already_installed? should return false so that we can search for candidates" do
-      @provider.load_current_resource
-      expect(@provider.target_version_already_installed?(@provider.current_resource.version, @new_resource.version)).to be_falsey
+      provider.load_current_resource
+      expect(provider.target_version_already_installed?(provider.current_resource.version, new_resource.version)).to be_falsey
     end
   end
 
-  describe "when new_resource version is current rspec version" do
-    let(:target_version) { RSpec::Core::Version::STRING }
+  describe "when new_resource version is an rspec version" do
+    let(:current_version) { RSpec::Core::Version::STRING }
+    let(:target_version) { current_version }
 
     it "triggers a gem configuration load so a later one will not stomp its config values" do
+      _ = provider
       # ugly, is there a better way?
       expect(Gem.instance_variable_get(:@configuration)).not_to be_nil
     end
 
     it "uses the CurrentGemEnvironment implementation when no gem_binary_path is provided" do
-      expect(@provider.gem_env).to be_a_kind_of(Chef::Provider::Package::Rubygems::CurrentGemEnvironment)
+      expect(provider.gem_env).to be_a_kind_of(Chef::Provider::Package::Rubygems::CurrentGemEnvironment)
     end
 
-    it "uses the AlternateGemEnvironment implementation when a gem_binary_path is provided" do
-      @new_resource.gem_binary('/usr/weird/bin/gem')
-      provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-      expect(provider.gem_env.gem_binary_location).to eq('/usr/weird/bin/gem')
-    end
+    context "when a gem_binary_path is provided" do
+      let(:gem_binary) { "/usr/weird/bin/gem" }
 
-    it "recognizes chef as omnibus" do
-      allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return("/opt/chef/embedded/bin")
-      provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-      expect(provider.is_omnibus?).to be true
-    end
+      it "uses the AlternateGemEnvironment implementation when a gem_binary_path is provided" do
+        expect(provider.gem_env.gem_binary_location).to eq(gem_binary)
+      end
 
-    it "recognizes opscode as omnibus" do
-      allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return("/opt/opscode/embedded/bin")
-      provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-      expect(provider.is_omnibus?).to be true
-    end
+      context "when you try to use a hash of install options" do
+        let(:options) { { :fail => :burger } }
 
-    it "recognizes chefdk as omnibus" do
-      allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return("/opt/chefdk/embedded/bin")
-      provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-      expect(provider.is_omnibus?).to be true
+        it "smites you" do
+          expect { provider }.to raise_error(ArgumentError)
+        end
+      end
     end
 
-    it "searches for a gem binary when running on Omnibus on Unix" do
-      platform_mock :unix do
-        allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return("/opt/chef/embedded/bin")
-        allow(ENV).to receive(:[]).with('PATH').and_return("/usr/bin:/usr/sbin:/opt/chef/embedded/bin")
-        allow(File).to receive(:exists?).with('/usr/bin/gem').and_return(false)
-        allow(File).to receive(:exists?).with('/usr/sbin/gem').and_return(true)
-        allow(File).to receive(:exists?).with('/opt/chef/embedded/bin/gem').and_return(true) # should not get here
-        provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-        expect(provider.gem_env.gem_binary_location).to eq('/usr/sbin/gem')
+    context "when in omnibus opscode" do
+      let(:bindir) { "/opt/opscode/embedded/bin" }
+
+      it "recognizes opscode as omnibus" do
+        expect(provider.is_omnibus?).to be true
       end
     end
 
-    it "searches for a gem binary when running on Omnibus on Windows" do
-      platform_mock :windows do
-        allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return("d:/opscode/chef/embedded/bin")
-        allow(ENV).to receive(:[]).with('PATH').and_return('C:\windows\system32;C:\windows;C:\Ruby186\bin;d:\opscode\chef\embedded\bin')
-        allow(File).to receive(:exists?).with('C:\\windows\\system32\\gem').and_return(false)
-        allow(File).to receive(:exists?).with('C:\\windows\\gem').and_return(false)
-        allow(File).to receive(:exists?).with('C:\\Ruby186\\bin\\gem').and_return(true)
-        allow(File).to receive(:exists?).with('d:\\opscode\\chef\\bin\\gem').and_return(false) # should not get here
-        allow(File).to receive(:exists?).with('d:\\opscode\\chef\\embedded\\bin\\gem').and_return(false) # should not get here
-        provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-        expect(provider.gem_env.gem_binary_location).to eq('C:\Ruby186\bin\gem')
+    context "when in omnibus chefdk" do
+      let(:bindir) { "/opt/chefdk/embedded/bin" }
+
+      it "recognizes chefdk as omnibus" do
+        expect(provider.is_omnibus?).to be true
       end
     end
 
-    it "smites you when you try to use a hash of install options with an explicit gem binary" do
-      @new_resource.gem_binary('/foo/bar')
-      @new_resource.options(:fail => :burger)
-      expect {Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)}.to raise_error(ArgumentError)
+    context "when in omnibus chef" do
+      let(:bindir) { "/opt/chef/embedded/bin" }
+
+      it "recognizes chef as omnibus" do
+        expect(provider.is_omnibus?).to be true
+      end
+
+      it "searches for a gem binary when running on Omnibus on Unix" do
+        platform_mock :unix do
+          allow(ENV).to receive(:[]).with("PATH").and_return("/usr/bin:/usr/sbin:/opt/chef/embedded/bin")
+          allow(File).to receive(:exists?).with("/usr/bin/gem").and_return(false)
+          allow(File).to receive(:exists?).with("/usr/sbin/gem").and_return(true)
+          allow(File).to receive(:exists?).with("/opt/chef/embedded/bin/gem").and_return(true) # should not get here
+          expect(provider.gem_env.gem_binary_location).to eq("/usr/sbin/gem")
+        end
+      end
+
+      context "when on Windows" do
+        let(:bindir) { "d:/opscode/chef/embedded/bin" }
+
+        it "searches for a gem binary when running on Omnibus on Windows" do
+          platform_mock :windows do
+            allow(ENV).to receive(:[]).with("PATH").and_return('C:\windows\system32;C:\windows;C:\Ruby186\bin;d:\opscode\chef\embedded\bin')
+            allow(File).to receive(:exists?).with('C:\\windows\\system32\\gem').and_return(false)
+            allow(File).to receive(:exists?).with('C:\\windows\\gem').and_return(false)
+            allow(File).to receive(:exists?).with('C:\\Ruby186\\bin\\gem').and_return(true)
+            allow(File).to receive(:exists?).with('d:\\opscode\\chef\\bin\\gem').and_return(false) # should not get here
+            allow(File).to receive(:exists?).with('d:\\opscode\\chef\\embedded\\bin\\gem').and_return(false) # should not get here
+            expect(provider.gem_env.gem_binary_location).to eq('C:\Ruby186\bin\gem')
+          end
+        end
+      end
     end
 
     it "converts the new resource into a gem dependency" do
-      expect(@provider.gem_dependency).to eq(Gem::Dependency.new('rspec-core', @spec_version))
-      @new_resource.version('~> 1.2.0')
-      expect(@provider.gem_dependency).to eq(Gem::Dependency.new('rspec-core', '~> 1.2.0'))
+      expect(provider.gem_dependency).to eq(gem_dep)
+    end
+
+    context "when the new resource is not the current version" do
+      let(:target_version) { "~> 9000.0.2" }
+
+      it "converts the new resource into a gem dependency" do
+        expect(provider.gem_dependency).to eq(gem_dep)
+      end
     end
 
     describe "when determining the currently installed version" do
+      before do
+        provider.load_current_resource
+      end
 
       it "sets the current version to the version specified by the new resource if that version is installed" do
-        @provider.load_current_resource
-        expect(@provider.current_resource.version).to eq(@spec_version)
+        expect(provider.current_resource.version).to eq(current_version)
       end
 
-      it "sets the current version to the highest installed version if the requested version is not installed" do
-        @new_resource.version('9000.0.2')
-        @provider.load_current_resource
-        expect(@provider.current_resource.version).to eq(@spec_version)
+      context "if the requested version is not installed" do
+        let(:target_version) { "9000.0.2" }
+
+        it "sets the current version to the highest installed version if the requested version is not installed" do
+          expect(provider.current_resource.version).to eq(current_version)
+        end
       end
 
-      it "leaves the current version at nil if the package is not installed" do
-        @new_resource.package_name("no-such-gem-should-exist-with-this-name")
-        @provider.load_current_resource
-        expect(@provider.current_resource.version).to be_nil
+      context "if the package is not currently installed" do
+        let(:gem_name) { "no-such-gem-should-exist-with-this-name" }
+
+        it "leaves the current version at nil" do
+          expect(provider.current_resource.version).to be_nil
+        end
       end
 
     end
 
     describe "when determining the candidate version to install" do
+      before do
+        provider.load_current_resource
+      end
 
       it "does not query for available versions when the current version is the target version" do
-        @provider.current_resource = @new_resource.dup
-        expect(@provider.candidate_version).to be_nil
+        expect(provider.candidate_version).to be_nil
       end
 
-      it "determines the candidate version by querying the remote gem servers" do
-        @new_resource.source('http://mygems.example.com')
-        @provider.load_current_resource
-        @provider.current_resource.version('0.0.1')
-        version = Gem::Version.new(@spec_version)
-        expect(@provider.gem_env).to receive(:candidate_version_from_remote).
-                          with(Gem::Dependency.new('rspec-core', @spec_version), "http://mygems.example.com").
-                          and_return(version)
-        expect(@provider.candidate_version).to eq(@spec_version)
+      context "when the current version is not the target version" do
+        let(:target_version) { "9000.0.2" }
+        let(:source) { "http://mygems.example.com" }
+
+        it "determines the candidate version by querying the remote gem servers" do
+          expect(provider.gem_env).to receive(:candidate_version_from_remote).
+            with(gem_dep, source).
+            and_return(Gem::Version.new(target_version))
+          expect(provider.candidate_version).to eq(target_version)
+        end
       end
 
-      it "parses the gem's specification if the requested source is a file" do
-        @new_resource.package_name('chef-integration-test')
-        @new_resource.source(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-        @new_resource.version('>= 0')
-        @provider.load_current_resource
-        expect(@provider.candidate_version).to eq('0.1.0')
+      context "when the requested source is a file" do
+        let (:gem_name) { "chef-integration-test" }
+        let (:source) { CHEF_SPEC_DATA + "/gems/chef-integration-test-0.1.0.gem" }
+        let (:target_version) { ">= 0" }
+
+        it "parses the gem's specification" do
+          expect(provider.candidate_version).to eq("0.1.0")
+        end
       end
 
     end
 
     describe "when installing a gem" do
+      let(:target_version) { "9000.0.2" }
+      let(:current_version) { nil }
+      let(:candidate_version) { "9000.0.2" }
+      let(:current_resource) do
+        current_resource = Chef::Resource::GemPackage.new(gem_name)
+        current_resource.version(current_version)
+        current_resource
+      end
+
       before do
-        @current_resource = Chef::Resource::GemPackage.new('rspec-core')
-        @provider.current_resource = @current_resource
-        @gem_dep = Gem::Dependency.new('rspec-core', @spec_version)
-        allow(@provider).to receive(:load_current_resource)
+        version = Gem::Version.new(candidate_version)
+        args = [gem_dep]
+        args << source if source
+        allow(provider.gem_env).to receive(:candidate_version_from_remote).
+          with(*args).
+          and_return(version)
       end
 
       describe "in the current gem environment" do
         it "installs the gem via the gems api when no explicit options are used" do
-          expect(@provider.gem_env).to receive(:install).with(@gem_dep, :sources => nil)
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+          expect(provider.gem_env).to receive(:install).with(gem_dep, :sources => nil)
+          provider.run_action(:install)
+          expect(new_resource).to be_updated_by_last_action
         end
 
-        it "installs the gem via the gems api when a remote source is provided" do
-          @new_resource.source('http://gems.example.org')
-          sources = ['http://gems.example.org']
-          expect(@provider.gem_env).to receive(:install).with(@gem_dep, :sources => sources)
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+        context "when a remote source is provided" do
+          let(:source) { "http://gems.example.org" }
+
+          it "installs the gem via the gems api" do
+            expect(provider.gem_env).to receive(:install).with(gem_dep, :sources => [source])
+            provider.run_action(:install)
+            expect(new_resource).to be_updated_by_last_action
+          end
         end
 
-        it "installs the gem from file via the gems api when no explicit options are used" do
-          @new_resource.source(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-          expect(@provider.gem_env).to receive(:install).with(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+        context "when source is a path" do
+          let(:source) { CHEF_SPEC_DATA + "/gems/chef-integration-test-0.1.0.gem" }
+
+          it "installs the gem from file via the gems api" do
+            expect(provider.gem_env).to receive(:install).with(source)
+            provider.run_action(:install)
+            expect(new_resource).to be_updated_by_last_action
+          end
         end
 
-        it "installs the gem from file via the gems api when the package is a path and the source is nil" do
-          @new_resource = Chef::Resource::GemPackage.new(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-          @provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-          @provider.current_resource = @current_resource
-          expect(@new_resource.source).to eq(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-          expect(@provider.gem_env).to receive(:install).with(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+        context "when the gem name is a file path and source is nil" do
+          let(:gem_name) { CHEF_SPEC_DATA + "/gems/chef-integration-test-0.1.0.gem" }
+
+          it "installs the gem from file via the gems api" do
+            expect(new_resource.source).to eq(gem_name)
+            expect(provider.gem_env).to receive(:install).with(gem_name)
+            provider.run_action(:install)
+            expect(new_resource).to be_updated_by_last_action
+          end
         end
 
         # this catches 'gem_package "foo"' when "./foo" is a file in the cwd, and instead of installing './foo' it fetches the remote gem
         it "installs the gem via the gems api, when the package has no file separator characters in it, but a matching file exists in cwd" do
           allow(::File).to receive(:exists?).and_return(true)
-          @new_resource.package_name('rspec-core')
-          expect(@provider.gem_env).to receive(:install).with(@gem_dep, :sources => nil)
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+          new_resource.package_name("rspec-core")
+          expect(provider.gem_env).to receive(:install).with(gem_dep, :sources => nil)
+          provider.run_action(:install)
+          expect(new_resource).to be_updated_by_last_action
         end
 
-        it "installs the gem by shelling out when options are provided as a String" do
-          @new_resource.options('-i /alt/install/location')
-          expected ="gem install rspec-core -q --no-rdoc --no-ri -v \"#{@spec_version}\" -i /alt/install/location"
-          expect(@provider).to receive(:shell_out!).with(expected, env: nil, timeout: 900)
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+        context "when options are provided as a String" do
+          let(:options) { "-i /alt/install/location" }
+
+          it "installs the gem by shelling out when options are provided as a String" do
+            expected = "gem install rspec-core -q --no-rdoc --no-ri -v \"#{target_version}\" #{options}"
+            expect(provider).to receive(:shell_out!).with(expected, env: nil, timeout: 900)
+            provider.run_action(:install)
+            expect(new_resource).to be_updated_by_last_action
+          end
         end
 
-        it "installs the gem with rubygems.org as an added source" do
-          @new_resource.gem_binary('/foo/bar')
-          @new_resource.source('http://mirror.ops.rhcloud.com/mirror/ruby')
-          expected ="/foo/bar install rspec-core -q --no-rdoc --no-ri -v \"#{@spec_version}\" --source=#{@new_resource.source} --source=https://rubygems.org"
-          expect(@provider).to receive(:shell_out!).with(expected, env: nil, timeout: 900)
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+        context "when another source and binary are provided" do
+          let(:source) { "http://mirror.ops.rhcloud.com/mirror/ruby" }
+          let(:gem_binary) { "/foo/bar" }
+
+          it "installs the gem with rubygems.org as an added source" do
+            expected = "#{gem_binary} install rspec-core -q --no-rdoc --no-ri -v \"#{target_version}\" --source=#{source} --source=https://rubygems.org"
+            expect(provider).to receive(:shell_out!).with(expected, env: nil, timeout: 900)
+            provider.run_action(:install)
+            expect(new_resource).to be_updated_by_last_action
+          end
         end
 
-        it "installs the gem with cleared sources and explict source when specified" do
-          @new_resource.gem_binary('/foo/bar')
-          @new_resource.source('http://mirror.ops.rhcloud.com/mirror/ruby')
-          @new_resource.clear_sources(true)
-          expected ="/foo/bar install rspec-core -q --no-rdoc --no-ri -v \"#{@spec_version}\" --clear-sources --source=#{@new_resource.source}"
-          expect(@provider).to receive(:shell_out!).with(expected, env: nil, timeout: 900)
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+        context "when we have cleared sources and an explict source is specified" do
+          let(:gem_binary) { "/foo/bar" }
+          let(:source) { "http://mirror.ops.rhcloud.com/mirror/ruby" }
+
+          it "installs the gem" do
+            new_resource.clear_sources(true)
+            expected = "#{gem_binary} install rspec-core -q --no-rdoc --no-ri -v \"#{target_version}\" --clear-sources --source=#{source}"
+            expect(provider).to receive(:shell_out!).with(expected, env: nil, timeout: 900)
+            provider.run_action(:install)
+            expect(new_resource).to be_updated_by_last_action
+          end
         end
 
         context "when no version is given" do
           let(:target_version) { nil }
+          let(:options) { "-i /alt/install/location" }
 
           it "installs the gem by shelling out when options are provided but no version is given" do
-            @new_resource.options('-i /alt/install/location')
-            expected ="gem install rspec-core -q --no-rdoc --no-ri -v \"#{@provider.candidate_version}\" -i /alt/install/location"
-            expect(@provider).to receive(:shell_out!).with(expected, env: nil, timeout: 900)
-            @provider.run_action(:install)
-            expect(@new_resource).to be_updated_by_last_action
+            expected = "gem install rspec-core -q --no-rdoc --no-ri -v \"#{candidate_version}\" #{options}"
+            expect(provider).to receive(:shell_out!).with(expected, env: nil, timeout: 900)
+            provider.run_action(:install)
+            expect(new_resource).to be_updated_by_last_action
           end
         end
 
-        it "installs the gem via the gems api when options are given as a Hash" do
-          @new_resource.options(:install_dir => '/alt/install/location')
-          expect(@provider.gem_env).to receive(:install).with(@gem_dep, :sources => nil, :install_dir => '/alt/install/location')
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+        context "when options are given as a Hash" do
+          let(:options) { { :install_dir => "/alt/install/location" } }
+
+          it "installs the gem via the gems api when options are given as a Hash" do
+            expect(provider.gem_env).to receive(:install).with(gem_dep, { :sources => nil }.merge(options))
+            provider.run_action(:install)
+            expect(new_resource).to be_updated_by_last_action
+          end
         end
 
         describe "at a specific version" do
-          before do
-            @gem_dep = Gem::Dependency.new('rspec-core', @spec_version)
-          end
+          let(:target_version) { "9000.0.2" }
 
           it "installs the gem via the gems api" do
-            expect(@provider.gem_env).to receive(:install).with(@gem_dep, :sources => nil)
-            @provider.run_action(:install)
-            expect(@new_resource).to be_updated_by_last_action
+            expect(provider.gem_env).to receive(:install).with(gem_dep, :sources => nil)
+            provider.run_action(:install)
+            expect(new_resource).to be_updated_by_last_action
           end
         end
-        describe "at version specified with comparison operator" do
-          it "skips install if current version satisifies requested version" do
-            @current_resource.version("2.3.3")
-            @new_resource.version(">=2.3.0")
 
-            expect(@provider.gem_env).not_to receive(:install)
-            @provider.run_action(:install)
+        describe "at version specified with comparison operator" do
+          context "if current version satisifies requested version" do
+            let(:target_version) { ">=2.3.0" }
+            let(:current_version) { "2.3.3" }
+
+            it "skips the install" do
+              expect(provider.gem_env).not_to receive(:install)
+              provider.run_action(:install)
+            end
           end
 
-          it "allows user to specify gem version with fuzzy operator" do
-            @current_resource.version("2.3.3")
-            @new_resource.version("~>2.3.0")
+          context "if the fuzzy operator is used" do
+            let(:target_version) { "~>2.3.0" }
+            let(:current_version) { "2.3.3" }
 
-            expect(@provider.gem_env).not_to receive(:install)
-            @provider.run_action(:install)
+            it "it matches an existing gem" do
+              expect(provider.gem_env).not_to receive(:install)
+              provider.run_action(:install)
+            end
           end
         end
       end
 
       describe "in an alternate gem environment" do
+        let(:gem_binary) { "/usr/weird/bin/gem" }
+
         it "installs the gem by shelling out to gem install" do
-          @new_resource.gem_binary('/usr/weird/bin/gem')
-          expect(@provider).to receive(:shell_out!).with("/usr/weird/bin/gem install rspec-core -q --no-rdoc --no-ri -v \"#{@spec_version}\"", env: nil, timeout: 900)
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+          expect(provider).to receive(:shell_out!).with("#{gem_binary} install rspec-core -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
 
-        it "installs the gem from file by shelling out to gem install" do
-          @new_resource.gem_binary('/usr/weird/bin/gem')
-          @new_resource.source(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-          @new_resource.version('>= 0')
-          expect(@provider).to receive(:shell_out!).with("/usr/weird/bin/gem install #{CHEF_SPEC_DATA}/gems/chef-integration-test-0.1.0.gem -q --no-rdoc --no-ri -v \">= 0\"", env: nil, timeout: 900)
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+        context "when source is a path" do
+          let(:source) { CHEF_SPEC_DATA + "/gems/chef-integration-test-0.1.0.gem" }
+          let(:target_version) { ">= 0" }
+
+          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}\"", env: nil, timeout: 900)
+            provider.run_action(:install)
+            expect(new_resource).to be_updated_by_last_action
+          end
         end
 
-        it "installs the gem from file by shelling out to gem install when the package is a path and the source is nil" do
-          @new_resource = Chef::Resource::GemPackage.new(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-          @provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-          @provider.current_resource = @current_resource
-          @new_resource.gem_binary('/usr/weird/bin/gem')
-          @new_resource.version('>= 0')
-          expect(@new_resource.source).to eq(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-          expect(@provider).to receive(:shell_out!).with("/usr/weird/bin/gem install #{CHEF_SPEC_DATA}/gems/chef-integration-test-0.1.0.gem -q --no-rdoc --no-ri -v \">= 0\"", env: nil, timeout: 900)
-          @provider.run_action(:install)
-          expect(@new_resource).to be_updated_by_last_action
+        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" }
+
+          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}\"", env: nil, timeout: 900)
+            provider.run_action(:install)
+            expect(new_resource).to be_updated_by_last_action
+          end
         end
       end
 
     end
 
     describe "when uninstalling a gem" do
-      before do
-        @new_resource = Chef::Resource::GemPackage.new("rspec")
-        @current_resource = @new_resource.dup
-        @current_resource.version('1.2.3')
-        @provider.new_resource = @new_resource
-        @provider.current_resource = @current_resource
+      let(:gem_name) { "rspec" }
+      let(:current_version) { "1.2.3" }
+      let(:target_version) { nil }
+
+      let(:current_resource) do
+        current_resource = Chef::Resource::GemPackage.new(gem_name)
+        current_resource.version(current_version)
+        current_resource
       end
 
       describe "in the current gem environment" do
         it "uninstalls via the api when no explicit options are used" do
           # pre-reqs for action_remove to actually remove the package:
-          expect(@provider.new_resource.version).to be_nil
-          expect(@provider.current_resource.version).not_to be_nil
+          expect(provider.new_resource.version).to be_nil
+          expect(provider.current_resource.version).not_to be_nil
           # the behavior we're testing:
-          expect(@provider.gem_env).to receive(:uninstall).with('rspec', nil)
-          @provider.action_remove
+          expect(provider.gem_env).to receive(:uninstall).with("rspec", nil)
+          provider.action_remove
         end
 
-        it "uninstalls via the api when options are given as a Hash" do
-          # pre-reqs for action_remove to actually remove the package:
-          expect(@provider.new_resource.version).to be_nil
-          expect(@provider.current_resource.version).not_to be_nil
-          # the behavior we're testing:
-          @new_resource.options(:install_dir => '/alt/install/location')
-          expect(@provider.gem_env).to receive(:uninstall).with('rspec', nil, :install_dir => '/alt/install/location')
-          @provider.action_remove
+        context "when options are given as a Hash" do
+          let(:options) { { :install_dir => "/alt/install/location" } }
+
+          it "uninstalls via the api" do
+            # pre-reqs for action_remove to actually remove the package:
+            expect(provider.new_resource.version).to be_nil
+            expect(provider.current_resource.version).not_to be_nil
+            # the behavior we're testing:
+            expect(provider.gem_env).to receive(:uninstall).with("rspec", nil, options)
+            provider.action_remove
+          end
         end
 
-        it "uninstalls via the gem command when options are given as a String" do
-          @new_resource.options('-i /alt/install/location')
-          expect(@provider).to receive(:shell_out!).with("gem uninstall rspec -q -x -I -a -i /alt/install/location", env: nil, timeout: 900)
-          @provider.action_remove
+        context "when options are given as a String" do
+          let(:options) { "-i /alt/install/location" }
+
+          it "uninstalls via the gem command" do
+            expect(provider).to receive(:shell_out!).with("gem uninstall rspec -q -x -I -a #{options}", env: nil, timeout: 900)
+            provider.action_remove
+          end
         end
 
-        it "uninstalls a specific version of a gem when a version is provided" do
-          @new_resource.version('1.2.3')
-          expect(@provider.gem_env).to receive(:uninstall).with('rspec', '1.2.3')
-          @provider.action_remove
+        context "when a version is provided" do
+          let(:target_version) { "1.2.3" }
+
+          it "uninstalls a specific version of a gem" do
+            expect(provider.gem_env).to receive(:uninstall).with("rspec", "1.2.3")
+            provider.action_remove
+          end
         end
       end
 
       describe "in an alternate gem environment" do
+        let(:gem_binary) { "/usr/weird/bin/gem" }
+
         it "uninstalls via the gem command" do
-          @new_resource.gem_binary('/usr/weird/bin/gem')
-          expect(@provider).to receive(:shell_out!).with("/usr/weird/bin/gem uninstall rspec -q -x -I -a", env: nil, timeout: 900)
-          @provider.action_remove
+          expect(provider).to receive(:shell_out!).with("#{gem_binary} uninstall rspec -q -x -I -a", env: nil, timeout: 900)
+          provider.action_remove
         end
       end
     end