cuken 0.1.1 → 0.1.2

data/lib/cuken/api/chef/common.rb

@@ -0,0 +1,80 @@
+module ::Cuken
+  module Api
+    module Chef
+      module Common
+
+        include Grit
+
+        attr_accessor :recipe, :cookbook, :api_response, :inflated_response, :log_level,
+                      :chef_args, :config_file, :stdout, :stderr, :status, :exception,
+                      :gemserver_thread, :sandbox_url,
+                      :uri, :client_private_key_path, :admin_client_name,
+                      :client_name, :client_knife_path, :cookbook_paths, :cookbooks_paths,
+                      :knife_debug, :local_cookbook_repo, :remote_cookbook_repo,
+                      :local_chef_repo, :remote_chef_repo
+
+        def self.ohai
+          # ohai takes a while, so only ever run it once.
+          @ohai ||= begin
+            o = Ohai::System.new
+            o.all_plugins
+            o
+          end
+        end
+
+        def ohai
+          ::Cuken::Api::Chef::Common.ohai
+        end
+
+        def chef
+          @remote_chef_repo ||= "git://github.com/opscode/chef-repo.git"
+          @knife_debug = true if @knife_debug.nil?
+          @cookbooks_paths ||= []
+          @cookbook_paths ||= []
+          @chef ||= self
+        end
+
+        def knife
+          'knife '
+        end
+
+        def client
+          @client ||= begin
+            c = ::Chef::Client.new
+            c.ohai = ohai
+            c
+          end
+        end
+
+        def make_admin
+          admin_client
+          @rest = ::Chef::REST.new(Chef::Config[:registration_url], 'bobo', "#{tmpdir}/bobo.pem")
+          #Chef::Config[:client_key] = "#{tmpdir}/bobo.pem"
+          #Chef::Config[:node_name] = "bobo"
+        end
+
+        def make_non_admin
+          r = ::Chef::REST.new(::Chef::Config[:registration_url], ::Chef::Config[:validation_client_name], ::Chef::Config[:validation_key])
+          r.register("not_admin", "#{tmpdir}/not_admin.pem")
+          c = ::Chef::ApiClient.cdb_load("not_admin")
+          c.cdb_save
+          @rest = ::Chef::REST.new(::Chef::Config[:registration_url], 'not_admin', "#{tmpdir}/not_admin.pem")
+          #Chef::Config[:client_key] = "#{tmpdir}/not_admin.pem"
+          #Chef::Config[:node_name] = "not_admin"
+        end
+
+        def admin_client
+          unless @admin_client
+            r = ::Chef::REST.new(::Chef::Config[:registration_url], ::Chef::Config[:validation_client_name], ::Chef::Config[:validation_key])
+            r.register("bobo", "#{tmpdir}/bobo.pem")
+            c = ::Chef::ApiClient.cdb_load("bobo")
+            c.admin(true)
+            c.cdb_save
+            @admin_client = c
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/cuken/api/file.rb

@@ -6,7 +6,27 @@ module Cuken
     module File
       include Etc
 
-      def parse_mode(mode)
+      def check_file_content(file, partial_content, expect_match, times = 1)
+        regexp = regexp(partial_content)
+        seen_count = 0
+        prep_for_fs_check do
+          content = IO.read(file)
+          while (seen_count < times.to_i || content =~ regexp)do
+            if content =~ regexp
+              content = content.sub(regexp,'')
+              seen_count+=1
+            end
+          end
+          if expect_match
+            seen_count.should == times.to_i
+          else
+            seen_count.should_not == times.to_i
+          end
+        end
+      end
+
+      def parse_mode(mode, octal=false)
+        return mode.to_s if octal
         if mode.respond_to?(:oct)
           mode.oct.to_s(8)
         else
@@ -21,10 +41,10 @@ module Cuken
         end
       end
 
-      def check_octalmodes(expected_mode, filename)
+      def check_modes(expected_mode, filename, octal = false)
         in_current_dir do
           cstats = ::File.stat(filename)
