chef 11.6.2-x86-mingw32 → 11.8.0.rc.1-x86-mingw32

data/spec/unit/role_spec.rb

@@ -244,6 +244,11 @@ describe Chef::Role do
     end
   end
 
+  ROLE_DSL=<<-EOR
+name "ceiling_cat"
+description "like Aliens, but furry"
+EOR
+
   describe "when loading from disk" do
     it "should return a Chef::Role object from JSON" do
       File.should_receive(:exists?).with(File.join(Chef::Config[:role_path], 'lolcat.json')).exactly(1).times.and_return(true)
@@ -256,10 +261,6 @@ describe Chef::Role do
       File.should_receive(:exists?).with(File.join(Chef::Config[:role_path], 'lolcat.json')).exactly(1).times.and_return(false)
       File.should_receive(:exists?).with(File.join(Chef::Config[:role_path], 'lolcat.rb')).exactly(2).times.and_return(true)
       File.should_receive(:readable?).with(File.join(Chef::Config[:role_path], 'lolcat.rb')).exactly(1).times.and_return(true)
-      ROLE_DSL=<<-EOR
-name "ceiling_cat"
-description "like Aliens, but furry"
-EOR
       IO.should_receive(:read).with(File.join(Chef::Config[:role_path], 'lolcat.rb')).and_return(ROLE_DSL)
       @role.should be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
@@ -271,5 +272,57 @@ EOR
       lambda {@role.class.from_disk("lolcat")}.should raise_error(Chef::Exceptions::RoleNotFound)
     end
   end
+
+  describe "when loading from disk and role_path is an array" do
+
+    before(:each) do
+      Chef::Config[:role_path] = ['/path1', '/path/path2']
+    end
+
+    it "should return a Chef::Role object from JSON" do
+      File.should_receive(:exists?).with(File.join('/path1', 'lolcat.json')).exactly(1).times.and_return(true)
+      IO.should_receive(:read).with(File.join('/path1', 'lolcat.json')).and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
+      @role.should be_a_kind_of(Chef::Role)
+      @role.class.from_disk("lolcat")
+    end
+
+    it "should return a Chef::Role object from JSON when role is in the second path" do
+      File.should_receive(:exists?).with(File.join('/path1', 'lolcat.json')).exactly(1).times.and_return(false)
+      File.should_receive(:exists?).with(File.join('/path1', 'lolcat.rb')).exactly(1).times.and_return(false)
+      File.should_receive(:exists?).with(File.join('/path/path2', 'lolcat.json')).exactly(1).times.and_return(true)
+      IO.should_receive(:read).with(File.join('/path/path2', 'lolcat.json')).and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
+      @role.should be_a_kind_of(Chef::Role)
+      @role.class.from_disk("lolcat")
+    end
+
+    it "should return a Chef::Role object from a Ruby DSL" do
+      File.should_receive(:exists?).with(File.join('/path1', 'lolcat.json')).exactly(1).times.and_return(false)
+      File.should_receive(:exists?).with(File.join('/path1', 'lolcat.rb')).exactly(2).times.and_return(true)
+      File.should_receive(:readable?).with(File.join('/path1', 'lolcat.rb')).exactly(1).times.and_return(true)
+      IO.should_receive(:read).with(File.join('/path1', 'lolcat.rb')).and_return(ROLE_DSL)
+      @role.should be_a_kind_of(Chef::Role)
+      @role.class.from_disk("lolcat")
+    end
+
+    it "should return a Chef::Role object from a Ruby DSL when role is in the second path" do
+      File.should_receive(:exists?).with(File.join('/path1', 'lolcat.json')).exactly(1).times.and_return(false)
+      File.should_receive(:exists?).with(File.join('/path1', 'lolcat.rb')).exactly(1).times.and_return(false)
+      File.should_receive(:exists?).with(File.join('/path/path2', 'lolcat.json')).exactly(1).times.and_return(false)
+      File.should_receive(:exists?).with(File.join('/path/path2', 'lolcat.rb')).exactly(2).times.and_return(true)
+      File.should_receive(:readable?).with(File.join('/path/path2', 'lolcat.rb')).exactly(1).times.and_return(true)
+      IO.should_receive(:read).with(File.join('/path/path2', 'lolcat.rb')).and_return(ROLE_DSL)
+      @role.should be_a_kind_of(Chef::Role)
+      @role.class.from_disk("lolcat")
+    end
+
+    it "should raise an exception if the file does not exist" do
+      File.should_receive(:exists?).with(File.join('/path1', 'lolcat.json')).exactly(1).times.and_return(false)
+      File.should_receive(:exists?).with(File.join('/path1', 'lolcat.rb')).exactly(1).times.and_return(false)
+      File.should_receive(:exists?).with(File.join('/path/path2', 'lolcat.json')).exactly(1).times.and_return(false)
+      File.should_receive(:exists?).with(File.join('/path/path2', 'lolcat.rb')).exactly(1).times.and_return(false)
+      lambda {@role.class.from_disk("lolcat")}.should raise_error(Chef::Exceptions::RoleNotFound)
+    end
+
+  end
 end
 

