puppet 6.0.7-x64-mingw32 → 6.0.8-x64-mingw32

data/spec/unit/type/service_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 def safely_load_service_type
@@ -7,7 +6,7 @@ def safely_load_service_type
     # on jruby. Thus, we stub it out here since we don't care to do any assertions on it.
     # This is only an issue if you're running these unit tests on a platform where upstart
     # is a default provider, like Ubuntu trusty.
-    Puppet::Util::Execution.stubs(:execute)
+    allow(Puppet::Util::Execution).to receive(:execute)
     Puppet::Type.type(:service)
   end
 end
@@ -46,8 +45,8 @@ describe test_title, "when validating attribute values" do
   safely_load_service_type
 
   before do
-    @provider = stub 'provider', :class => Puppet::Type.type(:service).defaultprovider, :clear => nil, :controllable? => false
-    Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(@provider)
+    @provider = double('provider', :class => Puppet::Type.type(:service).defaultprovider, :clear => nil, :controllable? => false)
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:new).and_return(@provider)
   end
 
   it "should support :running as a value to :ensure" do
@@ -70,8 +69,9 @@ describe test_title, "when validating attribute values" do
 
   describe "the enable property" do
     before :each do
-      @provider.class.stubs(:supports_parameter?).returns true
+      allow(@provider.class).to receive(:supports_parameter?).and_return(true)
     end
+
     it "should support :true as a value" do
       srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :true)
       expect(srv.should(:enable)).to eq(:true)
@@ -88,13 +88,13 @@ describe test_title, "when validating attribute values" do
     end
 
     it "should support :manual as a value on Windows" do
-      Puppet::Util::Platform.stubs(:windows?).returns true
+      allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
       srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :manual)
       expect(srv.should(:enable)).to eq(:manual)
     end
 
     it "should not support :manual as a value when not on Windows" do
-      Puppet::Util::Platform.stubs(:windows?).returns false
+      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
 
       expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :manual) }.to raise_error(
         Puppet::Error,
@@ -129,29 +129,29 @@ describe test_title, "when validating attribute values" do
   end
 
   it "should allow setting the :enable parameter if the provider has the :enableable feature" do
-    Puppet::Type.type(:service).defaultprovider.stubs(:supports_parameter?).returns(true)
-    Puppet::Type.type(:service).defaultprovider.expects(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).returns(true)
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).and_return(true)
+    expect(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).and_return(true)
     svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
     expect(svc.should(:enable)).to eq(:true)
   end
 
   it "should not allow setting the :enable parameter if the provider is missing the :enableable feature" do
-    Puppet::Type.type(:service).defaultprovider.stubs(:supports_parameter?).returns(true)
-    Puppet::Type.type(:service).defaultprovider.expects(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).returns(false)
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).and_return(true)
+    expect(Puppet::Type.type(:service).defaultprovider).to receive(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).and_return(false)
     svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
     expect(svc.should(:enable)).to be_nil
   end
 
   it "should split paths on '#{File::PATH_SEPARATOR}'" do
-    Puppet::FileSystem.stubs(:exist?).returns(true)
-    FileTest.stubs(:directory?).returns(true)
+    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+    allow(FileTest).to receive(:directory?).and_return(true)
     svc = Puppet::Type.type(:service).new(:name => "yay", :path => "/one/two#{File::PATH_SEPARATOR}/three/four")
     expect(svc[:path]).to eq(%w{/one/two /three/four})
   end
 
   it "should accept arrays of paths joined by '#{File::PATH_SEPARATOR}'" do
-    Puppet::FileSystem.stubs(:exist?).returns(true)
-    FileTest.stubs(:directory?).returns(true)
+    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+    allow(FileTest).to receive(:directory?).and_return(true)
     svc = Puppet::Type.type(:service).new(:name => "yay", :path => ["/one#{File::PATH_SEPARATOR}/two", "/three#{File::PATH_SEPARATOR}/four"])
     expect(svc[:path]).to eq(%w{/one /two /three /four})
   end
@@ -161,11 +161,11 @@ describe test_title, "when setting default attribute values" do
   safely_load_service_type
 
   it "should default to the provider's default path if one is available" do
-    FileTest.stubs(:directory?).returns(true)
-    Puppet::FileSystem.stubs(:exist?).returns(true)
+    allow(FileTest).to receive(:directory?).and_return(true)
+    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
 
