microwave 1.0.4 → 11.400.2

data/spec/unit/config_spec.rb

@@ -62,6 +62,58 @@ describe Chef::Config do
     it_behaves_like "server URL"
   end
 
+  describe "when configuring formatters" do
+      # if TTY and not(force-logger)
+      #   formatter = configured formatter or default formatter
+      #   formatter goes to STDOUT/ERR
+      #   if log file is writeable
+      #     log level is configured level or info
+      #     log location is file
+      #   else
+      #     log level is warn
+      #     log location is STDERR
+      #    end
+      # elsif not(TTY) and force formatter
+      #   formatter = configured formatter or default formatter
+      #   if log_location specified
+      #     formatter goes to log_location
+      #   else
+      #     formatter goes to STDOUT/ERR
+      #   end
+      # else
+      #   formatter = "null"
+      #   log_location = configured-value or defualt
+      #   log_level = info or defualt
+      # end
+      #
+    before do
+      @config_class = Class.new(Chef::Config)
+    end
+
+    it "has an empty list of formatters by default" do
+      @config_class.formatters.should == []
+    end
+
+    it "configures a formatter with a short name" do
+      @config_class.add_formatter(:doc)
+      @config_class.formatters.should == [[:doc, nil]]
+    end
+
+    it "configures a formatter with a file output" do
+      @config_class.add_formatter(:doc, "/var/log/formatter.log")
+      @config_class.formatters.should == [[:doc, "/var/log/formatter.log"]]
+    end
+
+  end
+
+  context "when the url is a frozen string" do
+    before do
+      Chef::Config.chef_server_url = " https://junglist.gen.nz".freeze
+    end
+
+    it_behaves_like "server URL"
+  end
+
   describe "class method: manage_secret_key" do
     before do
       Chef::FileCache.stub!(:load).and_return(true)
@@ -129,16 +181,14 @@ describe Chef::Config do
     it "should return given path on non-windows systems" do
       platform_mock :unix do
         path = "/etc/chef/cookbooks"
-        Chef::Config.platform_specific_path(path).should == "#{ENV['MICROWAVE_ROOT']}/etc/chef/cookbooks"
+        Chef::Config.platform_specific_path(path).should == "#{Chef::Config[:alt_root]}/etc/chef/cookbooks"
       end
     end
 
     it "should return a windows path on windows systems" do
       platform_mock :windows do
         path = "/etc/chef/cookbooks"
-        save_microwave_root = ENV['MICROWAVE_ROOT']
-        expected_microwave_root = save_microwave_root.gsub(File::SEPARATOR, (File::ALT_SEPARATOR || '\\'))
-        ENV.stub!(:[]).with('MICROWAVE_ROOT').and_return(save_microwave_root)
+        expected_microwave_root = Chef::Config[:alt_root].gsub(File::SEPARATOR, (File::ALT_SEPARATOR || '\\'))
         ENV.stub!(:[]).with('SYSTEMDRIVE').and_return('C:')
         # match on a regex that looks for the base path with an optional
         # system drive at the beginning (c:)

data/spec/unit/cookbook/chefignore_spec.rb

@@ -23,7 +23,7 @@ describe Chef::Cookbook::Chefignore do
   end
 
   it "loads the globs in the chefignore file" do
-    @chefignore.ignores.should =~ %w[recipes/ignoreme.rb]
+    @chefignore.ignores.should =~ %w[recipes/ignoreme.rb ignored]
   end
 
   it "removes items from an array that match the ignores" do
@@ -32,6 +32,7 @@ describe Chef::Cookbook::Chefignore do
   end
 
   it "determines if a file is ignored" do
+    @chefignore.ignored?('ignored').should be_true
     @chefignore.ignored?('recipes/ignoreme.rb').should be_true
     @chefignore.ignored?('recipes/dontignoreme.rb').should be_false
   end

data/spec/unit/cookbook/syntax_check_spec.rb

@@ -16,175 +16,114 @@
 # limitations under the License.
 #
 
