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

data/spec/unit/cookbook/syntax_check_spec.rb

@@ -21,7 +21,7 @@ require "chef/cookbook/syntax_check"
 
 describe Chef::Cookbook::SyntaxCheck do
   before do
-    Chef::Platform.stub(:windows?) { false }
+    allow(Chef::Platform).to receive(:windows?) { false }
   end
 
   let(:cookbook_path) { File.join(CHEF_SPEC_DATA, 'cookbooks', 'openldap') }
@@ -43,6 +43,7 @@ describe Chef::Cookbook::SyntaxCheck do
 
   before do
     Chef::Log.logger = Logger.new(StringIO.new)
+    @original_log_level = Chef::Log.level
     Chef::Log.level = :warn # suppress "Syntax OK" messages
 
     @attr_files = %w{default.rb smokey.rb}.map { |f| File.join(cookbook_path, 'attributes', f) }
@@ -61,17 +62,21 @@ describe Chef::Cookbook::SyntaxCheck do
     @template_files = basenames.map { |f| File.join(cookbook_path, 'templates', 'default', f)}
   end
 
+  after do
+    Chef::Log.level = @original_log_level
+  end
+
   it "creates a syntax checker given the cookbook name when Chef::Config.cookbook_path is set" do
     Chef::Config[:cookbook_path] = File.dirname(cookbook_path)
     syntax_check = Chef::Cookbook::SyntaxCheck.for_cookbook(:openldap)
-    syntax_check.cookbook_path.should == cookbook_path
-    syntax_check.ruby_files.sort.should == open_ldap_cookbook_files.sort
+    expect(syntax_check.cookbook_path).to eq(cookbook_path)
+    expect(syntax_check.ruby_files.sort).to eq(open_ldap_cookbook_files.sort)
   end
 
   it "creates a syntax checker given the cookbook name and cookbook_path" do
     syntax_check = Chef::Cookbook::SyntaxCheck.for_cookbook(:openldap, File.join(CHEF_SPEC_DATA, 'cookbooks'))
-    syntax_check.cookbook_path.should == cookbook_path
-    syntax_check.ruby_files.sort.should == open_ldap_cookbook_files.sort
+    expect(syntax_check.cookbook_path).to eq(cookbook_path)
+    expect(syntax_check.ruby_files.sort).to eq(open_ldap_cookbook_files.sort)
   end
 
   context "when using a standalone cookbook" do
@@ -79,22 +84,22 @@ describe Chef::Cookbook::SyntaxCheck do
 
     it "creates a syntax checker given the cookbook name and cookbook_path for a standalone cookbook" do
       syntax_check = Chef::Cookbook::SyntaxCheck.for_cookbook(:standalone_cookbook, CHEF_SPEC_DATA)
-      syntax_check.cookbook_path.should == cookbook_path
-      syntax_check.ruby_files.should == [File.join(cookbook_path, 'recipes/default.rb')]
+      expect(syntax_check.cookbook_path).to eq(cookbook_path)
+      expect(syntax_check.ruby_files).to eq([File.join(cookbook_path, 'recipes/default.rb')])
     end
   end
 
   describe "when first created" do
     it "has the path to the cookbook to syntax check" do
-      syntax_check.cookbook_path.should == cookbook_path
+      expect(syntax_check.cookbook_path).to eq(cookbook_path)
     end
 
     it "lists the ruby files in the cookbook" do
-      syntax_check.ruby_files.sort.should == @ruby_files.sort
+      expect(syntax_check.ruby_files.sort).to eq(@ruby_files.sort)
     end
 
     it "lists the erb templates in the cookbook" do
-      syntax_check.template_files.sort.should == @template_files.sort
+      expect(syntax_check.template_files.sort).to eq(@template_files.sort)
     end
 
   end
@@ -112,33 +117,33 @@ describe Chef::Cookbook::SyntaxCheck do
 
     describe "and the files have not been syntax checked previously" do
       it "shows that all ruby files require a syntax check" do
-        syntax_check.untested_ruby_files.sort.should == @ruby_files.sort
+        expect(syntax_check.untested_ruby_files.sort).to eq(@ruby_files.sort)
       end
 
       it "shows that all template files require a syntax check" do