-    Puppet::Type.type(:service).defaultprovider.stubs(:respond_to?).returns(true)
-    Puppet::Type.type(:service).defaultprovider.stubs(:defpath).returns("testing")
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:respond_to?).and_return(true)
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:defpath).and_return("testing")
     svc = Puppet::Type.type(:service).new(:name => "other")
     expect(svc[:path]).to eq(["testing"])
   end
@@ -181,8 +181,8 @@ describe test_title, "when setting default attribute values" do
   end
 
   it "should default 'control' to the upcased service name with periods replaced by underscores if the provider supports the 'controllable' feature" do
-    provider = stub 'provider', :controllable? => true, :class => Puppet::Type.type(:service).defaultprovider, :clear => nil
-    Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(provider)
+    provider = double('provider', :controllable? => true, :class => Puppet::Type.type(:service).defaultprovider, :clear => nil)
+    allow(Puppet::Type.type(:service).defaultprovider).to receive(:new).and_return(provider)
     svc = Puppet::Type.type(:service).new(:name => "nfs.client")
     expect(svc[:control]).to eq("NFS_CLIENT_START")
   end
@@ -196,14 +196,14 @@ describe test_title, "when retrieving the host's current state" do
   end
 
   it "should use the provider's status to determine whether the service is running" do
-    @service.provider.expects(:status).returns(:yepper)
+    expect(@service.provider).to receive(:status).and_return(:yepper)
     @service[:ensure] = :running
     expect(@service.property(:ensure).retrieve).to eq(:yepper)
   end
 
   it "should ask the provider whether it is enabled" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
-    @service.provider.expects(:enabled?).returns(:yepper)
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
+    expect(@service.provider).to receive(:enabled?).and_return(:yepper)
     @service[:enable] = true
     expect(@service.property(:enable).retrieve).to eq(:yepper)
   end
@@ -218,56 +218,56 @@ describe test_title, "when changing the host" do
 
   it "should start the service if it is supposed to be running" do
     @service[:ensure] = :running
-    @service.provider.expects(:start)
+    expect(@service.provider).to receive(:start)
     @service.property(:ensure).sync
   end
 
   it "should stop the service if it is supposed to be stopped" do
     @service[:ensure] = :stopped
-    @service.provider.expects(:stop)
+    expect(@service.provider).to receive(:stop)
     @service.property(:ensure).sync
   end
 
   it "should enable the service if it is supposed to be enabled" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
     @service[:enable] = true
-    @service.provider.expects(:enable)
+    expect(@service.provider).to receive(:enable)
     @service.property(:enable).sync
   end
 
   it "should disable the service if it is supposed to be disabled" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
     @service[:enable] = false
-    @service.provider.expects(:disable)
+    expect(@service.provider).to receive(:disable)
     @service.property(:enable).sync
   end
 
   it "should always consider the enable state of a static service to be in sync" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
-    @service.provider.expects(:cached_enabled?).returns('static')
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
+    expect(@service.provider).to receive(:cached_enabled?).and_return('static')
     @service[:enable] = false
-    Puppet.expects(:debug).with("Unable to enable or disable static service yay")
+    expect(Puppet).to receive(:debug).with("Unable to enable or disable static service yay")
     expect(@service.property(:enable).insync?(:true)).to eq(true)
   end
 
   it "should determine insyncness normally when the service is not static" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
-    @service.provider.expects(:cached_enabled?).returns('true')
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
+    expect(@service.provider).to receive(:cached_enabled?).and_return('true')
     @service[:enable] = true
-    Puppet.expects(:debug).never
+    expect(Puppet).not_to receive(:debug)
     expect(@service.property(:enable).insync?(:true)).to eq(true)
   end
 
   it "should sync the service's enable state when changing the state of :ensure if :enable is being managed" do
-    @service.provider.class.stubs(:supports_parameter?).returns(true)
+    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
     @service[:enable] = false
     @service[:ensure] = :stopped
 
-    @service.property(:enable).expects(:retrieve).returns("whatever")
-    @service.property(:enable).expects(:insync?).returns(false)
-    @service.property(:enable).expects(:sync)
+    expect(@service.property(:enable)).to receive(:retrieve).and_return("whatever")
+    expect(@service.property(:enable)).to receive(:insync?).and_return(false)
+    expect(@service.property(:enable)).to receive(:sync)
 
