puppet 5.5.22 → 6.0.0

data/spec/unit/file_serving/configuration_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/configuration'
@@ -24,16 +25,17 @@ describe Puppet::FileServing::Configuration do
   end
 
   describe "when initializing" do
+
     it "should work without a configuration file" do
-      allow(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(false)
+      Puppet::FileSystem.stubs(:exist?).with(@path).returns(false)
       expect { Puppet::FileServing::Configuration.configuration }.to_not raise_error
     end
 
     it "should parse the configuration file if present" do
-      allow(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
-      @parser = double('parser')
-      expect(@parser).to receive(:parse).and_return({})
-      allow(Puppet::FileServing::Configuration::Parser).to receive(:new).and_return(@parser)
+      Puppet::FileSystem.stubs(:exist?).with(@path).returns(true)
+      @parser = mock 'parser'
+      @parser.expects(:parse).returns({})
+      Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
       Puppet::FileServing::Configuration.configuration
     end
 
@@ -43,37 +45,38 @@ describe Puppet::FileServing::Configuration do
   end
 
   describe "when parsing the configuration file" do
+
     before do
-      allow(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
-      @parser = double('parser')
-      allow(Puppet::FileServing::Configuration::Parser).to receive(:new).and_return(@parser)
+      Puppet::FileSystem.stubs(:exist?).with(@path).returns(true)
+      @parser = mock 'parser'
+      Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
     end
 
     it "should set the mount list to the results of parsing" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
+      @parser.expects(:parse).returns("one" => mock("mount"))
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("one")).to be_truthy
     end
 
     it "should not raise exceptions" do
-      expect(@parser).to receive(:parse).and_raise(ArgumentError)
+      @parser.expects(:parse).raises(ArgumentError)
       expect { Puppet::FileServing::Configuration.configuration }.to_not raise_error
     end
 
     it "should replace the existing mount list with the results of reparsing" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
+      @parser.expects(:parse).returns("one" => mock("mount"))
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("one")).to be_truthy
       # Now parse again
-      expect(@parser).to receive(:parse).and_return("two" => double('other'))
+      @parser.expects(:parse).returns("two" => mock('other'))
       config.send(:readconfig, false)
       expect(config.mounted?("one")).to be_falsey
       expect(config.mounted?("two")).to be_truthy
     end
 
     it "should not replace the mount list until the file is entirely parsed successfully" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
-      expect(@parser).to receive(:parse).and_raise(ArgumentError)
+      @parser.expects(:parse).returns("one" => mock("mount"))
+      @parser.expects(:parse).raises(ArgumentError)
       config = Puppet::FileServing::Configuration.configuration
       # Now parse again, so the exception gets thrown
       config.send(:readconfig, false)
@@ -81,7 +84,7 @@ describe Puppet::FileServing::Configuration do
     end
 
     it "should add modules, plugins, and tasks mounts even if the file does not exist" do
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
+      Puppet::FileSystem.expects(:exist?).returns false # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("modules")).to be_truthy
       expect(config.mounted?("plugins")).to be_truthy
@@ -89,43 +92,43 @@ describe Puppet::FileServing::Configuration do
     end
 
     it "should allow all access to modules, plugins, and tasks if no fileserver.conf exists" do
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
-      modules = double('modules', :empty? => true)
-      allow(Puppet::FileServing::Mount::Modules).to receive(:new).and_return(modules)
-      expect(modules).to receive(:allow).with('*')
+      Puppet::FileSystem.expects(:exist?).returns false # the file doesn't exist
+      modules = stub 'modules', :empty? => true
+      Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
+      modules.expects(:allow).with('*')
 
-      plugins = double('plugins', :empty? => true)
-      allow(Puppet::FileServing::Mount::Plugins).to receive(:new).and_return(plugins)
-      expect(plugins).to receive(:allow).with('*')
+      plugins = stub 'plugins', :empty? => true
+      Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
+      plugins.expects(:allow).with('*')
 
-      tasks = double('tasks', :empty? => true)
-      allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
-      expect(tasks).to receive(:allow).with('*')
+      tasks = stub 'tasks', :empty? => true
+      Puppet::FileServing::Mount::Tasks.stubs(:new).returns(tasks)
+      tasks.expects(:allow).with('*')
 
       Puppet::FileServing::Configuration.configuration
     end
 
     it "should not allow access from all to modules, plugins, and tasks if the fileserver.conf provided some rules" do
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(false) # the file doesn't exist
+      Puppet::FileSystem.expects(:exist?).returns false # the file doesn't exist
 
-      modules = double('modules', :empty? => false)
-      allow(Puppet::FileServing::Mount::Modules).to receive(:new).and_return(modules)
-      expect(modules).not_to receive(:allow).with('*')
+      modules = stub 'modules', :empty? => false
+      Puppet::FileServing::Mount::Modules.stubs(:new).returns(modules)
+      modules.expects(:allow).with('*').never
 
-      plugins = double('plugins', :empty? => false)
-      allow(Puppet::FileServing::Mount::Plugins).to receive(:new).and_return(plugins)
-      expect(plugins).not_to receive(:allow).with('*')
+      plugins = stub 'plugins', :empty? => false
+      Puppet::FileServing::Mount::Plugins.stubs(:new).returns(plugins)
+      plugins.expects(:allow).with('*').never
 
-      tasks = double('tasks', :empty? => false)
-      allow(Puppet::FileServing::Mount::Tasks).to receive(:new).and_return(tasks)
-      expect(tasks).not_to receive(:allow).with('*')
+      tasks = stub 'tasks', :empty? => false
+      Puppet::FileServing::Mount::Tasks.stubs(:new).returns(tasks)
+      tasks.expects(:allow).with('*').never
 
       Puppet::FileServing::Configuration.configuration
     end
 
     it "should add modules, plugins, and tasks mounts even if they are not returned by the parser" do
-      expect(@parser).to receive(:parse).and_return("one" => double("mount"))
-      expect(Puppet::FileSystem).to receive(:exist?).and_return(true) # the file doesn't exist
+      @parser.expects(:parse).returns("one" => mock("mount"))
+      Puppet::FileSystem.expects(:exist?).returns true # the file doesn't exist
       config = Puppet::FileServing::Configuration.configuration
       expect(config.mounted?("modules")).to be_truthy
       expect(config.mounted?("plugins")).to be_truthy
@@ -136,16 +139,16 @@ describe Puppet::FileServing::Configuration do
   describe "when finding the specified mount" do
     it "should choose the named mount if one exists" do
       config = Puppet::FileServing::Configuration.configuration
-      expect(config).to receive(:mounts).and_return("one" => "foo")
-      expect(config.find_mount("one", double('env'))).to eq("foo")
+      config.expects(:mounts).returns("one" => "foo")
+      expect(config.find_mount("one", mock('env'))).to eq("foo")
     end
 
     it "should return nil if there is no such named mount" do
       config = Puppet::FileServing::Configuration.configuration
 
-      env = double('environment')
-      mount = double('mount')
-      allow(config).to receive(:mounts).and_return("modules" => mount)
+      env = mock 'environment'
+      mount = mock 'mount'
+      config.stubs(:mounts).returns("modules" => mount)
 
       expect(config.find_mount("foo", env)).to be_nil
     end
@@ -153,66 +156,66 @@ describe Puppet::FileServing::Configuration do
 
   describe "#split_path" do
     let(:config) { Puppet::FileServing::Configuration.configuration }
-    let(:request) { double('request', :key => "foo/bar/baz", :options => {}, :node => nil, :environment => double("env")) }
+    let(:request) { stub 'request', :key => "foo/bar/baz", :options => {}, :node => nil, :environment => mock("env") }
 
     before do
-      allow(config).to receive(:find_mount)
+      config.stubs(:find_mount)
     end
 
     it "should reread the configuration" do
-      expect(config).to receive(:readconfig)
+      config.expects(:readconfig)
 
       config.split_path(request)
     end
 
     it "should treat the first field of the URI path as the mount name" do
-      expect(config).to receive(:find_mount).with("foo", anything)
+      config.expects(:find_mount).with { |name, node| name == "foo" }
 
       config.split_path(request)
     end
 
     it "should fail if the mount name is not alpha-numeric" do
-      expect(request).to receive(:key).and_return("foo&bar/asdf")
+      request.expects(:key).returns "foo&bar/asdf"
 
       expect { config.split_path(request) }.to raise_error(ArgumentError)
     end
 
     it "should support dashes in the mount name" do
-      expect(request).to receive(:key).and_return("foo-bar/asdf")
+      request.expects(:key).returns "foo-bar/asdf"
 
       expect { config.split_path(request) }.to_not raise_error
     end
 
     it "should use the mount name and environment to find the mount" do
-      expect(config).to receive(:find_mount).with("foo", request.environment)
-      allow(request).to receive(:node).and_return("mynode")
+      config.expects(:find_mount).with { |name, env| name == "foo" and env == request.environment }
+      request.stubs(:node).returns("mynode")
 
       config.split_path(request)
     end
 
     it "should return nil if the mount cannot be found" do
-      expect(config).to receive(:find_mount).and_return(nil)
+      config.expects(:find_mount).returns nil
 
       expect(config.split_path(request)).to be_nil
     end
 
     it "should return the mount and the relative path if the mount is found" do
-      mount = double('mount', :name => "foo")
-      expect(config).to receive(:find_mount).and_return(mount)
+      mount = stub 'mount', :name => "foo"
+      config.expects(:find_mount).returns mount
 
       expect(config.split_path(request)).to eq([mount, "bar/baz"])
     end
 
     it "should remove any double slashes" do
-      allow(request).to receive(:key).and_return("foo/bar//baz")
-      mount = double('mount', :name => "foo")
-      expect(config).to receive(:find_mount).and_return(mount)
+      request.stubs(:key).returns "foo/bar//baz"
+      mount = stub 'mount', :name => "foo"
+      config.expects(:find_mount).returns mount
 
       expect(config.split_path(request)).to eq([mount, "bar/baz"])
     end
 
     it "should fail if the path contains .." do
-      allow(request).to receive(:key).and_return('module/foo/../../bar')
+      request.stubs(:key).returns 'module/foo/../../bar'
 
       expect do
         config.split_path(request)
@@ -220,17 +223,17 @@ describe Puppet::FileServing::Configuration do
     end
 
     it "should return the relative path as nil if it is an empty string" do
-      expect(request).to receive(:key).and_return("foo")
-      mount = double('mount', :name => "foo")
-      expect(config).to receive(:find_mount).and_return(mount)
+      request.expects(:key).returns "foo"
+      mount = stub 'mount', :name => "foo"
+      config.expects(:find_mount).returns mount
 
       expect(config.split_path(request)).to eq([mount, nil])
     end
 
     it "should add 'modules/' to the relative path if the modules mount is used but not specified, for backward compatibility" do
-      expect(request).to receive(:key).and_return("foo/bar")
-      mount = double('mount', :name => "modules")
-      expect(config).to receive(:find_mount).and_return(mount)
+      request.expects(:key).returns "foo/bar"
+      mount = stub 'mount', :name => "modules"
+      config.expects(:find_mount).returns mount
 
       expect(config.split_path(request)).to eq([mount, "foo/bar"])
     end

data/spec/unit/file_serving/content_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/content'
@@ -24,7 +25,7 @@ describe Puppet::FileServing::Content do
   it "should not retrieve and store its contents when its attributes are collected" do
     content = Puppet::FileServing::Content.new(path)
 
-    expect(File).not_to receive(:read).with(path)
+    File.expects(:read).with(path).never
     content.collect
 
     expect(content.instance_variable_get("@content")).to be_nil
@@ -46,10 +47,10 @@ describe Puppet::FileServing::Content do
   end
 
   it "should create an instance with a fake file name and correct content when converting from binary" do
-    instance = double('instance')
-    expect(Puppet::FileServing::Content).to receive(:new).with("/this/is/a/fake/path").and_return(instance)
+    instance = mock 'instance'
+    Puppet::FileServing::Content.expects(:new).with("/this/is/a/fake/path").returns instance
 
-    expect(instance).to receive(:content=).with("foo/bar")
+    instance.expects(:content=).with "foo/bar"
 
     expect(Puppet::FileServing::Content.from_binary("foo/bar")).to equal(instance)
   end
@@ -57,7 +58,7 @@ describe Puppet::FileServing::Content do
   it "should return an opened File when converted to binary" do
     content = Puppet::FileServing::Content.new(path)
 
-    expect(File).to receive(:new).with(path, "rb").and_return(:file)
+    File.expects(:new).with(path, "rb").returns :file
 
     expect(content.to_binary).to eq(:file)
   end
@@ -69,7 +70,7 @@ describe Puppet::FileServing::Content, "when returning the contents" do
 
   it "should fail if the file is a symlink and links are set to :manage" do
     content.links = :manage
-    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(double("stat", :ftype => "symlink"))
+    Puppet::FileSystem.expects(:lstat).with(path).returns stub("stat", :ftype => "symlink")
     expect { content.content }.to raise_error(ArgumentError)
   end
 
@@ -83,14 +84,14 @@ describe Puppet::FileServing::Content, "when returning the contents" do
   end
 
   it "should return the contents of the path if the file exists" do
-    expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(double('stat', :ftype => 'file'))
-    expect(Puppet::FileSystem).to receive(:binread).with(path).and_return(:mycontent)
+    Puppet::FileSystem.expects(:stat).with(path).returns(stub('stat', :ftype => 'file'))
+    Puppet::FileSystem.expects(:binread).with(path).returns(:mycontent)
     expect(content.content).to eq(:mycontent)
   end
 
   it "should cache the returned contents" do
-    expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(double('stat', :ftype => 'file'))
-    expect(Puppet::FileSystem).to receive(:binread).with(path).and_return(:mycontent)
+    Puppet::FileSystem.expects(:stat).with(path).returns(stub('stat', :ftype => 'file'))
+    Puppet::FileSystem.expects(:binread).with(path).returns(:mycontent)
     content.content
     # The second run would throw a failure if the content weren't being cached.
     content.content

data/spec/unit/file_serving/fileset_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/file_serving/fileset'
@@ -17,49 +18,49 @@ describe Puppet::FileServing::Fileset do
 
     it "removes a trailing file path separator" do
       path_with_separator = "#{somefile}#{File::SEPARATOR}"
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       fileset = Puppet::FileServing::Fileset.new(path_with_separator)
       expect(fileset.path).to eq(somefile)
     end
 
     it "can be created from the root directory" do
       path = File.expand_path(File::SEPARATOR)
-      expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(path).returns stub('stat')
       fileset = Puppet::FileServing::Fileset.new(path)
       expect(fileset.path).to eq(path)
     end
 
     it "fails if its path does not exist" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_raise(Errno::ENOENT)
+      Puppet::FileSystem.expects(:lstat).with(somefile).raises(Errno::ENOENT)
       expect { Puppet::FileServing::Fileset.new(somefile) }.to raise_error(ArgumentError, "Fileset paths must exist")
     end
 
     it "accepts a 'recurse' option" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :recurse => true)
       expect(set.recurse).to be_truthy
     end
 
     it "accepts a 'recurselimit' option" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :recurselimit => 3)
       expect(set.recurselimit).to eq(3)
     end
 
     it "accepts an 'ignore' option" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :ignore => ".svn")
       expect(set.ignore).to eq([".svn"])
     end
 
     it "accepts a 'links' option" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :links => :manage)
       expect(set.links).to eq(:manage)
     end
 
     it "accepts a 'checksum_type' option" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :checksum_type => :test)
       expect(set.checksum_type).to eq(:test)
     end
