chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/unit/cookbook_site_streaming_uploader_spec.rb

@@ -42,16 +42,16 @@ describe Chef::CookbookSiteStreamingUploader do
       @cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, 'cookbooks'))
       @loader = Chef::CookbookLoader.new(@cookbook_repo)
       @loader.load_cookbooks
-      File.stub(:unlink).and_return()
+      allow(File).to receive(:unlink)
     end
 
     it "should create the cookbook tmp dir" do
       cookbook = @loader[:openldap]
       files_count = Dir.glob(File.join(@cookbook_repo, cookbook.name.to_s, '**', '*'), File::FNM_DOTMATCH).count { |file| File.file?(file) }
 
-      Tempfile.should_receive(:new).with("chef-#{cookbook.name}-build").and_return(FakeTempfile.new("chef-#{cookbook.name}-build"))
-      FileUtils.should_receive(:mkdir_p).exactly(files_count + 1).times
-      FileUtils.should_receive(:cp).exactly(files_count).times
+      expect(Tempfile).to receive(:new).with("chef-#{cookbook.name}-build").and_return(FakeTempfile.new("chef-#{cookbook.name}-build"))
+      expect(FileUtils).to receive(:mkdir_p).exactly(files_count + 1).times
+      expect(FileUtils).to receive(:cp).exactly(files_count).times
       Chef::CookbookSiteStreamingUploader.create_build_dir(cookbook)
     end
 
@@ -64,39 +64,39 @@ describe Chef::CookbookSiteStreamingUploader do
       @secret_filename = File.join(CHEF_SPEC_DATA, 'ssl/private_key.pem')
       @rsa_key = File.read(@secret_filename)
       response = Net::HTTPResponse.new('1.0', '200', 'OK')
-      Net::HTTP.any_instance.stub(:request).and_return(response)
+      allow_any_instance_of(Net::HTTP).to receive(:request).and_return(response)
     end
 
     it "should send an http request" do
-      Net::HTTP.any_instance.should_receive(:request)
+      expect_any_instance_of(Net::HTTP).to receive(:request)
       Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, 'bill', @secret_filename)
     end
 
     it "should read the private key file" do
-      File.should_receive(:read).with(@secret_filename).and_return(@rsa_key)
+      expect(File).to receive(:read).with(@secret_filename).and_return(@rsa_key)
       Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, 'bill', @secret_filename)
     end
 
     it "should add the authentication signed header" do
-      Mixlib::Authentication::SigningObject.any_instance.should_receive(:sign).and_return({})
+      expect_any_instance_of(Mixlib::Authentication::SigningObject).to receive(:sign).and_return({})
       Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, 'bill', @secret_filename)
     end
 
     it "should be able to send post requests" do
       post = Net::HTTP::Post.new(@uri, {})
 
-      Net::HTTP::Post.should_receive(:new).once.and_return(post)
-      Net::HTTP::Put.should_not_receive(:new)
-      Net::HTTP::Get.should_not_receive(:new)
+      expect(Net::HTTP::Post).to receive(:new).once.and_return(post)
+      expect(Net::HTTP::Put).not_to receive(:new)
+      expect(Net::HTTP::Get).not_to receive(:new)
       Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, 'bill', @secret_filename)
     end
 
     it "should be able to send put requests" do
       put = Net::HTTP::Put.new(@uri, {})
 
-      Net::HTTP::Post.should_not_receive(:new)
-      Net::HTTP::Put.should_receive(:new).once.and_return(put)
-      Net::HTTP::Get.should_not_receive(:new)
+      expect(Net::HTTP::Post).not_to receive(:new)
+      expect(Net::HTTP::Put).to receive(:new).once.and_return(put)
+      expect(Net::HTTP::Get).not_to receive(:new)
       Chef::CookbookSiteStreamingUploader.make_request(:put, @uri, 'bill', @secret_filename)
     end
 
@@ -126,19 +126,19 @@ describe Chef::CookbookSiteStreamingUploader do
         @uri = "https://cookbooks.dummy.com/api/v1/cookbooks"
         uri_info = URI.parse(@uri)
         @http = Net::HTTP.new(uri_info.host, uri_info.port)
