puppet 5.5.12-x86-mingw32 → 5.5.13-x86-mingw32

data/spec/unit/provider/network_device_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/provider/network_device'
@@ -18,7 +17,7 @@ provider_class = Puppet::Type.type(:vlan).provider(:test)
 
 describe provider_class do
   before do
-    @resource = stub("resource", :name => "test")
+    @resource = double("resource", :name => "test")
     @provider = provider_class.new(@resource)
   end
 
@@ -32,34 +31,35 @@ describe provider_class do
 
   describe "when prefetching" do
     before do
-      @resource = stub_everything 'resource'
+      @resource = double('resource')
+      allow(@resource).to receive(:[])
       @resources = {"200" => @resource}
-      provider_class.stubs(:lookup)
+      allow(provider_class).to receive(:lookup)
     end
 
     it "should lookup an entry for each passed resource" do
-      provider_class.expects(:lookup).with{ |device,value| value ==  "200" }.returns nil
+      expect(provider_class).to receive(:lookup).with(anything, "200").and_return(nil)
 
-      provider_class.stubs(:new)
-      @resource.stubs(:provider=)
+      allow(provider_class).to receive(:new)
+      allow(@resource).to receive(:provider=)
       provider_class.prefetch(@resources)
     end
 
     describe "resources that do not exist" do
       it "should create a provider with :ensure => :absent" do
-        provider_class.stubs(:lookup).returns(nil)
-        provider_class.expects(:new).with(:device, :ensure => :absent).returns "myprovider"
-        @resource.expects(:provider=).with("myprovider")
+        allow(provider_class).to receive(:lookup).and_return(nil)
+        expect(provider_class).to receive(:new).with(:device, :ensure => :absent).and_return("myprovider")
+        expect(@resource).to receive(:provider=).with("myprovider")
         provider_class.prefetch(@resources)
       end
     end
 
     describe "resources that exist" do
       it "should create a provider with the results of the find and ensure at present" do
-        provider_class.stubs(:lookup).returns({ :name => "200", :description => "myvlan"})
+        allow(provider_class).to receive(:lookup).and_return({ :name => "200", :description => "myvlan"})
 
-        provider_class.expects(:new).with(:device, :name => "200", :description => "myvlan", :ensure => :present).returns "myprovider"
-        @resource.expects(:provider=).with("myprovider")
+        expect(provider_class).to receive(:new).with(:device, :name => "200", :description => "myvlan", :ensure => :present).and_return("myprovider")
+        expect(@resource).to receive(:provider=).with("myprovider")
 
         provider_class.prefetch(@resources)
       end
@@ -69,12 +69,12 @@ describe provider_class do
   describe "when being initialized" do
     describe "with a hash" do
       before do
-        @resource_class = mock 'resource_class'
-        provider_class.stubs(:resource_type).returns @resource_class
+        @resource_class = double('resource_class')
+        allow(provider_class).to receive(:resource_type).and_return(@resource_class)
 
-        @property_class = stub 'property_class', :array_matching => :all, :superclass => Puppet::Property
-        @resource_class.stubs(:attrclass).with(:one).returns(@property_class)
-        @resource_class.stubs(:valid_parameter?).returns true
+        @property_class = double('property_class', :array_matching => :all, :superclass => Puppet::Property)
+        allow(@resource_class).to receive(:attrclass).with(:one).and_return(@property_class)
+        allow(@resource_class).to receive(:valid_parameter?).and_return(true)
       end
 
       it "should store a copy of the hash as its vlan_properties" do
@@ -88,9 +88,9 @@ describe provider_class do
     before do
       @instance = provider_class.new(:device)
 
-      @property_class = stub 'property_class', :array_matching => :all, :superclass => Puppet::Property
-      @resource_class = stub 'resource_class', :attrclass => @property_class, :valid_parameter? => true, :validproperties => [:description]
-      provider_class.stubs(:resource_type).returns @resource_class
+      @property_class = double('property_class', :array_matching => :all, :superclass => Puppet::Property)
+      @resource_class = double('resource_class', :attrclass => @property_class, :valid_parameter? => true, :validproperties => [:description])
+      allow(provider_class).to receive(:resource_type).and_return(@resource_class)
     end
 
     it "should have a method for creating the instance" do
@@ -121,12 +121,12 @@ describe provider_class do
 
     describe "is being created" do
       before do
-        @rclass = mock 'resource_class'
-        @rclass.stubs(:validproperties).returns([:description])
-        @resource = stub_everything 'resource'
-        @resource.stubs(:class).returns @rclass
-        @resource.stubs(:should).returns nil
-        @instance.stubs(:resource).returns @resource
+        @rclass = double('resource_class')
+        allow(@rclass).to receive(:validproperties).and_return([:description])
+        @resource = double('resource')
+        allow(@resource).to receive(:class).and_return(@rclass)
+        allow(@resource).to receive(:should).and_return(nil)
+        allow(@instance).to receive(:resource).and_return(@resource)
       end
 
       it "should set its :ensure value to :present" do
@@ -135,7 +135,7 @@ describe provider_class do
       end
 
       it "should set all of the other attributes from the resource" do
