puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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

@@ -1,16 +1,19 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:pkgutil) do
+provider = Puppet::Type.type(:package).provider(:pkgutil)
+
+describe provider do
   before(:each) do
     @resource = Puppet::Type.type(:package).new(
       :name     => "TESTpkg",
       :ensure   => :present,
       :provider => :pkgutil
     )
-    @provider = described_class.new(@resource)
+    @provider = provider.new(@resource)
 
     # Stub all file and config tests
-    allow(described_class).to receive(:healthcheck)
+    provider.stubs(:healthcheck)
   end
 
   it "should have an install method" do
@@ -32,59 +35,59 @@ describe Puppet::Type.type(:package).provider(:pkgutil) do
   describe "when installing" do
     it "should use a command without versioned package" do
       @resource[:ensure] = :latest
-      expect(@provider).to receive(:pkguti).with('-y', '-i', 'TESTpkg')
+      @provider.expects(:pkguti).with('-y', '-i', 'TESTpkg')
       @provider.install
     end
 
     it "should support a single temp repo URL" do
       @resource[:ensure] = :latest
       @resource[:source] = "http://example.net/repo"
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-i', 'TESTpkg')
+      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-y', '-i', 'TESTpkg')
       @provider.install
     end
 
     it "should support multiple temp repo URLs as array" do
       @resource[:ensure] = :latest
       @resource[:source] = [ 'http://example.net/repo', 'http://example.net/foo' ]
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-i', 'TESTpkg')
+      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-i', 'TESTpkg')
       @provider.install
     end
   end
 
   describe "when updating" do
     it "should use a command without versioned package" do
-      expect(@provider).to receive(:pkguti).with('-y', '-u', 'TESTpkg')
+      @provider.expects(:pkguti).with('-y', '-u', 'TESTpkg')
       @provider.update
     end
 
     it "should support a single temp repo URL" do
       @resource[:source] = "http://example.net/repo"
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-u', 'TESTpkg')
+      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-y', '-u', 'TESTpkg')
       @provider.update
     end
 
     it "should support multiple temp repo URLs as array" do
       @resource[:source] = [ 'http://example.net/repo', 'http://example.net/foo' ]
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-u', 'TESTpkg')
+      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-u', 'TESTpkg')
       @provider.update
     end
   end
 
   describe "when uninstalling" do
     it "should call the remove operation" do
-      expect(@provider).to receive(:pkguti).with('-y', '-r', 'TESTpkg')
+      @provider.expects(:pkguti).with('-y', '-r', 'TESTpkg')
       @provider.uninstall
     end
 
     it "should support a single temp repo URL" do
       @resource[:source] = "http://example.net/repo"
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-r', 'TESTpkg')
+      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-y', '-r', 'TESTpkg')
       @provider.uninstall
     end
 
     it "should support multiple temp repo URLs as array" do
       @resource[:source] = [ 'http://example.net/repo', 'http://example.net/foo' ]
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-r', 'TESTpkg')
+      @provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-r', 'TESTpkg')
       @provider.uninstall
     end
   end
@@ -94,7 +97,7 @@ describe Puppet::Type.type(:package).provider(:pkgutil) do
       fake_data = "
 noisy output here
 TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
     end
 
@@ -103,7 +106,7 @@ TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
       fake_data = "
 noisy output here
 TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
     end
 
@@ -111,19 +114,19 @@ TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
       fake_data = "
 noisy output here
 TESTpkg                   1.4.5,REV=2007.11.18      SAME"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.latest).to eq("1.4.5,REV=2007.11.18")
     end
 
     it "should handle a non-existent package" do
       fake_data = "noisy output here
 Not in catalog"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.latest).to eq(nil)
     end
 
     it "should warn on unknown pkgutil noise" do
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return("testingnoise")
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns("testingnoise")
       expect(@provider.latest).to eq(nil)
     end
 
@@ -137,7 +140,7 @@ gpg: Good signature from \"Distribution Manager <dm@blastwave.org>\"
 ==> 2770 packages loaded from /var/opt/csw/pkgutil/catalog.mirror.opencsw.org_opencsw_unstable_i386_5.11
 package                   installed                 catalog
 TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
     end
 