@@ -69,22 +70,22 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "defaults to 'false' for recurse" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       expect(Puppet::FileServing::Fileset.new(somefile).recurse).to eq(false)
     end
 
     it "defaults to :infinite for recurselimit" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       expect(Puppet::FileServing::Fileset.new(somefile).recurselimit).to eq(:infinite)
     end
 
     it "defaults to an empty ignore list" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       expect(Puppet::FileServing::Fileset.new(somefile).ignore).to eq([])
     end
 
     it "defaults to :manage for links" do
-      expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+      Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       expect(Puppet::FileServing::Fileset.new(somefile).links).to eq(:manage)
     end
 
@@ -92,7 +93,7 @@ describe Puppet::FileServing::Fileset do
       let(:values) { { :links => :manage, :ignore => %w{a b}, :recurse => true, :recurselimit => 1234 } }
 
       before :each do
-        expect(Puppet::FileSystem).to receive(:lstat).with(somefile).and_return(double('stat'))
+        Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       end
 
       [:recurse, :recurselimit, :ignore, :links].each do |option|
@@ -129,16 +130,16 @@ describe Puppet::FileServing::Fileset do
   context "when recursing" do
     before do
       @path = make_absolute("/my/path")
-      allow(Puppet::FileSystem).to receive(:lstat).with(@path).and_return(double('stat', :directory? => true))
+      Puppet::FileSystem.stubs(:lstat).with(@path).returns stub('stat', :directory? => true)
 
       @fileset = Puppet::FileServing::Fileset.new(@path)
 
