puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/spec/unit/file_serving/http_metadata_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/http_metadata'
 require 'matchers/json'
@@ -31,8 +32,8 @@ describe Puppet::FileServing::HttpMetadata do
 
     context "with no Last-Modified or Content-MD5 header from the server" do
       before do
-        allow(http_response).to receive(:[]).with('last-modified').and_return(nil)
-        allow(http_response).to receive(:[]).with('content-md5').and_return(nil)
+        http_response.stubs(:[]).with('last-modified').returns nil
+        http_response.stubs(:[]).with('content-md5').returns nil
       end
 
       it "should use :mtime as the checksum type, based on current time" do
@@ -50,14 +51,13 @@ describe Puppet::FileServing::HttpMetadata do
 
     context "with a Last-Modified header from the server" do
       let(:time) { Time.now.utc }
-
       before do
-        allow(http_response).to receive(:[]).with('content-md5').and_return(nil)
+        http_response.stubs(:[]).with('content-md5').returns nil
       end
 
       it "should use :mtime as the checksum type, based on Last-Modified" do
         # HTTP uses "GMT" not "UTC"
-        allow(http_response).to receive(:[]).with('last-modified').and_return(time.strftime("%a, %d %b %Y %T GMT"))
+        http_response.stubs(:[]).with('last-modified').returns(time.strftime("%a, %d %b %Y %T GMT"))
         metadata = described_class.new(http_response)
         metadata.collect
         expect( metadata.checksum_type ).to eq :mtime
@@ -69,10 +69,9 @@ describe Puppet::FileServing::HttpMetadata do
       let(:input) { Time.now.to_s }
       let(:base64) { Digest::MD5.new.base64digest input }
       let(:hex) { Digest::MD5.new.hexdigest input }
-
       before do
-        allow(http_response).to receive(:[]).with('last-modified').and_return(nil)
-        allow(http_response).to receive(:[]).with('content-md5').and_return(base64)
+        http_response.stubs(:[]).with('last-modified').returns nil
+        http_response.stubs(:[]).with('content-md5').returns base64
       end
 
       it "should use the md5 checksum" do

data/spec/unit/file_serving/metadata_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/metadata'
 require 'matchers/json'
@@ -183,14 +184,14 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
 
           it "should give a mtime checksum when checksum_type is set" do
             metadata.checksum_type = "mtime"
-            expect(metadata).to receive(:mtime_file).and_return(time)
+            metadata.expects(:mtime_file).returns(time)
             metadata.collect
             expect(metadata.checksum).to eq("{mtime}#{time}")
           end
 
           it "should give a ctime checksum when checksum_type is set" do
             metadata.checksum_type = "ctime"
-            expect(metadata).to receive(:ctime_file).and_return(time)
+            metadata.expects(:ctime_file).returns(time)
             metadata.collect
             expect(metadata.checksum).to eq("{ctime}#{time}")
           end
@@ -217,7 +218,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
         let(:time) { Time.now }
 
         before :each do
-          expect(metadata).to receive(:ctime_file).and_return(time)
+          metadata.expects(:ctime_file).returns(time)
         end
 
         it "should only use checksums of type 'ctime' for directories" do
@@ -227,7 +228,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
 
         it "should only use checksums of type 'ctime' for directories even if checksum_type set" do
           metadata.checksum_type = "mtime"
-          expect(metadata).not_to receive(:mtime_file)
+          metadata.expects(:mtime_file).never
           metadata.collect
           expect(metadata.checksum).to eq("{ctime}#{time}")
         end
@@ -240,7 +241,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
     end
   end
 
-  describe "WindowsStat", :if => Puppet.features.microsoft_windows? do
+  describe "WindowsStat", :if => Puppet::Util::Platform.windows? do
     include PuppetSpec::Files
 
     it "should return default owner, group and mode when the given path has an invalid DACL (such as a non-NTFS volume)" do
@@ -248,9 +249,9 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       path = tmpfile('foo')
       FileUtils.touch(path)
 
-      allow(Puppet::Util::Windows::Security).to receive(:get_owner).with(path).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_group).with(path).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_mode).with(path).and_raise(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_owner).with(path).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_group).with(path).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_mode).with(path).raises(invalid_error)
 
       stat = Puppet::FileSystem.stat(path)
 
