puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/type/scheduled_task_spec.rb

@@ -4,29 +4,29 @@ require 'spec_helper'
 describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_windows? do
 
   it 'should use name as the namevar' do
-    described_class.new(
+    expect(described_class.new(
       :title   => 'Foo',
       :command => 'C:\Windows\System32\notepad.exe'
-    ).name.must == 'Foo'
+    ).name).to eq('Foo')
   end
 
   describe 'when setting the command' do
     it 'should accept an absolute path to the command' do
-      described_class.new(:name => 'Test Task', :command => 'C:\Windows\System32\notepad.exe')[:command].should == 'C:\Windows\System32\notepad.exe'
+      expect(described_class.new(:name => 'Test Task', :command => 'C:\Windows\System32\notepad.exe')[:command]).to eq('C:\Windows\System32\notepad.exe')
     end
 
     it 'should convert forward slashes to backslashes' do
-      described_class.new(
+      expect(described_class.new(
         :name      => 'Test Task',
         :command   => 'C:/Windows/System32/notepad.exe'
-      )[:command].should == 'C:\Windows\System32\notepad.exe'
+      )[:command]).to eq('C:\Windows\System32\notepad.exe')
     end
 
     it 'should normalize backslashes' do
-      described_class.new(
+      expect(described_class.new(
         :name      => 'Test Task',
         :command   => 'C:\Windows\\System32\\\\notepad.exe'
-      )[:command].should == 'C:\Windows\System32\notepad.exe'
+      )[:command]).to eq('C:\Windows\System32\notepad.exe')
     end
 
     it 'should fail if the path to the command is not absolute' do
@@ -41,18 +41,18 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
 
   describe 'when setting the command arguments' do
     it 'should accept a string' do
-      described_class.new(
+      expect(described_class.new(
         :name      => 'Test Task',
         :command   => 'C:\Windows\System32\notepad.exe',
         :arguments => '/a /b /c'
-      )[:arguments].should == '/a /b /c'
+      )[:arguments]).to eq('/a /b /c')
     end
 
     it 'should allow not specifying any command arguments' do
-      described_class.new(
+      expect(described_class.new(
         :name    => 'Test Task',
         :command => 'C:\Windows\System32\notepad.exe'
-      )[:arguments].should_not be
+      )[:arguments]).not_to be
     end
   end
 
@@ -61,11 +61,11 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
 
   describe 'when setting the working directory' do
     it 'should accept an absolute path to the working directory' do
-      described_class.new(
+      expect(described_class.new(
         :name        => 'Test Task',
         :command     => 'C:\Windows\System32\notepad.exe',
         :working_dir => 'C:\Windows\System32'
-      )[:working_dir].should == 'C:\Windows\System32'
+      )[:working_dir]).to eq('C:\Windows\System32')
     end
 
     it 'should fail if the path to the working directory is not absolute' do
@@ -82,10 +82,10 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
     end
 
     it 'should allow not specifying any working directory' do
-      described_class.new(
+      expect(described_class.new(
         :name    => 'Test Task',
         :command => 'C:\Windows\System32\notepad.exe'
-      )[:working_dir].should_not be
+      )[:working_dir]).not_to be
     end
   end
 

data/spec/unit/type/selboolean_spec.rb

@@ -4,12 +4,12 @@ require 'spec_helper'
 describe Puppet::Type.type(:selboolean), "when validating attributes" do
   [:name, :persistent].each do |param|
     it "should have a #{param} parameter" do
-      Puppet::Type.type(:selboolean).attrtype(param).should == :param
+      expect(Puppet::Type.type(:selboolean).attrtype(param)).to eq(:param)
     end
   end
 
   it "should have a value property" do
-    Puppet::Type.type(:selboolean).attrtype(:value).should == :property
+    expect(Puppet::Type.type(:selboolean).attrtype(:value)).to eq(:property)
   end
 end
 

data/spec/unit/type/selmodule_spec.rb

@@ -4,13 +4,13 @@ require 'spec_helper'
 describe Puppet::Type.type(:selmodule), "when validating attributes" do
   [:name, :selmoduledir, :selmodulepath].each do |param|
     it "should have a #{param} parameter" do
-      Puppet::Type.type(:selmodule).attrtype(param).should == :param
+      expect(Puppet::Type.type(:selmodule).attrtype(param)).to eq(:param)
     end
   end
 
   [:ensure, :syncversion].each do |param|
     it "should have a #{param} property" do
-      Puppet::Type.type(:selmodule).attrtype(param).should == :property
+      expect(Puppet::Type.type(:selmodule).attrtype(param)).to eq(:property)
     end
   end
 end