data/spec/unit/run_context/cookbook_compiler_spec.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -17,23 +17,7 @@
 #
 
 require 'spec_helper'
-
-# Keeps track of what file got loaded in what order.
-module LibraryLoadOrder
-  extend self
-
-  def load_order
-    @load_order ||= []
-  end
-
-  def reset!
-    @load_order = nil
-  end
-
-  def record(file)
-    load_order << file
-  end
-end
+require 'support/lib/library_load_order'
 
 # These tests rely on fixture data in spec/data/run_context/cookbooks.
 #
@@ -178,7 +162,7 @@ describe Chef::RunContext::CookbookCompiler do
     # Tests for this behavior are in RunContext's tests
   end
 
-  describe "listing cookbook order" do 
+  describe "listing cookbook order" do
     it "should return an array of cookbook names as symbols without duplicates" do
       node.run_list("test-with-circular-deps::default", "circular-dep1::default", "circular-dep2::default")
 

data/spec/unit/run_context_spec.rb

@@ -8,9 +8,9 @@
 # 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.
@@ -19,6 +19,7 @@
 #
 
 require 'spec_helper'
+require 'support/lib/library_load_order'
 
 Chef::Log.level = :debug
 
@@ -42,7 +43,7 @@ describe Chef::RunContext do
     @run_context.node.should == @node
   end
 
-  describe "after loading the cookbooks" do
+  describe "loading cookbooks for a run list" do
     before do
       @run_context.load(@node.run_list.expand('_default'))
     end
@@ -73,6 +74,46 @@ describe Chef::RunContext do
       @node.should_not_receive(:from_file)
       @node.include_attribute("test::george")
     end
+
+
+  end
+
+  describe "querying the contents of cookbooks" do
+    before do
+      @chef_repo_path = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
+      cl = Chef::CookbookLoader.new(@chef_repo_path)
+      cl.load_cookbooks
+      @cookbook_collection = Chef::CookbookCollection.new(cl)
+      @node = Chef::Node.new
+      @node.set[:platform] = "ubuntu"
+      @node.set[:platform_version] = "13.04"
+      @node.name("testing")
+      @events = Chef::EventDispatch::Dispatcher.new
+      @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+    end
+
+
+    it "queries whether a given cookbook has a specific template" do
+      @run_context.should have_template_in_cookbook("openldap", "test.erb")
+      @run_context.should_not have_template_in_cookbook("openldap", "missing.erb")
+    end
+
+    it "errors when querying for a template in a not-available cookbook" do
+      expect do
+        @run_context.has_template_in_cookbook?("no-such-cookbook", "foo.erb")
+      end.to raise_error(Chef::Exceptions::CookbookNotFound)
+    end
+
+    it "queries whether a given cookbook has a specific cookbook_file" do
+      @run_context.should have_cookbook_file_in_cookbook("java", "java.response")
+      @run_context.should_not have_cookbook_file_in_cookbook("java", "missing.txt")
+    end
+
+    it "errors when querying for a cookbook_file in a not-available cookbook" do
+      expect do
+        @run_context.has_cookbook_file_in_cookbook?("no-such-cookbook", "foo.txt")
+      end.to raise_error(Chef::Exceptions::CookbookNotFound)
+    end
   end
 
 end

