puppet 4.0.0 → 4.10.0

data/spec/unit/face/help_spec.rb

@@ -48,6 +48,24 @@ describe Puppet::Face[:help, '0.0.1'] do
       to eq(subject.help(:huzzah, :version => :current))
   end
 
+  it "raises an ArgumentError if the face raises a StandardError" do
+    face = Puppet::Face[:module, :current]
+    face.stubs(:short_description).raises(StandardError, "whoops")
+
+    expect {
+      subject.help(:module)
+    }.to raise_error(ArgumentError, /Detail: "whoops"/)
+  end
+
+  it "raises an ArgumentError if the face raises a LoadError" do
+    face = Puppet::Face[:module, :current]
+    face.stubs(:short_description).raises(LoadError, "cannot load such file -- yard")
+
+    expect {
+      subject.help(:module)
+    }.to raise_error(ArgumentError, /Detail: "cannot load such file -- yard"/)
+  end
+
   context "when listing subcommands" do
     subject { Puppet::Face[:help, :current].help }
 
@@ -84,6 +102,18 @@ describe Puppet::Face[:help, '0.0.1'] do
       end
     end
 
+    it "returns an 'unavailable' summary if the 'agent' application fails to generate help" do
+      Puppet::Application['agent'].class.any_instance.stubs(:help).raises(ArgumentError, "whoops")
+
+      expect(subject).to match(/agent\s+! Subcommand unavailable due to error\. Check error logs\./)
+    end
+
+    it "returns an 'unavailable' summary if the legacy application raises a LoadError" do
+      Puppet::Application['agent'].class.any_instance.stubs(:help).raises(LoadError, "cannot load such file -- yard")
+
+      expect(subject).to match(/agent\s+! Subcommand unavailable due to error\. Check error logs\./)
+    end
+
     context "face summaries" do
       it "can generate face summaries" do
         faces = Puppet::Face.faces
@@ -92,6 +122,13 @@ describe Puppet::Face[:help, '0.0.1'] do
           expect(Puppet::Face[name, :current]).to have_a_summary
         end
       end
+
+      it "returns an 'unavailable' summary if the face application raises a LoadError" do
+        face = Puppet::Face[:module, :current]
+        face.stubs(:summary).raises(LoadError, "cannot load such file -- yard")
+
+        expect(Puppet::Face[:help, :current].help).to match(/module\s+! Subcommand unavailable due to error\. Check error logs\./)
+      end
     end
 
     it "lists all legacy applications" do
@@ -104,6 +141,23 @@ describe Puppet::Face[:help, '0.0.1'] do
     end
   end
 
+  context "deprecated faces" do
+    it "prints a deprecation warning for deprecated faces" do
+      Puppet::Face[:module, :current].stubs(:deprecated?).returns(true)
+      expect(Puppet::Face[:help, :current].help(:module)).to match(/Warning: 'puppet module' is deprecated/)
+    end
+  end
+
+  context "#all_application_summaries" do
+    it "appends a deprecation warning for deprecated faces" do
+      # Stub the module face as deprecated
+      Puppet::Face[:module, :current].expects(:deprecated?).returns(true)
+      result = Puppet::Face[:help, :current].all_application_summaries.each do |appname,summary|
+        expect(summary).to match(/Deprecated/) if appname == 'module'
+      end
+    end
+  end
+
   context "#legacy_applications" do
     subject { Puppet::Face[:help, :current].legacy_applications }
 
@@ -141,5 +195,21 @@ describe Puppet::Face[:help, '0.0.1'] do
       expect { subject.help(appname, :whatever) }.
         to raise_error ArgumentError, /Legacy subcommands don't take actions/
     end
+
+    it "raises an ArgumentError if a legacy application raises a StandardError" do
+      Puppet::Application[appname].class.any_instance.stubs(:help).raises(StandardError, "whoops")
+
+      expect {
+        subject.help(appname)
+      }.to raise_error ArgumentError, /Detail: "whoops"/
+    end
+
+    it "raises an ArgumentError if a legacy application raises a LoadError" do
+      Puppet::Application[appname].class.any_instance.stubs(:help).raises(LoadError, "cannot load such file -- yard")
+
+      expect {
+        subject.help(appname)
+      }.to raise_error ArgumentError, /Detail: "cannot load such file -- yard"/
+    end
   end
 end