-      @dirstat = double('dirstat', :directory? => true)
-      @filestat = double('filestat', :directory? => false)
+      @dirstat = stub 'dirstat', :directory? => true
+      @filestat = stub 'filestat', :directory? => false
     end
 
     def mock_dir_structure(path, stat_method = :lstat)
-      allow(Puppet::FileSystem).to receive(stat_method).with(path).and_return(@dirstat)
+      Puppet::FileSystem.stubs(stat_method).with(path).returns @dirstat
 
       # Keep track of the files we're stubbing.
       @files = %w{.}
@@ -146,59 +147,53 @@ describe Puppet::FileServing::Fileset do
       top_names = %w{one two .svn CVS}
       sub_names = %w{file1 file2 .svn CVS 0 false}
 
-      allow(Dir).to receive(:entries).with(path, encoding: Encoding::UTF_8).and_return(top_names)
+      Dir.stubs(:entries).with(path).returns(top_names)
       top_names.each do |subdir|
         @files << subdir # relative path
         subpath = File.join(path, subdir)
-        allow(Puppet::FileSystem).to receive(stat_method).with(subpath).and_return(@dirstat)
-        allow(Dir).to receive(:entries).with(subpath, encoding: Encoding::UTF_8).and_return(sub_names)
+        Puppet::FileSystem.stubs(stat_method).with(subpath).returns @dirstat
+        Dir.stubs(:entries).with(subpath).returns(sub_names)
         sub_names.each do |file|
           @files << File.join(subdir, file) # relative path
           subfile_path = File.join(subpath, file)