data/spec/unit/run_list/run_list_item_spec.rb

@@ -101,7 +101,7 @@ describe Chef::RunList::RunListItem do
       item2 = Chef::RunList::RunListItem.new('recipe[lobsterragefist]')
       item1.should_not == item2
     end
-    
+
     it "is not equal to another run list item with the same name and type but different version" do
       item1 = Chef::RunList::RunListItem.new('recipe[lrf,0.1.0]')
       item2 = Chef::RunList::RunListItem.new('recipe[lrf,0.2.0]')

data/spec/unit/run_lock_spec.rb

@@ -20,14 +20,17 @@ require 'chef/client'
 
 describe Chef::RunLock do
 
+  default_pid_location = windows? ? 'C:\chef\cache\chef-client-running.pid' : '/var/chef/cache/chef-client-running.pid'
+
   describe "when first created" do
     it "locates the lockfile in the file cache path by default" do
-      run_lock = Chef::RunLock.new(:file_cache_path => "/var/chef/cache", :lockfile => nil)
-      run_lock.runlock_file.should == "/var/chef/cache/chef-client-running.pid"
+      run_lock = Chef::RunLock.new(Chef::Config.lockfile)
+      run_lock.runlock_file.should == default_pid_location
     end
 
     it "locates the lockfile in the user-configured path when set" do
-      run_lock = Chef::RunLock.new(:file_cache_path => "/var/chef/cache", :lockfile => "/tmp/chef-client-running.pid")
+      Chef::Config.lockfile = "/tmp/chef-client-running.pid"
+      run_lock = Chef::RunLock.new(Chef::Config.lockfile)
       run_lock.runlock_file.should == "/tmp/chef-client-running.pid"
     end
   end

data/spec/unit/scan_access_control_spec.rb

@@ -69,7 +69,7 @@ describe Chef::ScanAccessControl do
         it "sets the group of the current resource to the current group as a String" do
           @current_resource.group.should == Etc.getgrgid(0).name
         end
-  
+
         it "sets the owner of the current resource to the current owner as a String" do
           @current_resource.user.should == "root"
         end
@@ -79,7 +79,7 @@ describe Chef::ScanAccessControl do
         it "sets the group of the current resource to the current group as a String" do
           @current_resource.group.should == 0
         end
-  
+
         it "sets the owner of the current resource to the current owner as a String" do
           @current_resource.user.should == 0
         end

data/spec/unit/search/query_spec.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -19,7 +19,7 @@
 require 'spec_helper'
 require 'chef/search/query'
 
-describe Chef::Search::Query do 
+describe Chef::Search::Query do
   before(:each) do
     @rest = mock("Chef::REST")
     Chef::REST.stub!(:new).and_return(@rest)

data/spec/unit/util/backup_spec.rb

@@ -21,13 +21,6 @@ require 'spec_helper'
 require 'tmpdir'
 
 describe Chef::Util::Backup do
-  before(:all) do
-    @original_config = Chef::Config.configuration
-  end
-
-  after(:all) do
-    Chef::Config.configuration.replace(@original_config)
-  end
 
   let (:tempfile) do
     Tempfile.new("chef-util-backup-spec-test")
@@ -114,15 +107,15 @@ describe Chef::Util::Backup do
   describe "backup_filename" do
     it "should return a timestamped path" do
       @backup.should_receive(:path).and_return('/a/b/c.txt')