data/spec/unit/type/service_spec.rb

@@ -3,24 +3,24 @@ require 'spec_helper'
 
 describe Puppet::Type.type(:service) do
   it "should have an :enableable feature that requires the :enable, :disable, and :enabled? methods" do
-    Puppet::Type.type(:service).provider_feature(:enableable).methods.should == [:disable, :enable, :enabled?]
+    expect(Puppet::Type.type(:service).provider_feature(:enableable).methods).to eq([:disable, :enable, :enabled?])
   end
 
   it "should have a :refreshable feature that requires the :restart method" do
-    Puppet::Type.type(:service).provider_feature(:refreshable).methods.should == [:restart]
+    expect(Puppet::Type.type(:service).provider_feature(:refreshable).methods).to eq([:restart])
   end
 end
 
 describe Puppet::Type.type(:service), "when validating attributes" do
   [:name, :binary, :hasstatus, :path, :pattern, :start, :restart, :stop, :status, :hasrestart, :control].each do |param|
     it "should have a #{param} parameter" do
-      Puppet::Type.type(:service).attrtype(param).should == :param
+      expect(Puppet::Type.type(:service).attrtype(param)).to eq(:param)
     end
   end
 
   [:ensure, :enable].each do |param|
     it "should have an #{param} property" do
-      Puppet::Type.type(:service).attrtype(param).should == :property
+      expect(Puppet::Type.type(:service).attrtype(param)).to eq(:property)
     end
   end
 end
@@ -41,12 +41,12 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
 
   it "should alias the value :true to :running in :ensure" do
     svc = Puppet::Type.type(:service).new(:name => "yay", :ensure => true)
-    svc.should(:ensure).should == :running
+    expect(svc.should(:ensure)).to eq(:running)
   end
 
   it "should alias the value :false to :stopped in :ensure" do
     svc = Puppet::Type.type(:service).new(:name => "yay", :ensure => false)
-    svc.should(:ensure).should == :stopped
+    expect(svc.should(:ensure)).to eq(:stopped)
   end
 
   describe "the enable property" do
@@ -55,19 +55,19 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
     end
     it "should support :true as a value" do
       srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :true)
-      srv.should(:enable).should == :true
+      expect(srv.should(:enable)).to eq(:true)
     end
 
     it "should support :false as a value" do
       srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :false)
-      srv.should(:enable).should == :false
+      expect(srv.should(:enable)).to eq(:false)
     end
 
     it "should support :manual as a value on Windows" do
       Puppet.features.stubs(:microsoft_windows?).returns true
 
       srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :manual)
-      srv.should(:enable).should == :manual
+      expect(srv.should(:enable)).to eq(:manual)
     end
 
     it "should not support :manual as a value when not on Windows" do
@@ -82,55 +82,55 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
 
   it "should support :true as a value to :hasstatus" do
     srv = Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :true)
-    srv[:hasstatus].should == :true
+    expect(srv[:hasstatus]).to eq(:true)
   end
 
   it "should support :false as a value to :hasstatus" do
     srv = Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :false)
-    srv[:hasstatus].should == :false
+    expect(srv[:hasstatus]).to eq(:false)
   end
 
   it "should specify :true as the default value of hasstatus" do
     srv = Puppet::Type.type(:service).new(:name => "yay")
-    srv[:hasstatus].should == :true
+    expect(srv[:hasstatus]).to eq(:true)
   end
 
   it "should support :true as a value to :hasrestart" do
     srv = Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :true)
-    srv[:hasrestart].should == :true
+    expect(srv[:hasrestart]).to eq(:true)
   end
 
   it "should support :false as a value to :hasrestart" do
     srv = Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :false)
-    srv[:hasrestart].should == :false
+    expect(srv[:hasrestart]).to eq(:false)
   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)
     svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
-    svc.should(:enable).should == :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)
     svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
-    svc.should(:enable).should be_nil
+    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)
     svc = Puppet::Type.type(:service).new(:name => "yay", :path => "/one/two#{File::PATH_SEPARATOR}/three/four")
-    svc[:path].should == %w{/one/two /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)
     svc = Puppet::Type.type(:service).new(:name => "yay", :path => ["/one#{File::PATH_SEPARATOR}/two", "/three#{File::PATH_SEPARATOR}/four"])
-    svc[:path].should == %w{/one /two /three /four}
+    expect(svc[:path]).to eq(%w{/one /two /three /four})
   end
 end
 
