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

data/spec/unit/type/service_spec.rb

@@ -1,6 +1,22 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:service) do
+def safely_load_service_type
+  before(:each) do
+    # We have a :confine block that calls execute in our upstart provider, which fails
+    # 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)
+    Puppet::Type.type(:service)
+  end
+end
+
+test_title = 'Puppet::Type::Service'
+
+describe test_title do
+  safely_load_service_type
+
   it "should have an :enableable feature that requires the :enable, :disable, and :enabled? methods" do
     expect(Puppet::Type.type(:service).provider_feature(:enableable).methods).to eq([:disable, :enable, :enabled?])
   end
@@ -10,7 +26,9 @@ describe Puppet::Type.type(:service) do
   end
 end
 
-describe Puppet::Type.type(:service), "when validating attributes" do
+describe test_title, "when validating attributes" do
+  safely_load_service_type
+
   [:name, :binary, :hasstatus, :path, :pattern, :start, :restart, :stop, :status, :hasrestart, :control].each do |param|
     it "should have a #{param} parameter" do
       expect(Puppet::Type.type(:service).attrtype(param)).to eq(:param)
@@ -24,10 +42,12 @@ describe Puppet::Type.type(:service), "when validating attributes" do
   end
 end
 
-describe Puppet::Type.type(:service), "when validating attribute values" do
+describe test_title, "when validating attribute values" do
+  safely_load_service_type
+
   before do
-    @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)
+    @provider = stub 'provider', :class => Puppet::Type.type(:service).defaultprovider, :clear => nil, :controllable? => false
+    Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(@provider)
   end
 
   it "should support :running as a value to :ensure" do
@@ -50,9 +70,8 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
 
   describe "the enable property" do
     before :each do
-      allow(@provider.class).to receive(:supports_parameter?).and_return(true)
+      @provider.class.stubs(:supports_parameter?).returns 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)
@@ -69,36 +88,19 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
     end
 
     it "should support :manual as a value on Windows" do
-      allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
-
+      Puppet::Util::Platform.stubs(:windows?).returns true
       srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :manual)
       expect(srv.should(:enable)).to eq(:manual)
     end
 
-    it "should support :delayed as a value on Windows" do
-      allow(Puppet.features).to receive(:microsoft_windows?).and_return(true)
-
-      srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :delayed)
-      expect(srv.should(:enable)).to eq(:delayed)
-    end
-
     it "should not support :manual as a value when not on Windows" do
-      allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
+      Puppet::Util::Platform.stubs(:windows?).returns false
 
       expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :manual) }.to raise_error(
         Puppet::Error,
         /Setting enable to manual is only supported on Microsoft Windows\./
       )
     end
-
-    it "should not support :delayed as a value when not on Windows" do
-      allow(Puppet.features).to receive(:microsoft_windows?).and_return(false)
-
-      expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :delayed) }.to raise_error(
-        Puppet::Error,
-        /Setting enable to delayed is only supported on Microsoft Windows\./
-      )
-    end
   end
 
   it "should support :true as a value to :hasstatus" do
@@ -127,41 +129,43 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
   end
 
   it "should allow setting the :enable parameter if the provider has the :enableable feature" do
-    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)
+    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)
     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