@@ -266,9 +267,9 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       path = tmpfile('bar')
       FileUtils.touch(path)
 
-      allow(Puppet::Util::Windows::Security).to receive(:get_owner).with(path, :use).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_group).with(path, :use).and_raise(invalid_error)
-      allow(Puppet::Util::Windows::Security).to receive(:get_mode).with(path, :use).and_raise(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_owner).with(path, :use).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_group).with(path, :use).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_mode).with(path, :use).raises(invalid_error)
 
       stat = Puppet::FileSystem.stat(path)
 
@@ -347,8 +348,8 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
     let(:group) {20}
 
     before :each do
-      allow_any_instance_of(File::Stat).to receive(:uid).and_return(owner)
-      allow_any_instance_of(File::Stat).to receive(:gid).and_return(group)
+      File::Stat.any_instance.stubs(:uid).returns owner
+      File::Stat.any_instance.stubs(:gid).returns group
     end
 
     describe "when collecting attributes when managing files" do
@@ -387,14 +388,14 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
     end
   end
 
-  describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
+  describe "on Windows systems", :if => Puppet::Util::Platform.windows? do
     let(:owner) {'S-1-1-50'}
     let(:group) {'S-1-1-51'}
 
     before :each do
       require 'puppet/util/windows/security'
-      allow(Puppet::Util::Windows::Security).to receive(:get_owner).and_return(owner)
-      allow(Puppet::Util::Windows::Security).to receive(:get_group).and_return(group)
+      Puppet::Util::Windows::Security.stubs(:get_owner).returns owner
+      Puppet::Util::Windows::Security.stubs(:get_group).returns group
     end
 
     describe "when collecting attributes when managing files" do
@@ -440,19 +441,19 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       end
 
       it "should default owner" do
-        allow(Puppet::Util::Windows::Security).to receive(:get_owner).and_return(nil)
+        Puppet::Util::Windows::Security.stubs(:get_owner).returns nil
 
         expect(metadata.owner).to eq('S-1-5-32-544')
       end
 
       it "should default group" do
-        allow(Puppet::Util::Windows::Security).to receive(:get_group).and_return(nil)
+        Puppet::Util::Windows::Security.stubs(:get_group).returns nil
 
         expect(metadata.group).to eq('S-1-0-0')
       end
 
       it "should default mode" do
-        allow(Puppet::Util::Windows::Security).to receive(:get_mode).and_return(nil)
+        Puppet::Util::Windows::Security.stubs(:get_mode).returns nil
 
         expect(metadata.mode).to eq(0644)
       end
@@ -460,23 +461,24 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       describe "when the path raises an Invalid ACL error" do
         # these simulate the behavior of a symlink file whose target does not support ACLs
         it "should default owner" do
-          allow(Puppet::Util::Windows::Security).to receive(:get_owner).and_raise(invalid_dacl_error)
+          Puppet::Util::Windows::Security.stubs(:get_owner).raises(invalid_dacl_error)
 
           expect(metadata.owner).to eq('S-1-5-32-544')
         end
 
         it "should default group" do
-          allow(Puppet::Util::Windows::Security).to receive(:get_group).and_raise(invalid_dacl_error)
+          Puppet::Util::Windows::Security.stubs(:get_group).raises(invalid_dacl_error)
 
           expect(metadata.group).to eq('S-1-0-0')
         end
 
         it "should default mode" do
-          allow(Puppet::Util::Windows::Security).to receive(:get_mode).and_raise(invalid_dacl_error)
+          Puppet::Util::Windows::Security.stubs(:get_mode).raises(invalid_dacl_error)
 
           expect(metadata.mode).to eq(0644)
         end
       end
+
     end
 
     def set_mode(mode, path)
@@ -485,35 +487,35 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
   end
 end
 
+
 describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppet.features.manages_symlinks?, :uses_checksums => true do
   with_digest_algorithms do
     describe "when links are managed" do
       before do
         path = "/base/path/my/file"
         @file = Puppet::FileServing::Metadata.new(path, :links => :manage)
