puppet 5.3.4 → 6.29.0

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_bucket_file/file'
@@ -23,7 +22,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         expect(result.contents).to be_empty
       end
 
-      it "deals with multiple processes saving at the same time", :unless => Puppet::Util::Platform.windows? do
+      it "deals with multiple processes saving at the same time", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
         bucket_file = Puppet::FileBucket::File.new("contents")
 
         children = []
@@ -55,7 +54,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         checksum_value = save_bucket_file(first_contents, "/foo/bar")
 
         # We expect Puppet to log an error with the path to the file
-        Puppet.expects(:err).with(regexp_matches(/Unable to verify existing FileBucket backup at '#{Puppet[:bucketdir]}.*#{checksum_value}\/contents'/))
+        expect(Puppet).to receive(:err).with(/Unable to verify existing FileBucket backup at '#{Puppet[:bucketdir]}.*#{checksum_value}\/contents'/)
 
         # But the exception should not contain it
         expect do
@@ -80,7 +79,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         end
 
         it "issues a warning that the backup will be overwritten" do
-          Puppet.expects(:warning).with(regexp_matches(/Existing backup does not match its expected sum, #{bucket_file.checksum}/))
+          expect(Puppet).to receive(:warning).with(/Existing backup does not match its expected sum, #{bucket_file.checksum}/)
           Puppet::FileBucket::File.indirection.save(bucket_file)
         end
 
@@ -92,44 +91,60 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
 
       describe "when supplying a path" do
         with_digest_algorithms do
-          it "should store the path if not already stored" do
-            checksum = save_bucket_file(plaintext, "/foo/bar")
-
-            dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
-            contents_file = "#{dir_path}/contents"
-            paths_file = "#{dir_path}/paths"
-            expect(Puppet::FileSystem.binread(contents_file)).to eq(plaintext)
-            expect(Puppet::FileSystem.read(paths_file)).to eq("foo/bar\n")
-          end
-
-          it "should leave the paths file alone if the path is already stored" do
-            checksum = save_bucket_file(plaintext, "/foo/bar")
-            checksum = save_bucket_file(plaintext, "/foo/bar")
-            dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
-            expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
-            expect(File.read("#{dir_path}/paths")).to eq("foo/bar\n")
-          end
-
-          it "should store an additional path if the new path differs from those already stored" do
-            checksum = save_bucket_file(plaintext, "/foo/bar")
-
-            checksum = save_bucket_file(plaintext, "/foo/baz")
-
-            dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
-            expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
-            expect(File.read("#{dir_path}/paths")).to eq("foo/bar\nfoo/baz\n")
-          end
+            it "should store the path if not already stored" do
+              if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+                skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+              else
+                save_bucket_file(plaintext, "/foo/bar")
+  
+                dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+                contents_file = "#{dir_path}/contents"
+                paths_file = "#{dir_path}/paths"
+                expect(Puppet::FileSystem.binread(contents_file)).to eq(plaintext)
+                expect(Puppet::FileSystem.read(paths_file)).to eq("foo/bar\n")
+              end
+            end
+  
+            it "should leave the paths file alone if the path is already stored" do
+              if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+                skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+              else
+                # save it twice
+                save_bucket_file(plaintext, "/foo/bar")
+                save_bucket_file(plaintext, "/foo/bar")
+                dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+                expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
+                expect(File.read("#{dir_path}/paths")).to eq("foo/bar\n")
+              end
+            end
+  
+            it "should store an additional path if the new path differs from those already stored" do
+              if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+                skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+              else
+                save_bucket_file(plaintext, "/foo/bar")
+                save_bucket_file(plaintext, "/foo/baz")
+                dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+                expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
+                expect(File.read("#{dir_path}/paths")).to eq("foo/bar\nfoo/baz\n")
+              end
+            end
+          # end
         end
       end
 
       describe "when not supplying a path" do
         with_digest_algorithms do
           it "should save the file and create an empty paths file" do
-            checksum = save_bucket_file(plaintext, "")
-
-            dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
-            expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
-            expect(File.read("#{dir_path}/paths")).to eq("")
+            if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+              skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+            else
+              save_bucket_file(plaintext, "")
+  
+              dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
+              expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
+              expect(File.read("#{dir_path}/paths")).to eq("")
+            end
           end
         end
       end
@@ -157,37 +172,45 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
           end
 
           it "should return the list of bucketed files in a human readable way" do
-            checksum1 = save_bucket_file("I'm the contents of a file", '/foo/bar1')
-            checksum2 = save_bucket_file("I'm the contents of another file", '/foo/bar2')
-            checksum3 = save_bucket_file("I'm the modified content of a existing file", '/foo/bar1')
-
-            # Use the first checksum as we know it's stored in the bucket
-            find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}/foo/bar1", :list_all => true)
-
-            # The list is sort order from date and file name, so first and third checksums come before the second
-            date_pattern = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
-            expect(find_result.to_s).to match(Regexp.new("^(#{checksum1}|#{checksum3}) #{date_pattern} foo/bar1\\n(#{checksum3}|#{checksum1}) #{date_pattern} foo/bar1\\n#{checksum2} #{date_pattern} foo/bar2\\n$"))
+            if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+              skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+            else
+              checksum1 = save_bucket_file("I'm the contents of a file", '/foo/bar1')
+              checksum2 = save_bucket_file("I'm the contents of another file", '/foo/bar2')
+              checksum3 = save_bucket_file("I'm the modified content of a existing file", '/foo/bar1')
+  
+              # Use the first checksum as we know it's stored in the bucket
+              find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}/foo/bar1", :list_all => true)
+  
+              # The list is sort order from date and file name, so first and third checksums come before the second
+              date_pattern = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
+              expect(find_result.to_s).to match(Regexp.new("^(#{checksum1}|#{checksum3}) #{date_pattern} foo/bar1\\n(#{checksum3}|#{checksum1}) #{date_pattern} foo/bar1\\n#{checksum2} #{date_pattern} foo/bar2\\n$"))
+            end
           end
 
           it "should fail in an informative way when provided dates are not in the right format" do
-            contents = "I'm the contents of a file"
-            save_bucket_file(contents, '/foo/bar1')
-            expect {
-              Puppet::FileBucket::File.indirection.find(
-                "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
-                :list_all => true,
-                :todate => "0:0:0 1-1-1970",
-                :fromdate => "WEIRD"
-              )
-            }.to raise_error(Puppet::Error, /fromdate/)
-            expect {
-              Puppet::FileBucket::File.indirection.find(
-                "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
-                :list_all => true,
-                :todate => "WEIRD",
-                :fromdate => Time.now
-              )
-            }.to raise_error(Puppet::Error, /todate/)
+            if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+              skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+            else
+              contents = "I'm the contents of a file"
+              save_bucket_file(contents, '/foo/bar1')
+              expect {
+                Puppet::FileBucket::File.indirection.find(
+                  "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
+                  :list_all => true,
+                  :todate => "0:0:0 1-1-1970",
+                  :fromdate => "WEIRD"
+                )
+              }.to raise_error(Puppet::Error, /fromdate/)
+              expect {
+                Puppet::FileBucket::File.indirection.find(
+                  "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
+                  :list_all => true,
+                  :todate => "WEIRD",
+                  :fromdate => Time.now
+                )
+              }.to raise_error(Puppet::Error, /todate/)
+            end
           end
         end
 
@@ -198,21 +221,30 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
           end
 
           it "should return false/nil if the file is bucketed but with a different path" do
-            checksum = save_bucket_file("I'm the contents of a file", '/foo/bar')
 
-            expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/baz")).to eq(false)
-            expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/baz")).to eq(nil)
+            if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+              skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+            else
+              checksum = save_bucket_file("I'm the contents of a file", '/foo/bar')
+  
+              expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/baz")).to eq(false)
+              expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/baz")).to eq(nil)
+            end
           end
 
           it "should return true/file if the file is already bucketed with the given path" do
-            contents = "I'm the contents of a file"
-
-            checksum = save_bucket_file(contents, '/foo/bar')
-
-            expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/bar")).to eq(true)
-            find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/bar")
-            expect(find_result.checksum).to eq("{#{digest_algorithm}}#{checksum}")
-            expect(find_result.to_s).to eq(contents)
+            if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+              skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+            else
+              contents = "I'm the contents of a file"
+  
+              checksum = save_bucket_file(contents, '/foo/bar')
+  
+              expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/bar")).to eq(true)
+              find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/bar")
+              expect(find_result.checksum).to eq("{#{digest_algorithm}}#{checksum}")
+              expect(find_result.to_s).to eq(contents)
+            end
           end
         end
 
@@ -227,16 +259,21 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
               end
 
               it "should return true/file if the file is already bucketed" do
+    
                 # this one replaces most of the lets in the "when
                 # digest_digest_algorithm is set..." shared context, but it still needs digest_algorithm
-                contents = "I'm the contents of a file"
-
-                checksum = save_bucket_file(contents, '/foo/bar')
-
-                expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}#{trailing_string}")).to eq(true)
-                find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}#{trailing_string}")
-                expect(find_result.checksum).to eq("{#{digest_algorithm}}#{checksum}")
-                expect(find_result.to_s).to eq(contents)
+                if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+                  skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+                else
+                  contents = "I'm the contents of a file"
+  
+                  checksum = save_bucket_file(contents, '/foo/bar')
+  
+                  expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}#{trailing_string}")).to eq(true)
+                  find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}#{trailing_string}")
+                  expect(find_result.checksum).to eq("{#{digest_algorithm}}#{checksum}")
+                  expect(find_result.to_s).to eq(contents)
+                end
               end
             end
           end
