puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

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

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:macports) do
+provider_class = Puppet::Type.type(:package).provider(:macports)
+
+describe provider_class do
   let :resource_name do
     "foo"
   end
@@ -11,7 +13,7 @@ describe Puppet::Type.type(:package).provider(:macports) do
 
   let :provider do
     prov = resource.provider
-    expect(prov).not_to receive(:execute)
+    prov.expects(:execute).never
     prov
   end
 
@@ -19,7 +21,7 @@ describe Puppet::Type.type(:package).provider(:macports) do
     {:name => resource_name, :ensure => "1.2.3", :revision => "1", :provider => :macports}
   end
 
-  context "provider features" do
+  describe "provider features" do
     subject { provider }
 
     it { is_expected.to be_installable }
@@ -28,114 +30,110 @@ describe Puppet::Type.type(:package).provider(:macports) do
     it { is_expected.to be_versionable }
   end
 
-  context "when listing all instances" do
+  describe "when listing all instances" do
     it "should call port -q installed" do
-      expect(described_class).to receive(:port).with("-q", :installed).and_return("")
-      described_class.instances
+      provider_class.expects(:port).with("-q", :installed).returns("")
+      provider_class.instances
     end
 
     it "should create instances from active ports" do
-      expect(described_class).to receive(:port).and_return("foo @1.234.5_2 (active)")
-      expect(described_class.instances.size).to eq(1)
+      provider_class.expects(:port).returns("foo @1.234.5_2 (active)")
+      expect(provider_class.instances.size).to eq(1)
     end
 
     it "should ignore ports that aren't activated" do
-      expect(described_class).to receive(:port).and_return("foo @1.234.5_2")
-      expect(described_class.instances.size).to eq(0)
+      provider_class.expects(:port).returns("foo @1.234.5_2")
+      expect(provider_class.instances.size).to eq(0)
     end
 
     it "should ignore variants" do
-      expect(described_class.parse_installed_query_line("bar @1.0beta2_38_1+x11+java (active)")).
+      expect(provider_class.parse_installed_query_line("bar @1.0beta2_38_1+x11+java (active)")).
         to eq({:provider=>:macports, :revision=>"1", :name=>"bar", :ensure=>"1.0beta2_38"})
     end
 
   end
 
-  context "when installing" do
-    it "should not specify a version when ensure is set to latest" do
-      resource[:ensure] = :latest
-      # version would be the 4th argument, if provided.
-      expect(provider).to receive(:port).with(anything, anything, anything)
-
-      provider.install
-    end
-
-    it "should not specify a version when ensure is set to present" do
-      resource[:ensure] = :present
-      # version would be the 4th argument, if provided.
-      expect(provider).to receive(:port).with(anything, anything, anything)
-
-      provider.install
-    end
-
-    it "should specify a version when ensure is set to a version" do
-      resource[:ensure] = "1.2.3"
-      expect(provider).to receive(:port).with(anything, anything, anything, '@1.2.3')
-
-      provider.install
-    end
+  describe "when installing" do
+   it "should not specify a version when ensure is set to latest" do
+     resource[:ensure] = :latest
+     provider.expects(:port).with { |flag, method, name, version|
+       expect(version).to be_nil
+     }
+     provider.install
+   end
+
+   it "should not specify a version when ensure is set to present" do
+     resource[:ensure] = :present
+     provider.expects(:port).with { |flag, method, name, version|
+       expect(version).to be_nil
+     }
+     provider.install
+   end
+
+   it "should specify a version when ensure is set to a version" do
+     resource[:ensure] = "1.2.3"
+     provider.expects(:port).with { |flag, method, name, version|
+       expect(version).to be
+     }
+     provider.install
+   end
   end
 
-  context "when querying for the latest version" do
-    # Redefine provider to avoid the "expect(prov).not_to receive(:execute)"
-    # that was set in the original definition.
-    let(:provider) { resource.provider }
-    let(:new_info_line) do
+  describe "when querying for the latest version" do
+    let :new_info_line do
       "1.2.3 2"
     end