-        syntax_check.untested_template_files.sort.should == @template_files.sort
+        expect(syntax_check.untested_template_files.sort).to eq(@template_files.sort)
       end
 
       it "removes a ruby file from the list of untested files after it is marked as validated" do
         recipe = File.join(cookbook_path, 'recipes', 'default.rb')
         syntax_check.validated(recipe)
-        syntax_check.untested_ruby_files.should_not include(recipe)
+        expect(syntax_check.untested_ruby_files).not_to include(recipe)
       end
 
       it "removes a template file from the list of untested files after it is marked as validated" do
         template = File.join(cookbook_path, 'templates', 'default', 'test.erb')
         syntax_check.validated(template)
-        syntax_check.untested_template_files.should_not include(template)
+        expect(syntax_check.untested_template_files).not_to include(template)
       end
 
       it "validates all ruby files" do
-        syntax_check.validate_ruby_files.should be_true
-        syntax_check.untested_ruby_files.should be_empty
+        expect(syntax_check.validate_ruby_files).to be_truthy
+        expect(syntax_check.untested_ruby_files).to be_empty
       end
 
       it "validates all templates" do
-        syntax_check.validate_templates.should be_true
-        syntax_check.untested_template_files.should be_empty
+        expect(syntax_check.validate_templates).to be_truthy
+        expect(syntax_check.untested_template_files).to be_empty
       end
 
       describe "and a file has a syntax error" do
@@ -148,22 +153,22 @@ describe Chef::Cookbook::SyntaxCheck do
         end
 
         it "it indicates that a ruby file has a syntax error" do
-          syntax_check.validate_ruby_files.should be_false
+          expect(syntax_check.validate_ruby_files).to be_falsey
         end
 
         it "does not remove the invalid file from the list of untested files" do
-          syntax_check.untested_ruby_files.should include(File.join(cookbook_path, 'recipes', 'default.rb'))
+          expect(syntax_check.untested_ruby_files).to include(File.join(cookbook_path, 'recipes', 'default.rb'))
           syntax_check.validate_ruby_files
-          syntax_check.untested_ruby_files.should include(File.join(cookbook_path, 'recipes', 'default.rb'))
+          expect(syntax_check.untested_ruby_files).to include(File.join(cookbook_path, 'recipes', 'default.rb'))
         end
 
         it "indicates that a template file has a syntax error" do
-          syntax_check.validate_templates.should be_false
+          expect(syntax_check.validate_templates).to be_falsey
         end
 
         it "does not remove the invalid template from the list of untested templates" do
-          syntax_check.untested_template_files.should include(File.join(cookbook_path, 'templates', 'default', 'borken.erb'))
-          lambda {syntax_check.validate_templates}.should_not change(syntax_check, :untested_template_files)
+          expect(syntax_check.untested_template_files).to include(File.join(cookbook_path, 'templates', 'default', 'borken.erb'))
+          expect {syntax_check.validate_templates}.not_to change(syntax_check, :untested_template_files)
         end
 
       end
@@ -177,12 +182,12 @@ describe Chef::Cookbook::SyntaxCheck do
         end
 
         it "shows that ignored ruby files do not require a syntax check" do
-          syntax_check.untested_ruby_files.sort.should == @ruby_files.sort
+          expect(syntax_check.untested_ruby_files.sort).to eq(@ruby_files.sort)
         end
 
         it "does not indicate that a ruby file has a syntax error" do
-          syntax_check.validate_ruby_files.should be_true
-          syntax_check.untested_ruby_files.should be_empty
+          expect(syntax_check.validate_ruby_files).to be_truthy
+          expect(syntax_check.untested_ruby_files).to be_empty
         end
 
       end
@@ -196,13 +201,13 @@ describe Chef::Cookbook::SyntaxCheck do
       end
 
       it "does not syntax check ruby files" do
-        syntax_check.should_not_receive(:shell_out)
-        syntax_check.validate_ruby_files.should be_true
+        expect(syntax_check).not_to receive(:shell_out)
+        expect(syntax_check.validate_ruby_files).to be_truthy
       end
 
       it "does not syntax check templates" do
