puppet 6.19.1-x64-mingw32 → 6.23.0-x64-mingw32

data/spec/unit/http/service_spec.rb

@@ -137,7 +137,7 @@ describe Puppet::HTTP::Service do
     catalog_mimes = if Puppet.features.msgpack?
                       %w[application/vnd.puppet.rich+json application/json application/vnd.puppet.rich+msgpack application/x-msgpack text/pson]
                     else
-                      %w[application/vnd.puppet.rich+json application/json application/vnd.puppet.rich+msgpack text/pson]
+                      %w[application/vnd.puppet.rich+json application/json text/pson]
                     end
     expect(service.mime_types(Puppet::Resource::Catalog)).to eq(catalog_mimes)
   end

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -909,9 +909,10 @@ describe Puppet::Resource::Catalog::Compiler do
         it "inlines child metadata" do
           catalog = compile_to_catalog(<<-MANIFEST, node)
             file { '#{path}':
-              ensure  => directory,
-              recurse => true,
-              source  => '#{source_dir}'
+              ensure    => directory,
+              recurse   => true,
+              source    => '#{source_dir}',
+              max_files => 1234,
             }
           MANIFEST
 
@@ -925,6 +926,7 @@ describe Puppet::Resource::Catalog::Compiler do
             :source_permissions => :ignore,
             :recurse            => true,
             :recurselimit       => nil,
+            :max_files          => 1234,
             :ignore             => nil,
           }
           expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source_dir, options).and_return([metadata, child_metadata])
@@ -938,14 +940,15 @@ describe Puppet::Resource::Catalog::Compiler do
         it "uses resource parameters when inlining metadata" do
           catalog = compile_to_catalog(<<-MANIFEST, node)
             file { '#{path}':
-              ensure  => directory,
-              recurse => true,
-              source  => '#{source_dir}',
-              checksum => sha256,
+              ensure             => directory,
+              recurse            => true,
+              source             => '#{source_dir}',
+              checksum           => sha256,
               source_permissions => use_when_creating,
-              recurselimit => 2,
-              ignore => 'foo.+',
-              links => follow,
+              recurselimit       => 2,
+              max_files          => 4321,
+              ignore             => 'foo.+',
+              links              => follow,
             }
           MANIFEST
 
@@ -956,6 +959,7 @@ describe Puppet::Resource::Catalog::Compiler do
             :source_permissions => :use_when_creating,
             :recurse            => true,
             :recurselimit       => 2,
+            :max_files          => 4321,
             :ignore             => 'foo.+',
           }
           expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source_dir, options).and_return([metadata, child_metadata])

data/spec/unit/indirector/face_spec.rb

@@ -33,7 +33,6 @@ describe Puppet::Indirector::Face do
   describe "as an instance" do
     it "should be able to determine its indirection" do
       # Loading actions here can get, um, complicated
-      allow(Puppet::Face).to receive(:load_actions)
       expect(Puppet::Indirector::Face.new(:catalog, '0.0.1').indirection).to equal(Puppet::Resource::Catalog.indirection)
     end
   end

data/spec/unit/indirector/facts/facter_spec.rb

@@ -22,13 +22,13 @@ describe Puppet::Node::Facts::Facter do
   end
 
   before :each do
-    allow(Puppet::Node::Facts::Facter).to receive(:reload_facter)
     @facter = Puppet::Node::Facts::Facter.new
     allow(Facter).to receive(:to_hash).and_return({})
     @name = "me"
     @request = double('request', :key => @name)
     @environment = double('environment')
     allow(@request).to receive(:environment).and_return(@environment)
+    allow(@request).to receive(:options).and_return({})
     allow(@request.environment).to receive(:modules).and_return([])
     allow(@request.environment).to receive(:modulepath).and_return([])
   end
@@ -105,6 +105,7 @@ describe Puppet::Node::Facts::Facter do
       expect(FileTest).to receive(:directory?).with(factpath1).and_return(true)
       expect(FileTest).to receive(:directory?).with(factpath2).and_return(true)
       allow(@request.environment).to receive(:modulepath).and_return([modulepath])
