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

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

@@ -1,124 +1,126 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:zypper) do
+provider_class = Puppet::Type.type(:package).provider(:zypper)
+
+describe provider_class 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)
+    @provider = provider_class.new(@resource)
   end
 
   it "should have an install method" do
-    @provider = described_class.new
+    @provider = provider_class.new
     expect(@provider).to respond_to(:install)
   end
 
   it "should have an uninstall method" do
-    @provider = described_class.new
+    @provider = provider_class.new
     expect(@provider).to respond_to(:uninstall)
   end
 
   it "should have an update method" do
-    @provider = described_class.new
+    @provider = provider_class.new
     expect(@provider).to respond_to(:update)
   end
 
   it "should have a latest method" do
-    @provider = described_class.new
+    @provider = provider_class.new
     expect(@provider).to respond_to(:latest)
   end
 
   it "should have a install_options method" do
-    @provider = described_class.new
+    @provider = provider_class.new
     expect(@provider).to respond_to(:install_options)
   end
 
-  context "when installing with zypper version >= 1.0" do
+  describe "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
+  describe "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
+  describe "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
+  describe "when updating" do
     it "should call install method of instance" do
-      expect(@provider).to receive(:install)
+      @provider.expects(:install)
       @provider.update
     end
   end
 
-  context "when getting latest version" do
-    after { described_class.reset! }
-
+  describe "when getting latest version" do
+    after do described_class.reset! end
     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 +128,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,107 +137,94 @@ 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
   end
 