-        syntax_check.should_not_receive(:shell_out)
-        syntax_check.validate_templates.should be_true
+        expect(syntax_check).not_to receive(:shell_out)
+        expect(syntax_check.validate_templates).to be_truthy
       end
     end
   end

data/spec/unit/cookbook_loader_spec.rb

@@ -20,7 +20,7 @@ require 'spec_helper'
 
 describe Chef::CookbookLoader do
   before do
-    Chef::Platform.stub(:windows?) {false}
+    allow(Chef::Platform).to receive(:windows?) {false}
   end
   let(:repo_paths) do
     [
@@ -40,7 +40,7 @@ describe Chef::CookbookLoader do
     cookbook_paths.delete_if { |path| File.basename(path) == "chefignore" }
 
     cookbook_paths.each do |cookbook_path|
-      Chef::Cookbook::CookbookVersionLoader.should_receive(:new).
+      expect(Chef::Cookbook::CookbookVersionLoader).to receive(:new).
         with(cookbook_path, anything).
         once.
         and_call_original
@@ -56,19 +56,19 @@ describe Chef::CookbookLoader do
 
     describe "[]" do
       it "should return cookbook objects with []" do
-        cookbook_loader[:openldap].should be_a_kind_of(Chef::CookbookVersion)
+        expect(cookbook_loader[:openldap]).to be_a_kind_of(Chef::CookbookVersion)
       end
 
       it "should raise an exception if it cannot find a cookbook with []" do
-        lambda { cookbook_loader[:monkeypoop] }.should raise_error(Chef::Exceptions::CookbookNotFoundInRepo)
+        expect { cookbook_loader[:monkeypoop] }.to raise_error(Chef::Exceptions::CookbookNotFoundInRepo)
       end
 
       it "should allow you to look up available cookbooks with [] and a symbol" do
-        cookbook_loader[:openldap].name.should eql(:openldap)
+        expect(cookbook_loader[:openldap].name).to eql(:openldap)
       end
 
       it "should allow you to look up available cookbooks with [] and a string" do
-        cookbook_loader["openldap"].name.should eql(:openldap)
+        expect(cookbook_loader["openldap"].name).to eql(:openldap)
       end
     end
 
@@ -78,8 +78,8 @@ describe Chef::CookbookLoader do
         cookbook_loader.each do |cookbook_name, cookbook|
           seen[cookbook_name] = true
         end
-        seen.should have_key("openldap")
-        seen.should have_key("apache2")
+        expect(seen).to have_key("openldap")
+        expect(seen).to have_key("apache2")
       end
 
       it "should iterate in alphabetical order" do
@@ -87,86 +87,86 @@ describe Chef::CookbookLoader do
         cookbook_loader.each do |cookbook_name, cookbook|
           seen << cookbook_name
           end
-        seen[0].should == "angrybash"
-        seen[1].should == "apache2"
-        seen[2].should == "borken"
-        seen[3].should == "ignorken"
-        seen[4].should == "java"
-        seen[5].should == "name-mismatch"
-        seen[6].should == "openldap"
+        expect(seen[0]).to eq("angrybash")
+        expect(seen[1]).to eq("apache2")
+        expect(seen[2]).to eq("borken")
+        expect(seen[3]).to eq("ignorken")
+        expect(seen[4]).to eq("java")
+        expect(seen[5]).to eq("name-mismatch")
+        expect(seen[6]).to eq("openldap")
       end
     end
 
     describe "referencing cookbook files" do
       it "should find all the cookbooks in the cookbook path" do
         cookbook_loader.load_cookbooks
-        cookbook_loader.should have_key(:openldap)
-        cookbook_loader.should have_key(:apache2)
+        expect(cookbook_loader).to have_key(:openldap)
+        expect(cookbook_loader).to have_key(:apache2)
       end
 
       it "should allow you to override an attribute file via cookbook_path" do
-        cookbook_loader[:openldap].attribute_filenames.detect { |f|
+        expect(cookbook_loader[:openldap].attribute_filenames.detect { |f|
           f =~ /cookbooks\/openldap\/attributes\/default.rb/
-        }.should_not eql(nil)
-        cookbook_loader[:openldap].attribute_filenames.detect { |f|
+        }).not_to eql(nil)
+        expect(cookbook_loader[:openldap].attribute_filenames.detect { |f|
           f =~ /kitchen\/openldap\/attributes\/default.rb/
-        }.should eql(nil)
+        }).to eql(nil)
       end
 
       it "should load different attribute files from deeper paths" do
-        cookbook_loader[:openldap].attribute_filenames.detect { |f|
+        expect(cookbook_loader[:openldap].attribute_filenames.detect { |f|
           f =~ /kitchen\/openldap\/attributes\/robinson.rb/
-        }.should_not eql(nil)
+        }).not_to eql(nil)
       end
 
       it "should allow you to override a definition file via cookbook_path" do
-        cookbook_loader[:openldap].definition_filenames.detect { |f|
+        expect(cookbook_loader[:openldap].definition_filenames.detect { |f|
           f =~ /cookbooks\/openldap\/definitions\/client.rb/
-        }.should_not eql(nil)
-        cookbook_loader[:openldap].definition_filenames.detect { |f|
+        }).not_to eql(nil)
+        expect(cookbook_loader[:openldap].definition_filenames.detect { |f|
           f =~ /kitchen\/openldap\/definitions\/client.rb/
-        }.should eql(nil)
+        }).to eql(nil)
       end
 
       it "should load definition files from deeper paths" do
-        cookbook_loader[:openldap].definition_filenames.detect { |f|
+        expect(cookbook_loader[:openldap].definition_filenames.detect { |f|
           f =~ /kitchen\/openldap\/definitions\/drewbarrymore.rb/
-        }.should_not eql(nil)
+        }).not_to eql(nil)
       end
 
       it "should allow you to override a recipe file via cookbook_path" do
-        cookbook_loader[:openldap].recipe_filenames.detect { |f|
+        expect(cookbook_loader[:openldap].recipe_filenames.detect { |f|
           f =~ /cookbooks\/openldap\/recipes\/gigantor.rb/
-        }.should_not eql(nil)
-        cookbook_loader[:openldap].recipe_filenames.detect { |f|
+        }).not_to eql(nil)
+        expect(cookbook_loader[:openldap].recipe_filenames.detect { |f|
           f =~ /kitchen\/openldap\/recipes\/gigantor.rb/
-        }.should eql(nil)
+        }).to eql(nil)
       end
 
       it "should load recipe files from deeper paths" do
-        cookbook_loader[:openldap].recipe_filenames.detect { |f|
+        expect(cookbook_loader[:openldap].recipe_filenames.detect { |f|
           f =~ /kitchen\/openldap\/recipes\/woot.rb/
-        }.should_not eql(nil)
+        }).not_to eql(nil)
       end
 
       it "should allow you to have an 'ignore' file, which skips loading files in later cookbooks" do
-        cookbook_loader[:openldap].recipe_filenames.detect { |f|
+        expect(cookbook_loader[:openldap].recipe_filenames.detect { |f|
           f =~ /kitchen\/openldap\/recipes\/ignoreme.rb/
-        }.should eql(nil)
+        }).to eql(nil)
       end
 
       it "should find files that start with a ." do
-        cookbook_loader[:openldap].file_filenames.detect { |f|
+        expect(cookbook_loader[:openldap].file_filenames.detect { |f|
           f =~ /\.dotfile$/
-        }.should =~ /\.dotfile$/
-        cookbook_loader[:openldap].file_filenames.detect { |f|
+        }).to match(/\.dotfile$/)
+        expect(cookbook_loader[:openldap].file_filenames.detect { |f|
           f =~ /\.ssh\/id_rsa$/
-        }.should =~ /\.ssh\/id_rsa$/
+        }).to match(/\.ssh\/id_rsa$/)
       end
 
       it "should load the metadata for the cookbook" do
-        cookbook_loader.metadata[:openldap].name.to_s.should == "openldap"
-        cookbook_loader.metadata[:openldap].should be_a_kind_of(Chef::Cookbook::Metadata)
+        expect(cookbook_loader.metadata[:openldap].name.to_s).to eq("openldap")
+        expect(cookbook_loader.metadata[:openldap]).to be_a_kind_of(Chef::Cookbook::Metadata)
       end
 
     end # referencing cookbook files
@@ -190,6 +190,11 @@ describe Chef::CookbookLoader do
   end
 
   describe "loading only one cookbook" do
+
+    let(:openldap_cookbook) { cookbook_loader["openldap"] }
+
+    let(:cookbook_as_hash) { Chef::CookbookManifest.new(openldap_cookbook).to_hash }
+
     before(:each) do
       cookbook_loader.load_cookbook("openldap")
     end
@@ -199,27 +204,26 @@ describe Chef::CookbookLoader do
       cookbook_loader.each do |cookbook_name, cookbook|
         seen[cookbook_name] = true
       end
-      seen.should have_key("openldap")
+      expect(seen).to have_key("openldap")
     end
 
     it "should not duplicate keys when serialized to JSON" do
       # Chef JSON serialization will generate duplicate keys if given
       # a Hash containing matching string and symbol keys. See CHEF-4571.
-      aa = cookbook_loader["openldap"]
-      aa.to_hash["metadata"].recipes.keys.should_not include(:openldap)
-      aa.to_hash["metadata"].recipes.keys.should include("openldap")
+      expect(cookbook_as_hash["metadata"].recipes.keys).not_to include(:openldap)
+      expect(cookbook_as_hash["metadata"].recipes.keys).to include("openldap")
       expected_desc = "Main Open LDAP configuration"
-      aa.to_hash["metadata"].recipes["openldap"].should == expected_desc
-      raw = Chef::JSONCompat.to_json(aa.to_hash["metadata"].recipes)
+      expect(cookbook_as_hash["metadata"].recipes["openldap"]).to eq(expected_desc)
+      raw = Chef::JSONCompat.to_json(cookbook_as_hash["metadata"].recipes)
       search_str = "\"openldap\":\""
       key_idx = raw.index(search_str)
-      key_idx.should be > 0
+      expect(key_idx).to be > 0
       dup_idx = raw[(key_idx + 1)..-1].index(search_str)
-      dup_idx.should be_nil
+      expect(dup_idx).to be_nil
     end
 
     it "should not load the cookbook again when accessed" do
-      cookbook_loader.should_not_receive('load_cookbook')
+      expect(cookbook_loader).not_to receive('load_cookbook')
       cookbook_loader["openldap"]
     end
 
@@ -228,11 +232,11 @@ describe Chef::CookbookLoader do
       cookbook_loader.each do |cookbook_name, cookbook|
         seen[cookbook_name] = true
       end
-      seen.should_not have_key("apache2")
+      expect(seen).not_to have_key("apache2")
     end
 
     it "should load another cookbook lazily with []" do
-      cookbook_loader["apache2"].should be_a_kind_of(Chef::CookbookVersion)
+      expect(cookbook_loader["apache2"]).to be_a_kind_of(Chef::CookbookVersion)
     end
 
     context "when an unrelated cookbook has invalid metadata" do
@@ -265,8 +269,8 @@ describe Chef::CookbookLoader do
         cookbook_loader.each do |cookbook_name, cookbook|
           seen[cookbook_name] = true
         end
-        seen.should have_key("openldap")
-        seen.should have_key("apache2")
+        expect(seen).to have_key("openldap")
+        expect(seen).to have_key("apache2")
       end
     end
   end # loading only one cookbook
@@ -279,8 +283,8 @@ describe Chef::CookbookLoader do
 
     it "loads the correct cookbook" do
       cookbook_version = cookbook_loader["name-mismatch"]
-      cookbook_version.should be_a_kind_of(Chef::CookbookVersion)
-      cookbook_version.name.should == :"name-mismatch"
+      expect(cookbook_version).to be_a_kind_of(Chef::CookbookVersion)
+      expect(cookbook_version.name).to eq(:"name-mismatch")
     end
 
   end

data/spec/unit/cookbook_manifest_spec.rb

@@ -1,7 +1,6 @@
 #
-# Author:: Tim Hinderliter (<tim@opscode.com>)
-# Author:: Christopher Walters (<cw@opscode.com>)
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright (c) 2015 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,540 +14,214 @@
 # 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'
+require 'chef/cookbook_manifest'
+require 'chef/digester'
+require 'pathname'
 
-describe "Chef::CookbookVersion manifest" 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")
-    manifest_record.should_not be_nil
-    manifest_record[:checksum].should == "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")
-    manifest_record.should_not be_nil
-    manifest_record[:checksum].should == "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")
-    manifest_record.should_not be_nil
-    manifest_record[:checksum].should == "csum-platver-partial"
-  end
+describe Chef::CookbookManifest do
 
