chef 11.4.4 → 11.6.0.hotfix.1

data/spec/unit/knife_spec.rb

@@ -99,6 +99,9 @@ describe Chef::Knife do
       Chef::Knife.subcommands_by_category['cookbook site'].should include('test_explicit_category')
     end
 
+    it "has empty dependency_loader list by default" do
+      KnifeSpecs::TestNameMapping.dependency_loaders.should be_empty
+    end
   end
 
   describe "after loading all subcommands" do
@@ -180,6 +183,21 @@ describe Chef::Knife do
       lambda {Chef::Knife.run(%w{fuuu uuuu fuuuu})}.should raise_error(SystemExit) { |e| e.status.should_not == 0 }
     end
 
+    it "loads lazy dependencies" do
+      command = Chef::Knife.run(%w{test yourself})
+      KnifeSpecs::TestYourself.test_deps_loaded.should be_true
+    end
+
+    it "loads lazy dependencies from multiple deps calls" do
+      other_deps_loaded = false
+      KnifeSpecs::TestYourself.class_eval do
+        deps { other_deps_loaded = true }
+      end
+      command = Chef::Knife.run(%w{test yourself})
+      KnifeSpecs::TestYourself.test_deps_loaded.should be_true
+      other_deps_loaded.should be_true
+    end
+
     describe "merging configuration options" do
       before do
         KnifeSpecs::TestYourself.option(:opt_with_default,
@@ -228,6 +246,9 @@ describe Chef::Knife do
       @knife.name_args.should == %w{with some args}
     end
 
+    it "does not have lazy dependencies loaded" do
+      @knife.class.test_deps_loaded.should_not be_true
+    end
   end
 
   describe "when formatting exceptions" do

data/spec/unit/mixin/enforce_ownership_and_permissions_spec.rb

@@ -48,6 +48,7 @@ describe Chef::Mixin::EnforceOwnershipAndPermissions do
     before do
       Chef::FileAccessControl.any_instance.stub(:uid_from_resource).and_return(0)
       Chef::FileAccessControl.any_instance.stub(:requires_changes?).and_return(false)
+      Chef::FileAccessControl.any_instance.stub(:define_resource_requirements)
 
       passwd_struct = if windows?
                         Struct::Passwd.new("root", "x", 0, 0, "/root", "/bin/bash")

data/spec/unit/mixin/params_validate_spec.rb

@@ -368,5 +368,40 @@ describe Chef::Mixin::ParamsValidate do
     @vo.set_or_return(:name, value, { }).object_id.should == value.object_id
     @vo.set_or_return(:foo, nil, { :name_attribute => true }).object_id.should == value.object_id
   end
+
+  it "should allow DelayedEvaluator instance to be set for value regardless of restriction" do
+    value = Chef::DelayedEvaluator.new{ 'test' }
+    @vo.set_or_return(:test, value, {:kind_of => Numeric})
+  end
+
+  it "should raise an error when delayed evaluated attribute is not valid" do
+    value = Chef::DelayedEvaluator.new{ 'test' }
+    @vo.set_or_return(:test, value, {:kind_of => Numeric})
+    lambda do
+      @vo.set_or_return(:test, nil, {:kind_of => Numeric})
+    end.should raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "should create DelayedEvaluator instance when #lazy is used" do
+    @vo.set_or_return(:delayed, @vo.lazy{ 'test' }, {})
+    @vo.instance_variable_get(:@delayed).should be_a(Chef::DelayedEvaluator)
+  end
+
+  it "should execute block on each call when DelayedEvaluator" do
+    value = 'fubar'
+    @vo.set_or_return(:test, @vo.lazy{ value }, {})
+    @vo.set_or_return(:test, nil, {}).should == 'fubar'
+    value = 'foobar'
+    @vo.set_or_return(:test, nil, {}).should == 'foobar'
+    value = 'fauxbar'
+    @vo.set_or_return(:test, nil, {}).should == 'fauxbar'
+  end
+
+  it "should not evaluate non DelayedEvaluator instances" do
+    value = lambda{ 'test' }
+    @vo.set_or_return(:test, value, {})
+    @vo.set_or_return(:test, nil, {}).object_id.should == value.object_id
+    @vo.set_or_return(:test, nil, {}).should be_a(Proc)
+  end
   
 end

data/spec/unit/mixin/template_spec.rb

@@ -18,30 +18,25 @@
 
 require 'spec_helper'
 
-class TinyTemplateClass; include Chef::Mixin::Template; end
 require 'cgi'
 describe Chef::Mixin::Template, "render_template" do
 
+  let(:sep) { Chef::Platform.windows? ? "\r\n" : "\n" }
+
   before :each do
-    @template = TinyTemplateClass.new
+    @context = Chef::Mixin::Template::TemplateContext.new({})
   end
 
   it "should render the template evaluated in the given context" do
-    @template.render_template("<%= @foo %>", { :foo => "bar" }) do |tmp|
-      tmp.open.read.should == "bar"
-    end
+    @context[:foo] = "bar"
+    output = @context.render_template_from_string("<%= @foo %>")
+    output.should == "bar"
   end
 
   it "should provide a node method to access @node" do
-    @template.render_template("<%= node %>",{:node => "tehShizzle"}) do |tmp|
-      tmp.open.read.should == "tehShizzle"
-    end
-  end
-
-  it "should yield the tempfile it renders the template to" do
-    @template.render_template("abcdef", {}) do |tempfile|
-      tempfile.should be_kind_of(Tempfile)
-    end
+    @context[:node] = "tehShizzle"
+    output = @context.render_template_from_string("<%= @node %>")
+    output.should == "tehShizzle"
   end
 
   describe "with a template resource" do
@@ -60,33 +55,28 @@ describe Chef::Mixin::Template, "render_template" do
 
       @resource = Chef::Resource::Template.new(@rendered_file_location)
       @resource.cookbook_name = 'openldap'
-
-      @provider = Chef::Provider::Template.new(@resource, @run_context)
       @current_resource = @resource.dup
-      @provider.current_resource = @current_resource
-      @access_controls = mock("access controls")
-      @provider.stub!(:access_controls).and_return(@access_controls)
 
-      @template_context = {}
+      @content_provider = Chef::Provider::Template::Content.new(@resource, @current_resource, @run_context)
+
+      @template_context = Chef::Mixin::Template::TemplateContext.new({})
       @template_context[:node] = @node
       @template_context[:template_finder] = Chef::Provider::TemplateFinder.new(@run_context, @resource.cookbook_name, @node)
     end
 
     it "should provide a render method" do
-      @provider.render_template("before {<%= render 'test.erb' %>} after", @template_context) do |tmp|
-        tmp.open.read.should == "before {We could be diving for pearls!\n} after"
-      end
+      output = @template_context.render_template_from_string("before {<%= render('test.erb').strip -%>} after")
+      output.should == "before {We could be diving for pearls!} after"
     end
 
     it "should render local files" do
       begin
         tf = Tempfile.new("partial")
-        tf.puts "test"
+        tf.write "test"
         tf.rewind
 
-        @provider.render_template("before {<%= render '#{tf.path}', :local => true %>} after", @template_context) do |tmp|
-          tmp.open.read.should == "before {test\n} after"
-        end
+        output = @template_context.render_template_from_string("before {<%= render '#{tf.path}', :local => true %>} after")
+        output.should == "before {test} after"
       ensure
         tf.close
       end
@@ -95,20 +85,18 @@ describe Chef::Mixin::Template, "render_template" do
     it "should render partials from a different cookbook" do
       @template_context[:template_finder] = Chef::Provider::TemplateFinder.new(@run_context, 'apache2', @node)
 
-      @provider.render_template("before {<%= render 'test.erb', :cookbook => 'openldap' %>} after", @template_context) do |tmp|
-        tmp.open.read.should == "before {We could be diving for pearls!\n} after"
-      end
+      output = @template_context.render_template_from_string("before {<%= render('test.erb', :cookbook => 'openldap').strip %>} after")
+      output.should == "before {We could be diving for pearls!} after"
     end
 
     it "should render using the source argument if provided" do
       begin
         tf = Tempfile.new("partial")
-        tf.puts "test"
+        tf.write "test"
         tf.rewind
 
-        @provider.render_template("before {<%= render 'something', :local => true, :source => '#{tf.path}' %>} after", @template_context) do |tmp|
-          tmp.open.read.should == "before {test\n} after"
-        end
+        output = @template_context.render_template_from_string("before {<%= render 'something', :local => true, :source => '#{tf.path}' %>} after")
+        output.should == "before {test} after"
       ensure
         tf.close
       end
@@ -117,56 +105,80 @@ describe Chef::Mixin::Template, "render_template" do
     it "should pass the node to partials" do
       @node.normal[:slappiness] = "happiness"
 
-      @provider.render_template("before {<%= render 'openldap_stuff.conf.erb' %>} after", @template_context) do |tmp|
-        tmp.open.read.should == "before {slappiness is happiness} after"
-      end
+      output = @template_context.render_template_from_string("before {<%= render 'openldap_stuff.conf.erb' %>} after")
+      output.should == "before {slappiness is happiness} after"
     end
 
     it "should pass the original variables to partials" do
       @template_context[:secret] = 'candy'
 
-      @provider.render_template("before {<%= render 'openldap_variable_stuff.conf.erb' %>} after", @template_context) do |tmp|
-        tmp.open.read.should == "before {super secret is candy} after"
-      end
+      output = @template_context.render_template_from_string("before {<%= render 'openldap_variable_stuff.conf.erb' %>} after")
+      output == "before {super secret is candy} after"
     end
 
     it "should pass variables to partials" do
-      @provider.render_template("before {<%= render 'openldap_variable_stuff.conf.erb', :variables => {:secret => 'whatever' } %>} after", @template_context) do |tmp|
-        tmp.open.read.should == "before {super secret is whatever} after"
-      end
+      output = @template_context.render_template_from_string("before {<%= render 'openldap_variable_stuff.conf.erb', :variables => {:secret => 'whatever' } %>} after")
+      output.should == "before {super secret is whatever} after"
     end
 
     it "should pass variables to partials even if they are named the same" do
       @template_context[:secret] = 'one'
 
-      @provider.render_template("before {<%= render 'openldap_variable_stuff.conf.erb', :variables => {:secret => 'two' } %>} after <%= @secret %>", @template_context) do |tmp|
-        tmp.open.read.should == "before {super secret is two} after one"
-      end
+      output = @template_context.render_template_from_string("before {<%= render 'openldap_variable_stuff.conf.erb', :variables => {:secret => 'two' } %>} after <%= @secret %>")
+      output.should == "before {super secret is two} after one"
     end
 
     it "should pass nil for missing variables in partials" do
-      @provider.render_template("before {<%= render 'openldap_variable_stuff.conf.erb', :variables => {} %>} after", @template_context) do |tmp|
-        tmp.open.read.should == "before {super secret is } after"
-      end
+      output = @template_context.render_template_from_string("before {<%= render 'openldap_variable_stuff.conf.erb', :variables => {} %>} after")
+      output.should == "before {super secret is } after"
 
-      @provider.render_template("before {<%= render 'openldap_variable_stuff.conf.erb' %>} after", @template_context) do |tmp|
-        tmp.open.read.should == "before {super secret is } after"
-      end
+      output = @template_context.render_template_from_string("before {<%= render 'openldap_variable_stuff.conf.erb' %>} after")
+    output.should == "before {super secret is } after"
     end
 
     it "should render nested partials" do
       path = File.expand_path(File.join(CHEF_SPEC_DATA, "partial_one.erb"))
 
-      @provider.render_template("before {<%= render '#{path}', :local => true %>} after", @template_context) do |tmp|
-        tmp.open.read.should == "before {partial one We could be diving for pearls!\n calling home\n} after"
+      output = @template_context.render_template_from_string("before {<%= render('#{path}', :local => true).strip %>} after")
+      output.should == "before {partial one We could be diving for pearls! calling home} after"
+    end
+
+    describe "when customizing the template context" do
+
+      it "extends the context to include modules" do
+        mod = Module.new do
+          def hello
+            "ohai"
+          end
+        end
+        @template_context._extend_modules([mod])
+        output = @template_context.render_template_from_string("<%=hello%>")
+        output.should == "ohai"
+      end
+
+      it "emits a warning when overriding 'core' methods" do
+        mod = Module.new do
+          def render
+          end
+          def node
+          end
+          def render_template
+          end
+          def render_template_from_string
+          end
+        end
+        ['node', 'render', 'render_template', 'render_template_from_string'].each do |method_name|
+          Chef::Log.should_receive(:warn).with(/^Core template method `#{method_name}' overridden by extension module/)
+        end
+        @template_context._extend_modules([mod])
       end
     end
+
   end
 
   describe "when an exception is raised in the template" do
     def do_raise
-      @context = {:chef => "cool"}
-      @template.render_template("foo\nbar\nbaz\n<%= this_is_not_defined %>\nquin\nqunx\ndunno", @context) {|r| r}
+      @context.render_template_from_string("foo\nbar\nbaz\n<%= this_is_not_defined %>\nquin\nqunx\ndunno")
     end
 
     it "should catch and re-raise the exception as a TemplateError" do
@@ -174,7 +186,7 @@ describe Chef::Mixin::Template, "render_template" do
     end
 
     it "should raise an error if an attempt is made to access node but it is nil" do
-      lambda {@template.render_template("<%= node %>",{}) {|r| r}}.should raise_error(Chef::Mixin::Template::TemplateError)
+      lambda {@context.render_template_from_string("<%= node %>") {|r| r}}.should raise_error(Chef::Mixin::Template::TemplateError)
     end
 
     describe "the raised TemplateError" do

data/spec/unit/mixin/windows_architecture_helper_spec.rb

@@ -0,0 +1,83 @@
+#
+# Author:: Adam Edwards (<adamed@opscode.com>)
+# Copyright:: Copyright (c) 2013 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 'spec_helper'
+require 'chef/mixin/windows_architecture_helper'
+
+
+
+describe Chef::Mixin::WindowsArchitectureHelper do
+  include Chef::Mixin::WindowsArchitectureHelper
+
+  before do
+    @valid_architectures = [ :i386, :x86_64 ]
+    @invalid_architectures = [ "i386", "x86_64", :x64, :x86, :arm ]
+
+    @node_i386 = Chef::Node.new
+    @node_x86_64 = Chef::Node.new
+  end
+  
+  it "returns true when valid architectures are passed to valid_windows_architecture?" do
+    @valid_architectures.each do | architecture |
+      valid_windows_architecture?(architecture).should == true
+    end
+  end
+
+  it "returns false when invalid architectures are passed to valid_windows_architecture?" do
+    @invalid_architectures.each do | architecture |
+      valid_windows_architecture?(architecture).should == false
+    end
+  end
+
+  it "does not raise an exception when a valid architecture is passed to assert_valid_windows_architecture!" do
+    @valid_architectures.each do | architecture |
+      assert_valid_windows_architecture!(architecture)
+    end
+  end
+
+  it "raises an error if an invalid architecture is passed to assert_valid_windows_architecture!" do
+    @invalid_architectures.each do | architecture |
+      begin
+        assert_valid_windows_architecture!(architecture).should raise_error Chef::Exceptions::Win32ArchitectureIncorrect
+      rescue Chef::Exceptions::Win32ArchitectureIncorrect
+      end
+    end
+  end
+
+  it "returns true for each supported desired architecture for all nodes with each valid architecture passed to node_supports_windows_architecture" do
+    enumerate_architecture_node_combinations(true)
+  end
+
+  it "returns false for each unsupported desired architecture for all nodes with each valid architecture passed to node_supports_windows_architecture?" do
+    enumerate_architecture_node_combinations(true)
+  end
+  
+  def enumerate_architecture_node_combinations(only_valid_combinations)
+    @valid_architectures.each do | node_architecture |
+      new_node = Chef::Node.new
+      new_node.default["kernel"] = Hash.new
+      new_node.default["kernel"][:machine] = node_architecture.to_s
+
+      @valid_architectures.each do | supported_architecture |
+        node_supports_windows_architecture?(new_node, supported_architecture).should == true if only_valid_combinations && (supported_architecture != :x86_64 && node_architecture != :i386 )
+        node_supports_windows_architecture?(new_node, supported_architecture).should == false if ! only_valid_combinations && (supported_architecture == :x86_64 && node_architecture == :i386 )        
+      end
+    end
+  end
+end

data/spec/unit/node_spec.rb

@@ -35,6 +35,13 @@ describe Chef::Node do
     lambda{Chef::Node.build('solo node')}.should raise_error(Chef::Exceptions::ValidationFailed)
   end
 
+  it "should be sortable" do
+    n1 = Chef::Node.build('alpha')
+    n2 = Chef::Node.build('beta')
+    n3 = Chef::Node.build('omega')
+    [n3, n1, n2].sort.should == [n1, n2, n3]
+  end
+
   describe "when the node does not exist on the server" do
     before do
       response = OpenStruct.new(:code => '404')

data/spec/unit/platform_spec.rb

@@ -35,7 +35,8 @@ describe "Chef::Platform supports" do
     :solaris,
     :mswin,
     :mingw32,
-    :windows
+    :windows,
+    :gcel
   ].each do |platform|
     it "#{platform}" do
       Chef::Platform.platforms.should have_key(platform)
@@ -56,6 +57,9 @@ describe Chef::Platform do
   before(:each) do
     Chef::Platform.platforms = {
       :darwin => {
+        ">= 10.11" => {
+          :file => "new_darwinian"
+        },
         "9.2.2" => {
           :file => "darwinian",
           :else => "thing"
@@ -82,6 +86,12 @@ describe Chef::Platform do
     pmap[:file].should eql("darwinian")
   end
   
+  it "should allow you to look up a platform by name and version using \"greater than\" style operators" do
+    pmap = Chef::Platform.find("Darwin", "11.1.0")
+    pmap.should be_a_kind_of(Hash)
+    pmap[:file].should eql("new_darwinian")
+  end
+
   it "should use the default providers for an os if the specific version does not exist" do
     pmap = Chef::Platform.find("Darwin", "1")
     pmap.should be_a_kind_of(Hash)
@@ -134,6 +144,10 @@ describe Chef::Platform do
     Chef::Platform.find_provider_for_node(node, kitty).should eql("nice")
   end
 
+  it "should not throw an exception when the platform version has an unknown format" do
+    Chef::Platform.find_provider(:darwin, "bad-version", :file).should eql("old school")
+  end
+
   it "should prefer an explicit provider" do
     kitty = Chef::Resource::Cat.new("loulou")    
     kitty.stub!(:provider).and_return(Chef::Provider::File)