data/spec/unit/face/key_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:key, '0.0.1'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+

data/spec/unit/face/module/search_spec.rb

@@ -171,7 +171,7 @@ describe "puppet module search" do
       end
     end
 
-    it "should accept the --module-repository option" do
+    it "should accept the --module_repository option" do
       forge = mock("Puppet::Forge")
       searcher = mock("Searcher")
       options[:module_repository] = "http://forge.example.com"

data/spec/unit/face/node_spec.rb

@@ -47,7 +47,7 @@ describe Puppet::Face[:node, '0.0.1'] do
     end
 
     it "should not accept a call with no arguments" do
-      expect { subject.clean() }.to raise_error
+      expect { subject.clean() }.to raise_error(RuntimeError, /At least one node should be passed/)
     end
 
     it "should accept a node name" do

data/spec/unit/face/parser_spec.rb

@@ -14,6 +14,12 @@ describe Puppet::Face[:parser, :current] do
         from_an_interactive_terminal
       end
 
+      after(:each) do
+        # Reset cache of loaders (many examples run in the *root* environment
+        # which exists in "eternity")
+        Puppet.lookup(:current_environment).loaders = nil
+      end
+
       it "validates the configured site manifest when no files are given" do
         manifest = file_containing('site.pp', "{ invalid =>")
 
@@ -30,9 +36,25 @@ describe Puppet::Face[:parser, :current] do
       end
 
       it "runs error free when there are no validation errors" do
-        manifest = file_containing('site.pp', "notify { valid: }")
+        expect {
+            manifest = file_containing('site.pp', "notify { valid: }")
+            parser.validate(manifest)
+        }.to_not raise_error
+      end
 
-        parser.validate(manifest)
+      it "runs error free when there is a puppet function in manifest being validated" do
+        expect {
+          manifest = file_containing('site.pp', "function valid() { 'valid' } notify{ valid(): }")
+          parser.validate(manifest)
+        }.to_not raise_error
+      end
+
+      it "runs error free when there is a type alias in a manifest that requires type resolution" do
+        expect {
+          manifest = file_containing('site.pp',
+            "type A = String; type B = Array[A]; function valid(B $x) { $x } notify{ valid([valid]): }")
+          parser.validate(manifest)
+        }.to_not raise_error
       end
 
       it "reports missing files" do
@@ -98,6 +120,31 @@ describe Puppet::Face[:parser, :current] do
       expect(@logs[0].message).to eq("Syntax error at end of file")
       expect(@logs[0].level).to eq(:err)
     end
+
+    it "logs an error if the input begins with a UTF-8 BOM (Byte Order Mark)" do
+      utf8_bom_manifest = file_containing('utf8_bom.pp', "\uFEFFnotice hi")
+
+      output = parser.dump(utf8_bom_manifest)
+
+      expect(output).to eq("")
+      expect(@logs[1].message).to eq("Illegal UTF-8 Byte Order mark at beginning of input: [EF BB BF] - remove these from the puppet source")
+      expect(@logs[1].level).to eq(:err)
+    end
+
+    it "runs error free when there is a puppet function in manifest being dumped" do
+      expect {
+        manifest = file_containing('site.pp', "function valid() { 'valid' } notify{ valid(): }")
+        parser.dump(manifest)
+      }.to_not raise_error
+    end
+
+    it "runs error free when there is a type alias in a manifest that requires type resolution" do
+      expect {
+        manifest = file_containing('site.pp',
+          "type A = String; type B = Array[A]; function valid(B $x) { $x } notify{ valid([valid]): }")
+        parser.dump(manifest)
+      }.to_not raise_error
+    end
   end
 
   def from_an_interactive_terminal

data/spec/unit/face/plugin_spec.rb