-  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"
+  let(:version) { "1.2.3" }
 
-    manifest_record = @cookbook.preferred_manifest_record(node, :files, "afile.rb")
-    manifest_record.should_not be_nil
-    manifest_record[:checksum].should == "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")
-    manifest_record.should_not be_nil
-    manifest_record[:checksum].should == "csum-default"
+  let(:metadata) do
+    Chef::Cookbook::Metadata.new.tap do |m|
+      m.version(version)
+    end
   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"
+  let(:cookbook_root) { '/tmp/blah' }
 
-    manifest_record = @cookbook.preferred_manifest_record(node, :files, "bfile.rb")
-    manifest_record.should_not be_nil
-    manifest_record[:checksum].should == "csum2-platver-full"
+  let(:cookbook_version) do
+    Chef::CookbookVersion.new("tatft", cookbook_root).tap do |c|
+      c.metadata = metadata
+    end
   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"
+  let(:policy_mode) { false }
 
-    manifest_record = @cookbook.preferred_manifest_record(node, :files, "bfile.rb")
-    manifest_record.should_not be_nil
-    manifest_record[:checksum].should == "csum2-platver-partial"
-  end
+  subject(:cookbook_manifest) { Chef::CookbookManifest.new(cookbook_version, policy_mode: policy_mode) }
 