-      @backup.send(:backup_filename).should =~ %r|^/a/b/c.txt.chef-\d{14}$|
+      @backup.send(:backup_filename).should =~ %r|^/a/b/c.txt.chef-\d{14}.\d{6}$|
     end
     it "should strip the drive letter off for windows" do
       @backup.should_receive(:path).and_return('c:\a\b\c.txt')
-      @backup.send(:backup_filename).should =~ %r|^\\a\\b\\c.txt.chef-\d{14}$|
+      @backup.send(:backup_filename).should =~ %r|^\\a\\b\\c.txt.chef-\d{14}.\d{6}$|
     end
     it "should strip the drive letter off for windows (with forwardslashes)" do
       @backup.should_receive(:path).and_return('c:/a/b/c.txt')
-      @backup.send(:backup_filename).should =~ %r|^/a/b/c.txt.chef-\d{14}$|
+      @backup.send(:backup_filename).should =~ %r|^/a/b/c.txt.chef-\d{14}.\d{6}$|
     end
   end
 
@@ -130,19 +123,19 @@ describe Chef::Util::Backup do
     it "uses the file's directory when Chef::Config[:file_backup_path] is nil" do
       @backup.should_receive(:path).and_return('/a/b/c.txt')
       Chef::Config[:file_backup_path] = nil
-      @backup.send(:backup_path).should =~ %r|^/a/b/c.txt.chef-\d{14}$|
+      @backup.send(:backup_path).should =~ %r|^/a/b/c.txt.chef-\d{14}.\d{6}$|
     end
 
     it "uses the configured Chef::Config[:file_backup_path]" do
       @backup.should_receive(:path).and_return('/a/b/c.txt')
       Chef::Config[:file_backup_path] = '/backupdir'
-      @backup.send(:backup_path).should =~ %r|^/backupdir[\\/]+a/b/c.txt.chef-\d{14}$|
+      @backup.send(:backup_path).should =~ %r|^/backupdir[\\/]+a/b/c.txt.chef-\d{14}.\d{6}$|
     end
 
     it "uses the configured Chef::Config[:file_backup_path] and strips the drive on windows" do
       @backup.should_receive(:path).and_return('c:\\a\\b\\c.txt')
       Chef::Config[:file_backup_path] = 'c:\backupdir'
-      @backup.send(:backup_path).should =~ %r|^c:\\backupdir[\\/]+a\\b\\c.txt.chef-\d{14}$|
+      @backup.send(:backup_path).should =~ %r|^c:\\backupdir[\\/]+a\\b\\c.txt.chef-\d{14}.\d{6}$|
     end
   end
 

data/spec/unit/util/diff_spec.rb

@@ -20,32 +20,17 @@
 require 'spec_helper'
 require 'tmpdir'
 
-describe Chef::Util::Diff, :uses_diff => true do
-  before(:all) do
-    @original_config = Chef::Config.hash_dup
-  end
-
-  after(:all) do
-    Chef::Config.configuration = @original_config if @original_config
-  end
+shared_context "using file paths with spaces" do
+  let!(:old_tempfile) { Tempfile.new("chef-util diff-spec") }
+  let!(:new_tempfile) { Tempfile.new("chef-util diff-spec") }
+end
 
+shared_context "using file paths without spaces" do
   let!(:old_tempfile) { Tempfile.new("chef-util-diff-spec") }
   let!(:new_tempfile) { Tempfile.new("chef-util-diff-spec") }