-###################################################
-# OLD:
-###################################################
-# def test_ruby(cookbook_dir)
-#   cache = Chef::ChecksumCache.instance
-#   Dir[File.join(cookbook_dir, '**', '*.rb')].each do |ruby_file|
-#     key = cache.generate_key(ruby_file, "chef-test")
-#     fstat = File.stat(ruby_file)
-#
-#     if cache.lookup_checksum(key, fstat)
-#       Chef::Log.info("No change in checksum of #{ruby_file}")
-#     else
-#       Chef::Log.info("Testing #{ruby_file} for syntax errors...")
-#       Chef::Mixin::Command.run_command(:command => "ruby -c #{ruby_file}", :output_on_failure => true)
-#       cache.generate_checksum(key, ruby_file, fstat)
-#     end
-#   end
-# end
-#
-#def test_templates(cookbook_dir)
-#  cache = Chef::ChecksumCache.instance
-#  Dir[File.join(cookbook_dir, '**', '*.erb')].each do |erb_file|
-#    key = cache.generate_key(erb_file, "chef-test")
-#    fstat = File.stat(erb_file)
-#
-#    if cache.lookup_checksum(key, fstat)
-#      Chef::Log.info("No change in checksum of #{erb_file}")
-#    else
-#      Chef::Log.info("Testing template #{erb_file} for syntax errors...")
-#      Chef::Mixin::Command.run_command(:command => "sh -c 'erubis -x #{erb_file} | ruby -c'", :output_on_failure => true)
-#      cache.generate_checksum(key, erb_file, fstat)
-#    end
-#  end
-#end
-#
-
-###################################################
-# NEW:
-###################################################
-# def test_template_file(cookbook_dir, erb_file)
-#   Chef::Log.debug("Testing template #{erb_file} for syntax errors...")
-#   result = shell_out("sh -c 'erubis -x #{erb_file} | ruby -c'")
-#   result.error!
-# rescue Mixlib::ShellOut::ShellCommandFailed
-#   file_relative_path = erb_file[/^#{Regexp.escape(cookbook_dir+File::Separator)}(.*)/, 1]
-#   Chef::Log.fatal("Erb template #{file_relative_path} has a syntax error:")
-#   result.stderr.each_line { |l| Chef::Log.fatal(l.chomp) }
-#   exit(1)
-# end
-#
-# def test_ruby_file(cookbook_dir, ruby_file)
-#   Chef::Log.debug("Testing #{ruby_file} for syntax errors...")
-#   result = shell_out("ruby -c #{ruby_file}")
-#   result.error!
-# rescue Mixlib::ShellOut::ShellCommandFailed
-#   file_relative_path = ruby_file[/^#{Regexp.escape(cookbook_dir+File::Separator)}(.*)/, 1]
-#   Chef::Log.fatal("Cookbook file #{file_relative_path} has a syntax error:")
-#   result.stderr.each_line { |l| Chef::Log.fatal(l.chomp) }
-#   exit(1)
-# end
-#
-
 require 'spec_helper'
 require "chef/cookbook/syntax_check"
 
 describe Chef::Cookbook::SyntaxCheck do
+
+  let(:cookbook_path) { File.join(CHEF_SPEC_DATA, 'cookbooks', 'openldap') }
+  let(:syntax_check) { Chef::Cookbook::SyntaxCheck.new(cookbook_path) }
+
   before do
     Chef::Log.logger = Logger.new(StringIO.new)
+    Chef::Log.level = :warn # suppress "Syntax OK" messages
 
-    @cookbook_path = File.join(CHEF_SPEC_DATA, 'cookbooks', 'openldap')
 
-    @attr_files = %w{default.rb smokey.rb}.map { |f| File.join(@cookbook_path, 'attributes', f) }
-    @defn_files = %w{client.rb server.rb}.map { |f| File.join(@cookbook_path, 'definitions', f)}
-    @recipes = %w{default.rb gigantor.rb one.rb}.map { |f| File.join(@cookbook_path, 'recipes', f) }
+    @attr_files = %w{default.rb smokey.rb}.map { |f| File.join(cookbook_path, 'attributes', f) }
+    @defn_files = %w{client.rb server.rb}.map { |f| File.join(cookbook_path, 'definitions', f)}
+    @recipes = %w{default.rb gigantor.rb one.rb}.map { |f| File.join(cookbook_path, 'recipes', f) }
     @ruby_files = @attr_files + @defn_files + @recipes
 