+      allow(@request).to receive(:options).and_return({})
       expect(Dir).to receive(:glob).with("#{modulepath}/*/lib/facter").and_return([modulelibfacter])
       expect(Dir).to receive(:glob).with("#{modulepath}/*/plugins/facter").and_return([modulepluginsfacter])
 
@@ -150,4 +151,97 @@ describe Puppet::Node::Facts::Facter do
       Puppet::Node::Facts::Facter.setup_external_search_paths @request
     end
   end
+
+  describe 'when :resolve_options is true' do
+    let(:options) { { resolve_options: true, user_query: ["os", "timezone"], show_legacy: true } }
+    let(:facts) { Puppet::Node::Facts.new("foo") }
+
+    before :each do
+      allow(@request).to receive(:options).and_return(options)
+      allow(Puppet::Node::Facts).to receive(:new).and_return(facts)
+      allow(facts).to receive(:add_local_facts)
+    end
+
+    it 'should call Facter.resolve method' do
+      expect(Facter).to receive(:resolve).with("os timezone --show-legacy")
+      @facter.find(@request)
+    end
+
+    it 'should NOT add local facts' do
+      expect(facts).not_to receive(:add_local_facts)
+
+      @facter.find(@request)
+    end
+
+    describe 'when Facter version is lower than 4.0.40' do
+      before :each do
+        allow(Facter).to receive(:respond_to?).and_return(false)
+        allow(Facter).to receive(:respond_to?).with(:resolve).and_return(false)
+      end
+
+      it 'raises an error' do
+        expect { @facter.find(@request) }.to raise_error(Puppet::Error, "puppet facts show requires version 4.0.40 or greater of Facter.")
+      end
+    end
+
+    describe 'when setting up external search paths' do
+      let(:options) { { resolve_options: true, user_query: ["os", "timezone"], external_dir: 'some/dir' } }
+      let(:pluginfactdest) { File.expand_path 'plugin/dest' }
+      let(:modulepath) { File.expand_path 'module/foo' }
+      let(:modulefactsd) { File.expand_path 'module/foo/facts.d'  }
+
+      before :each do
+        expect(FileTest).to receive(:directory?).with(pluginfactdest).and_return(true)
+        mod = Puppet::Module.new('foo', modulepath, @request.environment)
+        allow(@request.environment).to receive(:modules).and_return([mod])
+        Puppet[:pluginfactdest] = pluginfactdest
+      end
+
+      it 'should skip files' do
+        expect(File).to receive(:directory?).with(modulefactsd).and_return(false)
+        expect(Facter).to receive(:search_external).with([pluginfactdest, options[:external_dir]])
+        Puppet::Node::Facts::Facter.setup_external_search_paths @request
+      end
+
+      it 'should add directories' do
+        expect(File).to receive(:directory?).with(modulefactsd).and_return(true)
+        expect(Facter).to receive(:search_external).with([modulefactsd, pluginfactdest, options[:external_dir]])
+        Puppet::Node::Facts::Facter.setup_external_search_paths @request
+      end
+    end
+
+    describe 'when setting up search paths' do
+      let(:factpath1) { File.expand_path 'one' }
+      let(:factpath2) { File.expand_path 'two' }
+      let(:factpath) { [factpath1, factpath2].join(File::PATH_SEPARATOR) }
+      let(:modulepath) { File.expand_path 'module/foo' }
+      let(:modulelibfacter) { File.expand_path 'module/foo/lib/facter' }
+      let(:modulepluginsfacter) { File.expand_path 'module/foo/plugins/facter' }
+      let(:options) { { resolve_options: true, custom_dir: 'some/dir' } }
+
+      before :each do
+        expect(FileTest).to receive(:directory?).with(factpath1).and_return(true)
+        expect(FileTest).to receive(:directory?).with(factpath2).and_return(true)
+        allow(@request.environment).to receive(:modulepath).and_return([modulepath])
+        expect(Dir).to receive(:glob).with("#{modulepath}/*/lib/facter").and_return([modulelibfacter])
+        expect(Dir).to receive(:glob).with("#{modulepath}/*/plugins/facter").and_return([modulepluginsfacter])
+
+        Puppet[:factpath] = factpath
+      end
+
+      it 'should skip files' do
+        expect(FileTest).to receive(:directory?).with(modulelibfacter).and_return(false)
+        expect(FileTest).to receive(:directory?).with(modulepluginsfacter).and_return(false)
+        expect(Facter).to receive(:search).with(factpath1, factpath2, options[:custom_dir])
+        Puppet::Node::Facts::Facter.setup_search_paths @request
+      end
+
+      it 'should add directories' do
+        expect(FileTest).to receive(:directory?).with(modulelibfacter).and_return(true)
+        expect(FileTest).to receive(:directory?).with(modulepluginsfacter).and_return(false)
+        expect(Facter).to receive(:search).with(modulelibfacter, factpath1, factpath2, options[:custom_dir])
+        Puppet::Node::Facts::Facter.setup_search_paths @request
+      end
+    end
+  end
 end