-    let(:infoargs) do
+    let :infoargs do
       ["/opt/local/bin/port", "-q", :info, "--line", "--version", "--revision",  resource_name]
     end
-    let(:arguments) do
-      {:failonfail => false, :combine => false}
-    end
+    let(:arguments) do {:failonfail => false, :combine => false} end
 
     before :each do
-      allow(provider).to receive(:command).with(:port).and_return("/opt/local/bin/port")
+      provider.stubs(:command).with(:port).returns("/opt/local/bin/port")
     end
 
     it "should return nil when the package cannot be found" do
       resource[:name] = resource_name
-      expect(provider).to receive(:execute).with(infoargs, arguments).and_return("")
+      provider.expects(:execute).with(infoargs, arguments).returns("")
       expect(provider.latest).to eq(nil)
     end
 
     it "should return the current version if the installed port has the same revision" do
       current_hash[:revision] = "2"
-      expect(provider).to receive(:execute).with(infoargs, arguments).and_return(new_info_line)
-      expect(provider).to receive(:query).and_return(current_hash)
+      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
+      provider.expects(:query).returns(current_hash)
       expect(provider.latest).to eq(current_hash[:ensure])
     end
 
     it "should return the new version_revision if the installed port has a lower revision" do
       current_hash[:revision] = "1"
-      expect(provider).to receive(:execute).with(infoargs, arguments).and_return(new_info_line)
-      expect(provider).to receive(:query).and_return(current_hash)
+      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
+      provider.expects(:query).returns(current_hash)
       expect(provider.latest).to eq("1.2.3_2")
     end
 
     it "should return the newest version if the port is not installed" do
       resource[:name] = resource_name
-      expect(provider).to receive(:execute).with(infoargs, arguments).and_return(new_info_line)
-      expect(provider).to receive(:execute).with(["/opt/local/bin/port", "-q", :installed, resource[:name]], arguments).and_return("")
+      provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
+      provider.expects(:execute).with(["/opt/local/bin/port", "-q", :installed, resource[:name]], arguments).returns("")
       expect(provider.latest).to eq("1.2.3_2")
     end
   end
 
-  context "when updating a port" do
+  describe "when updating a port" do
     it "should execute port install if the port is installed" do
       resource[:name] = resource_name
       resource[:ensure] = :present
-      allow(provider).to receive(:query).and_return(current_hash)
-      expect(provider).to receive(:port).with("-q", :install, resource_name)
+      provider.stubs(:query).returns(current_hash)
+      provider.expects(:port).with("-q", :install, resource_name)
       provider.update
     end
 
     it "should execute port install if the port is not installed" do
       resource[:name] = resource_name
       resource[:ensure] = :present
-      allow(provider).to receive(:query).and_return("")
-      expect(provider).to receive(:port).with("-q", :install, resource_name)
+      provider.stubs(:query).returns("")
+      provider.expects(:port).with("-q", :install, resource_name)
       provider.update
     end
   end

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

@@ -1,23 +1,28 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:nim) do
+provider_class = Puppet::Type.type(:package).provider(:nim)
+
+describe provider_class do
+
   before(:each) do
-    @resource = double('resource')
+    # Create a mock 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.foo")
-    allow(@resource).to receive(:[]).with(:source).and_return("mysource")
-    allow(@resource).to receive(:[]).with(:ensure).and_return(:installed)
+    @resource.stubs(:[]).with(:name).returns "mypackage.foo"
+    @resource.stubs(:[]).with(:source).returns "mysource"
+    @resource.stubs(:[]).with(:ensure).returns :installed
 
-    @provider = subject()
+    @provider = provider_class.new
     @provider.resource = @resource
   end
 
   it "should have an install method" do
-    @provider = subject()
+    @provider = provider_class.new
     expect(@provider).to respond_to(:install)
   end
 