-    @template_files = %w{openldap_stuff.conf.erb openldap_variable_stuff.conf.erb test.erb}.map { |f| File.join(@cookbook_path, 'templates', 'default', f)}
+    @template_files = %w{openldap_stuff.conf.erb openldap_variable_stuff.conf.erb test.erb}.map { |f| File.join(cookbook_path, 'templates', 'default', f)}
 
-    @syntax_check = Chef::Cookbook::SyntaxCheck.new(@cookbook_path)
   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)
+    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.cookbook_path.should == cookbook_path
   end
 
   describe "when first created" do
     it "has the path to the cookbook to syntax check" do
-      @syntax_check.cookbook_path.should == @cookbook_path
-    end
-
-    it "has access to the checksum cache" do
-      @syntax_check.cache.should equal(Chef::ChecksumCache.instance)
+      syntax_check.cookbook_path.should == cookbook_path
     end
 
     it "lists the ruby files in the cookbook" do
-      @syntax_check.ruby_files.sort.should == @ruby_files.sort
+      syntax_check.ruby_files.sort.should == @ruby_files.sort
     end
 
     it "lists the erb templates in the cookbook" do
-      @syntax_check.template_files.sort.should == @template_files.sort
+      syntax_check.template_files.sort.should == @template_files.sort
     end
 
   end
 
   describe "when validating cookbooks" do
+    let(:cache_path) { Dir.mktmpdir }
+
     before do
-      Chef::Config[:cache_type] = 'Memory'
-      @checksum_cache_klass = Class.new(Chef::ChecksumCache)
-      @checksum_cache = @checksum_cache_klass.instance
-      @checksum_cache.reset!('Memory')
-      @syntax_check.stub!(:cache).and_return(@checksum_cache)
-      $stdout.stub!(:write)
+      Chef::Config[:syntax_check_cache_path] = cache_path
+    end
+
+    after do
+      FileUtils.rm_rf(cache_path) if File.exist?(cache_path)
+      Chef::Config[:syntax_check_cache_path] = nil
     end
 
     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
+        syntax_check.untested_ruby_files.sort.should == @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
+        syntax_check.untested_template_files.sort.should == @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)
+        recipe = File.join(cookbook_path, 'recipes', 'default.rb')
+        syntax_check.validated(recipe)
+        syntax_check.untested_ruby_files.should_not 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)
+        template = File.join(cookbook_path, 'templates', 'default', 'test.erb')
+        syntax_check.validated(template)
+        syntax_check.untested_template_files.should_not 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
+        syntax_check.validate_ruby_files.should be_true
+        syntax_check.untested_ruby_files.should be_empty
       end
 
       it "validates all templates" do
-        @syntax_check.validate_templates.should be_true
-        @syntax_check.untested_template_files.should be_empty
+        syntax_check.validate_templates.should be_true
+        syntax_check.untested_template_files.should be_empty
       end
 
       describe "and a file has a syntax error" do
         before do
-          @cookbook_path = File.join(CHEF_SPEC_DATA, 'cookbooks', 'borken')
-          @syntax_check.cookbook_path.replace(@cookbook_path)
+          cookbook_path = File.join(CHEF_SPEC_DATA, 'cookbooks', 'borken')
+          syntax_check.cookbook_path.replace(cookbook_path)
         end
 
         it "it indicates that a ruby file has a syntax error" do
-          @syntax_check.validate_ruby_files.should be_false
+          syntax_check.validate_ruby_files.should be_false
         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'))
-          lambda { @syntax_check.validate_ruby_files }.should_not change(@syntax_check, :untested_ruby_files)
+          syntax_check.untested_ruby_files.should include(File.join(cookbook_path, 'recipes', 'default.rb'))
+          lambda { syntax_check.validate_ruby_files }.should_not change(syntax_check, :untested_ruby_files)
         end
 
         it "indicates that a template file has a syntax error" do
