puppet 5.5.22 → 6.0.0

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

@@ -1,6 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:aix) do
+provider_class = Puppet::Type.type(:package).provider(:aix)
+
+describe provider_class do
   before(:each) do
     # Create a mock resource
     @resource = Puppet::Type.type(:package).new(:name => 'mypackage', :ensure => :installed, :source => 'mysource', :provider => :aix)
@@ -15,36 +18,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
+  describe "when installing" do
     it "should install a package" do
-      allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => 'present', :status => :committed})
-      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")
-      allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => '1.2.3.4', :status => :committed})
-      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
 
-    [:broken, :inconsistent].each do |state|
-      it "should fail if the installation resulted in a '#{state}' state" do
-        allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => 'present', :status => state})
-        expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
-        expect { @provider.install }.to raise_error(Puppet::Error, "Package 'mypackage' is in a #{state} state and requires manual intervention")
-      end
-    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...
 +-----------------------------------------------------------------------------+
@@ -93,28 +86,28 @@ mypackage                 1.2.3.3         Already superseded by 1.2.3.4
     end
   end
 
-  context "when finding the latest version" do
+  describe "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
@@ -125,34 +118,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')
-    described_class.prefetch({ 'mypackage' => latest, 'otherpackage' => absent })
-  end
-
-  context "when querying instances" do
-    before(:each) do
-      allow(described_class).to receive(:execute).and_return(<<-END.chomp)
-sysmgt.cim.providers:sysmgt.cim.providers.metrics:2.12.1.1: : :B: :Metrics Providers for AIX OS: : : : : : :1:0:/:
-sysmgt.cim.providers:sysmgt.cim.providers.osbase:2.12.1.1: : :C: :Base Providers for AIX OS: : : : : : :1:0:/:
-openssl.base:openssl.base:1.0.2.1800: : :?: :Open Secure Socket Layer: : : : : : :0:0:/:
-END
-    end
-
-    it "should treat installed packages in broken and inconsistent state as absent" do
-      installed_packages = described_class.instances.map { |package| package.properties }
-      expected_packages = [{:name => 'sysmgt.cim.providers.metrics', :ensure => :absent, :status => :broken, :provider => :aix},
-                           {:name => 'sysmgt.cim.providers.osbase', :ensure => '2.12.1.1', :status => :committed, :provider => :aix},
-                           {:name => 'openssl.base', :ensure => :absent, :status => :inconsistent, :provider => :aix}]
-
-      expect(installed_packages).to eql(expected_packages)
-    end
+    Process.stubs(:euid).returns(0)
+    provider_class.expects(:execute).returns 'mypackage:mypackage.rte:1.8.6.4::I:T:::::N:A Super Cool Package::::0::\n'
+    provider_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

@@ -1,6 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:apt) do
+provider_class = Puppet::Type.type(:package).provider(:apt)
+
+describe provider_class do
   let(:name) { 'asdf' }
 
   let(:resource) do
@@ -11,57 +14,53 @@ describe Puppet::Type.type(:package).provider(:apt) do
   end
 
   let(:provider) do
-    provider = subject()
+    provider = provider_class.new
     provider.resource = resource
     provider
   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
 
   it "should be versionable" do
-    expect(described_class).to be_versionable
+    expect(provider_class).to be_versionable
   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)
-    expect(provider).to receive(:properties).and_return({:mark => :none})
+    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)
-    expect(provider).to receive(:properties).and_return({:mark => :none})
+    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
 
@@ -71,17 +70,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
@@ -89,100 +88,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)
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-      allow(provider).to receive(:aptget)
+      provider.expects(:run_preseed)
+
+      provider.stubs(:aptget)
       provider.install
     end
 
     it "should check for a cdrom" do
-      expect(provider).to receive(:checkforcdrom)
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-      allow(provider).to receive(:aptget)
+      provider.expects(:checkforcdrom)
+
+      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
-      expect(provider).to receive(:properties).and_return({:mark => :none})
+      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
-      expect(provider).to receive(:properties).and_return({:mark => :none})
+      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
-      expect(provider).to receive(:properties).and_return({:mark => :none})
+      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
-      expect(provider).to receive(:properties).and_return({:mark => :none})
+      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
-      expect(provider).to receive(:properties).and_return({:mark => :none})
+      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
-      expect(provider).to receive(:properties).and_return({:mark => :none})
+      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
-      expect(provider).to receive(:properties).and_return({:mark => :none})
+      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)
-      expect(provider).to receive(:properties).and_return({:mark => :none})
+      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)
-      expect(provider).to receive(:properties).and_return({:mark => :none})
+      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,16 +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)
-    expect(pkg.provider).to receive(:properties).and_return({:mark => :none})
+      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"]
+      ['-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