@@ -43,31 +48,37 @@ END
 
   context "when installing" do
     it "should install a package" do
-      allow(@resource).to receive(:should).with(:ensure).and_return(:installed)
-      expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo'").and_return(bff_showres_output)
-      expect(@provider).to receive(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.8")
+
+      @resource.stubs(:should).with(:ensure).returns(:installed)
+      Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo'").returns(bff_showres_output)
+      @provider.expects(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.8")
       @provider.install
     end
 
     context "when installing versioned packages" do
+
       it "should fail if the package is not available on the lpp source" do
         nimclient_showres_output = ""
 
-        allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3.4")
-        expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.4'").and_return(nimclient_showres_output)
+        @resource.stubs(:should).with(:ensure).returns("1.2.3.4")
+        Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.4'").returns(nimclient_showres_output)
         expect {
           @provider.install
         }.to raise_error(Puppet::Error, "Unable to find package 'mypackage.foo' with version '1.2.3.4' on lpp_source 'mysource'")
       end
 
       it "should succeed if a BFF/installp package is available on the lpp source" do
-        allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3.4")
-        expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.4'").and_return(bff_showres_output).ordered
-        expect(@provider).to receive(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.4").ordered
+        nimclient_sequence = sequence('nimclient')
+
+        @resource.stubs(:should).with(:ensure).returns("1.2.3.4")
+        Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.4'").returns(bff_showres_output).in_sequence(nimclient_sequence)
+        @provider.expects(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.4").in_sequence(nimclient_sequence)
         @provider.install
       end
 
       it "should fail if the specified version of a BFF package is superseded" do
+        nimclient_sequence = sequence('nimclient')
+
         install_output = <<OUTPUT
 +-----------------------------------------------------------------------------+
                     Pre-installation Verification...
@@ -113,22 +124,27 @@ Name                      Level           Pre-installation Failure/Warning
 mypackage.foo              1.2.3.1         Already superseded by 1.2.3.4
 OUTPUT
 
-        allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3.1")
-        expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.1'").and_return(bff_showres_output).ordered
-        expect(@provider).to receive(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.1").and_return(install_output).ordered
+        @resource.stubs(:should).with(:ensure).returns("1.2.3.1")
+        Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\.1'").returns(bff_showres_output).in_sequence(nimclient_sequence)
+        @provider.expects(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo 1.2.3.1").in_sequence(nimclient_sequence).returns(install_output)
 
         expect { @provider.install }.to raise_error(Puppet::Error, "NIM package provider is unable to downgrade packages")
     end
 
+
     it "should succeed if an RPM package is available on the lpp source" do
-        allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3-4")
-        expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\-4'").and_return(rpm_showres_output).ordered
-        expect(@provider).to receive(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo-1.2.3-4").ordered
+        nimclient_sequence = sequence('nimclient')
+
+        @resource.stubs(:should).with(:ensure).returns("1.2.3-4")
+        Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\-4'").returns(rpm_showres_output).in_sequence(nimclient_sequence)
+        @provider.expects(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo-1.2.3-4").in_sequence(nimclient_sequence)
         @provider.install
       end
     end
 
     it "should fail if the specified version of a RPM package is superseded" do
+      nimclient_sequence = sequence('nimclient')
+
       install_output = <<OUTPUT
 
 
@@ -146,9 +162,9 @@ mypackage.foo-1.2.3-1 is superseded by mypackage.foo-1.2.3-4
 
 OUTPUT
 
-      allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3-1")
-      expect(Puppet::Util::Execution).to receive(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\-1'").and_return(rpm_showres_output)
-      expect(@provider).to receive(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo-1.2.3-1").and_return(install_output)
+      @resource.stubs(:should).with(:ensure).returns("1.2.3-1")
+      Puppet::Util::Execution.expects(:execute).with("/usr/sbin/nimclient -o showres -a resource=mysource |/usr/bin/grep -p -E 'mypackage\\.foo( |-)1\\.2\\.3\\-1'").returns(rpm_showres_output).in_sequence(nimclient_sequence)
+      @provider.expects(:nimclient).with("-o", "cust", "-a", "installp_flags=acgwXY", "-a", "lpp_source=mysource", "-a", "filesets=mypackage.foo-1.2.3-1").in_sequence(nimclient_sequence).returns(install_output)
 
       expect { @provider.install }.to raise_error(Puppet::Error, "NIM package provider is unable to downgrade packages")
     end
@@ -156,16 +172,16 @@ OUTPUT
 
   context "when uninstalling" do
     it "should call installp to uninstall a bff package" do
-      expect(@provider).to receive(:lslpp).with("-qLc", "mypackage.foo").and_return("#bos.atm:bos.atm.atmle:7.1.2.0: : :C: :ATM LAN Emulation Client Support : : : : : : :0:0:/:1241")
-      expect(@provider).to receive(:installp).with("-gu", "mypackage.foo")
-      expect(@provider.class).to receive(:pkglist).with(:pkgname => 'mypackage.foo').and_return(nil)
+      @provider.expects(:lslpp).with("-qLc", "mypackage.foo").returns("#bos.atm:bos.atm.atmle:7.1.2.0: : :C: :ATM LAN Emulation Client Support : : : : : : :0:0:/:1241")
+      @provider.expects(:installp).with("-gu", "mypackage.foo")
+      @provider.class.expects(:pkglist).with(:pkgname => 'mypackage.foo').returns(nil)
       @provider.uninstall
     end
 
     it "should call rpm to uninstall an rpm package" do
-      expect(@provider).to receive(:lslpp).with("-qLc", "mypackage.foo").and_return("cdrecord:cdrecord-1.9-6:1.9-6: : :C:R:A command line CD/DVD recording program.: :/bin/rpm -e cdrecord: : : : :0: :/opt/freeware:Wed Jun 29 09:41:32 PDT 2005")
-      expect(@provider).to receive(:rpm).with("-e", "mypackage.foo")
-      expect(@provider.class).to receive(:pkglist).with(:pkgname => 'mypackage.foo').and_return(nil)
+      @provider.expects(:lslpp).with("-qLc", "mypackage.foo").returns("cdrecord:cdrecord-1.9-6:1.9-6: : :C:R:A command line CD/DVD recording program.: :/bin/rpm -e cdrecord: : : : :0: :/opt/freeware:Wed Jun 29 09:41:32 PDT 2005")
+      @provider.expects(:rpm).with("-e", "mypackage.foo")
+      @provider.class.expects(:pkglist).with(:pkgname => 'mypackage.foo').returns(nil)
       @provider.uninstall
     end
   end
@@ -193,7 +209,7 @@ OUTPUT
       end
     end
 
-    context "#determine_latest_version" do
+    describe "#determine_latest_version" do
       context "when there are multiple versions" do
         it "should return the latest version" do
           expect(subject.send(:determine_latest_version, rpm_showres_output, 'mypackage.foo')).to eq([:rpm, '1.2.3-8'])
@@ -212,7 +228,7 @@ END
       end
     end
 
-    context "#determine_package_type" do
+    describe "#determine_package_type" do
       it "should return :rpm for rpm packages" do
         expect(subject.send(:determine_package_type, rpm_showres_output, 'mypackage.foo', '1.2.3-4')).to eq(:rpm)
       end

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

@@ -1,37 +1,43 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'stringio'
 
-describe Puppet::Type.type(:package).provider(:openbsd) do
+provider_class = Puppet::Type.type(:package).provider(:openbsd)
+
+describe provider_class do
   let(:package) { Puppet::Type.type(:package).new(:name => 'bash', :provider => 'openbsd') }
-  let(:provider) { described_class.new(package) }
+  let(:provider) { provider_class.new(package) }
 
   def expect_read_from_pkgconf(lines)
-    pkgconf = double(:readlines => lines)
-    expect(Puppet::FileSystem).to receive(:exist?).with('/etc/pkg.conf').and_return(true)
-    expect(File).to receive(:open).with('/etc/pkg.conf', 'rb').and_return(pkgconf)
+    pkgconf = stub(:readlines => lines)
+    Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(true)
+    File.expects(:open).with('/etc/pkg.conf', 'rb').returns(pkgconf)
   end
 
   def expect_pkgadd_with_source(source)
-    expect(provider).to receive(:pkgadd).with([source]) do
-      expect(ENV).not_to have_key('PKG_PATH')
+    provider.expects(:pkgadd).with do |fullname|
+      expect(ENV).not_to be_key('PKG_PATH')
+      expect(fullname).to eq([source])
     end
   end
 
   def expect_pkgadd_with_env_and_name(source, &block)
-    expect(ENV).not_to have_key('PKG_PATH')
+    expect(ENV).not_to be_key('PKG_PATH')
 
-    expect(provider).to receive(:pkgadd).with([provider.resource[:name]]) do
-      expect(ENV).to have_key('PKG_PATH')
+    provider.expects(:pkgadd).with do |fullname|
+      expect(ENV).to be_key('PKG_PATH')
       expect(ENV['PKG_PATH']).to eq(source)
+
+      expect(fullname).to eq([provider.resource[:name]])
     end
-    expect(provider).to receive(:execpipe).with(['/bin/pkg_info', '-I', provider.resource[:name]]).and_yield('')
+    provider.expects(:execpipe).with(['/bin/pkg_info', '-I', provider.resource[:name]]).yields('')
 
     yield
 
     expect(ENV).not_to be_key('PKG_PATH')
   end
 
-  context 'provider features' do
+  describe 'provider features' do
     it { is_expected.to be_installable }
     it { is_expected.to be_install_options }
     it { is_expected.to be_uninstallable }
@@ -43,34 +49,34 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
   before :each do
     # Stub some provider methods to avoid needing the actual software
     # installed, so we can test on whatever platform we want.
-    allow(described_class).to receive(:command).with(:pkginfo).and_return('/bin/pkg_info')
-    allow(described_class).to receive(:command).with(:pkgadd).and_return('/bin/pkg_add')
-    allow(described_class).to receive(:command).with(:pkgdelete).and_return('/bin/pkg_delete')
+    provider_class.stubs(:command).with(:pkginfo).returns('/bin/pkg_info')
+    provider_class.stubs(:command).with(:pkgadd).returns('/bin/pkg_add')
+    provider_class.stubs(:command).with(:pkgdelete).returns('/bin/pkg_delete')
   end
 
   context "#instances" do
     it "should return nil if execution failed" do
-      expect(described_class).to receive(:execpipe).and_raise(Puppet::ExecutionFailure, 'wawawa')
-      expect(described_class.instances).to be_nil
+      provider_class.expects(:execpipe).raises(Puppet::ExecutionFailure, 'wawawa')
+      expect(provider_class.instances).to be_nil
     end
 
     it "should return the empty set if no packages are listed" do
-      expect(described_class).to receive(:execpipe).with(%w{/bin/pkg_info -a}).and_yield(StringIO.new(''))
-      expect(described_class.instances).to be_empty
+      provider_class.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(StringIO.new(''))
+      expect(provider_class.instances).to be_empty
     end
 
     it "should return all packages when invoked" do
       fixture = File.read(my_fixture('pkginfo.list'))
-      expect(described_class).to receive(:execpipe).with(%w{/bin/pkg_info -a}).and_yield(fixture)
-      expect(described_class.instances.map(&:name).sort).to eq(
+      provider_class.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(fixture)
+      expect(provider_class.instances.map(&:name).sort).to eq(
         %w{bash bzip2 expat gettext libiconv lzo openvpn python vim wget}.sort
       )
     end
 
     it "should return all flavors if set" do
       fixture = File.read(my_fixture('pkginfo_flavors.list'))
-      expect(described_class).to receive(:execpipe).with(%w{/bin/pkg_info -a}).and_yield(fixture)
-      instances = described_class.instances.map {|p| {:name => p.get(:name),
+      provider_class.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(fixture)
+      instances = provider_class.instances.map {|p| {:name => p.get(:name),
         :ensure => p.get(:ensure), :flavor => p.get(:flavor)}}
       expect(instances.size).to eq(2)
       expect(instances[0]).to eq({:name => 'bash', :ensure => '3.1.17', :flavor => 'static'})
@@ -80,7 +86,7 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
 
   context "#install" do
     it "should fail if the resource doesn't have a source" do
-      expect(Puppet::FileSystem).to receive(:exist?).with('/etc/pkg.conf').and_return(false)
+      Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(false)
 
       expect {
         provider.install
@@ -88,8 +94,8 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
     end
 
     it "should fail if /etc/pkg.conf exists, but is not readable" do
-      expect(Puppet::FileSystem).to receive(:exist?).with('/etc/pkg.conf').and_return(true)
-      expect(File).to receive(:open).with('/etc/pkg.conf', 'rb').and_raise(Errno::EACCES)
+      Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(true)
+      File.expects(:open).with('/etc/pkg.conf', 'rb').raises(Errno::EACCES)
 
       expect {
         provider.install
@@ -232,7 +238,7 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
     it 'should use install_options as Array' do
       provider.resource[:source] = '/tma1/'
       provider.resource[:install_options] = ['-r', '-z']
-      expect(provider).to receive(:pkgadd).with(['-r', '-z', 'bash'])
+      provider.expects(:pkgadd).with(['-r', '-z', 'bash'])
       provider.install
     end
   end
@@ -241,31 +247,31 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
     before do
       provider.resource[:source] = '/tmp/tcsh.tgz'
       provider.resource[:name] = 'tcsh'
-      allow(provider).to receive(:pkginfo).with('tcsh')
+      provider.stubs(:pkginfo).with('tcsh')
     end
 
     it "should return the ensure value if the package is already installed" do
-      allow(provider).to receive(:properties).and_return({:ensure => '4.2.45'})
-      allow(provider).to receive(:pkginfo).with('-Q', 'tcsh')
+      provider.stubs(:properties).returns({:ensure => '4.2.45'})
+      provider.stubs(:pkginfo).with('-Q', 'tcsh')
       expect(provider.latest).to eq('4.2.45')
     end
 
     it "should recognize a new version" do
       pkginfo_query = 'tcsh-6.18.01p1'
-      allow(provider).to receive(:pkginfo).with('-Q', 'tcsh').and_return(pkginfo_query)
+      provider.stubs(:pkginfo).with('-Q', 'tcsh').returns(pkginfo_query)
       expect(provider.latest).to eq('6.18.01p1')
     end
 
     it "should recognize a newer version" do
-      allow(provider).to receive(:properties).and_return({:ensure => '1.6.8'})
+      provider.stubs(:properties).returns({:ensure => '1.6.8'})
       pkginfo_query = 'tcsh-1.6.10'
-      allow(provider).to receive(:pkginfo).with('-Q', 'tcsh').and_return(pkginfo_query)
+      provider.stubs(:pkginfo).with('-Q', 'tcsh').returns(pkginfo_query)
       expect(provider.latest).to eq('1.6.10')
     end
 
     it "should recognize a package that is already the newest" do
       pkginfo_query = 'tcsh-6.18.01p0 (installed)'
-      allow(provider).to receive(:pkginfo).with('-Q', 'tcsh').and_return(pkginfo_query)
+      provider.stubs(:pkginfo).with('-Q', 'tcsh').returns(pkginfo_query)
       expect(provider.latest).to eq('6.18.01p0')
     end
   end
@@ -291,7 +297,7 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
 
     it "should lookup the correct version" do
       output = 'bash-3.1.17         GNU Bourne Again Shell'
-      expect(provider).to receive(:execpipe).with(%w{/bin/pkg_info -I bash}).and_yield(output)
+      provider.expects(:execpipe).with(%w{/bin/pkg_info -I bash}).yields(output)
       expect(provider.get_full_name).to eq('bash-3.1.17')
     end
 
@@ -299,26 +305,26 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
       provider.resource[:name] = 'fossil'
       provider.resource[:flavor] = 'static'
       output = 'fossil-1.29v0-static simple distributed software configuration management'
-      expect(provider).to receive(:execpipe).with(%w{/bin/pkg_info -I fossil}).and_yield(output)
+      provider.expects(:execpipe).with(%w{/bin/pkg_info -I fossil}).yields(output)
       expect(provider.get_full_name).to eq('fossil-1.29v0-static')
     end
   end
 
   context "#get_version" do
     it "should return nil if execution fails" do
-      expect(provider).to receive(:execpipe).and_raise(Puppet::ExecutionFailure, 'wawawa')
+      provider.expects(:execpipe).raises(Puppet::ExecutionFailure, 'wawawa')
       expect(provider.get_version).to be_nil
     end
 
     it "should return the package version if in the output" do
       output = 'bash-3.1.17         GNU Bourne Again Shell'
-      expect(provider).to receive(:execpipe).with(%w{/bin/pkg_info -I bash}).and_yield(output)
+      provider.expects(:execpipe).with(%w{/bin/pkg_info -I bash}).yields(output)
       expect(provider.get_version).to eq('3.1.17')
     end
 
     it "should return the empty string if the package is not present" do
       provider.resource[:name] = 'zsh'
-      expect(provider).to receive(:execpipe).with(%w{/bin/pkg_info -I zsh}).and_yield(StringIO.new(''))
+      provider.expects(:execpipe).with(%w{/bin/pkg_info -I zsh}).yields(StringIO.new(''))
       expect(provider.get_version).to eq('')
     end
   end
@@ -326,13 +332,13 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
   context "#query" do
     it "should return the installed version if present" do
       fixture = File.read(my_fixture('pkginfo.detail'))
-      expect(provider).to receive(:pkginfo).with('bash').and_return(fixture)
+      provider.expects(:pkginfo).with('bash').returns(fixture)
       expect(provider.query).to eq({ :ensure => '3.1.17' })
     end
 
     it "should return nothing if not present" do
       provider.resource[:name] = 'zsh'
-      expect(provider).to receive(:pkginfo).with('zsh').and_return('')
+      provider.expects(:pkginfo).with('zsh').returns('')
       expect(provider.query).to be_nil
     end
   end
@@ -382,7 +388,7 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
   context "#uninstall" do
     describe 'when uninstalling' do
       it 'should use erase to purge' do
-        expect(provider).to receive(:pkgdelete).with('-c', '-q', 'bash')
+        provider.expects(:pkgdelete).with('-c', '-q', 'bash')
         provider.purge
       end
     end
@@ -390,26 +396,9 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
     describe 'with uninstall_options' do
       it 'should use uninstall_options as Array' do
         provider.resource[:uninstall_options] = ['-q', '-c']
-        expect(provider).to receive(:pkgdelete).with(['-q', '-c'], 'bash')
+        provider.expects(:pkgdelete).with(['-q', '-c'], 'bash')
         provider.uninstall
       end
     end
   end
-
-  context "#flavor" do
-    before do
-      provider.instance_variable_get('@property_hash')[:flavor] = 'no_x11-python'
-    end
-
-    it 'should return the existing flavor' do
-      expect(provider.flavor).to eq('no_x11-python')
-    end
-
-    it 'should remove and install the new flavor if different' do
-      provider.resource[:flavor] = 'no_x11-ruby'
-      expect(provider).to receive(:uninstall).ordered
-      expect(provider).to receive(:install).ordered
-      provider.flavor = provider.resource[:flavor]
-    end
-  end
 end