-          @syntax_check.validate_templates.should be_false
+          syntax_check.validate_templates.should be_false
         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)
+          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)
         end
 
       end
@@ -193,18 +132,18 @@ describe Chef::Cookbook::SyntaxCheck do
 
     describe "and the files have been syntax checked previously" do
       before do
-        @syntax_check.untested_ruby_files.each { |f| @syntax_check.validated(f) }
-        @syntax_check.untested_template_files.each { |f| @syntax_check.validated(f) }
+        syntax_check.untested_ruby_files.each { |f| syntax_check.validated(f) }
+        syntax_check.untested_template_files.each { |f| syntax_check.validated(f) }
       end
 
       it "does not syntax check ruby files" do
-        @syntax_check.should_not_receive(:shell_out)
-        @syntax_check.validate_ruby_files.should be_true
+        syntax_check.should_not_receive(:shell_out)
+        syntax_check.validate_ruby_files.should be_true
       end
 
       it "does not syntax check templates" do
-        @syntax_check.should_not_receive(:shell_out)
-        @syntax_check.validate_templates.should be_true
+        syntax_check.should_not_receive(:shell_out)
+        syntax_check.validate_templates.should be_true
       end
     end
   end

data/spec/unit/cookbook_loader_spec.rb

@@ -25,121 +25,183 @@ describe Chef::CookbookLoader do
     @cookbook_loader = Chef::CookbookLoader.new(@repo_paths)
   end
 
-  describe "[]" do
-    it "should return cookbook objects with []" do
-      @cookbook_loader[:openldap].should be_a_kind_of(Chef::CookbookVersion)
+  describe "loading all cookbooks" do
+    before(:each) do
+      @cookbook_loader.load_cookbooks
     end
 
+    describe "[]" do
+      it "should return cookbook objects with []" do
+        @cookbook_loader[:openldap].should 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)
-    end
-
-    it "should allow you to look up available cookbooks with [] and a symbol" do
-      @cookbook_loader[:openldap].name.should eql(:openldap)
-    end
+      it "should raise an exception if it cannot find a cookbook with []" do
+        lambda { @cookbook_loader[:monkeypoop] }.should raise_error(Chef::Exceptions::CookbookNotFoundInRepo)
+      end
 
-    it "should allow you to look up available cookbooks with [] and a string" do
-      @cookbook_loader["openldap"].name.should eql(:openldap)
-    end
-  end
+      it "should allow you to look up available cookbooks with [] and a symbol" do
+        @cookbook_loader[:openldap].name.should eql(:openldap)
+      end
 
-  describe "each" do
-    it "should allow you to iterate over cookbooks with each" do
-      seen = Hash.new
-      @cookbook_loader.each do |cookbook_name, cookbook|
-        seen[cookbook_name] = true
+      it "should allow you to look up available cookbooks with [] and a string" do
+        @cookbook_loader["openldap"].name.should eql(:openldap)
       end
-      seen.should have_key("openldap")
-      seen.should have_key("apache2")
     end
 
-    it "should iterate in alphabetical order" do
-      seen = Array.new
-      @cookbook_loader.each do |cookbook_name, cookbook|
-        seen << cookbook_name
+    describe "each" do
+      it "should allow you to iterate over cookbooks with each" do
+        seen = Hash.new
+        @cookbook_loader.each do |cookbook_name, cookbook|
+          seen[cookbook_name] = true
+        end
+        seen.should have_key("openldap")
+        seen.should have_key("apache2")
       end
-      seen[0].should == "angrybash"
-      seen[1].should == "apache2"
-      seen[2].should == "borken"
-      seen[3].should == "java"
-      seen[4].should == "openldap"
-    end
-  end
 
-  describe "load_cookbooks" do
-    it "should find all the cookbooks in the cookbook path" do
-      Chef::Config.cookbook_path << File.expand_path(File.join(CHEF_SPEC_DATA, "hidden-cookbooks"))
-      @cookbook_loader.load_cookbooks
-      @cookbook_loader.should have_key(:openldap)
-      @cookbook_loader.should have_key(:apache2)
+      it "should iterate in alphabetical order" do
+        seen = Array.new
+        @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 == "java"
+        seen[4].should == "openldap"
+      end
     end