-  let!(:old_file) { old_tempfile.path }
-  let!(:new_file) { new_tempfile.path }
-
-  let(:plain_ascii) { "This is a text file.\nWith more than one line.\nAnd a \tTab.\nAnd lets make sure that other printable chars work too: ~!@\#$%^&*()`:\"<>?{}|_+,./;'[]\\-=\n" }
-  # these are all byte sequences that are illegal in the other encodings... (but they may legally transcode)
-  let(:utf_8) { "testing utf-8 unicode...\n\n\non a new line: \xE2\x80\x93\n" }  # unicode em-dash
-  let(:latin_1) { "It is more metal.\nif you have an \xFDmlaut.\n" } # NB: changed to y-with-diaresis, but i'm American so I don't know the difference
-  let(:shift_jis) { "I have no idea what this character is:\n \x83\x80.\n" } # seriously, no clue, but \x80 is nice and illegal in other encodings
-
-  let(:differ) do  # subject
-    differ = Chef::Util::Diff.new
-    differ.diff(old_file, new_file)
-    differ
-  end
+end
 
+shared_examples_for "a diff util" do
   it "should return a Chef::Util::Diff" do
     expect(differ).to be_a_kind_of(Chef::Util::Diff)
   end
@@ -393,37 +378,6 @@ describe Chef::Util::Diff, :uses_diff => true do
     end
   end
 
-  describe "when errors are thrown from shell_out" do
-    before do
-      differ.stub!(:shell_out).and_raise('boom')
-      differ.diff(old_file, new_file)
-    end
-
-    it "calling for_output should return the error message" do
-      expect(differ.for_output).to eql(["Could not determine diff. Error: boom"])
-    end
-
-    it "calling for_reporting should be nil" do
-      expect(differ.for_reporting).to be_nil
-    end
-  end
-
-  describe "when shell_out returns stderr output" do
-    before do
-      @result = mock('result', :stdout => "", :stderr => "boom")
-      differ.stub!(:shell_out).and_return(@result)
-      differ.diff(old_file, new_file)
-    end
-
-    it "calling for_output should return the error message" do
-      expect(differ.for_output).to eql(["Could not determine diff. Error: boom"])
-    end
-
-    it "calling for_reporting should be nil" do
-      expect(differ.for_reporting).to be_nil
-    end
-  end
-
   describe "when checking if files are binary or text" do
 
     it "should identify zero-length files as text" do
@@ -593,4 +547,33 @@ describe Chef::Util::Diff, :uses_diff => true do
 
 end
 
+describe Chef::Util::Diff, :uses_diff => true do
+  let!(:old_file) { old_tempfile.path }
+  let!(:new_file) { new_tempfile.path }
+
+  let(:plain_ascii) { "This is a text file.\nWith more than one line.\nAnd a \tTab.\nAnd lets make sure that other printable chars work too: ~!@\#$%^&*()`:\"<>?{}|_+,./;'[]\\-=\n" }
+  # these are all byte sequences that are illegal in the other encodings... (but they may legally transcode)
+  let(:utf_8) { "testing utf-8 unicode...\n\n\non a new line: \xE2\x80\x93\n" }  # unicode em-dash
+  let(:latin_1) { "It is more metal.\nif you have an \xFDmlaut.\n" } # NB: changed to y-with-diaresis, but i'm American so I don't know the difference
+  let(:shift_jis) { "I have no idea what this character is:\n \x83\x80.\n" } # seriously, no clue, but \x80 is nice and illegal in other encodings
+
+  let(:differ) do  # subject
+    differ = Chef::Util::Diff.new
+    differ.diff(old_file, new_file)
+    differ
+  end
+
+  describe "when file path has spaces" do
+    include_context "using file paths with spaces"
+
+    it_behaves_like "a diff util"
+  end
+
+
+  describe "when file path doesn't have spaces" do
+    include_context "using file paths without spaces"
+
+    it_behaves_like "a diff util"
+  end
+end
 

data/spec/unit/version/platform_spec.rb

@@ -5,9 +5,9 @@
 # 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.
@@ -28,7 +28,7 @@ describe Chef::Version::Platform do
   it "should transform 1 to 1.0.0" do
     Chef::Version::Platform.new("1").to_s.should == "1.0.0"
   end
-  
+
   describe "when creating valid Versions" do
     good_versions = %w(1 1.2 1.2.3 1000.80.50000 0.300.25 001.02.00003)
     good_versions.each do |v|