@@ -244,36 +281,54 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
       end
     end
 
-    describe "when diffing files", :unless => Puppet.features.microsoft_windows? do
+    describe "when diffing files", :unless => Puppet::Util::Platform.windows? do
       with_digest_algorithms do
         let(:not_bucketed_plaintext) { "other stuff" }
         let(:not_bucketed_checksum) { digest(not_bucketed_plaintext) }
 
         it "should generate an empty string if there is no diff" do
-          checksum = save_bucket_file("I'm the contents of a file")
-          expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}", :diff_with => checksum)).to eq('')
+          skip("usage of fork(1) no supported on this platform") if RUBY_PLATFORM == 'java'
+          if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+            skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+          else
+            checksum = save_bucket_file("I'm the contents of a file")
+            expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}", :diff_with => checksum)).to eq('')
+          end
         end
 
         it "should generate a proper diff if there is a diff" do
-          checksum1 = save_bucket_file("foo\nbar\nbaz")
-          checksum2 = save_bucket_file("foo\nbiz\nbaz")
-
-          diff = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}", :diff_with => checksum2)
-          expect(diff).to include("-bar\n+biz\n")
+          skip("usage of fork(1) no supported on this platform") if RUBY_PLATFORM == 'java'
+          if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+            skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+          else
+            checksum1 = save_bucket_file("foo\nbar\nbaz")
+            checksum2 = save_bucket_file("foo\nbiz\nbaz")
+  
+            diff = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}", :diff_with => checksum2)
+            expect(diff).to include("-bar\n+biz\n")
+          end
         end
 
         it "should raise an exception if the hash to diff against isn't found" do
