puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

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

@@ -1,24 +1,20 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.microsoft_windows? do
-  let(:name)        { 'mysql-5.1.58-win-x64' }
-  let(:source)      { 'E:\Rando\Directory\mysql-5.1.58-win-x64.msi' }
-  let(:resource)    {  Puppet::Type.type(:package).new(:name => name, :provider => :windows, :source => source) }
-  let(:provider)    { resource.provider }
-  let(:execute_options) do {:failonfail => false, :combine => true, :suppress_window => true} end
+  let (:name)        { 'mysql-5.1.58-win-x64' }
+  let (:source)      { 'E:\Rando\Directory\mysql-5.1.58-win-x64.msi' }
+  let (:resource)    {  Puppet::Type.type(:package).new(:name => name, :provider => :windows, :source => source) }
+  let (:provider)    { resource.provider }
+  let (:execute_options) do {:failonfail => false, :combine => true, :suppress_window => true} end
 
-  before(:each) do
+  before :each do
     # make sure we never try to execute anything
-    @times_execute_called = 0
-    allow(provider).to receive(:execute) { @times_execute_called += 1}
-  end
-
-  after(:each) do
-    expect(@times_execute_called).to eq(0)
+    provider.expects(:execute).never
   end
 
   def expect_execute(command, status)
-    expect(provider).to receive(:execute).with(command, execute_options).and_return(Puppet::Util::Execution::ProcessOutput.new('',status))
+    provider.expects(:execute).with(command, execute_options).returns(Puppet::Util::Execution::ProcessOutput.new('',status))
   end
 
   describe 'provider features' do
@@ -37,13 +33,13 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
 
   context '::instances' do
     it 'should return an array of provider instances' do
-      pkg1 = double('pkg1')
-      pkg2 = double('pkg2')
+      pkg1 = stub('pkg1')
+      pkg2 = stub('pkg2')
 
-      prov1 = double('prov1', :name => 'pkg1', :version => '1.0.0', :package => pkg1)
-      prov2 = double('prov2', :name => 'pkg2', :version => nil, :package => pkg2)
+      prov1 = stub('prov1', :name => 'pkg1', :version => '1.0.0', :package => pkg1)
+      prov2 = stub('prov2', :name => 'pkg2', :version => nil, :package => pkg2)
 
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:map).and_yield(prov1).and_yield(prov2).and_return([prov1, prov2])
+      Puppet::Provider::Package::Windows::Package.expects(:map).multiple_yields([prov1], [prov2]).returns([prov1, prov2])
 
       providers = provider.class.instances
       expect(providers.count).to eq(2)
@@ -57,7 +53,7 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
     end
 
     it 'should return an empty array if none found' do
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:map).and_return([])
+      Puppet::Provider::Package::Windows::Package.expects(:map).returns([])
 
       expect(provider.class.instances).to eq([])
     end
@@ -65,23 +61,23 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
 
   context '#query' do
     it 'should return the hash of the matched packaged' do
-      pkg = double(:name => 'pkg1', :version => nil)
-      expect(pkg).to receive(:match?).and_return(true)
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:find).and_yield(pkg)
+      pkg = mock(:name => 'pkg1', :version => nil)
+      pkg.expects(:match?).returns(true)
+      Puppet::Provider::Package::Windows::Package.expects(:find).yields(pkg)
 
       expect(provider.query).to eq({ :name => 'pkg1', :ensure => :installed, :provider => :windows })
     end
 
     it 'should include the version string when present' do
-      pkg = double(:name => 'pkg1', :version => '1.0.0')
-      expect(pkg).to receive(:match?).and_return(true)
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:find).and_yield(pkg)
+      pkg = mock(:name => 'pkg1', :version => '1.0.0')
+      pkg.expects(:match?).returns(true)
+      Puppet::Provider::Package::Windows::Package.expects(:find).yields(pkg)
 
       expect(provider.query).to eq({ :name => 'pkg1', :ensure => '1.0.0', :provider => :windows })
     end
 
     it 'should return nil if no package was found' do
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:find)
+      Puppet::Provider::Package::Windows::Package.expects(:find)
 
       expect(provider.query).to be_nil
     end
@@ -89,10 +85,10 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
 
   context '#install' do
     let(:command) { 'blarg.exe /S' }
