puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

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

@@ -15,26 +15,26 @@ describe Puppet::Type.type(:package).provider(:aix) do
   end
 
   it "should uninstall a package" do
-    expect(@provider).to receive(:installp).with('-gu', 'mypackage')
-    expect(@provider.class).to receive(:pkglist).with(:pkgname => 'mypackage').and_return(nil)
+    @provider.expects(:installp).with('-gu', 'mypackage')
+    @provider.class.expects(:pkglist).with(:pkgname => 'mypackage').returns(nil)
     @provider.uninstall
   end
 
   context "when installing" do
     it "should install a package" do
-      expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
+      @provider.expects(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
       @provider.install
     end
 
     it "should install a specific package version" do
-      allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3.4")
-      expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage 1.2.3.4')
+      @resource.stubs(:should).with(:ensure).returns("1.2.3.4")
+      @provider.expects(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage 1.2.3.4')
       @provider.install
     end
 
     it "should fail if the specified version is superseded" do
       @resource[:ensure] = '1.2.3.3'
-      allow(@provider).to receive(:installp).and_return(<<-OUTPUT)
+      @provider.stubs(:installp).returns <<-OUTPUT
 +-----------------------------------------------------------------------------+
                     Pre-installation Verification...
 +-----------------------------------------------------------------------------+
@@ -85,26 +85,26 @@ mypackage                 1.2.3.3         Already superseded by 1.2.3.4
 
   context "when finding the latest version" do
     it "should return the current version when no later version is present" do
-      allow(@provider).to receive(:latest_info).and_return(nil)
-      allow(@provider).to receive(:properties).and_return({ :ensure => "1.2.3.4" })
+      @provider.stubs(:latest_info).returns(nil)
+      @provider.stubs(:properties).returns( { :ensure => "1.2.3.4" } )
       expect(@provider.latest).to eq("1.2.3.4")
     end
 
     it "should return the latest version of a package" do
-      allow(@provider).to receive(:latest_info).and_return({ :version => "1.2.3.5" })
+      @provider.stubs(:latest_info).returns( { :version => "1.2.3.5" } )
       expect(@provider.latest).to eq("1.2.3.5")
     end
 
     it "should prefetch the right values" do
-      allow(Process).to receive(:euid).and_return(0)
+      Process.stubs(:euid).returns(0)
       resource = Puppet::Type.type(:package).
           new(:name => 'sudo.rte', :ensure => :latest,
               :source => 'mysource', :provider => :aix)
 
-      allow(resource).to receive(:should).with(:ensure).and_return(:latest)
+      resource.stubs(:should).with(:ensure).returns(:latest)
       resource.should(:ensure)
 
-      allow(resource.provider.class).to receive(:execute).and_return(<<-END.chomp)
+      resource.provider.class.stubs(:execute).returns(<<-END.chomp)
 sudo:sudo.rte:1.7.10.4::I:C:::::N:Configurable super-user privileges runtime::::0::
 sudo:sudo.rte:1.8.6.4::I:T:::::N:Configurable super-user privileges runtime::::0::
 END
@@ -115,15 +115,15 @@ END
   end
 
   it "update should install a package" do
-    expect(@provider).to receive(:install).with(false)
+    @provider.expects(:install).with(false)
     @provider.update
   end
 
   it "should prefetch when some packages lack sources" do
     latest = Puppet::Type.type(:package).new(:name => 'mypackage', :ensure => :latest, :source => 'mysource', :provider => :aix)
     absent = Puppet::Type.type(:package).new(:name => 'otherpackage', :ensure => :absent, :provider => :aix)
-    allow(Process).to receive(:euid).and_return(0)
-    expect(described_class).to receive(:execute).and_return('mypackage:mypackage.rte:1.8.6.4::I:T:::::N:A Super Cool Package::::0::\n')
+    Process.stubs(:euid).returns(0)
+    described_class.expects(:execute).returns 'mypackage:mypackage.rte:1.8.6.4::I:T:::::N:A Super Cool Package::::0::\n'
     described_class.prefetch({ 'mypackage' => latest, 'otherpackage' => absent })
   end
 end

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:appdmg) do
@@ -9,11 +10,12 @@ describe Puppet::Type.type(:package).provider(:appdmg) do
     let(:fake_hdiutil_plist) { {"system-entities" => [{"mount-point" => fake_mountpoint}]} }
 
     before do
-      fh = double('filehandle', path: '/tmp/foo')
+      fh = mock 'filehandle'
+      fh.stubs(:path).yields "/tmp/foo"
       resource[:source] = "foo.dmg"
-      allow(described_class).to receive(:open).and_yield(fh)
-      allow(Dir).to receive(:mktmpdir).and_return("/tmp/testtmp123")
-      allow(FileUtils).to receive(:remove_entry_secure)
+      described_class.stubs(:open).yields fh
+      Dir.stubs(:mktmpdir).returns "/tmp/testtmp123"
+      FileUtils.stubs(:remove_entry_secure)
     end
 
     describe "from a remote source" do
@@ -24,16 +26,14 @@ describe Puppet::Type.type(:package).provider(:appdmg) do
       end
 
       it "should call tmpdir and use the returned directory" do
-        expect(Dir).to receive(:mktmpdir).and_return(tmpdir)
-        allow(Dir).to receive(:entries).and_return(["foo.app"])
-        expect(described_class).to receive(:curl) do |*args|
-          expect(args[0]).to eq("-o")
-          expect(args[1]).to include(tmpdir)
-          expect(args).not_to include("-k")
+        Dir.expects(:mktmpdir).returns tmpdir
+        Dir.stubs(:entries).returns ["foo.app"]
+        described_class.expects(:curl).with do |*args|
+          args[0] == "-o" && args[1].include?(tmpdir) && ! args.include?("-k")
         end
-        allow(described_class).to receive(:hdiutil).and_return('a plist')
-        expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
-        expect(described_class).to receive(:installapp)
+        described_class.stubs(:hdiutil).returns 'a plist'
+        Puppet::Util::Plist.expects(:parse_plist).with('a plist').returns fake_hdiutil_plist
+        described_class.expects(:installapp)
 
         provider.install
       end

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

@@ -17,7 +17,7 @@ describe Puppet::Type.type(:package).provider(:apt) do
   end
 
   it "should be the default provider on :osfamily => Debian" do
-    expect(Facter).to receive(:value).with(:osfamily).and_return("Debian")
+    Facter.expects(:value).with(:osfamily).returns("Debian")
     expect(described_class.default?).to be_truthy
   end
 
@@ -26,40 +26,38 @@ describe Puppet::Type.type(:package).provider(:apt) do
   end
 
   it "should use :install to update" do
-    expect(provider).to receive(:install)
+    provider.expects(:install)
     provider.update
   end
 
   it "should use 'apt-get remove' to uninstall" do
-    expect(provider).to receive(:aptget).with("-y", "-q", :remove, name)
+    provider.expects(:aptget).with("-y", "-q", :remove, name)
     provider.uninstall
   end
 
   it "should use 'apt-get purge' and 'dpkg purge' to purge" do
-    expect(provider).to receive(:aptget).with("-y", "-q", :remove, "--purge", name)
-    expect(provider).to receive(:dpkg).with("--purge", name)
+    provider.expects(:aptget).with("-y", "-q", :remove, "--purge", name)
+    provider.expects(:dpkg).with("--purge", name)
     provider.purge
   end
 
   it "should use 'apt-cache policy' to determine the latest version of a package" do
-    expect(provider).to receive(:aptcache).with(:policy, name).and_return(<<-HERE)
-#{name}:
+    provider.expects(:aptcache).with(:policy, name).returns "#{name}:
 Installed: 1:1.0
 Candidate: 1:1.1
 Version table:
 1:1.0
   650 http://ftp.osuosl.org testing/main Packages
 *** 1:1.1
-  100 /var/lib/dpkg/status
-    HERE
+  100 /var/lib/dpkg/status"
 
     expect(provider.latest).to eq("1:1.1")
   end
 
   it "should print and error and return nil if no policy is found" do
-    expect(provider).to receive(:aptcache).with(:policy, name).and_return("#{name}:")
+    provider.expects(:aptcache).with(:policy, name).returns "#{name}:"
 
-    expect(provider).to receive(:err)
+    provider.expects(:err)
     expect(provider.latest).to be_nil
   end
 
@@ -69,17 +67,17 @@ Version table:
 
   it "should preseed with the provided responsefile when preseeding is called for" do
     resource[:responsefile] = '/my/file'
-    expect(Puppet::FileSystem).to receive(:exist?).with('/my/file').and_return(true)
+    Puppet::FileSystem.expects(:exist?).with('/my/file').returns true
 
-    expect(provider).to receive(:info)
-    expect(provider).to receive(:preseed).with('/my/file')
+    provider.expects(:info)
+    provider.expects(:preseed).with('/my/file')
 
     provider.run_preseed
   end
 
   it "should not preseed if no responsefile is provided" do
-    expect(provider).to receive(:info)
-    expect(provider).not_to receive(:preseed)
+    provider.expects(:info)
+    provider.expects(:preseed).never
 
     provider.run_preseed
   end
@@ -87,91 +85,76 @@ Version table:
   describe "when installing" do
     it "should preseed if a responsefile is provided" do
       resource[:responsefile] = "/my/file"
-      expect(provider).to receive(:run_preseed)
+      provider.expects(:run_preseed)
 
-      allow(provider).to receive(:aptget)
+      provider.stubs(:aptget)
       provider.install
     end
 
     it "should check for a cdrom" do
-      expect(provider).to receive(:checkforcdrom)
+      provider.expects(:checkforcdrom)
 
-      allow(provider).to receive(:aptget)
+      provider.stubs(:aptget)
       provider.install
     end
 
     it "should use 'apt-get install' with the package name if no version is asked for" do
       resource[:ensure] = :installed
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command[-1]).to eq(name)
-        expect(command[-2]).to eq(:install)
-      end
+      provider.expects(:aptget).with { |*command| command[-1] == name and command[-2] == :install }
 
       provider.install
     end
 
     it "should specify the package version if one is asked for" do
       resource[:ensure] = '1.0'
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command[-1]).to eq("#{name}=1.0")
-      end
+      provider.expects(:aptget).with { |*command| command[-1] == "#{name}=1.0" }
 
       provider.install
     end
 
     it "should use --force-yes if a package version is specified" do
       resource[:ensure] = '1.0'
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command).to include("--force-yes")
-      end
+      provider.expects(:aptget).with { |*command| command.include?("--force-yes") }
 
       provider.install
     end
 
     it "should do a quiet install" do
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command).to include("-q")
-      end
+      provider.expects(:aptget).with { |*command| command.include?("-q") }
 
       provider.install
     end
 
     it "should default to 'yes' for all questions" do
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command).to include("-y")
-      end
+      provider.expects(:aptget).with { |*command| command.include?("-y") }
 
       provider.install
     end
 
     it "should keep config files if asked" do
       resource[:configfiles] = :keep
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command).to include("DPkg::Options::=--force-confold")
-      end
+      provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confold") }
 
       provider.install
     end
 
     it "should replace config files if asked" do
       resource[:configfiles] = :replace
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command).to include("DPkg::Options::=--force-confnew")
-      end
+      provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confnew") }
 
       provider.install
     end
 
     it 'should support string install options' do
       resource[:install_options] = ['--foo', '--bar']