-        stat = double("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
-        expect(Puppet::FileSystem).to receive(:lstat).with(path).and_return(stat)
-        expect(Puppet::FileSystem).to receive(:readlink).with(path).and_return("/some/other/path")
-        allow(@file).to receive("#{digest_algorithm}_file".intern).and_return(checksum) # Remove these when :managed links are no longer checksumed.
+        stat = stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
+        Puppet::FileSystem.expects(:lstat).with(path).at_least_once.returns stat
+        Puppet::FileSystem.expects(:readlink).with(path).at_least_once.returns "/some/other/path"
+        @file.stubs("#{digest_algorithm}_file".intern).returns(checksum) # Remove these when :managed links are no longer checksumed.
 
-        if Puppet.features.microsoft_windows?
-          win_stat = double('win_stat', :owner => 'snarf', :group => 'thundercats',
+        if Puppet::Util::Platform.windows?
+          win_stat = stub('win_stat', :owner => 'snarf', :group => 'thundercats',
             :ftype => 'link', :mode => 0755)
-          allow(Puppet::FileServing::Metadata::WindowsStat).to receive(:new).and_return(win_stat)
+          Puppet::FileServing::Metadata::WindowsStat.stubs(:new).returns win_stat
         end
+
       end
 
       it "should store the destination of the link in :destination if links are :manage" do
         @file.collect
         expect(@file.destination).to eq("/some/other/path")
       end
-
       pending "should not collect the checksum if links are :manage" do
         # We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow.
         @file.collect
         expect(@file.checksum).to be_nil
       end
-
       it "should collect the checksum if links are :manage" do # see pending note above
         @file.collect
         expect(@file.checksum).to eq("{#{digest_algorithm}}#{checksum}")
@@ -524,24 +526,22 @@ describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppe
       before do
         path = "/base/path/my/file"
         @file = Puppet::FileServing::Metadata.new(path, :links => :follow)
-        stat = double("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
-        expect(Puppet::FileSystem).to receive(:stat).with(path).and_return(stat)
-        expect(Puppet::FileSystem).not_to receive(:readlink)
+        stat = stub("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
+        Puppet::FileSystem.expects(:stat).with(path).at_least_once.returns stat
+        Puppet::FileSystem.expects(:readlink).never
 
-        if Puppet.features.microsoft_windows?
-          win_stat = double('win_stat', :owner => 'snarf', :group => 'thundercats',
+        if Puppet::Util::Platform.windows?
+          win_stat = stub('win_stat', :owner => 'snarf', :group => 'thundercats',
             :ftype => 'file', :mode => 0755)
-          allow(Puppet::FileServing::Metadata::WindowsStat).to receive(:new).and_return(win_stat)
+          Puppet::FileServing::Metadata::WindowsStat.stubs(:new).returns win_stat
         end
 
-        allow(@file).to receive("#{digest_algorithm}_file".intern).and_return(checksum)
+        @file.stubs("#{digest_algorithm}_file".intern).returns(checksum)
       end
-
       it "should not store the destination of the link in :destination if links are :follow" do
         @file.collect
         expect(@file.destination).to be_nil
       end
-
       it "should collect the checksum if links are :follow" do
         @file.collect
         expect(@file.checksum).to eq("{#{digest_algorithm}}#{checksum}")

data/spec/unit/file_serving/mount/file_spec.rb

@@ -1,10 +1,11 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/mount/file'
 
 module FileServingMountTesting
   def stub_facter(hostname)
-    allow(Facter).to receive(:value).with("hostname").and_return(hostname.sub(/\..+/, ''))
-    allow(Facter).to receive(:value).with("domain").and_return(hostname.sub(/^[^.]+\./, ''))
+    Facter.stubs(:value).with("hostname").returns(hostname.sub(/\..+/, ''))
+    Facter.stubs(:value).with("domain").returns(hostname.sub(/^[^.]+\./, ''))
   end
 end
 
@@ -14,8 +15,8 @@ describe Puppet::FileServing::Mount::File do
   end
 
   it "should be valid if it has a path" do
-    allow(FileTest).to receive(:directory?).and_return(true)
-    allow(FileTest).to receive(:readable?).and_return(true)
+    FileTest.stubs(:directory?).returns true
+    FileTest.stubs(:readable?).returns true
     mount = Puppet::FileServing::Mount::File.new("foo")
     mount.path = "/foo"
     expect { mount.validate }.not_to raise_error
@@ -28,13 +29,13 @@ describe Puppet::FileServing::Mount::File do
     end
 
     it "should fail if the path is not a directory" do
-      expect(FileTest).to receive(:directory?).and_return(false)
+      FileTest.expects(:directory?).returns(false)
       expect { @mount.path = @dir }.to raise_error(ArgumentError)
     end
 
     it "should fail if the path is not readable" do
-      expect(FileTest).to receive(:directory?).and_return(true)
-      expect(FileTest).to receive(:readable?).and_return(false)
+      FileTest.expects(:directory?).returns(true)
+      FileTest.expects(:readable?).returns(false)
       expect { @mount.path = @dir }.to raise_error(ArgumentError)
     end
   end
@@ -43,8 +44,8 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:readable?).and_return(true)
+      FileTest.stubs(:directory?).returns(true)
+      FileTest.stubs(:readable?).returns(true)
       @mount = Puppet::FileServing::Mount::File.new("test")
       @host = "host.domain.com"
     end
@@ -84,9 +85,9 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:readable?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
+      FileTest.stubs(:directory?).returns(true)
+      FileTest.stubs(:readable?).returns(true)
       @mount = Puppet::FileServing::Mount::File.new("test")
       @mount.path = "/mount"
       stub_facter("myhost.mydomain.com")
@@ -94,25 +95,25 @@ describe Puppet::FileServing::Mount::File do
     end
 
     it "should return nil if the file is absent" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
       expect(@mount.complete_path("/my/path", nil)).to be_nil
     end
 
     it "should write a log message if the file is absent" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
 
-      expect(Puppet).to receive(:info).with("File does not exist or is not accessible: /mount/my/path")
+      Puppet.expects(:info).with("File does not exist or is not accessible: /mount/my/path")
 
       @mount.complete_path("/my/path", nil)
     end
 
     it "should return the file path if the file is present" do
-      allow(Puppet::FileSystem).to receive(:exist?).with("/my/path").and_return(true)
+      Puppet::FileSystem.stubs(:exist?).with("/my/path").returns(true)
       expect(@mount.complete_path("/my/path", nil)).to eq("/mount/my/path")
     end
 
     it "should treat a nil file name as the path to the mount itself" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
       expect(@mount.complete_path(nil, nil)).to eq("/mount")
     end
 
@@ -140,20 +141,20 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:readable?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
+      FileTest.stubs(:directory?).returns(true)
+      FileTest.stubs(:readable?).returns(true)
       @mount = Puppet::FileServing::Mount::File.new("test")
       @mount.path = "/mount"
       stub_facter("myhost.mydomain.com")
       @host = "host.domain.com"
 
-      @request = double('request', :node => "foo")
+      @request = stub 'request', :node => "foo"
     end
 
     it "should return the results of the complete file path" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
-      expect(@mount).to receive(:complete_path).with("/my/path", "foo").and_return("eh")
+      Puppet::FileSystem.stubs(:exist?).returns(false)
+      @mount.expects(:complete_path).with("/my/path", "foo").returns "eh"
       expect(@mount.find("/my/path", @request)).to eq("eh")
     end
   end
@@ -162,26 +163,26 @@ describe Puppet::FileServing::Mount::File do
     include FileServingMountTesting
 
     before do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:readable?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns(true)
+      FileTest.stubs(:directory?).returns(true)
+      FileTest.stubs(:readable?).returns(true)
       @mount = Puppet::FileServing::Mount::File.new("test")
       @mount.path = "/mount"
       stub_facter("myhost.mydomain.com")
       @host = "host.domain.com"
 
-      @request = double('request', :node => "foo")
+      @request = stub 'request', :node => "foo"
     end
 
     it "should return the results of the complete file path as an array" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
-      expect(@mount).to receive(:complete_path).with("/my/path", "foo").and_return("eh")
+      Puppet::FileSystem.stubs(:exist?).returns(false)
+      @mount.expects(:complete_path).with("/my/path", "foo").returns "eh"
       expect(@mount.search("/my/path", @request)).to eq(["eh"])
     end
 
     it "should return nil if the complete path is nil" do
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
-      expect(@mount).to receive(:complete_path).with("/my/path", "foo").and_return(nil)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
+      @mount.expects(:complete_path).with("/my/path", "foo").returns nil
       expect(@mount.search("/my/path", @request)).to be_nil
     end
   end

data/spec/unit/file_serving/mount/locales_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_serving/mount/locales'
 
@@ -5,67 +6,67 @@ describe Puppet::FileServing::Mount::Locales do
   before do
     @mount = Puppet::FileServing::Mount::Locales.new("locales")
 
-    @environment = double('environment', :module => nil)
+    @environment = stub 'environment', :module => nil
     @options = { :recurse => true }
-    @request = double('request', :environment => @environment, :options => @options)
+    @request = stub 'request', :environment => @environment, :options => @options
   end
 
   describe  "when finding files" do
     it "should use the provided environment to find the modules" do
-      expect(@environment).to receive(:modules).and_return([])
+      @environment.expects(:modules).returns []
 
       @mount.find("foo", @request)
     end
 
     it "should return nil if no module can be found with a matching locale" do
-      mod = double('module')
-      allow(mod).to receive(:locale).with("foo/bar").and_return(nil)
+      mod = mock 'module'
+      mod.stubs(:locale).with("foo/bar").returns nil
 
-      allow(@environment).to receive(:modules).and_return([mod])
+      @environment.stubs(:modules).returns [mod]
       expect(@mount.find("foo/bar", @request)).to be_nil
     end
 
     it "should return the file path from the module" do
-      mod = double('module')
-      allow(mod).to receive(:locale).with("foo/bar").and_return("eh")
+      mod = mock 'module'
+      mod.stubs(:locale).with("foo/bar").returns "eh"
 
-      allow(@environment).to receive(:modules).and_return([mod])
+      @environment.stubs(:modules).returns [mod]
       expect(@mount.find("foo/bar", @request)).to eq("eh")
     end
   end
 
   describe "when searching for files" do
     it "should use the node's environment to find the modules" do
-      expect(@environment).to receive(:modules).at_least(:once).and_return([])
-      allow(@environment).to receive(:modulepath).and_return(["/tmp/modules"])
+      @environment.expects(:modules).at_least_once.returns []
+      @environment.stubs(:modulepath).returns ["/tmp/modules"]
 
       @mount.search("foo", @request)
     end
 
     it "should return modulepath if no modules can be found that have locales" do
-      mod = double('module')
-      allow(mod).to receive(:locales?).and_return(false)
+      mod = mock 'module'
+      mod.stubs(:locales?).returns false
 
-      allow(@environment).to receive(:modules).and_return([])
-      allow(@environment).to receive(:modulepath).and_return(["/"])
-      expect(@options).to receive(:[]=).with(:recurse, false)
+      @environment.stubs(:modules).returns []
+      @environment.stubs(:modulepath).returns ["/"]
+      @options.expects(:[]=).with(:recurse, false)
       expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
-    it "should return the default search module path if no modules can be found that have locales and modulepath is invalid" do
-      mod = double('module')
-      allow(mod).to receive(:locales?).and_return(false)
+    it "should return nil if no modules can be found that have locales and modulepath is invalid" do
+      mod = mock 'module'
+      mod.stubs(:locales?).returns false
 
-      allow(@environment).to receive(:modules).and_return([])
-      allow(@environment).to receive(:modulepath).and_return([])
-      expect(@mount.search("foo/bar", @request)).to eq([Puppet[:codedir]])
+      @environment.stubs(:modules).returns []
+      @environment.stubs(:modulepath).returns []
+      expect(@mount.search("foo/bar", @request)).to be_nil
     end
 
     it "should return the locale paths for each module that has locales" do
-      one = double('module', :locales? => true, :locale_directory => "/one")
-      two = double('module', :locales? => true, :locale_directory => "/two")
+      one = stub 'module', :locales? => true, :locale_directory => "/one"
+      two = stub 'module', :locales? => true, :locale_directory => "/two"
 
-      allow(@environment).to receive(:modules).and_return([one, two])
+      @environment.stubs(:modules).returns [one, two]
       expect(@mount.search("foo/bar", @request)).to eq(%w{/one /two})
     end
   end