-          checksum = save_bucket_file("whatever")
-
-          expect do
-            Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}", :diff_with => not_bucketed_checksum)
-          end.to raise_error "could not find diff_with #{not_bucketed_checksum}"
+          if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+            skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+          else
+            checksum = save_bucket_file("whatever")
+  
+            expect do
+              Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}", :diff_with => not_bucketed_checksum)
+            end.to raise_error "could not find diff_with #{not_bucketed_checksum}"
+          end
         end
 
         it "should return nil if the hash to diff from isn't found" do
-          checksum = save_bucket_file("whatever")
-
-          expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}", :diff_with => checksum)).to eq(nil)
+          if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
+            skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+          else
+            checksum = save_bucket_file("whatever")
+  
+            expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}", :diff_with => checksum)).to eq(nil)
+          end
         end
       end
     end
@@ -285,7 +340,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         describe "when #{supply_path ? 'supplying' : 'not supplying'} a path" do
           with_digest_algorithms do
             before :each do
-              Puppet.settings.stubs(:use)
+              allow(Puppet.settings).to receive(:use)
               @store = Puppet::FileBucketFile::File.new
 
               @bucket_top_dir = tmpdir("bucket")
@@ -343,6 +398,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
 
             describe "when saving files" do
               it "should save the contents to the calculated path" do