-          parse_mode(cstats.mode)[/#{parse_mode(expected_mode)}\Z/].should_not be_nil
+          parse_mode(cstats.mode, octal).should match /#{expected_mode}\Z/# ].should_not be_nil
         end
       end
 

data/lib/cuken/chef.rb

@@ -0,0 +1,3 @@
+require 'cuken/common'
+require 'cuken/api/chef'
+require 'cuken/cucumber/chef'

data/lib/cuken/common.rb

@@ -3,4 +3,3 @@ require 'aruba/cucumber' unless defined? Aruba
 
 require 'cuken/api/common'
 require 'cuken/cucumber/common'
-

data/lib/cuken/cucumber/chef.rb

@@ -0,0 +1,16 @@
+load 'aruba/cucumber.rb' unless defined? ::Aruba
+require 'grit'
+
+World(::Cuken::Api::Chef)
+
+Before do
+  @aruba_timeout_seconds.nil? || @aruba_timeout_seconds < 20 ? @aruba_timeout_seconds = 20 : @aruba_timeout_seconds
+end
+
+Before('@work_in_cwd') do
+  @dirs = [Pathname.getwd.expand_path.realpath.to_s]
+end
+
+require 'cuken/cucumber/chef/common'
+require 'cuken/cucumber/chef/knife'
+require 'cuken/cucumber/chef/cookbook'

data/lib/cuken/cucumber/chef/common.rb

@@ -0,0 +1,68 @@
+#
+# Author:: Hedgehog (<hedgehogshiatus@gmail.com>)
+# Copyright:: Copyright (c) 2011 Hedgehog.
+#
+# 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.
+#
+World(::Cuken::Api::Chef)
+
+Before do
+  @aruba_timeout_seconds.nil? || @aruba_timeout_seconds < 3 ? @aruba_timeout_seconds = 3 : @aruba_timeout_seconds
+end
+
+Given /^the Chef server URI "([^"]*)"$/ do |uri|
+  chef.uri = uri
+end
+
+Given /^the Chef client "([^"]*)"$/ do |name|
+  chef.client_name =  name
+end
+
+Given /^the Chef admin client "([^"]*)"$/ do |name|
+  chef.admin_client_name =  name
+end
+
+Given /^the Chef client private key path "([^"]*)"$/ do |path|
+  in_current_dir do
+    chef.client_private_key_path = Pathname(path)
+  end
+end
+
+Given /^the remote chef repository "([^"]*)"$/ do |chf_pth|
+  in_current_dir do
+    chef.remote_chef_repo = Pathname(chf_pth).expand_path.realdirpath
+  end
+end
+
+Given /^the local chef repository "([^"]*)"$/ do |chf_pth|
+  in_current_dir do
+    chef.local_chef_repo = Pathname(chf_pth).expand_path.realdirpath
+  end
+end
+
+Then /^the local chef repository exists$/ do
+  chef.local_chef_repo.exist?.should be_true
+  #TODO: check_file_presence([file], true), etc.
+end
+
+Given /^I clone the remote chef repository branch "([^"]*)" to "([^"]*)"$/ do |brnch, path|
+  @chef_repo_path = "We are here..."
+  chef.local_chef_repo = chef_clone_repo(path, false, chef.remote_chef_repo, brnch)
+end
+
+Given /^a default base chef repository in "([^"]*)"$/ do |path|
+  chef.local_chef_repo = chef_clone_repo(path)
+  chef.local_chef_repo.exist?.should be_true
+end
+
+

data/lib/cuken/cucumber/chef/cookbook.rb