-    @service.provider.stubs(:stop)
+    allow(@service.provider).to receive(:stop)
 
     @service.property(:ensure).sync
   end
@@ -282,27 +282,27 @@ describe test_title, "when refreshing the service" do
 
   it "should restart the service if it is running" do
     @service[:ensure] = :running
-    @service.provider.expects(:status).returns(:running)
-    @service.provider.expects(:restart)
+    expect(@service.provider).to receive(:status).and_return(:running)
+    expect(@service.provider).to receive(:restart)
     @service.refresh
   end
 
   it "should restart the service if it is running, even if it is supposed to stopped" do
     @service[:ensure] = :stopped
-    @service.provider.expects(:status).returns(:running)
-    @service.provider.expects(:restart)
+    expect(@service.provider).to receive(:status).and_return(:running)
+    expect(@service.provider).to receive(:restart)
     @service.refresh
   end
 
   it "should not restart the service if it is not running" do
     @service[:ensure] = :running
-    @service.provider.expects(:status).returns(:stopped)
+    expect(@service.provider).to receive(:status).and_return(:stopped)
     @service.refresh
   end
 
   it "should add :ensure as a property if it is not being managed" do
-    @service.provider.expects(:status).returns(:running)
-    @service.provider.expects(:restart)
+    expect(@service.provider).to receive(:status).and_return(:running)
+    expect(@service.provider).to receive(:restart)
     @service.refresh
   end
 end

data/spec/unit/type/stage_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:stage) do

data/spec/unit/type/tidy_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_bucket/dipper'
 
@@ -9,7 +8,7 @@ describe tidy do
 
   before do
     @basepath = make_absolute("/what/ever")
-    Puppet.settings.stubs(:use)
+    allow(Puppet.settings).to receive(:use)
   end
 
   context "when normalizing 'path' on windows", :if => Puppet::Util::Platform.windows? do
@@ -21,8 +20,8 @@ describe tidy do
 
   it "should use :lstat when stating a file" do
     path = '/foo/bar'
-    stat = mock 'stat'
-    Puppet::FileSystem.expects(:lstat).with(path).returns stat
+    stat = double('stat')
+    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stat)
 
     resource = tidy.new :path => path, :age => "1d"
 
@@ -135,32 +134,32 @@ describe tidy do
   describe "when tidying" do
     before do
       @tidy = Puppet::Type.type(:tidy).new :path => @basepath
-      @stat = stub 'stat', :ftype => "directory"
+      @stat = double('stat', :ftype => "directory")
       lstat_is(@basepath, @stat)
     end
 
     describe "and generating files" do
       it "should set the backup on the file if backup is set on the tidy instance" do
         @tidy[:backup] = "whatever"
-        Puppet::Type.type(:file).expects(:new).with { |args| args[:backup] == "whatever" }
+        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(backup: "whatever"))
 
         @tidy.mkfile(@basepath)
       end
 
       it "should set the file's path to the tidy's path" do
-        Puppet::Type.type(:file).expects(:new).with { |args| args[:path] == @basepath }
+        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(path: @basepath))
 
         @tidy.mkfile(@basepath)
       end
 
       it "should configure the file for deletion" do
-        Puppet::Type.type(:file).expects(:new).with { |args| args[:ensure] == :absent }
+        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(ensure: :absent))
 
         @tidy.mkfile(@basepath)
       end
 
       it "should force deletion on the file" do
-        Puppet::Type.type(:file).expects(:new).with { |args| args[:force] == true }
+        expect(Puppet::Type.type(:file)).to receive(:new).with(hash_including(force: true))
 
         @tidy.mkfile(@basepath)
       end
@@ -174,16 +173,16 @@ describe tidy do
 
     describe "and recursion is not used" do
       it "should generate a file resource if the file should be tidied" do
-        @tidy.expects(:tidy?).with(@basepath).returns true
+        expect(@tidy).to receive(:tidy?).with(@basepath).and_return(true)
         file = Puppet::Type.type(:file).new(:path => @basepath+"/eh")
-        @tidy.expects(:mkfile).with(@basepath).returns file
+        expect(@tidy).to receive(:mkfile).with(@basepath).and_return(file)
 
         expect(@tidy.generate).to eq([file])
       end
 
       it "should do nothing if the file should not be tidied" do