@@ -142,24 +142,24 @@ describe Puppet::Type.type(:service), "when setting default attribute values" do
     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")
-    svc[:path].should == ["testing"]
+    expect(svc[:path]).to eq(["testing"])
   end
 
   it "should default 'pattern' to the binary if one is provided" do
     svc = Puppet::Type.type(:service).new(:name => "other", :binary => "/some/binary")
-    svc[:pattern].should == "/some/binary"
+    expect(svc[:pattern]).to eq("/some/binary")
   end
 
   it "should default 'pattern' to the name if no pattern is provided" do
     svc = Puppet::Type.type(:service).new(:name => "other")
-    svc[:pattern].should == "other"
+    expect(svc[:pattern]).to eq("other")
   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)
     svc = Puppet::Type.type(:service).new(:name => "nfs.client")
-    svc[:control].should == "NFS_CLIENT_START"
+    expect(svc[:control]).to eq("NFS_CLIENT_START")
   end
 end
 
@@ -171,14 +171,14 @@ describe Puppet::Type.type(:service), "when retrieving the host's current state"
   it "should use the provider's status to determine whether the service is running" do
     @service.provider.expects(:status).returns(:yepper)
     @service[:ensure] = :running
-    @service.property(:ensure).retrieve.should == :yepper
+    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)
     @service[:enable] = true
-    @service.property(:enable).retrieve.should == :yepper
+    expect(@service.property(:enable).retrieve).to eq(:yepper)
   end
 end
 

data/spec/unit/type/ssh_authorized_key_spec.rb

@@ -188,7 +188,7 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
       it "informs about an absent user" do
         Puppet::Log.level = :debug
         described_class.new(:name => "whev", :user => 'idontexist').should(:target)
-        @logs.map(&:message).should include("The required user is not yet present on the system")
+        expect(@logs.map(&:message)).to include("The required user is not yet present on the system")
       end
 
     end
@@ -245,7 +245,7 @@ describe Puppet::Type.type(:ssh_authorized_key), :unless => Puppet.features.micr
 
   describe "when calling validate" do
 