-  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"
+  context "when policy mode is not specified" do
 
-    manifest_record = @cookbook.preferred_manifest_record(node, :files, "bfile.rb")
-    manifest_record.should_not be_nil
-    manifest_record[:checksum].should == "csum3-platver-full"
-  end
+    subject(:cookbook_manifest) { Chef::CookbookManifest.new(cookbook_version) }
 
-  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"
+    it "defaults to policies disabled" do
+      expect(cookbook_manifest.policy_mode?).to be(false)
+    end
 
-    manifest_record = @cookbook.preferred_manifest_record(node, :files, "bfile.rb")
-    manifest_record.should_not be_nil
-    manifest_record[:checksum].should == "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"
+  describe "collecting cookbook data from the cookbook version object" do
 
-      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
-      manifest_records.should_not be_nil
-      manifest_records.size.should == 2
-
-      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
-      checksums.sort.should == ["csum-host-1", "csum-host-2"]
+    it "delegates `name' to cookbook_version" do
+      expect(cookbook_manifest.name).to eq("tatft")
     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")
-      manifest_records.should_not be_nil
-      manifest_records.size.should == 2
-
-      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
-      checksums.sort.should == ["csum-platver-full-1", "csum-platver-full-2"]
+    it "delegates `root_paths' to cookbook_version" do
+      expect(cookbook_manifest.root_paths).to eq(['/tmp/blah'])
     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")