-        @tidy.expects(:tidy?).with(@basepath).returns false
-        @tidy.expects(:mkfile).never
+        expect(@tidy).to receive(:tidy?).with(@basepath).and_return(false)
+        expect(@tidy).not_to receive(:mkfile)
 
         expect(@tidy.generate).to eq([])
       end
@@ -192,38 +191,38 @@ describe tidy do
     describe "and recursion is used" do
       before do
         @tidy[:recurse] = true
-        Puppet::FileServing::Fileset.any_instance.stubs(:stat).returns mock("stat")
+        allow_any_instance_of(Puppet::FileServing::Fileset).to receive(:stat).and_return(double("stat"))
         @fileset = Puppet::FileServing::Fileset.new(@basepath)
-        Puppet::FileServing::Fileset.stubs(:new).returns @fileset
+        allow(Puppet::FileServing::Fileset).to receive(:new).and_return(@fileset)
       end
 
       it "should use a Fileset for infinite recursion" do
-        Puppet::FileServing::Fileset.expects(:new).with(@basepath, :recurse => true).returns @fileset
-        @fileset.expects(:files).returns %w{. one two}
-        @tidy.stubs(:tidy?).returns false
+        expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true).and_return(@fileset)
+        expect(@fileset).to receive(:files).and_return(%w{. one two})
+        allow(@tidy).to receive(:tidy?).and_return(false)
 
         @tidy.generate
       end
 
       it "should use a Fileset for limited recursion" do
         @tidy[:recurse] = 42
-        Puppet::FileServing::Fileset.expects(:new).with(@basepath, :recurse => true, :recurselimit => 42).returns @fileset
-        @fileset.expects(:files).returns %w{. one two}
-        @tidy.stubs(:tidy?).returns false
+        expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true, :recurselimit => 42).and_return(@fileset)
+        expect(@fileset).to receive(:files).and_return(%w{. one two})
+        allow(@tidy).to receive(:tidy?).and_return(false)
 
         @tidy.generate
       end
 
       it "should generate a file resource for every file that should be tidied but not for files that should not be tidied" do
-        @fileset.expects(:files).returns %w{. one two}
+        expect(@fileset).to receive(:files).and_return(%w{. one two})
 
-        @tidy.expects(:tidy?).with(@basepath).returns true
-        @tidy.expects(:tidy?).with(@basepath+"/one").returns true
-        @tidy.expects(:tidy?).with(@basepath+"/two").returns false
+        expect(@tidy).to receive(:tidy?).with(@basepath).and_return(true)
+        expect(@tidy).to receive(:tidy?).with(@basepath+"/one").and_return(true)
+        expect(@tidy).to receive(:tidy?).with(@basepath+"/two").and_return(false)
 
         file = Puppet::Type.type(:file).new(:path => @basepath+"/eh")
-        @tidy.expects(:mkfile).with(@basepath).returns file
-        @tidy.expects(:mkfile).with(@basepath+"/one").returns file
+        expect(@tidy).to receive(:mkfile).with(@basepath).and_return(file)
+        expect(@tidy).to receive(:mkfile).with(@basepath+"/one").and_return(file)
 
         @tidy.generate
       end
@@ -234,7 +233,7 @@ describe tidy do
         @tidy = Puppet::Type.type(:tidy).new :path => @basepath, :recurse => 1
         @tidy[:matches] = %w{*foo* *bar*}
 
-        @stat = mock 'stat'
+        @stat = double('stat')
 
         @matcher = @tidy.parameter(:matches)
       end
@@ -258,7 +257,7 @@ describe tidy do
     describe "and determining whether a file is too old" do
       before do
         @tidy = Puppet::Type.type(:tidy).new :path => @basepath
-        @stat = stub 'stat'
+        @stat = double('stat')
 
         @tidy[:age] = "1s"
         @tidy[:type] = "mtime"
@@ -267,19 +266,19 @@ describe tidy do
 
       it "should use the age type specified" do
         @tidy[:type] = :ctime
-        @stat.expects(:ctime).returns(Time.now)
+        expect(@stat).to receive(:ctime).and_return(Time.now)
 
         @ager.tidy?(@basepath, @stat)
       end
 
       it "should return false if the file is more recent than the specified age" do