@@ -0,0 +1,75 @@
+#
+# Author:: Hedgehog (<hedgehogshiatus@gmail.com>)
+# Copyright:: Copyright (c) 2011 Hedgehog.
+# Portions of this work are derived from the Chef project
+# The original license header follows:
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2008, 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.
+#
+
+Given /^the remote cookbook repository "([^"]*)"$/ do |ckbk_repo|
+  in_current_dir do
+    chef.remote_cookbook_repo = Pathname(ckbk_repo).expand_path.realdirpath
+  end
+end
+
+Given /^the local cookbook repository "([^"]*)"$/ do |ckbk_repo|
+  in_current_dir do
+    chef.local_cookbook_repo = Pathname(ckbk_repo).expand_path.realdirpath
+  end
+end
+
+Then /^the local cookbook repository exists$/ do
+  chef.local_cookbook_repo.exist?.should be_true
+  #TODO: check_file_presence([file], true), etc.
+end
+
+Given /^a cookbook path "([^"]*)"$/ do |path|
+  in_current_dir do
+    chef.cookbook_paths << Pathname(path).expand_path.realdirpath
+  end
+end
+
+Then /^the local cookbook "([^"]*)" exists$/ do |ckbk|
+  chef.cookbook_paths.each do |pn|
+    curr_ckbk = pn.basename.to_s
+    curr_ckbk.should == ckbk if curr_ckbk == ckbk
+  end
+  #TODO: check_file_presence([file], true), etc.
+end
+
+Given /^I clone the remote cookbook repository branch "([^"]*)" to "([^"]*)"$/ do |brnch, ckbk_path|
+  chef.local_cookbook_repo = chef_clone_repo(ckbk_path, true, chef.remote_cookbook_repo, brnch)
+end
+
+When /^I successfully generate all cookbook metadata$/ do
+  chef.cookbook_paths.each do |pn|
+    curr_ckbk = pn.basename.to_s
+    run_knife_command("cookbook metadata #{curr_ckbk}")
+  end
+end
+
+When /^I successfully generate cookbook "([^"]*)" metadata$/ do |ckbk|
+  chef.cookbook_paths.each do |pn|
+    curr_ckbk = pn.basename.to_s
+    if curr_ckbk == ckbk
+      run_knife_command("cookbook metadata #{curr_ckbk}")
+    end
+  end
+end

data/lib/cuken/cucumber/chef/cookbook_steps.rb