-      manifest_records.should_not be_nil
-      manifest_records.size.should == 2
-
-      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
-      checksums.sort.should == ["csum-platver-partial-1", "csum-platver-partial-2"]
+    it "delegates `metadata' to cookbook_version" do
+      expect(cookbook_manifest.metadata).to eq(metadata)
     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")
-      manifest_records.should_not be_nil
-      manifest_records.size.should == 2
-
-      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
-      checksums.sort.should == ["csum-plat-1", "csum-plat-2"]
+    it "delegates `full_name' to cookbook_version" do
+      expect(cookbook_manifest.full_name).to eq("tatft-1.2.3")
     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")
-      manifest_records.should_not be_nil
-      manifest_records.size.should == 2
-
-      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
-      checksums.sort.should == ["csum-default-1", "csum-default-2"]
+    it "delegates `version' to cookbook_version" do
+      expect(cookbook_manifest.version).to eq(version)
     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")
-      manifest_records.should_not be_nil
-      manifest_records.size.should == 2
+    it "delegates `frozen_version?' to cookbook_version" do
+      expect(cookbook_manifest.frozen_version?).to be(false)
+    end
 
-      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
-      checksums.sort.should == ["csum2-platver-full-1", "csum2-platver-full-2"]
+    it "delegates `segment_filenames' to cookbook_version" do
+      expect(cookbook_version).to receive(:segment_filenames).with(:recipes).and_return([])
+      expect(cookbook_manifest.segment_filenames(:recipes)).to eq([])
     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"