-        Net::HTTP.should_receive(:new).with(uri_info.host, uri_info.port).and_return(@http)
+        expect(Net::HTTP).to receive(:new).with(uri_info.host, uri_info.port).and_return(@http)
       end
 
       it "should be VERIFY_NONE when ssl_verify_mode is :verify_none" do
         Chef::Config[:ssl_verify_mode] = :verify_none
         Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, 'bill', @secret_filename)
-        @http.verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+        expect(@http.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
       end
 
       it "should be VERIFY_PEER when ssl_verify_mode is :verify_peer" do
         Chef::Config[:ssl_verify_mode] = :verify_peer
         Chef::CookbookSiteStreamingUploader.make_request(:post, @uri, 'bill', @secret_filename)
-        @http.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+        expect(@http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
       end
     end
 
@@ -151,17 +151,17 @@ describe Chef::CookbookSiteStreamingUploader do
     end
 
     it "should create a StreamPart" do
-      @stream_part.should be_instance_of(Chef::CookbookSiteStreamingUploader::StreamPart)
+      expect(@stream_part).to be_instance_of(Chef::CookbookSiteStreamingUploader::StreamPart)
     end
 
     it "should expose its size" do
-      @stream_part.size.should eql(File.size(@file))
+      expect(@stream_part.size).to eql(File.size(@file))
     end
 
     it "should read with offset and how_much" do
       content = @file.read(4)
       @file.rewind
-      @stream_part.read(0, 4).should eql(content)
+      expect(@stream_part.read(0, 4)).to eql(content)
     end
 
   end # StreamPart
@@ -173,15 +173,15 @@ describe Chef::CookbookSiteStreamingUploader do
     end
 
     it "should create a StringPart" do
-      @string_part.should be_instance_of(Chef::CookbookSiteStreamingUploader::StringPart)
+      expect(@string_part).to be_instance_of(Chef::CookbookSiteStreamingUploader::StringPart)
     end
 
     it "should expose its size" do
-      @string_part.size.should eql(@str.size)
+      expect(@string_part.size).to eql(@str.size)
     end
 
     it "should read with offset and how_much" do
-      @string_part.read(2, 4).should eql(@str[2, 4])
+      expect(@string_part.read(2, 4)).to eql(@str[2, 4])
     end
 
   end # StringPart
@@ -198,21 +198,21 @@ describe Chef::CookbookSiteStreamingUploader do
     end
 
     it "should create a MultipartStream" do
-      @multipart_stream.should be_instance_of(Chef::CookbookSiteStreamingUploader::MultipartStream)
+      expect(@multipart_stream).to be_instance_of(Chef::CookbookSiteStreamingUploader::MultipartStream)
     end
 
     it "should expose its size" do
-      @multipart_stream.size.should eql(@stream1.size + @stream2.size)
+      expect(@multipart_stream.size).to eql(@stream1.size + @stream2.size)
     end
 
     it "should read with how_much" do
-      @multipart_stream.read(10).should eql("#{@string1}#{@string2}"[0, 10])
+      expect(@multipart_stream.read(10)).to eql("#{@string1}#{@string2}"[0, 10])
     end
 
     it "should read receiving destination buffer as second argument (CHEF-4456: Ruby 2 compat)" do
       dst_buf = ''
       @multipart_stream.read(10, dst_buf)
-      dst_buf.should eql("#{@string1}#{@string2}"[0, 10])
+      expect(dst_buf).to eql("#{@string1}#{@string2}"[0, 10])
     end
 
   end # MultipartStream

data/spec/unit/cookbook_spec.rb

@@ -33,43 +33,43 @@ describe Chef::CookbookVersion do
   end
 
   it "should have a name" do
-    @cookbook.name.should == :openldap
+    expect(@cookbook.name).to eq(:openldap)
   end
 
   it "should allow you to set the list of attribute files and create the mapping from short names to paths" do
     @cookbook.attribute_filenames = [ "attributes/one.rb", "attributes/two.rb" ]
-    @cookbook.attribute_filenames.should == [ "attributes/one.rb", "attributes/two.rb" ]
-    @cookbook.attribute_filenames_by_short_filename.keys.sort.should eql(["one", "two"])
-    @cookbook.attribute_filenames_by_short_filename["one"].should == "attributes/one.rb"
-    @cookbook.attribute_filenames_by_short_filename["two"].should == "attributes/two.rb"
+    expect(@cookbook.attribute_filenames).to eq([ "attributes/one.rb", "attributes/two.rb" ])
+    expect(@cookbook.attribute_filenames_by_short_filename.keys.sort).to eql(["one", "two"])
+    expect(@cookbook.attribute_filenames_by_short_filename["one"]).to eq("attributes/one.rb")
+    expect(@cookbook.attribute_filenames_by_short_filename["two"]).to eq("attributes/two.rb")
   end
 
   it "should allow you to set the list of recipe files and create the mapping of recipe short name to filename" do
     @cookbook.recipe_filenames = [ "recipes/one.rb", "recipes/two.rb" ]
-    @cookbook.recipe_filenames.should == [ "recipes/one.rb", "recipes/two.rb" ]
-    @cookbook.recipe_filenames_by_name.keys.sort.should eql(["one", "two"])
-    @cookbook.recipe_filenames_by_name["one"].should == "recipes/one.rb"
-    @cookbook.recipe_filenames_by_name["two"].should == "recipes/two.rb"
+    expect(@cookbook.recipe_filenames).to eq([ "recipes/one.rb", "recipes/two.rb" ])
+    expect(@cookbook.recipe_filenames_by_name.keys.sort).to eql(["one", "two"])
+    expect(@cookbook.recipe_filenames_by_name["one"]).to eq("recipes/one.rb")
+    expect(@cookbook.recipe_filenames_by_name["two"]).to eq("recipes/two.rb")
   end
 
   it "should generate a list of recipes by fully-qualified name" do
     @cookbook.recipe_filenames = [ "recipes/one.rb", "/recipes/two.rb", "three.rb" ]
-    @cookbook.fully_qualified_recipe_names.include?("openldap::one").should == true
-    @cookbook.fully_qualified_recipe_names.include?("openldap::two").should == true
-    @cookbook.fully_qualified_recipe_names.include?("openldap::three").should == true
+    expect(@cookbook.fully_qualified_recipe_names.include?("openldap::one")).to eq(true)
+    expect(@cookbook.fully_qualified_recipe_names.include?("openldap::two")).to eq(true)
+    expect(@cookbook.fully_qualified_recipe_names.include?("openldap::three")).to eq(true)
   end
 
   it "should find a preferred file" do
-    pending
+    skip
   end
 
   it "should not return an unchanged preferred file" do
     pending
-    @cookbook.preferred_filename(@node, :files, 'a-filename', 'the-checksum').should be_nil
+    expect(@cookbook.preferred_filename(@node, :files, 'a-filename', 'the-checksum')).to be_nil
   end
 
   it "should raise an ArgumentException if you try to load a bad recipe name" do
-    lambda { @cookbook.load_recipe("doesnt_exist", @node) }.should raise_error(ArgumentError)
+    expect { @cookbook.load_recipe("doesnt_exist", @node) }.to raise_error(ArgumentError)
   end
 
 end

data/spec/unit/cookbook_uploader_spec.rb

@@ -45,7 +45,13 @@ describe Chef::CookbookUploader do
 
   let(:sandbox_commit_uri) { "https://chef.example.org/sandboxes/abc123" }
 
-  let(:uploader) { described_class.new(cookbooks_to_upload, :rest => http_client) }
+  let(:policy_mode) { false }
+
+  let(:uploader) { described_class.new(cookbooks_to_upload, rest: http_client, policy_mode: policy_mode) }
+
+  it "defaults to not enabling policy mode" do
+    expect(described_class.new(cookbooks_to_upload, rest: http_client).policy_mode?).to be(false)
+  end
 
   it "has a list of cookbooks to upload" do
     expect(uploader.cookbooks).to eq(cookbooks_to_upload)
@@ -61,7 +67,7 @@ describe Chef::CookbookUploader do
   describe "uploading cookbooks" do
 
     def url_for(cksum)
-      "https://storage.example.com/#{cksum}" 
+      "https://storage.example.com/#{cksum}"
     end
 
     let(:sandbox_response) do
@@ -94,6 +100,10 @@ describe Chef::CookbookUploader do
       end
     end
 
+    def expected_save_url(cookbook)
+      "cookbooks/#{cookbook.name}/#{cookbook.version}"
+    end
+
     def expect_sandbox_commit
       expect(http_client).to receive(:put).with(sandbox_commit_uri, {:is_completed => true})
     end
@@ -102,7 +112,7 @@ describe Chef::CookbookUploader do
       cookbooks_to_upload.each do |cookbook|
 
         expect(http_client).to receive(:put).
-          with(cookbook.save_url, cookbook)
+          with(expected_save_url(cookbook), cookbook)
 
       end
     end
@@ -155,6 +165,30 @@ describe Chef::CookbookUploader do
       end
 
     end
+
+    context "when policy_mode is specified" do
+
+      let(:cksums_not_on_remote) do
+        checksums_of_cookbook_files.keys
+      end
+
+      let(:policy_mode) { true }
+
+      def expected_save_url(cookbook)
+        "cookbook_artifacts/#{cookbook.name}/#{cookbook.version}"
+      end
+
+      it "uploads all files in a sandbox transaction, then creates cookbooks on the server using cookbook_artifacts API" do
+        expect_sandbox_create
+        expect_checksum_upload
+        expect_sandbox_commit
+        expect_cookbook_create
+
+        uploader.upload_cookbooks
+      end
+
+
+    end
   end
 
 end

data/spec/unit/cookbook_version_file_specificity_spec.rb

@@ -0,0 +1,554 @@
+#
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::CookbookVersion, "file specificity" do
+  before(:each) do
+    @cookbook = Chef::CookbookVersion.new "test-cookbook"
+    @cookbook.manifest = {
+      "files" =>
+      [
+       # afile.rb
+       {
+         :name => "afile.rb",
+         :path => "files/host-examplehost.example.org/afile.rb",
+         :checksum => "csum-host",
+         :specificity => "host-examplehost.example.org"
+       },
+       {
+         :name => "afile.rb",
+         :path => "files/ubuntu-9.10/afile.rb",
+         :checksum => "csum-platver-full",
+         :specificity => "ubuntu-9.10"
+       },
+       {
+         :name => "afile.rb",
+         :path => "files/newubuntu-9/afile.rb",
+         :checksum => "csum-platver-partial",
+         :specificity => "newubuntu-9"
+       },
+       {
+         :name => "afile.rb",
+         :path => "files/ubuntu/afile.rb",
+         :checksum => "csum-plat",
+         :specificity => "ubuntu"
+       },
+       {
+         :name => "afile.rb",
+         :path => "files/default/afile.rb",
+         :checksum => "csum-default",
+         :specificity => "default"
+       },
+
+       # for different/odd platform_versions
+       {
+         :name => "bfile.rb",
+         :path => "files/fakeos-2.0.rc.1/bfile.rb",
+         :checksum => "csum2-platver-full",
+         :specificity => "fakeos-2.0.rc.1"
+       },
+       {
+         :name => "bfile.rb",
+         :path => "files/newfakeos-2.0.rc/bfile.rb",
+         :checksum => "csum2-platver-partial",
+         :specificity => "newfakeos-2.0.rc"
+       },
+       {
+         :name => "bfile.rb",
+         :path => "files/fakeos-maple tree/bfile.rb",
+         :checksum => "csum3-platver-full",
+         :specificity => "maple tree"
+       },
+       {
+         :name => "bfile.rb",
+         :path => "files/fakeos-1/bfile.rb",
+         :checksum => "csum4-platver-full",
+         :specificity => "fakeos-1"
+       },
+
+       # directory adirectory
+       {
+         :name => "anotherfile1.rb",
+         :path => "files/host-examplehost.example.org/adirectory/anotherfile1.rb.host",
+         :checksum => "csum-host-1",
+         :specificity => "host-examplehost.example.org"
+       },
+       {
+         :name => "anotherfile2.rb",
+         :path => "files/host-examplehost.example.org/adirectory/anotherfile2.rb.host",
+         :checksum => "csum-host-2",
+         :specificity => "host-examplehost.example.org"
+       },
+
+       {
+         :name => "anotherfile1.rb",
+         :path => "files/ubuntu-9.10/adirectory/anotherfile1.rb.platform-full-version",
+         :checksum => "csum-platver-full-1",
+         :specificity => "ubuntu-9.10"
+       },
+       {
+         :name => "anotherfile2.rb",
+         :path => "files/ubuntu-9.10/adirectory/anotherfile2.rb.platform-full-version",
+         :checksum => "csum-platver-full-2",
+         :specificity => "ubuntu-9.10"
+       },
+
+       {
+         :name => "anotherfile1.rb",
+         :path => "files/newubuntu-9/adirectory/anotherfile1.rb.platform-partial-version",
+         :checksum => "csum-platver-partial-1",
+         :specificity => "newubuntu-9"
+       },
+       {
+         :name => "anotherfile2.rb",
+         :path => "files/newubuntu-9/adirectory/anotherfile2.rb.platform-partial-version",
+         :checksum => "csum-platver-partial-2",
+         :specificity => "nweubuntu-9"
+       },
+
+       {
+         :name => "anotherfile1.rb",
+         :path => "files/ubuntu/adirectory/anotherfile1.rb.platform",
+         :checksum => "csum-plat-1",
+         :specificity => "ubuntu"
+       },
+       {
+         :name => "anotherfile2.rb",
+         :path => "files/ubuntu/adirectory/anotherfile2.rb.platform",
+         :checksum => "csum-plat-2",
+         :specificity => "ubuntu"
+       },
+
+       {
+         :name => "anotherfile1.rb",
+         :path => "files/default/adirectory/anotherfile1.rb.default",
+         :checksum => "csum-default-1",
+         :specificity => "default"
+       },
+       {
+         :name => "anotherfile2.rb",
+         :path => "files/default/adirectory/anotherfile2.rb.default",
+         :checksum => "csum-default-2",
+         :specificity => "default"
+       },
+       # for different/odd platform_versions
+       {
+         :name => "anotherfile1.rb",
+         :path => "files/fakeos-2.0.rc.1/adirectory/anotherfile1.rb.platform-full-version",
+         :checksum => "csum2-platver-full-1",
+         :specificity => "fakeos-2.0.rc.1"
+       },
+       {
+         :name => "anotherfile2.rb",
+         :path => "files/fakeos-2.0.rc.1/adirectory/anotherfile2.rb.platform-full-version",
+         :checksum => "csum2-platver-full-2",
+         :specificity => "fakeos-2.0.rc.1"
+       },
+       {
+         :name => "anotherfile1.rb",
+         :path => "files/newfakeos-2.0.rc.1/adirectory/anotherfile1.rb.platform-partial-version",
+         :checksum => "csum2-platver-partial-1",
+         :specificity => "newfakeos-2.0.rc"
+       },
+       {
+         :name => "anotherfile2.rb",
+         :path => "files/newfakeos-2.0.rc.1/adirectory/anotherfile2.rb.platform-partial-version",
+         :checksum => "csum2-platver-partial-2",
+         :specificity => "newfakeos-2.0.rc"
+       },
+       {
+         :name => "anotherfile1.rb",
+         :path => "files/fakeos-maple tree/adirectory/anotherfile1.rb.platform-full-version",
+         :checksum => "csum3-platver-full-1",
+         :specificity => "fakeos-maple tree"
+       },
+       {
+         :name => "anotherfile2.rb",
+         :path => "files/fakeos-maple tree/adirectory/anotherfile2.rb.platform-full-version",
+         :checksum => "csum3-platver-full-2",
+         :specificity => "fakeos-maple tree"
+       },
+       {
+         :name => "anotherfile1.rb",
+         :path => "files/fakeos-1/adirectory/anotherfile1.rb.platform-full-version",
+         :checksum => "csum4-platver-full-1",
+         :specificity => "fakeos-1"
+       },
+       {
+         :name => "anotherfile2.rb",
+         :path => "files/fakeos-1/adirectory/anotherfile2.rb.platform-full-version",
+         :checksum => "csum4-platver-full-2",
+         :specificity => "fakeos-1"
+       },
+      ]
+    }
+
+  end
+
+
+  it "should return a manifest record based on priority preference: host" do
+    node = Chef::Node.new
+    node.automatic_attrs[:platform] = "ubuntu"
+    node.automatic_attrs[:platform_version] = "9.10"
+    node.automatic_attrs[:fqdn] = "examplehost.example.org"
+
+    manifest_record = @cookbook.preferred_manifest_record(node, :files, "afile.rb")
+    expect(manifest_record).not_to be_nil
+    expect(manifest_record[:checksum]).to eq("csum-host")
+  end
+
+  it "should return a manifest record based on priority preference: platform & full version" do
+    node = Chef::Node.new
+    node.automatic_attrs[:platform] = "ubuntu"
+    node.automatic_attrs[:platform_version] = "9.10"
+    node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+    manifest_record = @cookbook.preferred_manifest_record(node, :files, "afile.rb")
+    expect(manifest_record).not_to be_nil
+    expect(manifest_record[:checksum]).to eq("csum-platver-full")
+  end
+
+  it "should return a manifest record based on priority preference: platform & partial version" do
+    node = Chef::Node.new
+    node.automatic_attrs[:platform] = "newubuntu"
+    node.automatic_attrs[:platform_version] = "9.10"
+    node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+    manifest_record = @cookbook.preferred_manifest_record(node, :files, "afile.rb")
+    expect(manifest_record).not_to be_nil
+    expect(manifest_record[:checksum]).to eq("csum-platver-partial")
+  end
+
+  it "should return a manifest record based on priority preference: platform only" do
+    node = Chef::Node.new
+    node.automatic_attrs[:platform] = "ubuntu"
+    node.automatic_attrs[:platform_version] = "1.0"
+    node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+    manifest_record = @cookbook.preferred_manifest_record(node, :files, "afile.rb")
+    expect(manifest_record).not_to be_nil
+    expect(manifest_record[:checksum]).to eq("csum-plat")
+  end
+
+  it "should return a manifest record based on priority preference: default" do
+    node = Chef::Node.new
+    node.automatic_attrs[:platform] = "notubuntu"
+    node.automatic_attrs[:platform_version] = "1.0"
+    node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+    manifest_record = @cookbook.preferred_manifest_record(node, :files, "afile.rb")
+    expect(manifest_record).not_to be_nil
+    expect(manifest_record[:checksum]).to eq("csum-default")
+  end
+
+  it "should return a manifest record based on priority preference: platform & full version - platform_version variant 1" do
+    node = Chef::Node.new
+    node.automatic_attrs[:platform] = "fakeos"
+    node.automatic_attrs[:platform_version] = "2.0.rc.1"
+    node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+    manifest_record = @cookbook.preferred_manifest_record(node, :files, "bfile.rb")
+    expect(manifest_record).not_to be_nil
+    expect(manifest_record[:checksum]).to eq("csum2-platver-full")
+  end
+
+  it "should return a manifest record based on priority preference: platform & partial version - platform_version variant 1" do
+    node = Chef::Node.new
+    node.automatic_attrs[:platform] = "newfakeos"
+    node.automatic_attrs[:platform_version] = "2.0.rc.1"
+    node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+    manifest_record = @cookbook.preferred_manifest_record(node, :files, "bfile.rb")
+    expect(manifest_record).not_to be_nil
+    expect(manifest_record[:checksum]).to eq("csum2-platver-partial")
+  end
+
+  it "should return a manifest record based on priority preference: platform & full version - platform_version variant 2" do
+    node = Chef::Node.new
+    node.automatic_attrs[:platform] = "fakeos"
+    node.automatic_attrs[:platform_version] = "maple tree"
+    node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+    manifest_record = @cookbook.preferred_manifest_record(node, :files, "bfile.rb")
+    expect(manifest_record).not_to be_nil
+    expect(manifest_record[:checksum]).to eq("csum3-platver-full")
+  end
+
+  it "should return a manifest record based on priority preference: platform & full version - platform_version variant 3" do
+    node = Chef::Node.new
+    node.automatic_attrs[:platform] = "fakeos"
+    node.automatic_attrs[:platform_version] = "1"
+    node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+    manifest_record = @cookbook.preferred_manifest_record(node, :files, "bfile.rb")
+    expect(manifest_record).not_to be_nil
+    expect(manifest_record[:checksum]).to eq("csum4-platver-full")
+  end
+
+  describe "when fetching the contents of a directory by file specificity" do
+
+    it "should return a directory of manifest records based on priority preference: host" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "ubuntu"
+      node.automatic_attrs[:platform_version] = "9.10"
+      node.automatic_attrs[:fqdn] = "examplehost.example.org"
+
+      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
+      expect(manifest_records).not_to be_nil
+      expect(manifest_records.size).to eq(2)
+
+      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
+      expect(checksums.sort).to eq(["csum-host-1", "csum-host-2"])
+    end
+
+    it "should return a directory of manifest records based on priority preference: platform & full version" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "ubuntu"
+      node.automatic_attrs[:platform_version] = "9.10"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
+      expect(manifest_records).not_to be_nil
+      expect(manifest_records.size).to eq(2)
+
+      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
+      expect(checksums.sort).to eq(["csum-platver-full-1", "csum-platver-full-2"])
+    end
+
+    it "should return a directory of manifest records based on priority preference: platform & partial version" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "newubuntu"
+      node.automatic_attrs[:platform_version] = "9.10"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
+      expect(manifest_records).not_to be_nil
+      expect(manifest_records.size).to eq(2)
+
+      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
+      expect(checksums.sort).to eq(["csum-platver-partial-1", "csum-platver-partial-2"])
+    end
+
+    it "should return a directory of manifest records based on priority preference: platform only" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "ubuntu"
+      node.automatic_attrs[:platform_version] = "1.0"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
+      expect(manifest_records).not_to be_nil
+      expect(manifest_records.size).to eq(2)
+
+      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
+      expect(checksums.sort).to eq(["csum-plat-1", "csum-plat-2"])
+    end
+
+    it "should return a directory of manifest records based on priority preference: default" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "notubuntu"
+      node.automatic_attrs[:platform_version] = "1.0"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
+      expect(manifest_records).not_to be_nil
+      expect(manifest_records.size).to eq(2)
+
+      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
+      expect(checksums.sort).to eq(["csum-default-1", "csum-default-2"])
+    end
+
+    it "should return a manifest record based on priority preference: platform & full version - platform_version variant 1" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "fakeos"
+      node.automatic_attrs[:platform_version] = "2.0.rc.1"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
+      expect(manifest_records).not_to be_nil
+      expect(manifest_records.size).to eq(2)
+
+      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
+      expect(checksums.sort).to eq(["csum2-platver-full-1", "csum2-platver-full-2"])
+    end
+
+    it "should return a manifest record based on priority preference: platform & partial version - platform_version variant 1" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "newfakeos"
+      node.automatic_attrs[:platform_version] = "2.0.rc.1"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
+      expect(manifest_records).not_to be_nil
+      expect(manifest_records.size).to eq(2)
+
+      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
+      expect(checksums.sort).to eq(["csum2-platver-partial-1", "csum2-platver-partial-2"])
+    end
+
+    it "should return a manifest record based on priority preference: platform & full version - platform_version variant 2" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "fakeos"
+      node.automatic_attrs[:platform_version] = "maple tree"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
+      expect(manifest_records).not_to be_nil
+      expect(manifest_records.size).to eq(2)
+
+      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
+      expect(checksums.sort).to eq(["csum3-platver-full-1", "csum3-platver-full-2"])
+    end
+
+    it "should return a manifest record based on priority preference: platform & full version - platform_version variant 3" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "fakeos"
+      node.automatic_attrs[:platform_version] = "1"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
+      expect(manifest_records).not_to be_nil
+      expect(manifest_records.size).to eq(2)
+
+      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
+      expect(checksums.sort).to eq(["csum4-platver-full-1", "csum4-platver-full-2"])
+    end
+  end
+
+  ## Globbing the relative paths out of the manifest records ##
+
+  describe "when globbing for relative file paths based on filespecificity" do
+    it "should return a list of relative paths based on priority preference: host" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "ubuntu"
+      node.automatic_attrs[:platform_version] = "9.10"
+      node.automatic_attrs[:fqdn] = "examplehost.example.org"
+
+      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
+      expect(filenames).not_to be_nil
+      expect(filenames.size).to eq(2)
+
+      expect(filenames.sort).to eq(['anotherfile1.rb.host', 'anotherfile2.rb.host'])
+    end
+
+    it "should return a list of relative paths based on priority preference: platform & full version" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "ubuntu"
+      node.automatic_attrs[:platform_version] = "9.10"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
+      expect(filenames).not_to be_nil
+      expect(filenames.size).to eq(2)
+
+      expect(filenames.sort).to eq(['anotherfile1.rb.platform-full-version', 'anotherfile2.rb.platform-full-version'])
+    end
+
+    it "should return a list of relative paths based on priority preference: platform & partial version" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "newubuntu"
+      node.automatic_attrs[:platform_version] = "9.10"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
+      expect(filenames).not_to be_nil
+      expect(filenames.size).to eq(2)
+
+      expect(filenames.sort).to eq(['anotherfile1.rb.platform-partial-version', 'anotherfile2.rb.platform-partial-version'])
+    end
+
+    it "should return a list of relative paths based on priority preference: platform only" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "ubuntu"
+      node.automatic_attrs[:platform_version] = "1.0"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
+      expect(filenames).not_to be_nil
+      expect(filenames.size).to eq(2)
+
+      expect(filenames.sort).to eq(['anotherfile1.rb.platform', 'anotherfile2.rb.platform'])
+    end
+
+    it "should return a list of relative paths based on priority preference: default" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "notubuntu"
+      node.automatic_attrs[:platform_version] = "1.0"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
+      expect(filenames).not_to be_nil
+      expect(filenames.size).to eq(2)
+
+      expect(filenames.sort).to eq(['anotherfile1.rb.default', 'anotherfile2.rb.default'])
+    end
+
+    it "should return a list of relative paths based on priority preference: platform & full version - platform_version variant 1" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "fakeos"
+      node.automatic_attrs[:platform_version] = "2.0.rc.1"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
+      expect(filenames).not_to be_nil
+      expect(filenames.size).to eq(2)
+
+      expect(filenames.sort).to eq(['anotherfile1.rb.platform-full-version', 'anotherfile2.rb.platform-full-version'])
+    end
+
+    it "should return a list of relative paths based on priority preference: platform & partial version - platform_version variant 1" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "newfakeos"
+      node.automatic_attrs[:platform_version] = "2.0.rc.1"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
+      expect(filenames).not_to be_nil
+      expect(filenames.size).to eq(2)
+
+      expect(filenames.sort).to eq(['anotherfile1.rb.platform-partial-version', 'anotherfile2.rb.platform-partial-version'])
+    end
+
+    it "should return a list of relative paths based on priority preference: platform & full version - platform_version variant 2" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "fakeos"
+      node.automatic_attrs[:platform_version] = "maple tree"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
+      expect(filenames).not_to be_nil
+      expect(filenames.size).to eq(2)
+
+      expect(filenames.sort).to eq(['anotherfile1.rb.platform-full-version', 'anotherfile2.rb.platform-full-version'])
+    end
+
+    it "should return a list of relative paths based on priority preference: platform & full version - platform_version variant 3" do
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "fakeos"
+      node.automatic_attrs[:platform_version] = "1"
+      node.automatic_attrs[:fqdn] = "differenthost.example.org"
+
+      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
+      expect(filenames).not_to be_nil
+      expect(filenames.size).to eq(2)
+
+      expect(filenames.sort).to eq(['anotherfile1.rb.platform-full-version', 'anotherfile2.rb.platform-full-version'])
+    end
+  end
+end