-        @stat.expects(:mtime).returns(Time.now)
+        expect(@stat).to receive(:mtime).and_return(Time.now)
 
         expect(@ager).not_to be_tidy(@basepath, @stat)
       end
 
       it "should return true if the file is older than the specified age" do
-        @stat.expects(:mtime).returns(Time.now - 10)
+        expect(@stat).to receive(:mtime).and_return(Time.now - 10)
 
         expect(@ager).to be_tidy(@basepath, @stat)
       end
@@ -288,26 +287,26 @@ describe tidy do
     describe "and determining whether a file is too large" do
       before do
         @tidy = Puppet::Type.type(:tidy).new :path => @basepath
-        @stat = stub 'stat', :ftype => "file"
+        @stat = double('stat', :ftype => "file")
 
         @tidy[:size] = "1kb"
         @sizer = @tidy.parameter(:size)
       end
 
       it "should return false if the file is smaller than the specified size" do
-        @stat.expects(:size).returns(4) # smaller than a kilobyte
+        expect(@stat).to receive(:size).and_return(4) # smaller than a kilobyte
 
         expect(@sizer).not_to be_tidy(@basepath, @stat)
       end
 
       it "should return true if the file is larger than the specified size" do
-        @stat.expects(:size).returns(1500) # larger than a kilobyte
+        expect(@stat).to receive(:size).and_return(1500) # larger than a kilobyte
 
         expect(@sizer).to be_tidy(@basepath, @stat)
       end
 
       it "should return true if the file is equal to the specified size" do
-        @stat.expects(:size).returns(1024)
+        expect(@stat).to receive(:size).and_return(1024)
 
         expect(@sizer).to be_tidy(@basepath, @stat)
       end
@@ -318,7 +317,7 @@ describe tidy do
         @tidy = Puppet::Type.type(:tidy).new :path => @basepath
         @catalog = Puppet::Resource::Catalog.new
         @tidy.catalog = @catalog
-        @stat = stub 'stat', :ftype => "file"
+        @stat = double('stat', :ftype => "file")
         lstat_is(@basepath, @stat)
       end
 
@@ -343,7 +342,7 @@ describe tidy do
       end
 
       it "should not be tidied if it is a directory and rmdirs is set to false" do
-        stat = mock 'stat', :ftype => "directory"
+        stat = double('stat', :ftype => "directory")
         lstat_is(@basepath, stat)
 
         expect(@tidy).not_to be_tidy(@basepath)
@@ -354,7 +353,7 @@ describe tidy do
         @tidy[:matches] = "globs"
 
         matches = @tidy.parameter(:matches)
-        matches.expects(:tidy?).with(@basepath, @stat).returns false
+        expect(matches).to receive(:tidy?).with(@basepath, @stat).and_return(false)
         expect(@tidy).not_to be_tidy(@basepath)
       end
 
@@ -362,7 +361,7 @@ describe tidy do
         @tidy[:age] = "1d"
 
         ager = @tidy.parameter(:age)
-        ager.expects(:tidy?).with(@basepath, @stat).returns false
+        expect(ager).to receive(:tidy?).with(@basepath, @stat).and_return(false)
         expect(@tidy).not_to be_tidy(@basepath)
       end
 
@@ -370,7 +369,7 @@ describe tidy do
         @tidy[:size] = "1b"
 
         sizer = @tidy.parameter(:size)
-        sizer.expects(:tidy?).with(@basepath, @stat).returns false
+        expect(sizer).to receive(:tidy?).with(@basepath, @stat).and_return(false)
         expect(@tidy).not_to be_tidy(@basepath)
       end
 
@@ -378,8 +377,8 @@ describe tidy do
         @tidy[:size] = "1b"
         @tidy[:age] = "1d"
 
-        @tidy.parameter(:size).stubs(:tidy?).returns true
-        @tidy.parameter(:age).stubs(:tidy?).returns false
+        allow(@tidy.parameter(:size)).to receive(:tidy?).and_return(true)
+        allow(@tidy.parameter(:age)).to receive(:tidy?).and_return(false)
         expect(@tidy).to be_tidy(@basepath)
       end
 
@@ -387,8 +386,8 @@ describe tidy do
         @tidy[:size] = "1b"
         @tidy[:age] = "1d"
 