@@ -145,7 +148,7 @@ TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
       fake_data = "
 noisy output here
 REALpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.query[:name]).to eq("TESTpkg")
     end
   end
@@ -153,79 +156,80 @@ REALpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
   describe "when querying current version" do
     it "should return TESTpkg's version string" do
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.query[:ensure]).to eq("1.4.5,REV=2007.11.18")
     end
 
     it "should handle a package that isn't installed" do
       fake_data = "TESTpkg  notinst  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.query[:ensure]).to eq(:absent)
     end
 
     it "should handle a non-existent package" do
       fake_data = "noisy output here
 Not in catalog"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.query[:ensure]).to eq(:absent)
     end
 
     it "should support a temp repo URL" do
       @resource[:source] = "http://example.net/repo"
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').and_return(fake_data)
+      provider.expects(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').returns fake_data
       expect(@provider.query[:ensure]).to eq("1.4.5,REV=2007.11.18")
     end
   end
 
   describe "when querying current instances" do
     it "should warn on unknown pkgutil noise" do
-      expect(described_class).to receive(:pkguti).with(['-a']).and_return("testingnoise")
-      expect(described_class).to receive(:pkguti).with(['-c']).and_return("testingnoise")
-      expect(Puppet).to receive(:warning).twice
-      expect(described_class).not_to receive(:new)
-      expect(described_class.instances).to eq([])
+      provider.expects(:pkguti).with(['-a']).returns("testingnoise")
+      provider.expects(:pkguti).with(['-c']).returns("testingnoise")
+      Puppet.expects(:warning).times(2)
+      provider.expects(:new).never
+      expect(provider.instances).to eq([])
     end
 
     it "should return TESTpkg's version string" do
       fake_data = "TESTpkg  TESTpkg  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-a']).returns fake_data
 
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-c']).returns fake_data
 
-      testpkg = double('pkg1')
-      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).and_return(testpkg)
-      expect(described_class.instances).to eq([testpkg])
+      testpkg = mock 'pkg1'
+      provider.expects(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).returns testpkg
+      expect(provider.instances).to eq([testpkg])
     end
 
     it "should also return both TESTpkg and mypkg alias instances" do
       fake_data = "mypkg  TESTpkg  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-a']).returns fake_data
 
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-c']).returns fake_data
 
-      testpkg = double('pkg1')
-      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).and_return(testpkg)
+      testpkg = mock 'pkg1'
+      provider.expects(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).returns testpkg
 
-      aliaspkg = double('pkg2')
-      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "mypkg", :provider => :pkgutil).and_return(aliaspkg)
+      aliaspkg = mock 'pkg2'
+      provider.expects(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "mypkg", :provider => :pkgutil).returns aliaspkg
 
-      expect(described_class.instances).to eq([testpkg,aliaspkg])
+      expect(provider.instances).to eq([testpkg,aliaspkg])
     end
 
     it "shouldn't mind noise in the -a output" do
       fake_data = "noisy output here"
-      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-a']).returns fake_data
 
       fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
+      provider.expects(:pkguti).with(['-c']).returns fake_data
 
-      testpkg = double('pkg1')
-      expect(described_class).to receive(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).and_return(testpkg)
+      testpkg = mock 'pkg1'
+      provider.expects(:new).with(:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil).returns testpkg
 
-      expect(described_class.instances).to eq([testpkg])
+      expect(provider.instances).to eq([testpkg])
     end
   end
+
 end

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

@@ -1,139 +1,143 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:portage) do
+provider = Puppet::Type.type(:package).provider(:portage)
+
+describe provider do
   before do