-        @resource.expects(:should).with(:description).returns "myvlan"
+        expect(@resource).to receive(:should).with(:description).and_return("myvlan")
 
         @instance.create
         expect(@instance.properties[:description]).to eq("myvlan")

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
-    @provider.expects(:installp).with('-gu', 'mypackage')
-    @provider.class.expects(:pkglist).with(:pkgname => 'mypackage').returns(nil)
+    expect(@provider).to receive(:installp).with('-gu', 'mypackage')
+    expect(@provider.class).to receive(:pkglist).with(:pkgname => 'mypackage').and_return(nil)
     @provider.uninstall
   end
 
   context "when installing" do
     it "should install a package" do
-      @provider.expects(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
+      expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
       @provider.install
     end
 
     it "should install a specific package version" do
-      @resource.stubs(:should).with(:ensure).returns("1.2.3.4")
-      @provider.expects(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage 1.2.3.4')
+      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')
       @provider.install
     end
 
     it "should fail if the specified version is superseded" do
       @resource[:ensure] = '1.2.3.3'
-      @provider.stubs(:installp).returns <<-OUTPUT
+      allow(@provider).to receive(:installp).and_return(<<-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
-      @provider.stubs(:latest_info).returns(nil)
-      @provider.stubs(:properties).returns( { :ensure => "1.2.3.4" } )
+      allow(@provider).to receive(:latest_info).and_return(nil)
+      allow(@provider).to receive(:properties).and_return({ :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
-      @provider.stubs(:latest_info).returns( { :version => "1.2.3.5" } )
+      allow(@provider).to receive(:latest_info).and_return({ :version => "1.2.3.5" })
       expect(@provider.latest).to eq("1.2.3.5")
     end
 
     it "should prefetch the right values" do
-      Process.stubs(:euid).returns(0)
+      allow(Process).to receive(:euid).and_return(0)
       resource = Puppet::Type.type(:package).
           new(:name => 'sudo.rte', :ensure => :latest,
               :source => 'mysource', :provider => :aix)
 
-      resource.stubs(:should).with(:ensure).returns(:latest)
+      allow(resource).to receive(:should).with(:ensure).and_return(:latest)
       resource.should(:ensure)
 
-      resource.provider.class.stubs(:execute).returns(<<-END.chomp)
+      allow(resource.provider.class).to receive(:execute).and_return(<<-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
-    @provider.expects(:install).with(false)
+    expect(@provider).to receive(: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)
-    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'
+    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
 end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:appdmg) do
@@ -10,12 +9,11 @@ describe Puppet::Type.type(:package).provider(:appdmg) do
     let(:fake_hdiutil_plist) { {"system-entities" => [{"mount-point" => fake_mountpoint}]} }
 
     before do
-      fh = mock 'filehandle'
-      fh.stubs(:path).yields "/tmp/foo"
+      fh = double('filehandle', path: '/tmp/foo')
       resource[:source] = "foo.dmg"
-      described_class.stubs(:open).yields fh
-      Dir.stubs(:mktmpdir).returns "/tmp/testtmp123"
-      FileUtils.stubs(:remove_entry_secure)
+      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)
     end
 
     describe "from a remote source" do
@@ -26,14 +24,16 @@ describe Puppet::Type.type(:package).provider(:appdmg) do
       end
 
       it "should call tmpdir and use the returned directory" do
-        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")
+        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")
         end
-        described_class.stubs(:hdiutil).returns 'a plist'
-        Puppet::Util::Plist.expects(:parse_plist).with('a plist').returns fake_hdiutil_plist
-        described_class.expects(:installapp)
+        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)
 
         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
-    Facter.expects(:value).with(:osfamily).returns("Debian")
+    expect(Facter).to receive(:value).with(:osfamily).and_return("Debian")
     expect(described_class.default?).to be_truthy
   end
 
@@ -26,38 +26,40 @@ describe Puppet::Type.type(:package).provider(:apt) do
   end
 
   it "should use :install to update" do
-    provider.expects(:install)
+    expect(provider).to receive(:install)
     provider.update
   end
 
   it "should use 'apt-get remove' to uninstall" do
-    provider.expects(:aptget).with("-y", "-q", :remove, name)
+    expect(provider).to receive(:aptget).with("-y", "-q", :remove, name)
     provider.uninstall
   end
 
   it "should use 'apt-get purge' and 'dpkg purge' to purge" do
-    provider.expects(:aptget).with("-y", "-q", :remove, "--purge", name)
-    provider.expects(:dpkg).with("--purge", name)
+    expect(provider).to receive(:aptget).with("-y", "-q", :remove, "--purge", name)
+    expect(provider).to receive(:dpkg).with("--purge", name)
     provider.purge
   end
 
   it "should use 'apt-cache policy' to determine the latest version of a package" do
-    provider.expects(:aptcache).with(:policy, name).returns "#{name}:
+    expect(provider).to receive(:aptcache).with(:policy, name).and_return(<<-HERE)
+#{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"
+  100 /var/lib/dpkg/status
+    HERE
 
     expect(provider.latest).to eq("1:1.1")
   end
 
   it "should print and error and return nil if no policy is found" do
-    provider.expects(:aptcache).with(:policy, name).returns "#{name}:"
+    expect(provider).to receive(:aptcache).with(:policy, name).and_return("#{name}:")
 
-    provider.expects(:err)
+    expect(provider).to receive(:err)
     expect(provider.latest).to be_nil
   end
 
@@ -67,17 +69,17 @@ Version table:
 
   it "should preseed with the provided responsefile when preseeding is called for" do
     resource[:responsefile] = '/my/file'
-    Puppet::FileSystem.expects(:exist?).with('/my/file').returns true
+    expect(Puppet::FileSystem).to receive(:exist?).with('/my/file').and_return(true)
 
-    provider.expects(:info)
-    provider.expects(:preseed).with('/my/file')
+    expect(provider).to receive(:info)
+    expect(provider).to receive(:preseed).with('/my/file')
 
     provider.run_preseed
   end
 
   it "should not preseed if no responsefile is provided" do
-    provider.expects(:info)
-    provider.expects(:preseed).never
+    expect(provider).to receive(:info)
+    expect(provider).not_to receive(:preseed)
 
     provider.run_preseed
   end
@@ -85,76 +87,91 @@ Version table:
   describe "when installing" do
     it "should preseed if a responsefile is provided" do
       resource[:responsefile] = "/my/file"
-      provider.expects(:run_preseed)
+      expect(provider).to receive(:run_preseed)
 
-      provider.stubs(:aptget)
+      allow(provider).to receive(:aptget)
       provider.install
     end
 
     it "should check for a cdrom" do
-      provider.expects(:checkforcdrom)
+      expect(provider).to receive(:checkforcdrom)
 
-      provider.stubs(:aptget)
+      allow(provider).to receive(:aptget)
       provider.install
     end
 
     it "should use 'apt-get install' with the package name if no version is asked for" do
       resource[:ensure] = :installed
-      provider.expects(:aptget).with { |*command| command[-1] == name and command[-2] == :install }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command[-1]).to eq(name)
+        expect(command[-2]).to eq(:install)
+      end
 
       provider.install
     end
 
     it "should specify the package version if one is asked for" do
       resource[:ensure] = '1.0'
-      provider.expects(:aptget).with { |*command| command[-1] == "#{name}=1.0" }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command[-1]).to eq("#{name}=1.0")
+      end
 
       provider.install
     end
 
     it "should use --force-yes if a package version is specified" do
       resource[:ensure] = '1.0'
-      provider.expects(:aptget).with { |*command| command.include?("--force-yes") }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command).to include("--force-yes")
+      end
 
       provider.install
     end
 
     it "should do a quiet install" do