-        @tidy.parameter(:size).stubs(:tidy?).returns false
-        @tidy.parameter(:age).stubs(:tidy?).returns true
+        allow(@tidy.parameter(:size)).to receive(:tidy?).and_return(false)
+        allow(@tidy.parameter(:age)).to receive(:tidy?).and_return(true)
         expect(@tidy).to be_tidy(@basepath)
       end
 
@@ -400,10 +399,10 @@ describe tidy do
         @tidy[:recurse] = true
         @tidy[:rmdirs] = true
         fileset = Puppet::FileServing::Fileset.new(@basepath)
-        Puppet::FileServing::Fileset.expects(:new).returns fileset
-        fileset.expects(:files).returns %w{. one one/two}
+        expect(Puppet::FileServing::Fileset).to receive(:new).and_return(fileset)
+        expect(fileset).to receive(:files).and_return(%w{. one one/two})
 
-        @tidy.stubs(:tidy?).returns true
+        allow(@tidy).to receive(:tidy?).and_return(true)
 
         expect(@tidy.generate.collect { |r| r[:path] }).to eq([@basepath+"/one/two", @basepath+"/one", @basepath])
       end
@@ -412,10 +411,10 @@ describe tidy do
     it "should configure directories to require their contained files if rmdirs is enabled, so the files will be deleted first" do
       @tidy[:recurse] = true
       @tidy[:rmdirs] = true
-      fileset = mock 'fileset'
-      Puppet::FileServing::Fileset.expects(:new).with(@basepath, :recurse => true).returns fileset
-      fileset.expects(:files).returns %w{. one two one/subone two/subtwo one/subone/ssone}
-      @tidy.stubs(:tidy?).returns true
+      fileset = double('fileset')
+      expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true).and_return(fileset)
+      expect(fileset).to receive(:files).and_return(%w{. one two one/subone two/subtwo one/subone/ssone})
+      allow(@tidy).to receive(:tidy?).and_return(true)
 
       result = @tidy.generate.inject({}) { |hash, res| hash[res[:path]] = res; hash }
       {
@@ -434,10 +433,10 @@ describe tidy do
     it "should configure directories to require their contained files in sorted order" do
       @tidy[:recurse] = true
       @tidy[:rmdirs] = true
-      fileset = mock 'fileset'
-      Puppet::FileServing::Fileset.expects(:new).with(@basepath, :recurse => true).returns fileset
-      fileset.expects(:files).returns %w{. a a/2 a/1 a/3}
-      @tidy.stubs(:tidy?).returns true
+      fileset = double('fileset')
+      expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true).and_return(fileset)
+      expect(fileset).to receive(:files).and_return(%w{. a a/2 a/1 a/3})
+      allow(@tidy).to receive(:tidy?).and_return(true)
 
       result = @tidy.generate.inject({}) { |hash, res| hash[res[:path]] = res; hash }
       expect(result[@basepath + '/a'][:require].collect{|a| a.name[('File//a/' + @basepath).length..-1]}.join()).to eq('321')
@@ -447,10 +446,10 @@ describe tidy do
       @tidy[:recurse] = true
       @tidy[:noop] = true
 
-      fileset = mock 'fileset'
-      Puppet::FileServing::Fileset.expects(:new).with(@basepath, :recurse => true).returns fileset
-      fileset.expects(:files).returns %w{. a a/2 a/1 a/3}
-      @tidy.stubs(:tidy?).returns true
+      fileset = double('fileset')
+      expect(Puppet::FileServing::Fileset).to receive(:new).with(@basepath, :recurse => true).and_return(fileset)
+      expect(fileset).to receive(:files).and_return(%w{. a a/2 a/1 a/3})
+      allow(@tidy).to receive(:tidy?).and_return(true)
 
       result = @tidy.generate.inject({}) { |hash, res| hash[res[:path]] = res; hash }
 
@@ -459,10 +458,10 @@ describe tidy do
   end
 
   def lstat_is(path, stat)
-    Puppet::FileSystem.stubs(:lstat).with(path).returns(stat)
+    allow(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stat)
   end
 
   def lstat_raises(path, error_class)
-    Puppet::FileSystem.expects(:lstat).with(path).raises Errno::ENOENT
+    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_raise(Errno::ENOENT)
   end
 end