@@ -2,9 +2,34 @@
 require 'spec_helper'
 require 'puppet/face'
 
-describe Puppet::Face[:plugin, '0.0.1'] do
-  [:download].each do |action|
-    it { is_expected.to be_action action }
-    it { is_expected.to respond_to action }
+describe Puppet::Face[:plugin, :current] do
+
+  let(:pluginface) { described_class }
+  let(:action) { pluginface.get_action(:download) }
+
+  def render(result)
+    action.when_rendering(:console).call(result)
+  end
+
+  context "download" do
+    it "downloads plugins and external facts" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns([])
+
+      pluginface.download
+    end
+
+    it "renders 'No plugins downloaded' if nothing was downloaded" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns([])
+
+      result = pluginface.download
+      expect(render(result)).to eq('No plugins downloaded.')
+    end
+
+    it "renders comma separate list of downloaded file names" do
+      Puppet::Configurer::Downloader.any_instance.expects(:evaluate).twice.returns(%w[/a]).then.returns(%w[/b])
+
+      result = pluginface.download
+      expect(render(result)).to eq('Downloaded these plugins: /a, /b')
+    end
   end
 end

data/spec/unit/face/status_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:status, '0.0.1'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+

data/spec/unit/file_bucket/dipper_spec.rb

@@ -72,6 +72,216 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     expect { @dipper.backup(file) }.to raise_error(Puppet::Error)
   end
 