-          allow(Puppet::FileSystem).to receive(stat_method).with(subfile_path).and_return(@filestat)
+          Puppet::FileSystem.stubs(stat_method).with(subfile_path).returns(@filestat)
         end
       end
     end
 
-    def setup_mocks_for_dir(mock_dir, base_path)
-      path = File.join(base_path, mock_dir.name)
-      allow(Puppet::FileSystem).to receive(:lstat).with(path).and_return(MockStat.new(path, true))
-      allow(Dir).to receive(:entries).with(path, encoding: Encoding::UTF_8).and_return(['.', '..'] + mock_dir.entries.map(&:name))
-      mock_dir.entries.each do |entry|
-        setup_mocks_for_entry(entry, path)
+    MockStat = Struct.new(:path, :directory) do
+      # struct doesn't support thing ending in ?
+      def directory?
+        directory
       end
     end
 
-    def setup_mocks_for_file(mock_file, base_path)
-      path = File.join(base_path, mock_file.name)
-      allow(Puppet::FileSystem).to receive(:lstat).with(path).and_return(MockStat.new(path, false))
-    end
-
-    def setup_mocks_for_entry(entry, base_path)
-      case entry
-      when MockDirectory
-        setup_mocks_for_dir(entry, base_path)
-      when MockFile
-        setup_mocks_for_file(entry, base_path)
+    MockDirectory = Struct.new(:name, :entries) do
+      def mock(base_path)
+        extend Mocha::API
+        path = File.join(base_path, name)
+        Puppet::FileSystem.stubs(:lstat).with(path).returns MockStat.new(path, true)
+        Dir.stubs(:entries).with(path).returns(['.', '..'] + entries.map(&:name))
+        entries.each do |entry|
+          entry.mock(path)
+        end
       end
     end
 