+  
+    describe "load_cookbooks" do
+      it "should find all the cookbooks in the cookbook path" do
+        Chef::Config.cookbook_path << File.expand_path(File.join(CHEF_SPEC_DATA, "hidden-cookbooks"))
+        @cookbook_loader.load_cookbooks
+        @cookbook_loader.should have_key(:openldap)
+        @cookbook_loader.should have_key(:apache2)
+      end
+  
+      it "should allow you to override an attribute file via cookbook_path" do
+        @cookbook_loader[:openldap].attribute_filenames.detect { |f|
+          f =~ /cookbooks\/openldap\/attributes\/default.rb/
+        }.should_not eql(nil)
+        @cookbook_loader[:openldap].attribute_filenames.detect { |f|
+          f =~ /kitchen\/openldap\/attributes\/default.rb/
+        }.should eql(nil)
+      end
+  
+      it "should load different attribute files from deeper paths" do
+        @cookbook_loader[:openldap].attribute_filenames.detect { |f|
+          f =~ /kitchen\/openldap\/attributes\/robinson.rb/
+        }.should_not eql(nil)
+      end
+  
+      it "should allow you to override a definition file via cookbook_path" do
+        @cookbook_loader[:openldap].definition_filenames.detect { |f|
+          f =~ /cookbooks\/openldap\/definitions\/client.rb/
+        }.should_not eql(nil)
+        @cookbook_loader[:openldap].definition_filenames.detect { |f|
+          f =~ /kitchen\/openldap\/definitions\/client.rb/
+        }.should eql(nil)
+      end
+  
+      it "should load definition files from deeper paths" do
+        @cookbook_loader[:openldap].definition_filenames.detect { |f|
+          f =~ /kitchen\/openldap\/definitions\/drewbarrymore.rb/
+        }.should_not eql(nil)
+      end
+  
+      it "should allow you to override a recipe file via cookbook_path" do
+        @cookbook_loader[:openldap].recipe_filenames.detect { |f|
+          f =~ /cookbooks\/openldap\/recipes\/gigantor.rb/
+        }.should_not eql(nil)
+        @cookbook_loader[:openldap].recipe_filenames.detect { |f|
+          f =~ /kitchen\/openldap\/recipes\/gigantor.rb/
+        }.should eql(nil)
+      end
+  
+      it "should load recipe files from deeper paths" do
+        @cookbook_loader[:openldap].recipe_filenames.detect { |f|
+          f =~ /kitchen\/openldap\/recipes\/woot.rb/
+        }.should_not 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|
+          f =~ /kitchen\/openldap\/recipes\/ignoreme.rb/
+        }.should eql(nil)
+      end
+  
+      it "should find files that start with a ." do
+        @cookbook_loader[:openldap].file_filenames.detect { |f|
+          f =~ /\.dotfile$/
+        }.should =~ /\.dotfile$/
+        @cookbook_loader[:openldap].file_filenames.detect { |f|
+          f =~ /\.ssh\/id_rsa$/
+        }.should =~ /\.ssh\/id_rsa$/
+      end
+  
+      it "should load the metadata for the cookbook" do
+        @cookbook_loader.metadata[:openldap].name.should == :openldap
+        @cookbook_loader.metadata[:openldap].should be_a_kind_of(Chef::Cookbook::Metadata)
+      end
 
-    it "should allow you to override an attribute file via cookbook_path" do
-      @cookbook_loader[:openldap].attribute_filenames.detect { |f|
-        f =~ /cookbooks\/openldap\/attributes\/default.rb/
-      }.should_not eql(nil)
-      @cookbook_loader[:openldap].attribute_filenames.detect { |f|
-        f =~ /kitchen\/openldap\/attributes\/default.rb/
-      }.should eql(nil)
-    end
+      it "should check each cookbook directory only once (CHEF-3487)" do
+        cookbooks = []
+        @repo_paths.each do |repo_path|
+          cookbooks |= Dir[File.join(repo_path, "*")]
+        end
+        cookbooks.each do |cookbook|
+            File.should_receive(:directory?).with(cookbook).once;
+        end
+        @cookbook_loader.load_cookbooks
+      end
+    end # load_cookbooks
 