+  describe "when diffing on a local filebucket" do
+    describe "in non-windows environments", :unless => Puppet.features.microsoft_windows? do
+      with_digest_algorithms do
+
+        it "should fail in an informative way when one or more checksum doesn't exists" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
+          wrong_checksum = "DEADBEEF"
+
+          # First checksum fails
+          expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(RuntimeError, "Invalid checksum #{wrong_checksum.inspect}")
+
+          file = make_tmp_file(plaintext)
+          @dipper.backup(file)
+
+          #Diff_with checksum fails
+          expect { @dipper.diff(checksum, wrong_checksum, nil, nil) }.to raise_error(RuntimeError, "could not find diff_with #{wrong_checksum}")
+        end
+
+        it "should properly diff files on the filebucket" do
+          file1 = make_tmp_file("OriginalContent")
+          file2 = make_tmp_file("ModifiedContent")
+          @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
+          checksum1 = @dipper.backup(file1)
+          checksum2 = @dipper.backup(file2)
+
+          # Diff without the context
+          diff12 = `diff -uN #{file1} #{file2} | sed '1,2d'`
+          diff21 = `diff -uN #{file2} #{file1} | sed '1,2d'`
+
+          expect(@dipper.diff(checksum1, checksum2, nil, nil)).to include(diff12)
+          expect(@dipper.diff(checksum1, nil, nil, file2)).to include(diff12)
+          expect(@dipper.diff(nil, checksum2, file1, nil)).to include(diff12)
+          expect(@dipper.diff(nil, nil, file1, file2)).to include(diff12)
+          expect(@dipper.diff(checksum2, checksum1, nil, nil)).to include(diff21)
+          expect(@dipper.diff(checksum2, nil, nil, file1)).to include(diff21)
+          expect(@dipper.diff(nil, checksum1, file2, nil)).to include(diff21)
+          expect(@dipper.diff(nil, nil, file2, file1)).to include(diff21)
+
+        end
+      end
+      describe "in windows environment", :if => Puppet.features.microsoft_windows? do
+        it "should fail in an informative way when trying to diff" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Path => tmpdir("bucket"))
+          wrong_checksum = "DEADBEEF"
+
+          # First checksum fails
+          expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+
+          # Diff_with checksum fails
+          expect { @dipper.diff(checksum, wrong_checksum, nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+        end
+      end
+    end
+  end
+  it "should fail in an informative way when there are failures listing files on the server" do
+    @dipper = Puppet::FileBucket::Dipper.new(:Path => "/unexistent/bucket")
+    Puppet::FileBucket::File.indirection.expects(:find).returns nil
+
+    expect { @dipper.list(nil, nil) }.to raise_error(Puppet::Error)
+  end
+
+  describe "listing files in local filebucket" do
+    with_digest_algorithms do
+      it "should list all files present" do
+        Puppet[:bucketdir] =  "/my/bucket"
+        file_bucket = tmpdir("bucket")
+
+        @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
+
+        onehour=60*60
+        twohours=onehour*2
+
+        #First File
+        file1 = make_tmp_file(plaintext)
+        real_path = Pathname.new(file1).realpath
+        expect(digest(plaintext)).to eq(checksum)
+        expect(@dipper.backup(file1)).to eq(checksum)
+        expected_list1_1 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        File.open(file1, 'w') {|f| f.write("Blahhhh")}
+        new_checksum = digest("Blahhhh")
+        expect(@dipper.backup(file1)).to eq(new_checksum)
+        expected_list1_2 = /#{new_checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        #Second File
+        content = "DummyFileWithNonSenseTextInIt"
+        file2 = make_tmp_file(content)
+        real_path = Pathname.new(file2).realpath
+        checksum = digest(content)
+        expect(@dipper.backup(file2)).to eq(checksum)
+        expected_list2 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        #Third file : Same as the first one with a different path
+        file3 = make_tmp_file(plaintext)
+        real_path = Pathname.new(file3).realpath
+        checksum = digest(plaintext)
+        expect(digest(plaintext)).to eq(checksum)
+        expect(@dipper.backup(file3)).to eq(checksum)
+        date = Time.now
+        expected_list3 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        result = @dipper.list(nil, nil)
+        expect(result).to match(expected_list1_1)
+        expect(result).to match(expected_list1_2)
+        expect(result).to match(expected_list2)
+        expect(result).to match(expected_list3)
+      end
+
+      it "should filter with the provided dates" do
+        Puppet[:bucketdir] =  "/my/bucket"
+        file_bucket = tmpdir("bucket")
+
+        twentyminutes=60*20
+        thirtyminutes=60*30
+        onehour=60*60
+        twohours=onehour*2
+        threehours=onehour*3
+
+        # First File created now
+        @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
+        file1 = make_tmp_file(plaintext)
+        real_path = Pathname.new(file1).realpath
+
+        expect(digest(plaintext)).to eq(checksum)
+        expect(@dipper.backup(file1)).to eq(checksum)
+        expected_list1 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        # Second File created an hour ago
+        content = "DummyFileWithNonSenseTextInIt"
+        file2 = make_tmp_file(content)
+        real_path = Pathname.new(file2).realpath
+        checksum = digest(content)
+        expect(@dipper.backup(file2)).to eq(checksum)
+
+        # Modify mtime of the second file to be an hour ago
+        onehourago = Time.now - onehour
+        bucketed_paths_file = Dir.glob("#{file_bucket}/**/#{checksum}/paths")
+        FileUtils.touch(bucketed_paths_file, :mtime => onehourago)
+        expected_list2 = /#{checksum} \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} #{real_path}\n/
+
+        now = Time.now
+
+        #Future
+        expect(@dipper.list((now + threehours).strftime("%F %T"), nil )).to eq("")
+
+        #Epoch -> Future = Everything (Sorted (desc) by date)
+        expect(@dipper.list(nil, (now + twohours).strftime("%F %T"))).to match(expected_list1)
+        expect(@dipper.list(nil, (now + twohours).strftime("%F %T"))).to match(expected_list2)
+
+        #Now+1sec -> Future = Nothing
+        expect(@dipper.list((now + 1).strftime("%F %T"), (now + twohours).strftime("%F %T"))).to eq("")
+
+        #Now-30mins -> Now-20mins = Nothing
+        expect(@dipper.list((now - thirtyminutes).strftime("%F %T"), (now - twentyminutes).strftime("%F %T"))).to eq("")
+
+        #Now-2hours -> Now-30mins = Second file only
+        expect(@dipper.list((now - twohours).strftime("%F %T"), (now - thirtyminutes).strftime("%F %T"))).to match(expected_list2)
+        expect(@dipper.list((now - twohours).strftime("%F %T"), (now - thirtyminutes).strftime("%F %T"))).not_to match(expected_list1)
+
+        #Now-30minutes -> Now = First file only
+        expect(@dipper.list((now - thirtyminutes).strftime("%F %T"), now.strftime("%F %T"))).to match(expected_list1)
+        expect(@dipper.list((now - thirtyminutes).strftime("%F %T"), now.strftime("%F %T"))).not_to match(expected_list2)
+      end
+    end
+  end
+
+  describe "when diffing on a remote filebucket" do
+    describe "in non-windows environments", :unless => Puppet.features.microsoft_windows? do
+      with_digest_algorithms do
+        it "should fail in an informative way when one or more checksum doesn't exists" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
+          wrong_checksum = "DEADBEEF"
+
+          Puppet::FileBucketFile::Rest.any_instance.expects(:find).returns(nil)
+          expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(Puppet::Error, "Failed to diff files")
+
+        end
+
+        it "should properly diff files on the filebucket" do
+          @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
+
+          Puppet::FileBucketFile::Rest.any_instance.expects(:find).returns("Probably valid diff")
+
+          expect(@dipper.diff("checksum1", "checksum2", nil, nil)).to eq("Probably valid diff")
+        end
+      end
+    end
+
+    describe "in windows environment", :if => Puppet.features.microsoft_windows? do
+      it "should fail in an informative way when trying to diff" do
+        @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
+        wrong_checksum = "DEADBEEF"
+
+        expect { @dipper.diff(wrong_checksum, "WEIRDCKSM", nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+
+        expect { @dipper.diff(wrong_checksum, nil, nil, nil) }.to raise_error(RuntimeError, "Diff is not supported on this platform")
+      end
+    end
+  end
+
+  describe "listing files in remote filebucket" do
+    it "is not allowed" do
+      @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port=> "31337")
+
+      expect {
+        @dipper.list(nil, nil)
+      }.to raise_error(Puppet::Error, "Listing remote file buckets is not allowed")
+    end
+  end
+
   describe "backing up and retrieving local files" do
     with_digest_algorithms do
       it "should backup files to a local bucket" do
@@ -173,4 +383,3 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
     end
   end
 end
-

data/spec/unit/file_serving/configuration/parser_spec.rb

@@ -33,16 +33,6 @@ describe Puppet::FileServing::Configuration::Parser do
       expect { @parser.parse }.not_to raise_error
     end
 
-    it "should create a new mount for each section in the configuration" do
-      mount1 = mock 'one', :validate => true
-      mount2 = mock 'two', :validate => true
-      Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
-      Puppet::FileServing::Mount::File.expects(:new).with("two").returns(mount2)
-      write_config_file "[one]\n[two]\n"
-      @parser.parse
-    end
-
-    # This test is almost the exact same as the previous one.
     it "should return a hash of the created mounts" do
       mount1 = mock 'one', :validate => true
       mount2 = mock 'two', :validate => true
@@ -108,29 +98,34 @@ describe Puppet::FileServing::Configuration::Parser do
       @parser.parse
     end
 
-    it "should tell the mount to allow any allow values from the section" do
-      write_config_file "[one]\nallow something\n"
+    [:allow,:deny].each { |acl_type|
+      it "should support inline comments in #{acl_type}" do
+        write_config_file "[one]\n#{acl_type} something \# will it work?\n"
 
       @mount.expects(:info)
-      @mount.expects(:allow).with("something")
+      @mount.expects(acl_type).with("something")
       @parser.parse
-    end
-
-    it "should support inline comments" do
-      write_config_file "[one]\nallow something \# will it work?\n"
-
-      @mount.expects(:info)
-      @mount.expects(:allow).with("something")
-      @parser.parse
-    end
-
-    it "should tell the mount to deny any deny values from the section" do
-      write_config_file "[one]\ndeny something\n"
-
-      @mount.expects(:info)
-      @mount.expects(:deny).with("something")
-      @parser.parse
-    end
+      end
+
+      it "should tell the mount to #{acl_type} from ACLs with varying spacing around commas" do
+        write_config_file "[one]\n#{acl_type} someone,sometwo, somethree , somefour ,somefive\n"
+
+        @mount.expects(:info).times(5)
+        @mount.expects(acl_type).times(5).with(any_of('someone','sometwo','somethree','somefour','somefive'))
+        @parser.parse
+      end
+
+      # each ip, with glob in the various octet positions
+      ['100','4','42','*'].permutation.map {|permutes| permutes.join('.') }.each { |ip_pattern|
+        it "should tell the mount to #{acl_type} from ACLs with glob at #{ip_pattern}" do
+          write_config_file "[one]\n#{acl_type} #{ip_pattern}\n"
+
+          @mount.expects(:info)
+          @mount.expects(acl_type).with(ip_pattern)
+          @parser.parse
+        end
+      }
+    }
 
     it "should return comprehensible error message, if failed on invalid attribute" do
       write_config_file "[one]\ndo something\n"

data/spec/unit/file_serving/configuration_spec.rb

@@ -17,7 +17,7 @@ describe Puppet::FileServing::Configuration do
   end
 
   it "should make :new a private method" do
-    expect { Puppet::FileServing::Configuration.new }.to raise_error
+    expect { Puppet::FileServing::Configuration.new }.to raise_error(NoMethodError, /private method `new' called/)
   end
 
   it "should return the same configuration each time 'configuration' is called" do

data/spec/unit/file_serving/http_metadata_spec.rb

@@ -0,0 +1,85 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/file_serving/http_metadata'
+require 'matchers/json'
+require 'net/http'
+require 'digest'
+
+describe Puppet::FileServing::HttpMetadata do
+  let(:foobar) { File.expand_path('/foo/bar') }
+
+  it "should be a subclass of Metadata" do
+    expect( described_class.superclass ).to be Puppet::FileServing::Metadata
+  end
+
+  describe "when initializing" do
+    let(:http_response) { Net::HTTPOK.new(1.0, '200', 'OK') }
+
+    it "can be instantiated from a HTTP response object" do
+      expect( described_class.new(http_response) ).to_not be_nil
+    end
+
+    it "represents a plain file" do
+      expect( described_class.new(http_response).ftype ).to eq 'file'
+    end
+
+    it "carries no information on owner, group and mode" do
+      metadata = described_class.new(http_response)
+      expect( metadata.owner ).to be_nil
+      expect( metadata.group ).to be_nil
+      expect( metadata.mode ).to be_nil
+    end
+
+    context "with no Last-Modified or Content-MD5 header from the server" do
+      before do
+        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
+        # Stringifying Time.now does some rounding; do so here so we don't end up with a time
+        # that's greater than the stringified version returned by collect.
+        time = Time.parse(Time.now.to_s)
+        metadata = described_class.new(http_response)
+        metadata.collect
+        expect( metadata.checksum_type ).to eq :mtime
+        checksum = metadata.checksum
+        expect( checksum[0...7] ).to eq '{mtime}'
+        expect( Time.parse(checksum[7..-1]) ).to be >= time
+      end
+    end
+
+    context "with a Last-Modified header from the server" do
+      let(:time) { Time.now.utc }
+      before do
+        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"
+        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
+        expect( metadata.checksum ).to eq "{mtime}#{time.to_time}"
+      end
+    end
+
+    context "with a Content-MD5 header being received" do
+      let(:input) { Time.now.to_s }
+      let(:base64) { Digest::MD5.new.base64digest input }
+      let(:hex) { Digest::MD5.new.hexdigest input }
+      before do
+        http_response.stubs(:[]).with('last-modified').returns nil
+        http_response.stubs(:[]).with('content-md5').returns base64
+      end
+
+      it "should use the md5 checksum" do
+        metadata = described_class.new(http_response)
+        metadata.collect
+        expect( metadata.checksum_type ).to eq :md5
+        expect( metadata.checksum ).to eq "{md5}#{hex}"
+      end
+    end
+  end
+end