-    let(:klass) { double('installer', :install_command => ['blarg.exe', '/S'] ) }
-    let(:execute_options) do {:failonfail => false, :combine => true, :cwd => nil, :suppress_window => true} end
+    let(:klass) { mock('installer', :install_command => ['blarg.exe', '/S'] ) }
+    let(:execute_options) do {:failonfail => false, :combine => true, :cwd => 'E:\Rando\Directory', :suppress_window => true} end
     before :each do
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:installer_class).and_return(klass)
+      Puppet::Provider::Package::Windows::Package.expects(:installer_class).returns(klass)
     end
 
     it 'should join the install command and options' do
@@ -111,21 +107,21 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
 
     it 'should not warn if the package install succeeds' do
       expect_execute(command, 0)
-      expect(provider).not_to receive(:warning)
+      provider.expects(:warning).never
 
       provider.install
     end
 
     it 'should warn if reboot initiated' do
       expect_execute(command, 1641)
-      expect(provider).to receive(:warning).with('The package installed successfully and the system is rebooting now.')
+      provider.expects(:warning).with('The package installed successfully and the system is rebooting now.')
 
       provider.install
     end
 
     it 'should warn if reboot required' do
       expect_execute(command, 3010)
-      expect(provider).to receive(:warning).with('The package installed successfully, but the system must be rebooted.')
+      provider.expects(:warning).with('The package installed successfully, but the system must be rebooted.')
 
       provider.install
     end
@@ -140,22 +136,11 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
         expect(error.code).to eq(5) # ERROR_ACCESS_DENIED
       end
     end
-
-    context 'With a real working dir' do
-      let(:execute_options) do {:failonfail => false, :combine => true, :cwd => 'E:\Rando\Directory', :suppress_window => true} end
-
-      it 'should not try to set the working directory' do
-        expect(Puppet::FileSystem).to receive(:exist?).with('E:\Rando\Directory').and_return(true)
-        expect_execute(command, 0)
-
-        provider.install
-      end
-    end
   end
 
   context '#uninstall' do
     let(:command) { 'unblarg.exe /Q' }
-    let(:package) { double('package', :uninstall_command => ['unblarg.exe', '/Q'] ) }
+    let(:package) { mock('package', :uninstall_command => ['unblarg.exe', '/Q'] ) }
 
     before :each do
       resource[:ensure] = :absent
@@ -177,21 +162,21 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
 
     it 'should not warn if the package install succeeds' do
       expect_execute(command, 0)
-      expect(provider).not_to receive(:warning)
+      provider.expects(:warning).never
 
       provider.uninstall
     end
 
     it 'should warn if reboot initiated' do
       expect_execute(command, 1641)
-      expect(provider).to receive(:warning).with('The package uninstalled successfully and the system is rebooting now.')
+      provider.expects(:warning).with('The package uninstalled successfully and the system is rebooting now.')
 
       provider.uninstall
     end
 
     it 'should warn if reboot required' do
       expect_execute(command, 3010)
-      expect(provider).to receive(:warning).with('The package uninstalled successfully, but the system must be rebooted.')
+      provider.expects(:warning).with('The package uninstalled successfully, but the system must be rebooted.')
 
       provider.uninstall
     end

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

@@ -6,9 +6,9 @@ describe Puppet::Type.type(:package).provider(:yum) do
   it_behaves_like 'RHEL package provider', described_class, 'yum'
 
   it "should have lower specificity" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("22")
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("22")
     expect(described_class.specificity).to be < 200
   end
 
@@ -28,13 +28,13 @@ describe Puppet::Type.type(:package).provider(:yum) do
       provider
     end
 
-    before { allow(described_class).to receive(:command).with(:cmd).and_return("/usr/bin/yum") }
+    before { described_class.stubs(:command).with(:cmd).returns("/usr/bin/yum") }
 
     context "when installing" do
       it "should use the supplied source as the explicit path to a package to install" do
         resource[:ensure] = :present
         resource[:source] = "/foo/bar/baz-1.1.0.rpm"
-        expect(provider).to receive(:execute) do |arr|
+        provider.expects(:execute).with do |arr|
           expect(arr[-2..-1]).to eq([:install, "/foo/bar/baz-1.1.0.rpm"])
         end
         provider.install
@@ -45,10 +45,10 @@ describe Puppet::Type.type(:package).provider(:yum) do
       it "should use the suppplied source as the explicit path to the package to update" do
         # The first query response informs yum provider that package 1.1.0 is
         # already installed, and the second that it's been upgraded
-        expect(provider).to receive(:query).twice.and_return({:ensure => "1.1.0"}, {:ensure => "1.2.0"})
+        provider.expects(:query).twice.returns({:ensure => "1.1.0"}, {:ensure => "1.2.0"})
         resource[:ensure] = "1.2.0"
         resource[:source] = "http://foo.repo.com/baz-1.2.0.rpm"