-    it "should load different attribute files from deeper paths" do
-      @cookbook_loader[:openldap].attribute_filenames.detect { |f|
-        f =~ /kitchen\/openldap\/attributes\/robinson.rb/
-      }.should_not eql(nil)
-    end
+  end # loading all cookbooks
 
-    it "should allow you to override a definition file via cookbook_path" do
-      @cookbook_loader[:openldap].definition_filenames.detect { |f|
-        f =~ /cookbooks\/openldap\/definitions\/client.rb/
-      }.should_not eql(nil)
-      @cookbook_loader[:openldap].definition_filenames.detect { |f|
-        f =~ /kitchen\/openldap\/definitions\/client.rb/
-      }.should eql(nil)
+  describe "loading only one cookbook" do
+    before(:each) do
+      @cookbook_loader = Chef::CookbookLoader.new(@repo_paths)
+      @cookbook_loader.load_cookbook("openldap")
     end
 
-    it "should load definition files from deeper paths" do
-      @cookbook_loader[:openldap].definition_filenames.detect { |f|
-        f =~ /kitchen\/openldap\/definitions\/drewbarrymore.rb/
-      }.should_not eql(nil)
+    it "should have loaded the correct cookbook" do
+      seen = Hash.new
+      @cookbook_loader.each do |cookbook_name, cookbook|
+        seen[cookbook_name] = true
+      end
+      seen.should have_key("openldap")
     end
 
-    it "should allow you to override a recipe file via cookbook_path" do
-      @cookbook_loader[:openldap].recipe_filenames.detect { |f|
-        f =~ /cookbooks\/openldap\/recipes\/gigantor.rb/
-      }.should_not eql(nil)
-      @cookbook_loader[:openldap].recipe_filenames.detect { |f|
-        f =~ /kitchen\/openldap\/recipes\/gigantor.rb/
-      }.should eql(nil)
+    it "should not load the cookbook again when accessed" do
+      @cookbook_loader.should_not_receive('load_cookbook')
+      @cookbook_loader["openldap"]
     end
 
-    it "should load recipe files from deeper paths" do
-      @cookbook_loader[:openldap].recipe_filenames.detect { |f|
-        f =~ /kitchen\/openldap\/recipes\/woot.rb/
-      }.should_not eql(nil)
+    it "should not load the other cookbooks" do
+      seen = Hash.new
+      @cookbook_loader.each do |cookbook_name, cookbook|
+        seen[cookbook_name] = true
+      end
+      seen.should_not have_key("apache2")
     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|
-        f =~ /kitchen\/openldap\/recipes\/ignoreme.rb/
-      }.should eql(nil)
+    it "should load another cookbook lazily with []" do
+      @cookbook_loader["apache2"].should be_a_kind_of(Chef::CookbookVersion)
     end
 
-    it "should find files that start with a ." do
-      @cookbook_loader[:openldap].file_filenames.detect { |f|
-        f =~ /\.dotfile$/
-      }.should =~ /\.dotfile$/
-      @cookbook_loader[:openldap].file_filenames.detect { |f|
-        f =~ /\.ssh\/id_rsa$/
-      }.should =~ /\.ssh\/id_rsa$/
-    end
+    describe "loading all cookbooks after loading only one cookbook" do
+      before(:each) do
+        @cookbook_loader.load_cookbooks
+      end
 
-    it "should load the metadata for the cookbook" do
-      @cookbook_loader.metadata[:openldap].name.should == :openldap
-      @cookbook_loader.metadata[:openldap].should be_a_kind_of(Chef::Cookbook::Metadata)
+      it "should load all cookbooks" do
+        seen = Hash.new
+        @cookbook_loader.each do |cookbook_name, cookbook|
+          seen[cookbook_name] = true
+        end
+        seen.should have_key("openldap")
+        seen.should have_key("apache2")
+      end   
     end
-
-  end
-
+  end # loading only one cookbook
 end