+  end
 
-      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
-      manifest_records.should_not be_nil
-      manifest_records.size.should == 2
+  context "when given an empty cookbook" do
 
-      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
-      checksums.sort.should == ["csum2-platver-partial-1", "csum2-platver-partial-2"]
-    end
+    let(:expected_hash) do
+      {
+        "chef_type" => "cookbook_version",
 
-    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"
+        "name"          => "tatft-1.2.3",
+        "version"       => "1.2.3",
+        "cookbook_name" => "tatft",
+        "metadata"      => metadata,
 
-      manifest_records = @cookbook.preferred_manifest_records_for_directory(node, :files, "adirectory")
-      manifest_records.should_not be_nil
-      manifest_records.size.should == 2
+        "frozen?" => false,
 
-      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
-      checksums.sort.should == ["csum3-platver-full-1", "csum3-platver-full-2"]
+        "recipes"     =>[],
+        "definitions" =>[],
+        "libraries"   =>[],
+        "attributes"  =>[],
+        "files"       =>[],
+        "templates"   =>[],
+        "resources"   =>[],
+        "providers"   =>[],
+        "root_files"  =>[],
+      }
     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")
-      manifest_records.should_not be_nil
-      manifest_records.size.should == 2
-
-      checksums = manifest_records.map{ |manifest_record| manifest_record[:checksum] }
-      checksums.sort.should == ["csum4-platver-full-1", "csum4-platver-full-2"]
+    it "converts the CookbookVersion to a ruby Hash representation" do
+      expect(cookbook_manifest.to_hash).to eq(expected_hash)
     end
+
   end
 
-  ## Globbing the relative paths out of the manifest records ##
+  context "when given a cookbook with files" do
 
-  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"
+    let(:cookbook_root) { File.join(CHEF_SPEC_DATA, 'cb_version_cookbooks', 'tatft') }
 
-      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
-      filenames.should_not be_nil
-      filenames.size.should == 2
+    let(:attribute_filenames)   { Dir[File.join(cookbook_root, 'attributes', '**', '*.rb')] }
+    let(:definition_filenames)  { Dir[File.join(cookbook_root, 'definitions', '**', '*.rb')] }
+    let(:file_filenames)        { Dir[File.join(cookbook_root, 'files', '**', '*.tgz')] }
+    let(:recipe_filenames)      { Dir[File.join(cookbook_root, 'recipes', '**', '*.rb')] }
+    let(:template_filenames)    { Dir[File.join(cookbook_root, 'templates', '**', '*.erb')] }
+    let(:library_filenames)     { Dir[File.join(cookbook_root, 'libraries', '**', '*.rb')] }
+    let(:resource_filenames)    { Dir[File.join(cookbook_root, 'resources', '**', '*.rb')] }
+    let(:provider_filenames)    { Dir[File.join(cookbook_root, 'providers', '**', '*.rb')] }
+    let(:root_filenames)        { Array(File.join(cookbook_root, 'README.rdoc')) }
+    let(:metadata_filenames)    { Array(File.join(cookbook_root, 'metadata.json')) }
 
-      filenames.sort.should == ['anotherfile1.rb.host', 'anotherfile2.rb.host']
-    end
+    let(:match_md5) { /[0-9a-f]{32}/ }
 
-    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"
+    def map_to_file_specs(paths)
+      paths.map do |path|
 
-      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
-      filenames.should_not be_nil
-      filenames.size.should == 2
+        relative_path = Pathname.new(path).relative_path_from(Pathname.new(cookbook_root)).to_s
 
-      filenames.sort.should == ['anotherfile1.rb.platform-full-version', 'anotherfile2.rb.platform-full-version']
+        {
+          "name"        => File.basename(path),
+          "path"        => relative_path,
+          "checksum"    => Chef::Digester.generate_md5_checksum_for_file(path),
+          "specificity" => "default",
+        }
+      end
     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")