-        expect(provider).to receive(:execute) do |arr|
+        provider.expects(:execute).with do |arr|
           expect(arr[-2..-1]).to eq(['update', "http://foo.repo.com/baz-1.2.0.rpm"])
         end
         provider.install

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

@@ -3,15 +3,15 @@ require 'spec_helper'
 describe Puppet::Type.type(:package).provider(:zypper) do
   before(:each) do
     # Create a mock resource
-    @resource = double('resource')
+    @resource = stub 'resource'
 
     # A catch all; no parameters set
-    allow(@resource).to receive(:[]).and_return(nil)
+    @resource.stubs(:[]).returns(nil)
 
     # But set name and source
-    allow(@resource).to receive(:[]).with(:name).and_return("mypackage")
-    allow(@resource).to receive(:[]).with(:ensure).and_return(:installed)
-    allow(@resource).to receive(:command).with(:zypper).and_return("/usr/bin/zypper")
+    @resource.stubs(:[]).with(:name).returns "mypackage"
+    @resource.stubs(:[]).with(:ensure).returns :installed
+    @resource.stubs(:command).with(:zypper).returns "/usr/bin/zypper"
 
     @provider = described_class.new(@resource)
   end
@@ -43,70 +43,70 @@ describe Puppet::Type.type(:package).provider(:zypper) do
 
   context "when installing with zypper version >= 1.0" do
     it "should use a command-line with versioned package'" do
-      allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3-4.5.6")
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("1.2.8")
+      @resource.stubs(:should).with(:ensure).returns "1.2.3-4.5.6"
+      @resource.stubs(:allow_virtual?).returns false
+      @provider.stubs(:zypper_version).returns "1.2.8"
 
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage-1.2.3-4.5.6')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage-1.2.3-4.5.6')
+      @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
 
     it "should use a command-line without versioned package" do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:latest)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("1.2.8")
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', 'mypackage')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
+      @resource.stubs(:should).with(:ensure).returns :latest
+      @resource.stubs(:allow_virtual?).returns false
+      @provider.stubs(:zypper_version).returns "1.2.8"
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--name', 'mypackage')
+      @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
   end
 
   context "when installing with zypper version = 0.6.104" do
     it "should use a command-line with versioned package'" do
-      allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3-4.5.6")
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("0.6.104")
+      @resource.stubs(:should).with(:ensure).returns "1.2.3-4.5.6"
+      @resource.stubs(:allow_virtual?).returns false
+      @provider.stubs(:zypper_version).returns "0.6.104"
 