+                skip("Windows Long File Name support is incomplete PUP-8257, this doesn't fail reliably so it should be skipped.") if Puppet::Util::Platform.windows? && (['sha512', 'sha384'].include? digest_algorithm)
                 options = {}
                 if override_bucket_path
                   options[:bucket_path] = @bucket_top_dir

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

@@ -1,10 +1,89 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_bucket_file/rest'
 
 describe Puppet::FileBucketFile::Rest do
-  it "should be a sublcass of Puppet::Indirector::REST" do
-    expect(Puppet::FileBucketFile::Rest.superclass).to equal(Puppet::Indirector::REST)
+  let(:rest_path) {"filebucket://xanadu:8141/"}
+  let(:file_bucket_file) {Puppet::FileBucket::File.new('file contents', :bucket_path => '/some/random/path')}
+  let(:files_original_path) {'/path/to/file'}
+  let(:dest_path) {"#{rest_path}#{file_bucket_file.name}/#{files_original_path}"}
+  let(:file_bucket_path) {"#{rest_path}#{file_bucket_file.checksum_type}/#{file_bucket_file.checksum_data}/#{files_original_path}"}
+  let(:source_path) {"#{rest_path}#{file_bucket_file.checksum_type}/#{file_bucket_file.checksum_data}"}
+
+  let(:uri) { %r{/puppet/v3/file_bucket_file} }
+
+  describe '#head' do
+    it 'includes the environment as a request parameter' do
+      stub_request(:head, uri).with(query: hash_including(environment: 'outerspace'))
+
+      described_class.indirection.head(file_bucket_path, :bucket_path => file_bucket_file.bucket_path, environment: Puppet::Node::Environment.remote('outerspace'))
+    end
+
+    it 'includes bucket path in the request if bucket path is set' do
+      stub_request(:head, uri).with(query: hash_including(bucket_path: '/some/random/path'))
+
+      described_class.indirection.head(file_bucket_path, :bucket_path => file_bucket_file.bucket_path)
+    end
+
+    it "returns nil on 404" do
+      stub_request(:head, uri).to_return(status: 404)
+
+      expect(described_class.indirection.head(file_bucket_path, :bucket_path => file_bucket_file.bucket_path)).to be_falsy
+    end
+
+    it "raises for all other fail codes" do
+      stub_request(:head, uri).to_return(status: [503, 'server unavailable'])
+
+      expect{described_class.indirection.head(file_bucket_path, :bucket_path => file_bucket_file.bucket_path)}.to raise_error(Net::HTTPError, "Error 503 on SERVER: server unavailable")
+    end
+  end
+
+  describe '#find' do
+    it 'includes the environment as a request parameter' do
+      stub_request(:get, uri).with(query: hash_including(environment: 'outerspace')).to_return(status: 200, headers: {'Content-Type' => 'application/octet-stream'})
+
+      described_class.indirection.find(source_path, :bucket_path => nil, environment: Puppet::Node::Environment.remote('outerspace'))
+    end
+
+    {bucket_path: 'path', diff_with: '4aabe1257043bd0', list_all: 'true', fromdate: '20200404', todate: '20200404'}.each do |param, val|
+      it "includes #{param} as a parameter in the request if #{param} is set" do
+        stub_request(:get, uri).with(query: hash_including(param => val)).to_return(status: 200, headers: {'Content-Type' => 'application/octet-stream'})
+
+        options = { param => val }
+        described_class.indirection.find(source_path, **options)
+      end
+    end
+
+    it 'raises if unsuccessful' do
+      stub_request(:get, uri).to_return(status: [503, 'server unavailable'])
+
+      expect{described_class.indirection.find(source_path, :bucket_path => nil)}.to raise_error(Net::HTTPError, "Error 503 on SERVER: server unavailable")
+    end
+
+    it 'raises if Content-Type is not included in the response' do
+      stub_request(:get, uri).to_return(status: 200, headers: {})
+
+      expect{described_class.indirection.find(source_path, :bucket_path => nil)}.to raise_error(RuntimeError, "No content type in http response; cannot parse")
+    end
+  end
+
+  describe '#save' do
+    it 'includes the environment as a request parameter' do
+      stub_request(:put, uri).with(query: hash_including(environment: 'outerspace'))
+
+      described_class.indirection.save(file_bucket_file, dest_path, environment: Puppet::Node::Environment.remote('outerspace'))
+    end
+
+    it 'sends the contents of the file as the request body' do
+      stub_request(:put, uri).with(body: file_bucket_file.contents)
+
+      described_class.indirection.save(file_bucket_file, dest_path)
+    end
+
+    it 'raises if unsuccessful' do
+      stub_request(:put, uri).to_return(status: [503, 'server unavailable'])
+
+      expect{described_class.indirection.save(file_bucket_file, dest_path)}.to raise_error(Net::HTTPError, "Error 503 on SERVER: server unavailable")
+    end
   end
 end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_bucket_file/selector'