-      filenames.should_not be_nil
-      filenames.size.should == 2
+    let(:expected_hash) do
+      {
+        "chef_type" => "cookbook_version",
 
-      filenames.sort.should == ['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"
+        "name"          => "tatft-1.2.3",
+        "version"       => "1.2.3",
+        "cookbook_name" => "tatft",
+        "metadata"      => metadata,
 
-      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
-      filenames.should_not be_nil
-      filenames.size.should == 2
+        "frozen?" => false,
 
-      filenames.sort.should == ['anotherfile1.rb.platform', 'anotherfile2.rb.platform']
+        "recipes"     => map_to_file_specs(recipe_filenames),
+        "definitions" => map_to_file_specs(definition_filenames),
+        "libraries"   => map_to_file_specs(library_filenames),
+        "attributes"  => map_to_file_specs(attribute_filenames),
+        "files"       => map_to_file_specs(file_filenames),
+        "templates"   => map_to_file_specs(template_filenames),
+        "resources"   => map_to_file_specs(resource_filenames),
+        "providers"   => map_to_file_specs(provider_filenames),
+        "root_files"  => map_to_file_specs(root_filenames),
+      }
     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"
+    before do
+      cookbook_version.attribute_filenames   = attribute_filenames
+      cookbook_version.definition_filenames  = definition_filenames
+      cookbook_version.file_filenames        = file_filenames
+      cookbook_version.recipe_filenames      = recipe_filenames
+      cookbook_version.template_filenames    = template_filenames
+      cookbook_version.library_filenames     = library_filenames
+      cookbook_version.resource_filenames    = resource_filenames
+      cookbook_version.provider_filenames    = provider_filenames
+      cookbook_version.root_filenames        = root_filenames
+      cookbook_version.metadata_filenames    = metadata_filenames
+    end
 
-      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
-      filenames.should_not be_nil
-      filenames.size.should == 2
+    it "converts the CookbookVersion to a ruby Hash representation" do
+      cookbook_manifest_hash = cookbook_manifest.to_hash
 
-      filenames.sort.should == ['anotherfile1.rb.default', 'anotherfile2.rb.default']
+      expect(cookbook_manifest_hash.keys).to match_array(expected_hash.keys)
+      cookbook_manifest_hash.each do |key, value|
+        expect(cookbook_manifest_hash[key]).to eq(expected_hash[key])
+      end
     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"
+  end
 
-      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
-      filenames.should_not be_nil
-      filenames.size.should == 2
+  describe "providing upstream URLs for save" do
 
-      filenames.sort.should == ['anotherfile1.rb.platform-full-version', 'anotherfile2.rb.platform-full-version']
-    end
+    context "and policy mode is disabled" do
 
-    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"
+      it "gives the save URL" do
+        expect(cookbook_manifest.save_url).to eq("cookbooks/tatft/1.2.3")
+      end
 
-      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
-      filenames.should_not be_nil
-      filenames.size.should == 2
+      it "gives the force save URL" do
+        expect(cookbook_manifest.force_save_url).to eq("cookbooks/tatft/1.2.3?force=true")
+      end
 
-      filenames.sort.should == ['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")
-      filenames.should_not be_nil
-      filenames.size.should == 2
+    context "and policy mode is enabled" do
 
-      filenames.sort.should == ['anotherfile1.rb.platform-full-version', 'anotherfile2.rb.platform-full-version']
-    end
+      let(:policy_mode) { true }
 
-    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"
+      it "gives the save URL" do
+        expect(cookbook_manifest.save_url).to eq("cookbook_artifacts/tatft/1.2.3")
+      end
 
-      filenames = @cookbook.relative_filenames_in_preferred_directory(node, :files, "adirectory")
-      filenames.should_not be_nil
-      filenames.size.should == 2
+      it "gives the force save URL" do
+        expect(cookbook_manifest.force_save_url).to eq("cookbook_artifacts/tatft/1.2.3?force=true")
+      end
 
-      filenames.sort.should == ['anotherfile1.rb.platform-full-version', 'anotherfile2.rb.platform-full-version']
     end
   end
+
 end
+