-      expect(@provider).to receive(:zypper).with('--terse', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage-1.2.3-4.5.6')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
+      @provider.expects(:zypper).with('--terse', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage-1.2.3-4.5.6')
+      @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
 
     it "should use a command-line without versioned package" do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:latest)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("0.6.104")
-      expect(@provider).to receive(:zypper).with('--terse', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
+      @resource.stubs(:should).with(:ensure).returns :latest
+      @resource.stubs(:allow_virtual?).returns false
+      @provider.stubs(:zypper_version).returns "0.6.104"
+      @provider.expects(:zypper).with('--terse', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage')
+      @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
   end
 
   context "when installing with zypper version = 0.6.13" do
     it "should use a command-line with versioned package'" do
-      allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3-4.5.6")
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("0.6.13")
+      @resource.stubs(:should).with(:ensure).returns "1.2.3-4.5.6"
+      @resource.stubs(:allow_virtual?).returns false
+      @provider.stubs(:zypper_version).returns "0.6.13"
 
-      expect(@provider).to receive(:zypper).with('--terse', :install, '--no-confirm', 'mypackage-1.2.3-4.5.6')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
+      @provider.expects(:zypper).with('--terse', :install, '--no-confirm', 'mypackage-1.2.3-4.5.6')
+      @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
 
     it "should use a command-line without versioned package" do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:latest)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("0.6.13")
-      expect(@provider).to receive(:zypper).with('--terse', :install, '--no-confirm', 'mypackage')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
+      @resource.stubs(:should).with(:ensure).returns :latest
+      @resource.stubs(:allow_virtual?).returns false
+      @provider.stubs(:zypper_version).returns "0.6.13"
+      @provider.expects(:zypper).with('--terse', :install, '--no-confirm', 'mypackage')
+      @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
   end
 
   context "when updating" do
     it "should call install method of instance" do
-      expect(@provider).to receive(:install)
+      @provider.expects(:install)
       @provider.update
     end
   end
@@ -117,8 +117,8 @@ describe Puppet::Type.type(:package).provider(:zypper) do
     context "when the package has available update" do
       it "should return a version string with valid list-updates data from SLES11sp1" do
         fake_data = File.read(my_fixture('zypper-list-updates-SLES11sp1.out'))
-        allow(@resource).to receive(:[]).with(:name).and_return("at")
-        expect(described_class).to receive(:zypper).with("list-updates").and_return(fake_data)
+        @resource.stubs(:[]).with(:name).returns "at"
+        described_class.expects(:zypper).with("list-updates").returns fake_data
         expect(@provider.latest).to eq("3.1.8-1069.18.2")
       end
     end
@@ -126,8 +126,8 @@ describe Puppet::Type.type(:package).provider(:zypper) do
     context "when the package is in the latest version" do
       it "should return nil with valid list-updates data from SLES11sp1" do
         fake_data = File.read(my_fixture('zypper-list-updates-SLES11sp1.out'))
-        allow(@resource).to receive(:[]).with(:name).and_return("zypper-log")
-        expect(described_class).to receive(:zypper).with("list-updates").and_return(fake_data)
+        @resource.stubs(:[]).with(:name).returns "zypper-log"
+        described_class.expects(:zypper).with("list-updates").returns fake_data
         expect(@provider.latest).to eq(nil)
       end
     end
@@ -135,8 +135,8 @@ describe Puppet::Type.type(:package).provider(:zypper) do
     context "when there are no updates available" do
       it "should return nil" do
         fake_data_empty = File.read(my_fixture('zypper-list-updates-empty.out'))
-        allow(@resource).to receive(:[]).with(:name).and_return("at")
-        expect(described_class).to receive(:zypper).with("list-updates").and_return(fake_data_empty)
+        @resource.stubs(:[]).with(:name).returns "at"
+        described_class.expects(:zypper).with("list-updates").returns fake_data_empty
         expect(@provider.latest).to eq(nil)
       end
     end
@@ -144,85 +144,85 @@ describe Puppet::Type.type(:package).provider(:zypper) do
 
   context "should install a virtual package" do
     it "when zypper version = 0.6.13" do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:installed)
-      allow(@resource).to receive(:allow_virtual?).and_return(true)
-      allow(@provider).to receive(:zypper_version).and_return("0.6.13")
-      expect(@provider).to receive(:zypper).with('--terse', :install, '--no-confirm', 'mypackage')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
+      @resource.stubs(:should).with(:ensure).returns :installed
+      @resource.stubs(:allow_virtual?).returns true
+      @provider.stubs(:zypper_version).returns "0.6.13"
+      @provider.expects(:zypper).with('--terse', :install, '--no-confirm', 'mypackage')
+      @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
 
     it "when zypper version >= 1.0.0" do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:installed)
-      allow(@resource).to receive(:allow_virtual?).and_return(true)
-      allow(@provider).to receive(:zypper_version).and_return("1.2.8")
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage')
-      expect(@provider).to receive(:query).and_return("mypackage 0 1.2.3 4.5.6 x86_64")
+      @resource.stubs(:should).with(:ensure).returns :installed
+      @resource.stubs(:allow_virtual?).returns true
+      @provider.stubs(:zypper_version).returns "1.2.8"
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', 'mypackage')
+      @provider.expects(:query).returns "mypackage 0 1.2.3 4.5.6 x86_64"
       @provider.install
     end
   end
 
   context "when installing with zypper install options" do
     it "should install the package without checking keys" do
-      allow(@resource).to receive(:[]).with(:name).and_return("php5")
-      allow(@resource).to receive(:[]).with(:install_options).and_return(['--no-gpg-check', {'-p' => '/vagrant/files/localrepo/'}])
-      allow(@resource).to receive(:should).with(:ensure).and_return("5.4.10-4.5.6")
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-      allow(@provider).to receive(:zypper_version).and_return("1.2.8")
+      @resource.stubs(:[]).with(:name).returns "php5"
+      @resource.stubs(:[]).with(:install_options).returns ['--no-gpg-check', {'-p' => '/vagrant/files/localrepo/'}]
+      @resource.stubs(:should).with(:ensure).returns "5.4.10-4.5.6"
+      @resource.stubs(:allow_virtual?).returns false
+      @provider.stubs(:zypper_version).returns "1.2.8"
 