@@ -6,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 = stub 'request', :protocol => 'https'
+        key = "https://example.com/path/to/file"
 
-        Puppet::FileBucketFile::Rest.any_instance.expects(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 = stub 'request', :protocol => 'file'
-
-        Puppet::FileBucketFile::File.any_instance.expects(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

data/spec/unit/indirector/file_content/file_server_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_content/file_server'

data/spec/unit/indirector/file_content/file_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_content/file'

data/spec/unit/indirector/file_content/rest_spec.rb

@@ -1,12 +1,62 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_content/rest'
 
 describe Puppet::Indirector::FileContent::Rest do
-  it "should add the node's cert name to the arguments"
+  let(:certname) { 'ziggy' }
+  let(:uri) { %r{/puppet/v3/file_content/:mount/path/to/file} }
+  let(:key) { "puppet:///:mount/path/to/file" }
 
-  it "should set the content type to text/plain"
+  before :each do
+    described_class.indirection.terminus_class = :rest
+  end
+
+  def file_content_response
+    {body: "some content", headers: { 'Content-Type' => 'application/octet-stream' } }
+  end
+
+  it "returns content as a binary string" do
+    stub_request(:get, uri).to_return(status: 200, **file_content_response)
+
+    file_content = described_class.indirection.find(key)
+    expect(file_content.content.encoding).to eq(Encoding::BINARY)
+    expect(file_content.content).to eq('some content')
+  end
+
+  it "URL encodes special characters" do
+    stub_request(:get, %r{/puppet/v3/file_content/:mount/path%20to%20file}).to_return(status: 200, **file_content_response)
+
+    described_class.indirection.find('puppet:///:mount/path to file')
+  end
+
+  it "returns nil if the content doesn't exist" do
+    stub_request(:get, uri).to_return(status: 404)
+
+    expect(described_class.indirection.find(key)).to be_nil
+  end
+
+  it "raises if fail_on_404 is true" do
+    stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json'}, body: "{}")
+
+    expect {
+      described_class.indirection.find(key, fail_on_404: true)
+    }.to raise_error(Puppet::Error, %r{Find /puppet/v3/file_content/:mount/path/to/file resulted in 404 with the message: {}})
+  end
+
+  it "raises an error on HTTP 500" do
+    stub_request(:get, uri).to_return(status: 500, headers: { 'Content-Type' => 'application/json'}, body: "{}")
+
+    expect {
+      described_class.indirection.find(key)
+    }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
+  end
+
+  it "connects to a specific host" do
+    stub_request(:get, %r{https://example.com:8140/puppet/v3/file_content/:mount/path/to/file})
+      .to_return(status: 200, **file_content_response)
+
+    described_class.indirection.find("puppet://example.com:8140/:mount/path/to/file")
+  end
 
   it "should use the :fileserver SRV service" do
     expect(Puppet::Indirector::FileContent::Rest.srv_service).to eq(:fileserver)

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_content/selector'

data/spec/unit/indirector/file_metadata/file_server_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_metadata/file_server'