-    packagename = "sl"
-    @resource = double('resource', :should => true)
-    allow(@resource).to receive(:[]).with(:name).and_return(packagename)
-    allow(@resource).to receive(:[]).with(:install_options).and_return(['--foo', '--bar'])
-    allow(@resource).to receive(:[]).with(:uninstall_options).and_return(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
+    packagename="sl"
+    @resource = stub('resource', :should => true)
+    @resource.stubs(:[]).with(:name).returns(packagename)
+    @resource.stubs(:[]).with(:install_options).returns(['--foo', '--bar'])
+    @resource.stubs(:[]).with(:uninstall_options).returns(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
 
     unslotted_packagename = "dev-lang/ruby"
-    @unslotted_resource = double('resource', :should => true)
-    allow(@unslotted_resource).to receive(:should).with(:ensure).and_return(:latest)
-    allow(@unslotted_resource).to receive(:[]).with(:name).and_return(unslotted_packagename)
-    allow(@unslotted_resource).to receive(:[]).with(:install_options).and_return([])
+    @unslotted_resource = stub('resource', :should => true)
+    @unslotted_resource.stubs(:should).with(:ensure).returns :latest
+    @unslotted_resource.stubs(:[]).with(:name).returns(unslotted_packagename)
+    @unslotted_resource.stubs(:[]).with(:install_options).returns([])
 
     slotted_packagename = "dev-lang/ruby:2.1"
-    @slotted_resource = double('resource', :should => true)
-    allow(@slotted_resource).to receive(:[]).with(:name).and_return(slotted_packagename)
-    allow(@slotted_resource).to receive(:[]).with(:install_options).and_return(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
+    @slotted_resource = stub('resource', :should => true)
+    @slotted_resource.stubs(:[]).with(:name).returns(slotted_packagename)
+    @slotted_resource.stubs(:[]).with(:install_options).returns(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
 
     versioned_packagename = "dev-lang/ruby-1.9.3"
-    @versioned_resource = double('resource', :should => true)
-    allow(@versioned_resource).to receive(:[]).with(:name).and_return(versioned_packagename)
-    allow(@versioned_resource).to receive(:[]).with(:uninstall_options).and_return([])
+    @versioned_resource = stub('resource', :should => true)
+    @versioned_resource.stubs(:[]).with(:name).returns(versioned_packagename)
+    @versioned_resource.stubs(:[]).with(:uninstall_options).returns([])
 
     versioned_slotted_packagename = "=dev-lang/ruby-1.9.3:1.9"
-    @versioned_slotted_resource = double('resource', :should => true)
-    allow(@versioned_slotted_resource).to receive(:[]).with(:name).and_return(versioned_slotted_packagename)
-    allow(@versioned_slotted_resource).to receive(:[]).with(:uninstall_options).and_return([])
+    @versioned_slotted_resource = stub('resource', :should => true)
+    @versioned_slotted_resource.stubs(:[]).with(:name).returns(versioned_slotted_packagename)
+    @versioned_slotted_resource.stubs(:[]).with(:uninstall_options).returns([])
 
     set_packagename = "@system"
-    @set_resource = double('resource', :should => true)
-    allow(@set_resource).to receive(:[]).with(:name).and_return(set_packagename)
-    allow(@set_resource).to receive(:[]).with(:install_options).and_return([])
+    @set_resource = stub('resource', :should => true)
+    @set_resource.stubs(:[]).with(:name).returns(set_packagename)
+    @set_resource.stubs(:[]).with(:install_options).returns([])
 
     package_sets = "system\nworld\n"
-    @provider = described_class.new(@resource)
-    allow(@provider).to receive(:qatom).and_return({:category=>nil, :pn=>"sl", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
-    allow(@provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-    @unslotted_provider = described_class.new(@unslotted_resource)
-    allow(@unslotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
-    allow(@unslotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-    @slotted_provider = described_class.new(@slotted_resource)
-    allow(@slotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>"2.1", :pfx=>nil, :sfx=>nil})
-    allow(@slotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-    @versioned_provider = described_class.new(@versioned_resource)
-    allow(@versioned_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
-    allow(@versioned_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-    @versioned_slotted_provider = described_class.new(@versioned_slotted_resource)
-    allow(@versioned_slotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>"1.9", :pfx=>"=", :sfx=>nil})
-    allow(@versioned_slotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-    @set_provider = described_class.new(@set_resource)
-    allow(@set_provider).to receive(:qatom).and_return({:category=>nil, :pn=>"@system", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
-    allow(@set_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-
-    portage= double(:executable => "foo",:execute => true)
-    allow(Puppet::Provider::CommandDefiner).to receive(:define).and_return(portage)
-
-    @nomatch_result    = ""
-    @match_result      = "app-misc sl [] [5.02] [] [] [5.02] [5.02:0] http://www.tkl.iis.u-tokyo.ac.jp/~toyoda/index_e.html https://github.com/mtoyoda/sl/ sophisticated graphical program which corrects your miss typing\n"
+    @provider = provider.new(@resource)
+    @provider.stubs(:qatom).returns({:category=>nil, :pn=>"sl", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
+    @provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
+    @unslotted_provider = provider.new(@unslotted_resource)
+    @unslotted_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
+    @unslotted_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
+    @slotted_provider = provider.new(@slotted_resource)
+    @slotted_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>":2.1", :pfx=>nil, :sfx=>nil})
+    @slotted_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
+    @versioned_provider = provider.new(@versioned_resource)
+    @versioned_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
+    @versioned_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
+    @versioned_slotted_provider = provider.new(@versioned_slotted_resource)
+    @versioned_slotted_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>":1.9", :pfx=>"=", :sfx=>nil})
+    @versioned_slotted_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
+    @set_provider = provider.new(@set_resource)
+    @set_provider.stubs(:qatom).returns({:category=>nil, :pn=>"@system", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
+    @set_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
+
+    portage   = stub(:executable => "foo",:execute => true)
+    Puppet::Provider::CommandDefiner.stubs(:define).returns(portage)
+
+    @nomatch_result = ""
+    @match_result    = "app-misc sl [] [5.02] [] [] [5.02] [5.02:0] http://www.tkl.iis.u-tokyo.ac.jp/~toyoda/index_e.html https://github.com/mtoyoda/sl/ sophisticated graphical program which corrects your miss typing\n"
     @slot_match_result = "dev-lang ruby [2.1.8] [2.1.9] [2.1.8:2.1] [2.1.8] [2.1.9,,,,,,,] [2.1.9:2.1] http://www.ruby-lang.org/ An object-oriented scripting language\n"
   end
 
   it "is versionable" do
-    expect(described_class).to be_versionable
+    expect(provider).to be_versionable
   end
 
   it "is reinstallable" do
-    expect(described_class).to be_reinstallable
+    expect(provider).to be_reinstallable
   end
 
   it 'should support string install options' do
-    expect(@provider).to receive(:emerge).with('--foo', '--bar', @resource[:name])
+    @provider.expects(:emerge).with('--foo', '--bar', @resource[:name])
 
     @provider.install
   end
 
   it 'should support updating' do
-    expect(@unslotted_provider).to receive(:emerge).with('--update', @unslotted_resource[:name])
+    @unslotted_provider.expects(:emerge).with('--update', @unslotted_resource[:name])
 
     @unslotted_provider.install
   end
 
   it 'should support hash install options' do
-    expect(@slotted_provider).to receive(:emerge).with('--foo', '--bar=baz', '--baz=foo', @slotted_resource[:name])
+    @slotted_provider.expects(:emerge).with('--foo', '--bar=baz', '--baz=foo', @slotted_resource[:name])
 
     @slotted_provider.install
   end
 
   it 'should support hash uninstall options' do
-    expect(@provider).to receive(:emerge).with('--rage-clean', '--foo', '--bar=baz', '--baz=foo', @resource[:name])
+    @provider.expects(:emerge).with('--rage-clean', '--foo', '--bar=baz', '--baz=foo', @resource[:name])
 
     @provider.uninstall
   end
 
   it 'should support uninstall of specific version' do
-    expect(@versioned_provider).to receive(:emerge).with('--rage-clean', @versioned_resource[:name])
+    @versioned_provider.expects(:emerge).with('--rage-clean', @versioned_resource[:name])
 
     @versioned_provider.uninstall
   end
 
   it 'should support uninstall of specific version and slot' do
-    expect(@versioned_slotted_provider).to receive(:emerge).with('--rage-clean', @versioned_slotted_resource[:name])
+    @versioned_slotted_provider.expects(:emerge).with('--rage-clean', @versioned_slotted_resource[:name])
 
     @versioned_slotted_provider.uninstall
   end
 
   it "uses :emerge to install packages" do
-    expect(@provider).to receive(:emerge)
+    @provider.expects(:emerge)
 
     @provider.install
   end
 
   it "uses query to find the latest package" do
-    expect(@provider).to receive(:query).and_return({:versions_available => "myversion"})
+    @provider.expects(:query).returns({:versions_available => "myversion"})
 
     @provider.latest
   end
 
   it "uses eix to search the lastest version of a package" do
-    allow(@provider).to receive(:update_eix)
-    expect(@provider).to receive(:eix).and_return(StringIO.new(@match_result))
+    @provider.stubs(:update_eix)
+    @provider.expects(:eix).returns(StringIO.new(@match_result))
 
     @provider.query
   end
 
   it "allows to emerge package sets" do
-    expect(@set_provider).to receive(:emerge).with(@set_resource[:name])
+    @set_provider.expects(:emerge).with(@set_resource[:name])
 
     @set_provider.install
   end
 
   it "allows to emerge and update package sets" do
-    allow(@set_resource).to receive(:should).with(:ensure).and_return(:latest)
-    expect(@set_provider).to receive(:emerge).with('--update', @set_resource[:name])
+    @set_resource.stubs(:should).with(:ensure).returns :latest
+    @set_provider.expects(:emerge).with('--update', @set_resource[:name])
 
     @set_provider.install
   end
@@ -147,16 +151,16 @@ describe Puppet::Type.type(:package).provider(:portage) do
   end
 
   it "query uses default arguments" do
-    allow(@provider).to receive(:update_eix)
-    expect(@provider).to receive(:eix).and_return(StringIO.new(@match_result))
-    expect(@provider.class).to receive(:eix_search_arguments).and_return([])
+    @provider.stubs(:update_eix)
+    @provider.expects(:eix).returns(StringIO.new(@match_result))
+    @provider.class.expects(:eix_search_arguments).returns([])
 
     @provider.query
   end
 
   it "can handle search output with empty square brackets" do
-    allow(@provider).to receive(:update_eix)
-    expect(@provider).to receive(:eix).and_return(StringIO.new(@match_result))
+    @provider.stubs(:update_eix)
+    @provider.expects(:eix).returns(StringIO.new(@match_result))
 
     expect(@provider.query[:name]).to eq("sl")
   end
@@ -166,7 +170,7 @@ describe Puppet::Type.type(:package).provider(:portage) do
   end
 
   it "can extract the slot from the package name" do
-    expect(@slotted_provider.qatom[:slot]).to eq('2.1')
+    expect(@slotted_provider.qatom[:slot]).to eq(':2.1')
   end
 
   it "returns nil for as the slot when no slot is specified" do
@@ -182,12 +186,12 @@ describe Puppet::Type.type(:package).provider(:portage) do
     expect(@versioned_slotted_provider.qatom[:category]).to eq('dev-lang')
     expect(@versioned_slotted_provider.qatom[:pn]).to eq('ruby')
     expect(@versioned_slotted_provider.qatom[:pv]).to eq('1.9.3')
-    expect(@versioned_slotted_provider.qatom[:slot]).to eq('1.9')
+    expect(@versioned_slotted_provider.qatom[:slot]).to eq(':1.9')
   end
 
   it "can handle search output with slots for unslotted packages" do
-    allow(@unslotted_provider).to receive(:update_eix)
-    expect(@unslotted_provider).to receive(:eix).and_return(StringIO.new(@slot_match_result))
+    @unslotted_provider.stubs(:update_eix)
+    @unslotted_provider.expects(:eix).returns(StringIO.new(@slot_match_result))
 
     result = @unslotted_provider.query
     expect(result[:name]).to eq('ruby')
@@ -196,8 +200,8 @@ describe Puppet::Type.type(:package).provider(:portage) do
   end
 
   it "can handle search output with slots" do
-    allow(@slotted_provider).to receive(:update_eix)
-    expect(@slotted_provider).to receive(:eix).and_return(StringIO.new(@slot_match_result))
+    @slotted_provider.stubs(:update_eix)
+    @slotted_provider.expects(:eix).returns(StringIO.new(@slot_match_result))
 
     result = @slotted_provider.query
     expect(result[:name]).to eq('ruby')