-    MockStat = Struct.new(:path, :directory) do
-      # struct doesn't support thing ending in ?
-      def directory?
-        directory
+    MockFile = Struct.new(:name) do
+      def mock(base_path)
+        extend Mocha::API
+        path = File.join(base_path, name)
+        Puppet::FileSystem.stubs(:lstat).with(path).returns MockStat.new(path, false)
       end
     end
 
-    MockDirectory = Struct.new(:name, :entries)
-    MockFile = Struct.new(:name)
-
     it "doesn't ignore pending directories when the last entry at the top level is a file" do
       structure = MockDirectory.new('path',
                     [MockDirectory.new('dir1',
                                    [MockDirectory.new('a', [MockFile.new('f')])]),
                      MockFile.new('file')])
-      setup_mocks_for_dir(structure, make_absolute('/your'))
+      structure.mock(make_absolute('/your'))
       fileset = Puppet::FileServing::Fileset.new(make_absolute('/your/path'))
       fileset.recurse = true
       fileset.links = :manage
@@ -281,8 +276,8 @@ describe Puppet::FileServing::Fileset do
 
     it "works when paths have regexp significant characters" do
       @path = make_absolute("/my/path/rV1x2DafFr0R6tGG+1bbk++++TM")
-      stat = double('dir_stat', :directory? => true)
-      expect(Puppet::FileSystem).to receive(:lstat).with(@path).and_return(double(@path, :stat => stat, :lstat => stat))
+      stat = stub('dir_stat', :directory? => true)
+      Puppet::FileSystem.expects(:lstat).with(@path).returns stub(@path, :stat => stat, :lstat => stat)
       @fileset = Puppet::FileServing::Fileset.new(@path)
       mock_dir_structure(@path)
       @fileset.recurse = true