data/spec/unit/indirector/facts/json_spec.rb

@@ -0,0 +1,255 @@
+require 'spec_helper'
+
+require 'puppet/node/facts'
+require 'puppet/indirector/facts/json'
+
+def dir_containing_json_facts(hash)
+  jsondir = tmpdir('json_facts')
+
+  Puppet[:client_datadir] = jsondir
+  dir = File.join(jsondir, 'facts')
+  Dir.mkdir(dir)
+  hash.each_pair do |file, facts|
+    File.open(File.join(dir, file), 'wb') do |f|
+      f.write(JSON.dump(facts))
+    end
+  end
+end
+
+describe Puppet::Node::Facts::Json do
+  include PuppetSpec::Files
+
+  it "should be a subclass of the Json terminus" do
+    expect(Puppet::Node::Facts::Json.superclass).to equal(Puppet::Indirector::JSON)
+  end
+
+  it "should have documentation" do
+    expect(Puppet::Node::Facts::Json.doc).not_to be_nil
+    expect(Puppet::Node::Facts::Json.doc).not_to be_empty
+  end
+
+  it "should be registered with the facts indirection" do
+    indirection = Puppet::Indirector::Indirection.instance(:facts)
+    expect(Puppet::Node::Facts::Json.indirection).to equal(indirection)
+  end
+
+  it "should have its name set to :json" do
+    expect(Puppet::Node::Facts::Json.name).to eq(:json)
+  end
+
+  it "should allow network requests" do
+    # Doesn't allow json as a network format, but allows `puppet facts upload`
+    # to update the JSON cache on a master.
+    expect(Puppet::Node::Facts::Json.new.allow_remote_requests?).to be(true)
+  end
+
+  describe "#search" do
+    def assert_search_matches(matching, nonmatching, query)
+      request = Puppet::Indirector::Request.new(:inventory, :search, nil, nil, query)
+
+      dir_containing_json_facts(matching.merge(nonmatching))
+
+      results = Puppet::Node::Facts::Json.new.search(request)
+      expect(results).to match_array(matching.values.map {|facts| facts.name})
+    end
+
+    it "should return node names that match the search query options" do
+      assert_search_matches({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386", 'processor_count' => '4'),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "i386", 'processor_count' => '4', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
+          "nonmatching1.json" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
+          "nonmatching3.json" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
+        },
+        {'facts.architecture' => 'i386', 'facts.processor_count' => '4'}
+      )
+    end
+
+    it "should return empty array when no nodes match the search query options" do
+      assert_search_matches({}, {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '10'),
+          "nonmatching1.json" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
+          "nonmatching3.json" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
+        },
+        {'facts.processor_count.lt' => '4', 'facts.processor_count.gt' => '4'}
+      )
+    end
+
+    it "should return node names that match the search query options with the greater than operator" do
+      assert_search_matches({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '10', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '3'),
+          "nonmatching3.json" => Puppet::Node::Facts.new("nonmatchingnode3"                                                       ),
+        },
+        {'facts.processor_count.gt' => '4'}
+      )
+    end
+
+    it "should return node names that match the search query options with the less than operator" do
+      assert_search_matches({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '30', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '50' ),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '100'),
+          "nonmatching3.json" => Puppet::Node::Facts.new("nonmatchingnode3"                                                         ),
+        },
+        {'facts.processor_count.lt' => '50'}
+      )
+    end
+
+    it "should return node names that match the search query options with the less than or equal to operator" do
+      assert_search_matches({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '100' ),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5000'),
+          "nonmatching3.json" => Puppet::Node::Facts.new("nonmatchingnode3"                                                          ),
+        },
+        {'facts.processor_count.le' => '50'}
+      )
+    end
+
+    it "should return node names that match the search query options with the greater than or equal to operator" do
+      assert_search_matches({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '100'),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '40'),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '9' ),
+          "nonmatching3.json" => Puppet::Node::Facts.new("nonmatchingnode3"                                                        ),
+        },
+        {'facts.processor_count.ge' => '50'}
+      )
+    end
+
+    it "should return node names that match the search query options with the not equal operator" do
+      assert_search_matches({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => 'arm'                           ),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => 'powerpc', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "i386"                           ),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '9' ),
+          "nonmatching3.json" => Puppet::Node::Facts.new("nonmatchingnode3"                                                     ),
+        },
+        {'facts.architecture.ne' => 'i386'}
+      )
+    end
+
+    def apply_timestamp(facts, timestamp)
+      facts.timestamp = timestamp
+      facts
+    end
+
+    it "should be able to query based on meta.timestamp.gt" do
+      assert_search_matches({
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        },
+        {
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {'meta.timestamp.gt' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp.le" do
+      assert_search_matches({
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        },
+        {'meta.timestamp.le' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp.lt" do
+      assert_search_matches({
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {'meta.timestamp.lt' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp.ge" do
+      assert_search_matches({
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {'meta.timestamp.ge' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp.eq" do
+      assert_search_matches({
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {'meta.timestamp.eq' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp" do
+      assert_search_matches({
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {'meta.timestamp' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp.ne" do
+      assert_search_matches({
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {'meta.timestamp.ne' => '2010-10-15'}
+      )
+    end
+  end
+end

data/spec/unit/indirector/file_bucket_file/selector_spec.rb

@@ -5,22 +5,40 @@ require 'puppet/indirector/file_bucket_file/file'
 require 'puppet/indirector/file_bucket_file/rest'
 
 describe Puppet::FileBucketFile::Selector do
+  let(:model) { Puppet::FileBucket::File.new('') }
+  let(:indirection) { Puppet::FileBucket::File.indirection }
+  let(:terminus) { indirection.terminus(:selector) }
+
   %w[head find save search destroy].each do |method|
     describe "##{method}" do
       it "should proxy to rest terminus for https requests" do
-        request = double('request', :protocol => 'https')
+        key = "https://example.com/path/to/file"
 
-        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(method).with(request)
+        expect(indirection.terminus(:rest)).to receive(method)
 
-        subject.send(method, request)
+        if method == 'save'
+          terminus.send(method, indirection.request(method, key, model))
+        else
+          terminus.send(method, indirection.request(method, key, nil))
+        end
       end
 
       it "should proxy to file terminus for other requests" do
-        request = double('request', :protocol => 'file')
-
-        expect_any_instance_of(Puppet::FileBucketFile::File).to receive(method).with(request)
-
-        subject.send(method, request)
+        key = "file:///path/to/file"
+
+        case method
+        when 'save'
+          expect(indirection.terminus(:file)).to receive(method)
+          terminus.send(method, indirection.request(method, key, model))
+        when 'find', 'head'
+          expect(indirection.terminus(:file)).to receive(method)
+          terminus.send(method, indirection.request(method, key, nil))
+        else
+          # file terminus doesn't implement search or destroy
+          expect {
+            terminus.send(method, indirection.request(method, key, nil))
+          }.to raise_error(NoMethodError)
+        end
       end
     end
   end