-      expect(provider).to receive(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar', :install, name)
+      provider.expects(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar', :install, name)
 
       provider.install
     end
 
     it 'should support hash install options' do
       resource[:install_options] = ['--foo', { '--bar' => 'baz', '--baz' => 'foo' }]
-      expect(provider).to receive(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar=baz', '--baz=foo', :install, name)
+      provider.expects(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar=baz', '--baz=foo', :install, name)
 
       provider.install
     end

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:aptitude) do
@@ -12,17 +13,17 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
     let(:dpkgquery_path) { '/bin/dpkg-query' }
 
     before do
-      allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
+      Puppet::Util.stubs(:which).with('/usr/bin/dpkg-query').returns(dpkgquery_path)
     end
 
     { :absent   => "deinstall ok config-files faff 1.2.3-1\n",
       "1.2.3-1" => "install ok installed faff 1.2.3-1\n",
     }.each do |expect, output|
       it "detects #{expect} packages" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(
+        Puppet::Util::Execution.expects(:execute).with(
           [dpkgquery_path, '-W', '--showformat', "'${Status} ${Package} ${Version}\\n'", 'faff'],
           {:failonfail => true, :combine => true, :custom_environment => {}}
-        ).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
+        ).returns(Puppet::Util::Execution::ProcessOutput.new(output, 0))
 
         expect(pkg.property(:ensure).retrieve).to eq(expect)
       end
@@ -30,15 +31,15 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
   end
 
   it "installs when asked" do
-    expect(pkg.provider).to receive(:aptitude).
+    pkg.provider.expects(:aptitude).
       with('-y', '-o', 'DPkg::Options::=--force-confold', :install, 'faff').
-      and_return(0)
+      returns(0)
 
     pkg.provider.install
   end
 
   it "purges when asked" do
-    expect(pkg.provider).to receive(:aptitude).with('-y', 'purge', 'faff').and_return(0)
+    pkg.provider.expects(:aptitude).with('-y', 'purge', 'faff').returns(0)
     pkg.provider.purge
   end
 end

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:aptrpm) do
@@ -10,33 +11,37 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
 
   context "when retrieving ensure" do
     before(:each) do
-      allow(Puppet::Util).to receive(:which).with("rpm").and_return("/bin/rpm")
-      allow(pkg.provider).to receive(:which).with("rpm").and_return("/bin/rpm")
-      expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).and_return(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most(:once)
+      Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
+      pkg.provider.stubs(:which).with("rpm").returns("/bin/rpm")
+      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most_once
     end
 
     def rpm_args
       ['-q', 'faff', '--nosignature', '--nodigest', '--qf', "'%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n'"]
     end
 
+    def rpm(args = rpm_args)
+      pkg.provider.expects(:rpm).with(*args)
+    end
+
     it "should report purged packages" do
-      expect(pkg.provider).to receive(:rpm).and_raise(Puppet::ExecutionFailure, "couldn't find rpm")
+      rpm.raises(Puppet::ExecutionFailure, "couldn't find rpm")
       expect(pkg.property(:ensure).retrieve).to eq(:purged)
     end
 
     it "should report present packages correctly" do
-      expect(pkg.provider).to receive(:rpm).and_return("faff-1.2.3-1 0 1.2.3-1 5 i686\n")
+      rpm.returns("faff-1.2.3-1 0 1.2.3-1 5 i686\n")
       expect(pkg.property(:ensure).retrieve).to eq("1.2.3-1-5")
     end
   end
 
   it "should try and install when asked" do
-    expect(pkg.provider).to receive(:aptget).with('-q', '-y', 'install', 'faff').and_return(0)
+    pkg.provider.expects(:aptget). with('-q', '-y', 'install', 'faff'). returns(0)
     pkg.provider.install
   end
 
   it "should try and purge when asked" do
-    expect(pkg.provider).to receive(:aptget).with('-y', '-q', 'remove', '--purge', 'faff').and_return(0)
+    pkg.provider.expects(:aptget).with('-y', '-q', 'remove', '--purge', 'faff').returns(0)
     pkg.provider.purge
   end
 end

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

@@ -4,15 +4,15 @@ require 'puppet/provider/package'
 describe Puppet::Provider::Package do
   it 'returns absent for uninstalled packages when not purgeable' do
     provider = Puppet::Provider::Package.new
-    expect(provider).to receive(:query).and_return(nil)
-    expect(provider.class).to receive(:feature?).with(:purgeable).and_return(false)
+    provider.expects(:query).returns nil
+    provider.class.expects(:feature?).with(:purgeable).returns false
     expect(provider.properties[:ensure]).to eq(:absent)
   end
 
   it 'returns purged for uninstalled packages when purgeable' do
     provider = Puppet::Provider::Package.new
-    expect(provider).to receive(:query).and_return(nil)
-    expect(provider.class).to receive(:feature?).with(:purgeable).and_return(true)
+    provider.expects(:query).returns nil
+    provider.class.expects(:feature?).with(:purgeable).returns true
     expect(provider.properties[:ensure]).to eq(:purged)
   end
 end

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

@@ -2,46 +2,48 @@ require 'spec_helper'
 
 # Note that much of the functionality of the dnf provider is already tested with yum provider tests,
 # as yum is the parent provider.
+
 describe Puppet::Type.type(:package).provider(:dnf) do
   context 'default' do
     (19..21).each do |ver|
       it "should not be the default provider on fedora#{ver}" 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("#{ver}")
+        Facter.stubs(:value).with(:osfamily).returns(:redhat)
+        Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
         expect(described_class).to_not be_default
       end
     end
 
     (22..26).each do |ver|
       it "should be the default provider on fedora#{ver}" 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("#{ver}")
+        Facter.stubs(:value).with(:osfamily).returns(:redhat)
+        Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("#{ver}")
         expect(described_class).to be_default
       end
     end
 
     it "should not be the default provider on rhel7" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("7")
-      expect(described_class).to_not be_default
+        Facter.stubs(:value).with(:osfamily).returns(:redhat)
+        Facter.stubs(:value).with(:operatingsystem).returns(:redhat)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
+        expect(described_class).to_not be_default
     end
 
     it "should be the default provider on some random future fedora" 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("8675")
-      expect(described_class).to be_default
+        Facter.stubs(:value).with(:osfamily).returns(:redhat)
+        Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("8675")
+        expect(described_class).to be_default
     end
 
     it "should be the default provider on rhel8" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("8")
-      expect(described_class).to be_default
+        Facter.stubs(:value).with(:osfamily).returns(:redhat)
+        Facter.stubs(:value).with(:operatingsystem).returns(:redhat)
+        Facter.stubs(:value).with(:operatingsystemmajrelease).returns("8")
+        expect(described_class).to be_default
     end
+
   end
 
   it_behaves_like 'RHEL package provider', described_class, 'dnf'