chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/unit/cookbook/syntax_check_spec.rb

@@ -16,175 +16,139 @@
 # 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)}
-
-    @syntax_check = Chef::Cookbook::SyntaxCheck.new(@cookbook_path)
+    basenames = %w{ helpers_via_partial_test.erb
+                    helper_test.erb
+                    openldap_stuff.conf.erb
+                    openldap_variable_stuff.conf.erb
+                    test.erb
+                    some_windows_line_endings.erb
+                    all_windows_line_endings.erb
+                    no_windows_line_endings.erb }
+    @template_files = basenames.map { |f| File.join(cookbook_path, 'templates', 'default', f)}
   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
+
+      describe "and an ignored file has a syntax error" do
+        before do
+          cookbook_path = File.join(CHEF_SPEC_DATA, 'cookbooks', 'ignorken')
+          Chef::Config[:cookbook_path] = File.dirname(cookbook_path)
+          syntax_check.cookbook_path.replace(cookbook_path)
+          @ruby_files = [File.join(cookbook_path, 'recipes/default.rb')]
+        end
+
+        it "shows that ignored ruby files do not require a syntax check" do
+          syntax_check.untested_ruby_files.sort.should == @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
         end
 
       end
@@ -193,18 +157,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,184 @@ 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 == "ignorken"
+        seen[4].should == "java"
+        seen[5].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