-    it "doesn't crash on a non-existant user" do
+    it "doesn't crash on a non-existent user" do
       resource = described_class.new(
         :name   => "Test",
         :user   => "ihopesuchuserdoesnotexist"

data/spec/unit/type/stage_spec.rb

@@ -3,6 +3,6 @@ require 'spec_helper'
 
 describe Puppet::Type.type(:stage) do
   it "should have a 'name' parameter'" do
-    Puppet::Type.type(:stage).new(:name => :foo)[:name].should == :foo
+    expect(Puppet::Type.type(:stage).new(:name => :foo)[:name]).to eq(:foo)
   end
 end

data/spec/unit/type/tidy_spec.rb

@@ -12,6 +12,13 @@ describe tidy do
     Puppet.settings.stubs(:use)
   end
 
+  context "when normalizing 'path' on windows", :if => Puppet.features.microsoft_windows? do
+    it "replaces backslashes with forward slashes" do
+      resource = tidy.new(:path => 'c:\directory')
+      expect(resource[:path]).to eq('c:/directory')
+    end
+  end
+
   it "should use :lstat when stating a file" do
     path = '/foo/bar'
     stat = mock 'stat'
@@ -19,16 +26,16 @@ describe tidy do
 
     resource = tidy.new :path => path, :age => "1d"
 
-    resource.stat(path).should == stat
+    expect(resource.stat(path)).to eq(stat)
   end
 
   [:age, :size, :path, :matches, :type, :recurse, :rmdirs].each do |param|
     it "should have a #{param} parameter" do
-      Puppet::Type.type(:tidy).attrclass(param).ancestors.should be_include(Puppet::Parameter)
+      expect(Puppet::Type.type(:tidy).attrclass(param).ancestors).to be_include(Puppet::Parameter)
     end
 
     it "should have documentation for its #{param} param" do
-      Puppet::Type.type(:tidy).attrclass(param).doc.should be_instance_of(String)
+      expect(Puppet::Type.type(:tidy).attrclass(param).doc).to be_instance_of(String)
     end
   end
 
@@ -39,27 +46,27 @@ describe tidy do
       end
 
       it "should allow 'true'" do
-        lambda { @tidy[:recurse] = true }.should_not raise_error
+        expect { @tidy[:recurse] = true }.not_to raise_error
       end
 
       it "should allow 'false'" do
-        lambda { @tidy[:recurse] = false }.should_not raise_error
+        expect { @tidy[:recurse] = false }.not_to raise_error
       end
 
       it "should allow integers" do
-        lambda { @tidy[:recurse] = 10 }.should_not raise_error
+        expect { @tidy[:recurse] = 10 }.not_to raise_error
       end
 
       it "should allow string representations of integers" do
-        lambda { @tidy[:recurse] = "10" }.should_not raise_error
+        expect { @tidy[:recurse] = "10" }.not_to raise_error
       end
 
       it "should allow 'inf'" do
-        lambda { @tidy[:recurse] = "inf" }.should_not raise_error
+        expect { @tidy[:recurse] = "inf" }.not_to raise_error
       end
 
       it "should not allow arbitrary values" do
-        lambda { @tidy[:recurse] = "whatever" }.should raise_error
+        expect { @tidy[:recurse] = "whatever" }.to raise_error
       end
     end
 
@@ -69,19 +76,19 @@ describe tidy do
       end
 
       it "should object if matches is given with recurse is not specified" do
-        lambda { @tidy[:matches] = '*.doh' }.should raise_error
+        expect { @tidy[:matches] = '*.doh' }.to raise_error
       end
       it "should object if matches is given and recurse is 0" do
-        lambda { @tidy[:recurse] = 0; @tidy[:matches] = '*.doh' }.should raise_error
+        expect { @tidy[:recurse] = 0; @tidy[:matches] = '*.doh' }.to raise_error
       end
       it "should object if matches is given and recurse is false" do
-        lambda { @tidy[:recurse] = false; @tidy[:matches] = '*.doh' }.should raise_error
+        expect { @tidy[:recurse] = false; @tidy[:matches] = '*.doh' }.to raise_error
       end
       it "should not object if matches is given and recurse is > 0" do
-        lambda { @tidy[:recurse] = 1; @tidy[:matches] = '*.doh' }.should_not raise_error
+        expect { @tidy[:recurse] = 1; @tidy[:matches] = '*.doh' }.not_to raise_error
       end
       it "should not object if matches is given and recurse is true" do
-        lambda { @tidy[:recurse] = true; @tidy[:matches] = '*.doh' }.should_not raise_error
+        expect { @tidy[:recurse] = true; @tidy[:matches] = '*.doh' }.not_to raise_error
       end
     end
   end
@@ -100,7 +107,7 @@ describe tidy do
       it "should consider a #{unit} to be #{multiple} seconds" do
         @tidy = Puppet::Type.type(:tidy).new :path => @basepath, :age => "5#{unit.to_s[0..0]}"
 
-        @tidy[:age].should == 5 * multiple
+        expect(@tidy[:age]).to eq(5 * multiple)
       end
     end
   end
@@ -120,7 +127,7 @@ describe tidy do
 
         total = 5
         multiple.times { total *= 1024 }
-        @tidy[:size].should == total
+        expect(@tidy[:size]).to eq(total)
       end
     end
   end
@@ -161,7 +168,7 @@ describe tidy do
       it "should do nothing if the targeted file does not exist" do
         lstat_raises(@basepath, Errno::ENOENT)
 
-        @tidy.generate.should == []
+        expect(@tidy.generate).to eq([])
       end
     end
 
@@ -171,14 +178,14 @@ describe tidy do
         file = Puppet::Type.type(:file).new(:path => @basepath+"/eh")
         @tidy.expects(:mkfile).with(@basepath).returns file
 
-        @tidy.generate.should == [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
 
-        @tidy.generate.should == []
+        expect(@tidy.generate).to eq([])
       end
     end
 
@@ -234,17 +241,17 @@ describe tidy do
 
       it "should always convert the globs to an array" do
         @matcher.value = "*foo*"
-        @matcher.value.should == %w{*foo*}
+        expect(@matcher.value).to eq(%w{*foo*})
       end
 
       it "should return true if any pattern matches the last part of the file" do
         @matcher.value = %w{*foo* *bar*}
-        @matcher.must be_tidy("/file/yaybarness", @stat)
+        expect(@matcher).to be_tidy("/file/yaybarness", @stat)
       end
 
       it "should return false if no pattern matches the last part of the file" do
         @matcher.value = %w{*foo* *bar*}
-        @matcher.should_not be_tidy("/file/yayness", @stat)
+        expect(@matcher).not_to be_tidy("/file/yayness", @stat)
       end
     end
 
@@ -268,13 +275,13 @@ describe tidy do
       it "should return false if the file is more recent than the specified age" do
         @stat.expects(:mtime).returns(Time.now)
 
-        @ager.should_not be_tidy(@basepath, @stat)
+        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)
 
-        @ager.must be_tidy(@basepath, @stat)
+        expect(@ager).to be_tidy(@basepath, @stat)
       end
     end
 
@@ -290,19 +297,19 @@ describe tidy do
       it "should return false if the file is smaller than the specified size" do
         @stat.expects(:size).returns(4) # smaller than a kilobyte
 
-        @sizer.should_not be_tidy(@basepath, @stat)
+        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
 
-        @sizer.must be_tidy(@basepath, @stat)
+        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)
 