-    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)
+    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)
     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
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-    allow(FileTest).to receive(:directory?).and_return(true)
+    Puppet::FileSystem.stubs(:exist?).returns(true)
+    FileTest.stubs(:directory?).returns(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
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-    allow(FileTest).to receive(:directory?).and_return(true)
+    Puppet::FileSystem.stubs(:exist?).returns(true)
+    FileTest.stubs(:directory?).returns(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
 end
 
-describe Puppet::Type.type(:service), "when setting default attribute values" do
+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
-    allow(FileTest).to receive(:directory?).and_return(true)
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+    FileTest.stubs(:directory?).returns(true)
+    Puppet::FileSystem.stubs(:exist?).returns(true)
 
-    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")
+    Puppet::Type.type(:service).defaultprovider.stubs(:respond_to?).returns(true)
+    Puppet::Type.type(:service).defaultprovider.stubs(:defpath).returns("testing")
     svc = Puppet::Type.type(:service).new(:name => "other")
     expect(svc[:path]).to eq(["testing"])
   end
@@ -177,123 +181,128 @@ describe Puppet::Type.type(:service), "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 = double('provider', :controllable? => true, :class => Puppet::Type.type(:service).defaultprovider, :clear => nil)
-    allow(Puppet::Type.type(:service).defaultprovider).to receive(:new).and_return(provider)
+    provider = stub 'provider', :controllable? => true, :class => Puppet::Type.type(:service).defaultprovider, :clear => nil
+    Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(provider)
     svc = Puppet::Type.type(:service).new(:name => "nfs.client")
     expect(svc[:control]).to eq("NFS_CLIENT_START")
   end
 end
 
-describe Puppet::Type.type(:service), "when retrieving the host's current state" do
+describe test_title, "when retrieving the host's current state" do
+  safely_load_service_type
+
   before do
     @service = Puppet::Type.type(:service).new(:name => "yay")
   end
 
   it "should use the provider's status to determine whether the service is running" do
-    expect(@service.provider).to receive(:status).and_return(:yepper)
+    @service.provider.expects(:status).returns(:yepper)
     @service[:ensure] = :running
     expect(@service.property(:ensure).retrieve).to eq(:yepper)
   end
 
   it "should ask the provider whether it is enabled" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    expect(@service.provider).to receive(:enabled?).and_return(:yepper)
+    @service.provider.class.stubs(:supports_parameter?).returns(true)
+    @service.provider.expects(:enabled?).returns(:yepper)
     @service[:enable] = true
     expect(@service.property(:enable).retrieve).to eq(:yepper)
   end
 end
 
-describe Puppet::Type.type(:service), "when changing the host" do
+describe test_title, "when changing the host" do
+  safely_load_service_type
+
   before do
     @service = Puppet::Type.type(:service).new(:name => "yay")
   end
 
   it "should start the service if it is supposed to be running" do
     @service[:ensure] = :running
-    expect(@service.provider).to receive(:start)
+    @service.provider.expects(:start)
     @service.property(:ensure).sync
   end
 
   it "should stop the service if it is supposed to be stopped" do
     @service[:ensure] = :stopped
-    expect(@service.provider).to receive(:stop)
+    @service.provider.expects(:stop)
     @service.property(:ensure).sync
   end
 
   it "should enable the service if it is supposed to be enabled" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
+    @service.provider.class.stubs(:supports_parameter?).returns(true)
     @service[:enable] = true
-    expect(@service.provider).to receive(:enable)
+    @service.provider.expects(:enable)
     @service.property(:enable).sync
   end
 
   it "should disable the service if it is supposed to be disabled" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
+    @service.provider.class.stubs(:supports_parameter?).returns(true)
     @service[:enable] = false
-    expect(@service.provider).to receive(:disable)
+    @service.provider.expects(:disable)
     @service.property(:enable).sync
   end
 
-  it "should let superclass implementation resolve insyncness when provider does not respond to the 'enabled_insync?' method" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
-    @service[:enable] = true
-    allow(@service.provider).to receive(:respond_to?).with(:enabled_insync?).and_return(false)
-
+  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')
+    @service[:enable] = false
+    Puppet.expects(:debug).with("Unable to enable or disable static service yay")
     expect(@service.property(:enable).insync?(:true)).to eq(true)
   end
 
-  it "insyncness should be resolved by provider instead of superclass implementation when provider responds to the 'enabled_insync?' method" do
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
+  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')
     @service[:enable] = true
-    allow(@service.provider).to receive(:respond_to?).with(:enabled_insync?).and_return(true)
-    allow(@service.provider).to receive(:enabled_insync?).and_return(false)
-
-    expect(@service.property(:enable).insync?(:true)).to eq(false)
+    Puppet.expects(:debug).never
+    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
-    allow(@service.provider.class).to receive(:supports_parameter?).and_return(true)
+    @service.provider.class.stubs(:supports_parameter?).returns(true)
     @service[:enable] = false
     @service[:ensure] = :stopped
 
-    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.property(:enable).expects(:retrieve).returns("whatever")
+    @service.property(:enable).expects(:insync?).returns(false)
+    @service.property(:enable).expects(:sync)
 
-    allow(@service.provider).to receive(:stop)
+    @service.provider.stubs(:stop)
 
     @service.property(:ensure).sync
   end
 end
 
-describe Puppet::Type.type(:service), "when refreshing the service" do
+describe test_title, "when refreshing the service" do
+  safely_load_service_type
+
   before do
     @service = Puppet::Type.type(:service).new(:name => "yay")
   end
 
   it "should restart the service if it is running" do
     @service[:ensure] = :running
-    expect(@service.provider).to receive(:status).and_return(:running)
-    expect(@service.provider).to receive(:restart)
+    @service.provider.expects(:status).returns(:running)
+    @service.provider.expects(:restart)
     @service.refresh
   end
 
   it "should restart the service if it is running, even if it is supposed to stopped" do
     @service[:ensure] = :stopped
-    expect(@service.provider).to receive(:status).and_return(:running)
-    expect(@service.provider).to receive(:restart)
+    @service.provider.expects(:status).returns(:running)
+    @service.provider.expects(:restart)
     @service.refresh
   end
 
   it "should not restart the service if it is not running" do
     @service[:ensure] = :running
-    expect(@service.provider).to receive(:status).and_return(:stopped)
+    @service.provider.expects(:status).returns(:stopped)
     @service.refresh
   end
 
   it "should add :ensure as a property if it is not being managed" do
-    expect(@service.provider).to receive(:status).and_return(:running)
-    expect(@service.provider).to receive(:restart)
+    @service.provider.expects(:status).returns(:running)
+    @service.provider.expects(:restart)
     @service.refresh
   end
 end

data/spec/unit/type/stage_spec.rb

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

data/spec/unit/type/tidy_spec.rb

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