-  context "should install a virtual package" do
+  describe "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
+  describe "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")
-
-      expect(@provider).to receive(: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.install
-    end
-
-    it "should install the package with --no-gpg-checks" do
-      allow(@resource).to receive(:[]).with(:name).and_return("php5")
-      allow(@resource).to receive(:[]).with(:install_options).and_return(['--no-gpg-checks', {'-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-checks', :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
+  describe '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

data/spec/unit/provider/parsedfile_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 
@@ -30,60 +31,60 @@ describe Puppet::Provider::ParsedFile do
 
   describe "when generating a list of instances" do
     it "should return an instance for each record parsed from all of the registered targets" do
-      expect(provider).to receive(:targets).and_return(%w{/one /two})
-      allow(provider).to receive(:skip_record?).and_return(false)
+      provider.expects(:targets).returns %w{/one /two}
+      provider.stubs(:skip_record?).returns false
       one = [:uno1, :uno2]
       two = [:dos1, :dos2]
-      expect(provider).to receive(:prefetch_target).with("/one").and_return(one)
-      expect(provider).to receive(:prefetch_target).with("/two").and_return(two)
+      provider.expects(:prefetch_target).with("/one").returns one
+      provider.expects(:prefetch_target).with("/two").returns two
 
       results = []
       (one + two).each do |inst|
         results << inst.to_s + "_instance"
-        expect(provider).to receive(:new).with(inst).and_return(results[-1])
+        provider.expects(:new).with(inst).returns(results[-1])
       end
 
       expect(provider.instances).to eq(results)
     end
 
     it "should ignore target when retrieve fails" do
-      expect(provider).to receive(:targets).and_return(%w{/one /two /three})
-      allow(provider).to receive(:skip_record?).and_return(false)
-      expect(provider).to receive(:retrieve).with("/one").and_return([
+      provider.expects(:targets).returns %w{/one /two /three}
+      provider.stubs(:skip_record?).returns false
+      provider.expects(:retrieve).with("/one").returns [
         {:name => 'target1_record1'},
         {:name => 'target1_record2'}
-      ])
-      expect(provider).to receive(:retrieve).with("/two").and_raise(Puppet::Util::FileType::FileReadError, "some error")
-      expect(provider).to receive(:retrieve).with("/three").and_return([
+      ]
+      provider.expects(:retrieve).with("/two").raises Puppet::Util::FileType::FileReadError, "some error"
+      provider.expects(:retrieve).with("/three").returns [
         {:name => 'target3_record1'},
         {:name => 'target3_record2'}
-      ])
-      expect(Puppet).to receive(:err).with('Could not prefetch parsedfile_type provider \'parsedfile_provider\' target \'/two\': some error. Treating as empty')
-      expect(provider).to receive(:new).with(:name => 'target1_record1', :on_disk => true, :target => '/one', :ensure => :present).and_return('r1')
-      expect(provider).to receive(:new).with(:name => 'target1_record2', :on_disk => true, :target => '/one', :ensure => :present).and_return('r2')
-      expect(provider).to receive(:new).with(:name => 'target3_record1', :on_disk => true, :target => '/three', :ensure => :present).and_return('r3')
-      expect(provider).to receive(:new).with(:name => 'target3_record2', :on_disk => true, :target => '/three', :ensure => :present).and_return('r4')
+      ]
+      Puppet.expects(:err).with('Could not prefetch parsedfile_type provider \'parsedfile_provider\' target \'/two\': some error. Treating as empty')
+      provider.expects(:new).with(:name => 'target1_record1', :on_disk => true, :target => '/one', :ensure => :present).returns 'r1'
+      provider.expects(:new).with(:name => 'target1_record2', :on_disk => true, :target => '/one', :ensure => :present).returns 'r2'
+      provider.expects(:new).with(:name => 'target3_record1', :on_disk => true, :target => '/three', :ensure => :present).returns 'r3'
+      provider.expects(:new).with(:name => 'target3_record2', :on_disk => true, :target => '/three', :ensure => :present).returns 'r4'
 
       expect(provider.instances).to eq(%w{r1 r2 r3 r4})
     end
 
     it "should skip specified records" do
-      expect(provider).to receive(:targets).and_return(%w{/one})
-      expect(provider).to receive(:skip_record?).with(:uno).and_return(false)
-      expect(provider).to receive(:skip_record?).with(:dos).and_return(true)
+      provider.expects(:targets).returns %w{/one}
+      provider.expects(:skip_record?).with(:uno).returns false
+      provider.expects(:skip_record?).with(:dos).returns true
       one = [:uno, :dos]
-      expect(provider).to receive(:prefetch_target).and_return(one)
+      provider.expects(:prefetch_target).returns one
 
-      expect(provider).to receive(:new).with(:uno).and_return("eh")
-      expect(provider).not_to receive(:new).with(:dos)
+      provider.expects(:new).with(:uno).returns "eh"
+      provider.expects(:new).with(:dos).never
 
       provider.instances
     end
   end
 
   describe "when matching resources to existing records" do
-    let(:first_resource) { double(:one, :name => :one) }
-    let(:second_resource) { double(:two, :name => :two) }
+    let(:first_resource) { stub(:one, :name => :one) }
+    let(:second_resource) { stub(:two, :name => :two) }
 
     let(:resources) {{:one => first_resource, :two => second_resource}}
 
@@ -101,41 +102,41 @@ describe Puppet::Provider::ParsedFile do
   describe "when flushing a file's records to disk" do
     before do
       # This way we start with some @records, like we would in real life.
-      allow(provider).to receive(:retrieve).and_return([])
+      provider.stubs(:retrieve).returns []
       provider.default_target = "/foo/bar"
       provider.initvars
       provider.prefetch
 
       @filetype = Puppet::Util::FileType.filetype(:flat).new("/my/file")
-      allow(Puppet::Util::FileType.filetype(:flat)).to receive(:new).with("/my/file").and_return(@filetype)
+      Puppet::Util::FileType.filetype(:flat).stubs(:new).with("/my/file",nil).returns @filetype
 
-      allow(@filetype).to receive(:write)
+      @filetype.stubs(:write)
     end
 
     it "should back up the file being written if the filetype can be backed up" do
-      expect(@filetype).to receive(:backup)
+      @filetype.expects(:backup)
 
       provider.flush_target("/my/file")
     end
 
     it "should not try to back up the file if the filetype cannot be backed up" do
       @filetype = Puppet::Util::FileType.filetype(:ram).new("/my/file")
-      expect(Puppet::Util::FileType.filetype(:flat)).to receive(:new).and_return(@filetype)
+      Puppet::Util::FileType.filetype(:flat).expects(:new).returns @filetype
 
-      allow(@filetype).to receive(:write)
+      @filetype.stubs(:write)
 
       provider.flush_target("/my/file")
     end
 
     it "should not back up the file more than once between calls to 'prefetch'" do
-      expect(@filetype).to receive(:backup).once
+      @filetype.expects(:backup).once
 
       provider.flush_target("/my/file")
       provider.flush_target("/my/file")
     end
 
     it "should back the file up again once the file has been reread" do
-      expect(@filetype).to receive(:backup).twice
+      @filetype.expects(:backup).times(2)
 
       provider.flush_target("/my/file")
       provider.prefetch
@@ -146,19 +147,19 @@ describe Puppet::Provider::ParsedFile do
   describe "when flushing multiple files" do
     describe "and an error is encountered" do
       it "the other file does not fail" do
-        allow(provider).to receive(:backup_target)
+        provider.stubs(:backup_target)
 
         bad_file = 'broken'
         good_file = 'writable'
 
-        bad_writer = double('bad')
-        expect(bad_writer).to receive(:write).and_raise(Exception, "Failed to write to bad file")
+        bad_writer = mock 'bad'
+        bad_writer.expects(:write).raises(Exception, "Failed to write to bad file")
 
-        good_writer = double('good')
-        expect(good_writer).to receive(:write).and_return(nil)
+        good_writer = mock 'good'
+        good_writer.expects(:write).returns(nil)
 
-        allow(provider).to receive(:target_object).with(bad_file).and_return(bad_writer)
-        allow(provider).to receive(:target_object).with(good_file).and_return(good_writer)
+        provider.stubs(:target_object).with(bad_file).returns(bad_writer)
+        provider.stubs(:target_object).with(good_file).returns(good_writer)
 
         bad_resource = parsed_type.new(:name => 'one', :target => bad_file)
         good_resource = parsed_type.new(:name => 'two', :target => good_file)
@@ -189,8 +190,8 @@ describe "A very basic provider based on ParsedFile" do
     example_provider_class.initvars
     example_provider_class.prefetch
     # evade a race between multiple invocations of the header method
-    allow(example_provider_class).to receive(:header).
-      and_return("# HEADER As added by puppet.\n")
+    example_provider_class.stubs(:header).
+      returns("# HEADER As added by puppet.\n")
     example_provider_class
   end
 
@@ -207,7 +208,7 @@ describe "A very basic provider based on ParsedFile" do
     let(:input_records) { provider.parse(input_text) }
 
     before :each do
-      allow(provider).to receive(:native_header_regex).and_return(regex)
+      provider.stubs(:native_header_regex).returns(regex)
     end
 
     it "should move the native header to the top" do
@@ -216,7 +217,7 @@ describe "A very basic provider based on ParsedFile" do
 
     context "and dropping native headers found in input" do
       before :each do
-        allow(provider).to receive(:drop_native_header).and_return(true)
+        provider.stubs(:drop_native_header).returns(true)
       end
 
       it "should not include the native header in the output" do