@@ -292,15 +287,15 @@ describe Puppet::FileServing::Fileset do
 
   it "manages the links to missing files" do
     path = make_absolute("/my/path")
-    stat = double('stat', :directory? => true)
+    stat = stub 'stat', :directory? => true
 
-    expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(stat)
-    expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stat)
+    Puppet::FileSystem.expects(:stat).with(path).returns stat
+    Puppet::FileSystem.expects(:lstat).with(path).returns stat
 
     link_path = File.join(path, "mylink")
-    expect(Puppet::FileSystem).to receive(:stat).with(link_path).and_raise(Errno::ENOENT)
+    Puppet::FileSystem.expects(:stat).with(link_path).raises(Errno::ENOENT)
 
-    allow(Dir).to receive(:entries).with(path, encoding: Encoding::UTF_8).and_return(["mylink"])
+    Dir.stubs(:entries).with(path).returns(["mylink"])
 
     fileset = Puppet::FileServing::Fileset.new(path)
 
@@ -313,20 +308,20 @@ describe Puppet::FileServing::Fileset do
   context "when merging other filesets" do
     before do
       @paths = [make_absolute("/first/path"), make_absolute("/second/path"), make_absolute("/third/path")]
-      allow(Puppet::FileSystem).to receive(:lstat).and_return(double('stat', :directory? => false))
+      Puppet::FileSystem.stubs(:lstat).returns stub('stat', :directory? => false)
 
       @filesets = @paths.collect do |path|
-        allow(Puppet::FileSystem).to receive(:lstat).with(path).and_return(double('stat', :directory? => true))
+        Puppet::FileSystem.stubs(:lstat).with(path).returns stub('stat', :directory? => true)
         Puppet::FileServing::Fileset.new(path, :recurse => true)
       end
 
-      allow(Dir).to receive(:entries).and_return([])
+      Dir.stubs(:entries).returns []
     end
 
     it "returns a hash of all files in each fileset with the value being the base path" do
-      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).and_return(%w{one uno})
-      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).and_return(%w{two dos})
-      expect(Dir).to receive(:entries).with(make_absolute("/third/path"), encoding: Encoding::UTF_8).and_return(%w{three tres})
+      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one uno})
+      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{two dos})
+      Dir.expects(:entries).with(make_absolute("/third/path")).returns(%w{three tres})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)).to eq({
         "." => make_absolute("/first/path"),
@@ -340,15 +335,15 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "includes the base directory from the first fileset" do
-      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).and_return(%w{one})
-      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).and_return(%w{two})
+      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{two})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["."]).to eq(make_absolute("/first/path"))
     end
 
     it "uses the base path of the first found file when relative file paths conflict" do
-      expect(Dir).to receive(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).and_return(%w{one})
-      expect(Dir).to receive(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).and_return(%w{one})
+      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{one})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["one"]).to eq(make_absolute("/first/path"))
     end