-      provider.expects(:aptget).with { |*command| command.include?("-q") }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command).to include("-q")
+      end
 
       provider.install
     end
 
     it "should default to 'yes' for all questions" do
-      provider.expects(:aptget).with { |*command| command.include?("-y") }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command).to include("-y")
+      end
 
       provider.install
     end
 
     it "should keep config files if asked" do
       resource[:configfiles] = :keep
-      provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confold") }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command).to include("DPkg::Options::=--force-confold")
+      end
 
       provider.install
     end
 
     it "should replace config files if asked" do
       resource[:configfiles] = :replace
-      provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confnew") }
+      expect(provider).to receive(:aptget) do |*command|
+        expect(command).to include("DPkg::Options::=--force-confnew")
+      end
 
       provider.install
     end
 
     it 'should support string install options' do
       resource[:install_options] = ['--foo', '--bar']
-      provider.expects(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar', :install, name)
+      expect(provider).to receive(: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' }]
-      provider.expects(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar=baz', '--baz=foo', :install, name)
+      expect(provider).to receive(: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,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:package).provider(:aptitude) do
@@ -13,17 +12,17 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
     let(:dpkgquery_path) { '/bin/dpkg-query' }
 
     before do
-      Puppet::Util.stubs(:which).with('/usr/bin/dpkg-query').returns(dpkgquery_path)
+      allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(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
-        Puppet::Util::Execution.expects(:execute).with(
+        expect(Puppet::Util::Execution).to receive(:execute).with(
           [dpkgquery_path, '-W', '--showformat', "'${Status} ${Package} ${Version}\\n'", 'faff'],
           {:failonfail => true, :combine => true, :custom_environment => {}}
-        ).returns(Puppet::Util::Execution::ProcessOutput.new(output, 0))
+        ).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
 
         expect(pkg.property(:ensure).retrieve).to eq(expect)
       end
@@ -31,15 +30,15 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
   end
 
   it "installs when asked" do
-    pkg.provider.expects(:aptitude).
+    expect(pkg.provider).to receive(:aptitude).
       with('-y', '-o', 'DPkg::Options::=--force-confold', :install, 'faff').
-      returns(0)
+      and_return(0)
 
     pkg.provider.install
   end
 
   it "purges when asked" do
-    pkg.provider.expects(:aptitude).with('-y', 'purge', 'faff').returns(0)
+    expect(pkg.provider).to receive(:aptitude).with('-y', 'purge', 'faff').and_return(0)
     pkg.provider.purge
   end
 end