-      expect(@provider).to receive(:zypper).with('--quiet', '--no-gpg-check', :install,
+      @provider.expects(:zypper).with('--quiet', '--no-gpg-check', :install,
         '--auto-agree-with-licenses', '--no-confirm', '-p=/vagrant/files/localrepo/', 'php5-5.4.10-4.5.6')
-      expect(@provider).to receive(:query).and_return("php5 0 5.4.10 4.5.6 x86_64")
+      @provider.expects(:query).returns "php5 0 5.4.10 4.5.6 x86_64"
       @provider.install
     end
 
     it "should install package with hash install options" do
-      allow(@resource).to receive(:[]).with(:name).and_return('vim')
-      allow(@resource).to receive(:[]).with(:install_options).and_return([{ '--a' => 'foo', '--b' => '"quoted bar"' }])
-      allow(@resource).to receive(:should).with(:ensure).and_return(:present)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-
-      allow(@provider).to receive(:zypper_version).and_return('1.2.8')
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a=foo', '--b="quoted bar"', '--name', 'vim')
-      expect(@provider).to receive(:query).and_return('package vim is not installed')
+      @resource.stubs(:[]).with(:name).returns 'vim'
+      @resource.stubs(:[]).with(:install_options).returns([{ '--a' => 'foo', '--b' => '"quoted bar"' }])
+      @resource.stubs(:should).with(:ensure).returns :present
+      @resource.stubs(:allow_virtual?).returns false
+
+      @provider.stubs(:zypper_version).returns '1.2.8'
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a=foo', '--b="quoted bar"', '--name', 'vim')
+      @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end
 
     it "should install package with array install options" do
-      allow(@resource).to receive(:[]).with(:name).and_return('vim')
-      allow(@resource).to receive(:[]).with(:install_options).and_return([['--a', '--b', '--c']])
-      allow(@resource).to receive(:should).with(:ensure).and_return(:present)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-
-      allow(@provider).to receive(:zypper_version).and_return('1.2.8')
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a', '--b', '--c', '--name', 'vim')
-      expect(@provider).to receive(:query).and_return('package vim is not installed')
+      @resource.stubs(:[]).with(:name).returns 'vim'
+      @resource.stubs(:[]).with(:install_options).returns([['--a', '--b', '--c']])
+      @resource.stubs(:should).with(:ensure).returns :present
+      @resource.stubs(:allow_virtual?).returns false
+
+      @provider.stubs(:zypper_version).returns '1.2.8'
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a', '--b', '--c', '--name', 'vim')
+      @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end
 
     it "should install package with string install options" do
-      allow(@resource).to receive(:[]).with(:name).and_return('vim')
-      allow(@resource).to receive(:[]).with(:install_options).and_return(['--a --b --c'])
-      allow(@resource).to receive(:should).with(:ensure).and_return(:present)
-      allow(@resource).to receive(:allow_virtual?).and_return(false)
-
-      allow(@provider).to receive(:zypper_version).and_return('1.2.8')
-      expect(@provider).to receive(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a --b --c', '--name', 'vim')
-      expect(@provider).to receive(:query).and_return('package vim is not installed')
+      @resource.stubs(:[]).with(:name).returns 'vim'
+      @resource.stubs(:[]).with(:install_options).returns(['--a --b --c'])
+      @resource.stubs(:should).with(:ensure).returns :present
+      @resource.stubs(:allow_virtual?).returns false
+
+      @provider.stubs(:zypper_version).returns '1.2.8'
+      @provider.expects(:zypper).with('--quiet', :install, '--auto-agree-with-licenses', '--no-confirm', '--a --b --c', '--name', 'vim')
+      @provider.expects(:query).returns 'package vim is not installed'
       @provider.install
     end
   end
 
   context 'when uninstalling' do
     it 'should use remove to uninstall on zypper version 1.6 and above' do
-      allow(@provider).to receive(:zypper_version).and_return('1.6.308')
-      expect(@provider).to receive(:zypper).with(:remove, '--no-confirm', 'mypackage')
+      @provider.stubs(:zypper_version).returns '1.6.308'
+      @provider.expects(:zypper).with(:remove, '--no-confirm', 'mypackage')
       @provider.uninstall
     end
 
     it 'should use remove  --force-solution to uninstall on zypper versions between 1.0 and 1.6' do
-      allow(@provider).to receive(:zypper_version).and_return('1.0.2')
-      expect(@provider).to receive(:zypper).with(:remove, '--no-confirm', '--force-resolution', 'mypackage')
+      @provider.stubs(:zypper_version).returns '1.0.2'
+      @provider.expects(:zypper).with(:remove, '--no-confirm', '--force-resolution', 'mypackage')
       @provider.uninstall
     end
   end