@@ -0,0 +1,406 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2008, 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 'chef/cookbook/file_system_file_vendor'
+
+def compare_manifests(manifest1, manifest2)
+  Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
+    next unless manifest1[segment]
+    manifest2.should have_key(segment)
+
+    manifest2_records_by_path = manifest2[segment].inject({}) {|memo,manifest2_record| memo[manifest2_record[:path]] = manifest2_record; memo}
+    manifest1[segment].each do |manifest1_record|
+      path = manifest1_record[:path]
+
+      manifest2_records_by_path.should have_key(path)
+      manifest1_record.should == manifest2_records_by_path[path]
+    end
+  end
+end
+
+Before do
+  save_cookbook_path = Chef::Config[:cookbook_path]
+  FileUtils.mkdir "#{datadir}/cookbooks_not_uploaded_at_feature_start/testcookbook_invalid_empty" unless File.exist?("#{datadir}/cookbooks_not_uploaded_at_feature_start/testcookbook_invalid_empty")
+  Chef::Config[:cookbook_path] = File.join(datadir, "cookbooks_not_uploaded_at_feature_start")
+  Chef::Cookbook::FileVendor.on_create {|manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest) }
+  @cookbook_loader_not_uploaded_at_feature_start = Chef::CookbookLoader.new
+  Chef::Config[:cookbook_path] = save_cookbook_path
+end
+
+#Given /^a local cookbook repository$/ do
+#  Dir.mkdir(File.join(tmpdir, 'cookbooks_dir'))
+#  Dir.mkdir(File.join(tmpdir, 'cookbooks_dir', 'cookbooks'))
+#  Dir.mkdir(File.join(tmpdir, 'cookbooks_dir', 'config'))
+#  system("cp #{datadir}/Rakefile #{tmpdir}/cookbooks_dir")
+#  system("cp -r #{datadir}/config/* #{tmpdir}/cookbooks_dir/config")
+#  system("cp -r #{datadir}/cookbooks/* #{tmpdir}/cookbooks_dir/cookbooks")
+#  cleanup_dirs << "#{tmpdir}/cookbooks_dir"
+#end
+
+#Given /^a local cookbook named '(.+)'$/ do |cb|
+#  Dir.mkdir(File.join(tmpdir, 'cookbooks_dir'))
+#  Dir.mkdir(File.join(tmpdir, 'cookbooks_dir', 'cookbooks'))
+#  Dir.mkdir(File.join(tmpdir, 'cookbooks_dir', 'config'))
+#  system("cp #{datadir}/Rakefile #{tmpdir}/cookbooks_dir")
+#  system("cp -r #{datadir}/config/* #{tmpdir}/cookbooks_dir/config")
+#  system("cp -r #{datadir}/cookbooks/#{cb} #{tmpdir}/cookbooks_dir/cookbooks")
+#  cleanup_dirs << "#{tmpdir}/cookbooks_dir"
+#end
+
+Given "I upload the cookbook" do
+  cookbook_name, recipe_name = recipe.split('::')
+  shell_out!("#{KNIFE_CMD} cookbook upload -c #{KNIFE_CONFIG} -a -o #{INTEGRATION_COOKBOOKS}")
+end
+
+Given /^I delete the cookbook's on disk checksum files$/ do
+  #pp :checksums => @last_uploaded_cookbook.checksums.keys
+  #pending # express the regexp above with the code you wish you had
+  @last_uploaded_cookbook.checksums.keys.each do |file_checksum|
+    file_location_in_checksum_repo = File.join(datadir, 'repo', 'checksums', file_checksum[0...2], file_checksum)
+    #pp :expected_cksum_path => {file_checksum => file_location_in_checksum_repo}
+    #puts "deleting checksum file #{file_location_in_checksum_repo}"
+    FileUtils.rm(file_location_in_checksum_repo)
+  end
+end
+
+#When /^I run the task to generate cookbook metadata for '(.+)'$/ do |cb|
+#  self.cookbook = cb
+#  When('I run the task to generate cookbook metadata')
+#end
+#
+#When /^I run the task to generate cookbook metadata$/ do
+#  to_run = "#{KNIFE_CMD} cookbook metadata"
+#  if cookbook
+#    to_run += " #{cookbook}"
+#  else
+#    to_run += " -a"
+#  end
+#  to_run += " -o #{File.join(tmpdir, 'cookbooks_dir', 'cookbooks')}"
+#  Dir.chdir(File.join(tmpdir, 'cookbooks_dir', 'cookbooks')) do
+#    self.status = Chef::Mixin::Command.popen4(to_run) do |p, i, o, e|
+#      self.stdout = o.gets(nil)
+#      self.stderr = o.gets(nil)
+#    end
+#  end
+#end
+
+#####
+# Cookbook upload/download-specific steps
+#####
+
+When /^I create a versioned cookbook(?: named '(.*?)')?(?: versioned '(.*?)')? with '(.*?)'$/ do |request_name, request_version, cookbook_name|
+  cookbook = @cookbook_loader_not_uploaded_at_feature_start[cookbook_name]
+  raise ArgumentError, "no such cookbook in cookbooks_not_uploaded_at_feature_start: #{cookbook_name}" unless cookbook
+
+  begin
+    self.api_response = rest.put_rest("/cookbooks/#{request_name}/#{request_version}", cookbook)
+    self.inflated_response = api_response
+  rescue => e
+    self.exception = e
+  end
+end
+
+# The argument handling in the above step defn isn't working for me, so dup city.
+# :/
+When "I create a cookbook named '$cookbook_name' with only the metadata file" do |cookbook_name|
+  cookbook = @cookbook_loader_not_uploaded_at_feature_start[cookbook_name.to_sym]
+  raise ArgumentError, "no such cookbook in cookbooks_not_uploaded_at_feature_start: #{cookbook_name}" unless cookbook
+
+  begin
+    self.api_response = rest.put_rest("/cookbooks/#{cookbook_name}/1.0.0", cookbook)
+    self.inflated_response = api_response
+  rescue => e
+    Chef::Log.debug("Caught exception #{e} from HTTP request")
+    self.exception = e
+  end
+end
+
+When /^I create a sandbox named '(.+)' for cookbook '([^\']+)'(?: minus files '(.+)')?$/ do |sandbox_name, cookbook_name, filenames_to_exclude|
+  cookbook = @cookbook_loader_not_uploaded_at_feature_start[cookbook_name]
+  raise ArgumentError, "no such cookbook in cookbooks_not_uploaded_at_feature_start: #{cookbook_name}" unless cookbook
+
+  if filenames_to_exclude
+    filenames_to_exclude = filenames_to_exclude.split(",").inject({}) { |memo, filename| memo[filename] = 1; memo }
+  else
+    filenames_to_exclude = Hash.new
+  end
+
+  # add all the checksums from the given cookbook into the sandbox.
+  checksums = Hash.new
+  Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
+    next unless cookbook.manifest[segment]
+    cookbook.manifest[segment].each do |manifest_record|
+      # include the checksum, unless it was included in the filenames to exclude
+      checksums[manifest_record[:checksum]] = nil unless filenames_to_exclude.has_key?(manifest_record[:path])
+    end
+  end
+
+  sandbox = {
+    :checksums => checksums
+  }
+
+  begin
+    self.api_response = self.inflated_response = nil
+    self.exception = nil
+
+    self.inflated_response = rest.post_rest('/sandboxes', sandbox)
+    self.sandbox_url = self.inflated_response['uri']
+
+    @stash['sandbox_response'] = self.inflated_response
+  rescue
+    Chef::Log.debug("Caught exception in sandbox create (POST) request: #{$!.message}: #{$!.backtrace.join("\n")}")
+    self.exception = $!
+  end
+end
+
+Then /^I upload a file named '(.+)' from cookbook '(.+)' to the sandbox/ do |path, cookbook_name|
+  cookbook = @cookbook_loader_not_uploaded_at_feature_start[cookbook_name]
+  raise ArgumentError, "no such cookbook in cookbooks_not_uploaded_at_feature_start: #{cookbook_name}" unless cookbook
+
+  if path =~ /([^\/]+)\/(.+)/
+    segment, path_no_segment = $1, $2
+  else
+    segment = :root_files
+    path_no_segment = path
+  end
+  if cookbook.manifest[segment]
+    manifest_record = cookbook.manifest[segment].find {|manifest_record| manifest_record[:path] == path }
+  end
+  raise ArgumentError, "no such file in cookbooks_not_uploaded_at_feature_start/#{cookbook_name}: #{path}" unless manifest_record
+
+  full_path = File.join(datadir, "cookbooks_not_uploaded_at_feature_start", cookbook_name, path)
+
+  begin
+    url = @stash['sandbox_response']['checksums'][manifest_record[:checksum]]['url']
+    upload_to_sandbox(full_path, manifest_record[:checksum], url)
+  rescue
+    Chef::Log.debug("Caught exception in cookbook/sandbox checksum upload (PUT) request: #{$!.message}: #{$!.backtrace.join("\n")}")
+    self.exception = $!
+  end
+end
+
+# Shortcut for uploading a whole cookbook based on data in the
+# cookbooks_not_uploaded_at_feature_start directory
+Then /I fully upload a sandboxed cookbook (force-)?named '([^\']+)' versioned '([^\']+)' with '(.+)'/ do |forced, request_name, request_version, cookbook_name|
+  @last_uploaded_cookbook = cookbook = @cookbook_loader_not_uploaded_at_feature_start[cookbook_name]
+  raise ArgumentError, "no such cookbook in cookbooks_not_uploaded_at_feature_start: #{cookbook_name}" unless cookbook
+
+  # If they said 'force-named', we will reach into the cookbook and change its
+  # name. This is to get around the fact that CookbookLoader uses the
+  # directory name as the cookbook name. This is super awesome right here.
+  if forced == "force-"
+    # If the paths contain the name of the old cookbook name, change it to the
+    # new cookbook name.
+    Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
+      next unless cookbook.manifest[segment]
+      cookbook.manifest[segment].each do |manifest_record|
+        if manifest_record[:path] =~ /^(.+)\/#{cookbook.name}\/(.+)$/
+          manifest_record[:path] = "#{$1}/#{request_name}/#{$2}"
+        end
+      end
+    end
+    cookbook.name = request_name
+    cookbook.manifest[:cookbook_name] = request_name
+    cookbook.manifest[:name] = "#{cookbook.manifest[:cookbook_name]}-#{cookbook.manifest[:version]}"
+  end
+
+  When "I create a sandbox named 'sandbox1' for cookbook '#{cookbook_name}'"
+  Then "the inflated responses key 'uri' should match '^http://.+/sandboxes/[^\/]+$'"
+
+  Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
+    next unless cookbook.manifest[segment]
+    cookbook.manifest[segment].each do |manifest_record|
+      full_path = File.join(datadir, "cookbooks_not_uploaded_at_feature_start", cookbook_name, manifest_record[:path])
+
+      begin
+        csum_entry = @stash['sandbox_response']['checksums'][manifest_record[:checksum]]
+        next unless csum_entry['url']
+        url = @stash['sandbox_response']['checksums'][manifest_record[:checksum]]['url']
+        upload_to_sandbox(full_path, manifest_record[:checksum], url)
+      rescue
+        Chef::Log.debug("Caught exception in cookbook/sandbox checksum upload (PUT) request: #{$!.message}: #{$!.backtrace.join("\n")}")
+        self.exception = $!
+      end
+      Then "the response code should be '200'"
+    end
+  end
+
+  When "I commit the sandbox"
+  Then "I should not get an exception"
+  When "I create a versioned cookbook named '#{request_name}' versioned '#{request_version}' with '#{cookbook_name}'"
+  Then "I should not get an exception"
+end
+
+When /I download the cookbook manifest for '(.+)' version '(.+)'$/ do |cookbook_name, cookbook_version|
+  self.api_response = self.inflated_response = self.exception = nil
+
+  When "I 'GET' to the path '/cookbooks/#{cookbook_name}/#{cookbook_version}'"
+  @downloaded_cookbook = self.inflated_response
+end
+
+Then /the downloaded cookbook manifest contents should match '(.+)'$/ do |cookbook_name|
+  expected_cookbook = @cookbook_loader_not_uploaded_at_feature_start[cookbook_name]
+  raise ArgumentError, "no such cookbook in cookbooks_not_uploaded_at_feature_start: #{cookbook_name}" unless expected_cookbook
+
+  downloaded_cookbook_manifest = Mash.new(@downloaded_cookbook.manifest)
+  downloaded_cookbook_manifest.delete("uri")
+
+  # remove the uri's from the manifest records
+  Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
+    next unless downloaded_cookbook_manifest[segment]
+    downloaded_cookbook_manifest[segment].each do |downloaded_manifest_record|
+      downloaded_manifest_record.delete("url")
+    end
+  end
+
+  # ensure that each file expected (from the cookbook on disk) was downloaded,
+  # and then do the opposite.
+  begin
+    compare_manifests(expected_cookbook.manifest, downloaded_cookbook_manifest)
+    compare_manifests(downloaded_cookbook_manifest, expected_cookbook.manifest)
+  rescue
+    pp({:expected_cookbook_manifest => expected_cookbook.manifest})
+    pp({:downloaded_cookbook_manifest => downloaded_cookbook_manifest})
+
+    raise
+  end
+end
+
+When /I download the file '([^\']+)' from the downloaded cookbook manifest/ do |path|
+  raise "no @downloaded_cookbook" unless @downloaded_cookbook
+
+  # TODO: timh, 2010-5-26: Cookbook really should have a "get me a file by its
+  # path" method.
+  if path =~ /^([^\/]+)\/(.+)$/
+    segment, path_in_segment = $1, $2
+  else
+    segment = :root_files
+    path_in_segment = path
+  end
+
+  raise "no such file #{path}" unless @downloaded_cookbook.manifest[segment]
+  found_manifest_record = @downloaded_cookbook.manifest[segment].find {|manifest_record| manifest_record[:path] == path}
+  raise "no such file #{path}" unless found_manifest_record
+
+  begin
+    cookbook_name = @downloaded_cookbook.name
+    cookbook_version = @downloaded_cookbook.version
+
+    checksum = found_manifest_record[:checksum]
+
+    self.api_response = nil
+    self.inflated_response = nil
+    self.exception = nil
+
+    url = found_manifest_record[:url]
+    downloaded_cookbook_file = rest.get_rest(url, true)
+    @downloaded_cookbook_file_contents = IO.read(downloaded_cookbook_file.path)
+  rescue
+    self.exception = $!
+  end
+end
+
+Then /^the downloaded cookbook file contents should match the pattern '(.+)'$/ do |pattern|
+  raise "no @downloaded_cookbook_file_contents" unless @downloaded_cookbook_file_contents
+
+  @downloaded_cookbook_file_contents.should =~ /#{pattern}/
+end
+
+Then /^the dependencies in its metadata should be an empty hash$/ do
+  inflated_response.metadata.dependencies.should == {}
+end
+
+Then /^the metadata should include a dependency on '(.+)'$/ do |key|
+  inflated_response.metadata.dependencies.should have_key(key)
+end
+
+RSpec::Matchers.define :have_been_deleted do
+  match do |file_name|
+    ! File.exist?(file_name)
+  end
+  failure_message_for_should do |file_name|
+    "Expected file #{file_name} to have been deleted but it was not"
+  end
+  failure_message_for_should_not do |player|
+    "Expected file #{file_name} to not have been deleted but it was (i.e., it should exist)"
+  end
+  description do
+    "The file should have been deleted"
+  end
+end
+
+Then /^the cookbook's files should have been deleted$/ do
+  #pp @last_uploaded_cookbook
+  @last_uploaded_cookbook.checksums.keys.each do |file_checksum|
+    file_location_in_checksum_repo = File.join(datadir, 'repo', 'checksums', file_checksum[0...2], file_checksum)
+    #pp :expected_cksum_path => {file_checksum => file_location_in_checksum_repo}
+    file_location_in_checksum_repo.should have_been_deleted
+  end
+end
+
+RSpec::Matchers.define :have_checksum_document do |checksum|
+  match do |checksum_list|
+    checksum_list.include?(checksum)
+  end
+  failure_message_for_should do |checksum_list|
+    "Expected checksum document #{checksum} to exist in couchdb but it is not in the list of existing checksums:\n#{checksum_list.sort.join("\n")}\n"
+  end
+  failure_message_for_should_not do |checksum_list|
+    "Expected checksum document #{checksum} not to exist in couchdb but it is in the list of existing checksums:\n#{checksum_list.sort.join("\n")}\n"
+  end
+  description do
+    "The checksum should exist"
+  end
+end
+
+Then /^the cookbook's checksums should be removed from couchdb$/ do
+  #pp @last_uploaded_cookbook
+  all_checksum_docs = couchdb_rest_client.get_rest('/_design/checksums/_view/all')["rows"]
+  checksums_in_couchdb = all_checksum_docs.map {|c| c["key"]}
+  #pp :checksums_in_couchdb => checksums_in_couchdb
+  @last_uploaded_cookbook.checksums.keys.each do |checksum|
+    checksums_in_couchdb.should_not have_checksum_document(checksum)
+  end
+end
+
+Given "I upload multiple versions of the 'version_test' cookbook" do
+  When "I fully upload a sandboxed cookbook force-named 'version_test' versioned '0.1.0' with 'version_test_0.1.0'"
+  When "I fully upload a sandboxed cookbook force-named 'version_test' versioned '0.1.1' with 'version_test_0.1.1'"
+  When "I fully upload a sandboxed cookbook force-named 'version_test' versioned '0.2.0' with 'version_test_0.2.0'"
+end
+
+Given "I upload multiple versions of the 'version_test' cookbook that do not lexically sort correctly" do
+  When "I fully upload a sandboxed cookbook force-named 'version_test' versioned '0.9.0' with 'version_test_0.9.0'"
+  When "I fully upload a sandboxed cookbook force-named 'version_test' versioned '0.10.0' with 'version_test_0.10.0'"
+  When "I fully upload a sandboxed cookbook force-named 'version_test' versioned '0.9.7' with 'version_test_0.9.7'"
+end
+
+Given "I upload the set of 'dep_test_*' cookbooks" do
+  %w{a b c}.each do |letter|
+    %w{1 2 3}.each do |number|
+      When "I fully upload a sandboxed cookbook force-named 'dep_test_#{letter}' versioned '#{number}.0.0' with 'dep_test_#{letter}_#{number}.0.0'"
+    end
+  end
+end
+
+Then /^cookbook '(.+)' should have version '(.+)'$/ do |cookbook, version|
+  Then "the inflated responses key '#{cookbook}' should exist"
+  Then "the inflated responses key 'dep_test_a' should match '\"version\":\"#{version}\"' as json"
+end