-        @sizer.must be_tidy(@basepath, @stat)
+        expect(@sizer).to be_tidy(@basepath, @stat)
       end
     end
 
@@ -318,26 +325,26 @@ describe tidy do
 
         lstat_is(@basepath, nil)
 
-        @tidy.generate.should == []
+        expect(@tidy.generate).to eq([])
       end
 
       it "should not be tidied if the file does not exist" do
         lstat_raises(@basepath, Errno::ENOENT)
 
-        @tidy.should_not be_tidy(@basepath)
+        expect(@tidy).not_to be_tidy(@basepath)
       end
 
       it "should not be tidied if the user has no access to the file" do
         lstat_raises(@basepath, Errno::EACCES)
 
-        @tidy.should_not be_tidy(@basepath)
+        expect(@tidy).not_to be_tidy(@basepath)
       end
 
       it "should not be tidied if it is a directory and rmdirs is set to false" do
         stat = mock 'stat', :ftype => "directory"
         lstat_is(@basepath, stat)
 
-        @tidy.should_not be_tidy(@basepath)
+        expect(@tidy).not_to be_tidy(@basepath)
       end
 
       it "should return false if it does not match any provided globs" do
@@ -346,7 +353,7 @@ describe tidy do
 
         matches = @tidy.parameter(:matches)
         matches.expects(:tidy?).with(@basepath, @stat).returns false
-        @tidy.should_not be_tidy(@basepath)
+        expect(@tidy).not_to be_tidy(@basepath)
       end
 
       it "should return false if it does not match aging requirements" do
@@ -354,7 +361,7 @@ describe tidy do
 
         ager = @tidy.parameter(:age)
         ager.expects(:tidy?).with(@basepath, @stat).returns false
-        @tidy.should_not be_tidy(@basepath)
+        expect(@tidy).not_to be_tidy(@basepath)
       end
 
       it "should return false if it does not match size requirements" do
@@ -362,7 +369,7 @@ describe tidy do
 
         sizer = @tidy.parameter(:size)
         sizer.expects(:tidy?).with(@basepath, @stat).returns false
-        @tidy.should_not be_tidy(@basepath)
+        expect(@tidy).not_to be_tidy(@basepath)
       end
 
       it "should tidy a file if age and size are set but only size matches" do
@@ -371,7 +378,7 @@ describe tidy do
 
         @tidy.parameter(:size).stubs(:tidy?).returns true
         @tidy.parameter(:age).stubs(:tidy?).returns false
-        @tidy.must be_tidy(@basepath)
+        expect(@tidy).to be_tidy(@basepath)
       end
 
       it "should tidy a file if age and size are set but only age matches" do
@@ -380,11 +387,11 @@ describe tidy do
 
         @tidy.parameter(:size).stubs(:tidy?).returns false
         @tidy.parameter(:age).stubs(:tidy?).returns true
-        @tidy.must be_tidy(@basepath)
+        expect(@tidy).to be_tidy(@basepath)
       end
 
       it "should tidy all files if neither age nor size is set" do
-        @tidy.must be_tidy(@basepath)
+        expect(@tidy).to be_tidy(@basepath)
       end
 
       it "should sort the results inversely by path length, so files are added to the catalog before their directories" do
@@ -396,7 +403,7 @@ describe tidy do
 
         @tidy.stubs(:tidy?).returns true
 
-        @tidy.generate.collect { |r| r[:path] }.should == [@basepath+"/one/two", @basepath+"/one", @basepath]
+        expect(@tidy.generate.collect { |r| r[:path] }).to eq([@basepath+"/one/two", @basepath+"/one", @basepath])
       end
     end
 
@@ -417,10 +424,22 @@ describe tidy do
       }.each do |parent, children|
         children.each do |child|
           ref = Puppet::Resource.new(:file, child)
-          result[parent][:require].find { |req| req.to_s == ref.to_s }.should_not be_nil
+          expect(result[parent][:require].find { |req| req.to_s == ref.to_s }).not_to be_nil
         end
       end
     end
+
+    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
+
+      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')
+    end
   end
 
   def lstat_is(path, stat)