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

data/spec/unit/mixin/deprecation_spec.rb

@@ -19,6 +19,29 @@
 require 'spec_helper'
 require 'chef/mixin/deprecation'
 
+describe Chef::Mixin do
+  describe "deprecating constants (Class/Module)" do
+    before do
+      Chef::Mixin.deprecate_constant(:DeprecatedClass, Chef::Node, "This is a test deprecation")
+      @log_io = StringIO.new
+      Chef::Log.init(@log_io)
+    end
+
+    it "has a list of deprecated constants" do
+      Chef::Mixin.deprecated_constants.should have_key(:DeprecatedClass)
+    end
+
+    it "returns the replacement when accessing the deprecated constant" do
+      Chef::Mixin::DeprecatedClass.should == Chef::Node
+    end
+
+    it "warns when accessing the deprecated constant" do
+      Chef::Mixin::DeprecatedClass
+      @log_io.string.should include("This is a test deprecation")
+    end
+  end
+end
+
 describe Chef::Mixin::Deprecation::DeprecatedInstanceVariable do
   before do
     Chef::Log.logger = Logger.new(StringIO.new)

data/spec/unit/mixin/enforce_ownership_and_permissions_spec.rb

@@ -27,13 +27,18 @@ describe Chef::Mixin::EnforceOwnershipAndPermissions do
     @node.name "make_believe"
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
-    @resource = Chef::Resource::File.new("#{Dir.mktmpdir}/madeup.txt")
+    @tmpdir = Dir.mktmpdir
+    @resource = Chef::Resource::File.new("#{@tmpdir}/madeup.txt")
     FileUtils.touch @resource.path
     @resource.owner "adam"
     @provider = Chef::Provider::File.new(@resource, @run_context)
     @provider.current_resource = @resource
   end
 
+  after(:each) do
+    FileUtils.rm_rf(@tmpdir)
+  end
+
   it "should call set_all on the file access control object" do
     Chef::FileAccessControl.any_instance.should_receive(:set_all)
     @provider.enforce_ownership_and_permissions
@@ -43,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

@@ -330,10 +330,12 @@ describe Chef::Mixin::ParamsValidate do
 
   it "asserts that a value returns false from a predicate method" do
     lambda do
-      @vo.validate({:not_blank => "should pass"}, {:not_blank => {:cannot_be => :blank}})
+      @vo.validate({:not_blank => "should pass"},
+                   {:not_blank => {:cannot_be => :nil, :cannot_be => :empty}})
     end.should_not raise_error
     lambda do
-      @vo.validate({:not_blank => ""}, {:not_blank => {:cannot_be => :blank}})
+      @vo.validate({:not_blank => ""},
+                   {:not_blank => {:cannot_be => :nil, :cannot_be => :empty}})
     end.should raise_error(Chef::Exceptions::ValidationFailed)
   end
 

data/spec/unit/mixin/securable_spec.rb

@@ -112,9 +112,11 @@ describe Chef::Mixin::Securable do
         @original_config = Chef::Config.hash_dup
         load File.join(File.dirname(__FILE__), "..", "..", "..", "lib", "chef", "config.rb")
         load File.join(File.dirname(__FILE__), "..", "..", "..", "lib", "chef", "mixin", "securable.rb")
-        @securable = Object.new
-        @securable.send(:extend, Chef::Mixin::Securable)
-        @securable.send(:extend, Chef::Mixin::ParamsValidate)
+        SECURABLE_CLASS = Class.new do
+          include Chef::Mixin::Securable
+          include Chef::Mixin::ParamsValidate
+        end
+        @securable = SECURABLE_CLASS.new
       end
     end
 

data/spec/unit/mixin/template_spec.rb

@@ -18,36 +18,167 @@
 
 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
+    @context[:node] = "tehShizzle"
+    output = @context.render_template_from_string("<%= @node %>")
+    output.should == "tehShizzle"
   end
 
-  it "should yield the tempfile it renders the template to" do
-    @template.render_template("abcdef", {}) do |tempfile|
-      tempfile.should be_kind_of(Tempfile)
+  describe "with a template resource" do
+    before :each do
+      @cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
+      Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, @cookbook_repo) }
+
+      @node = Chef::Node.new
+      cl = Chef::CookbookLoader.new(@cookbook_repo)
+      cl.load_cookbooks
+      @cookbook_collection = Chef::CookbookCollection.new(cl)
+      @events = Chef::EventDispatch::Dispatcher.new
+      @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+
+      @rendered_file_location = Dir.tmpdir + '/openldap_stuff.conf'
+
+      @resource = Chef::Resource::Template.new(@rendered_file_location)
+      @resource.cookbook_name = 'openldap'
+      @current_resource = @resource.dup
+
+      @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
+      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.write "test"
+        tf.rewind
+
+        output = @template_context.render_template_from_string("before {<%= render '#{tf.path}', :local => true %>} after")
+        output.should == "before {test} after"
+      ensure
+        tf.close
+      end
+    end
+
+    it "should render partials from a different cookbook" do
+      @template_context[:template_finder] = Chef::Provider::TemplateFinder.new(@run_context, 'apache2', @node)
+
+      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.write "test"
+        tf.rewind
+
+        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
+    end
+
+    it "should pass the node to partials" do
+      @node.normal[:slappiness] = "happiness"
+
+      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'
+
+      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
+      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'
+
+      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
+      output = @template_context.render_template_from_string("before {<%= render 'openldap_variable_stuff.conf.erb', :variables => {} %>} after")
+      output.should == "before {super secret is } after"
+
+      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"))
+
+      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
@@ -55,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/attribute_spec.rb

@@ -7,9 +7,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.
@@ -20,9 +20,9 @@
 require 'spec_helper'
 require 'chef/node/attribute'
 
-describe Chef::Node::Attribute do
+describe Chef::Node::Attribute do 
   before(:each) do
-    @attribute_hash =
+    @attribute_hash = 
       {"dmi"=>{},
         "command"=>{"ps"=>"ps -ef"},
         "platform_version"=>"10.5.7",
@@ -193,7 +193,7 @@ describe Chef::Node::Attribute do
     @default_hash = {
       "domain" => "opscode.com",
       "hot" => { "day" => "saturday" },
-      "music" => {
+      "music" => { 
         "jimmy_eat_world" => "is fun!",
         "mastodon" => "rocks",
         "mars_volta" => "is loud and nutty",
@@ -225,30 +225,171 @@ describe Chef::Node::Attribute do
     [ :normal, :default, :override, :automatic ].each do |accessor|
       it "should set #{accessor}" do
         na = Chef::Node::Attribute.new({ :normal => true }, { :default => true }, { :override => true }, { :automatic => true })
-        na.send(accessor).should == { accessor => true }
+        na.send(accessor).should == { accessor.to_s => true } 
       end
     end
 
-    it "should allow you to set the initial state" do
-      attrs = {"first" => {"second" => {"third" => {"jackpot" => "jackpot!"}}}}
-      na = Chef::Node::Attribute.new(attrs, {}, {}, {}, [ "first", "second", "third" ])
-      na.should have_key("jackpot")
-    end
-
     it "should be enumerable" do
       @attributes.should be_is_a(Enumerable)
     end
   end
 
-  describe "hash_and_not_cna" do
-    it "should return false if we pass it a Chef::Node::Attribute" do
-      @attributes.hash_and_not_cna?(@attributes).should == false
+  describe "when printing attribute components" do
+
+    it "does not cause a type error" do
+      # See CHEF-3799; IO#puts implicitly calls #to_ary on its argument. This
+      # is expected to raise a NoMethodError or return an Array. `to_ary` is
+      # the "strict" conversion method that should only be implemented by
+      # things that are truly Array-like, so NoMethodError is the right choice.
+      # (cf. there is no Hash#to_ary).
+      lambda { @attributes.default.to_ary }.should raise_error(NoMethodError)
+    end
+
+  end
+
+  describe "when debugging attributes" do
+    before do
+      @attributes.default[:foo][:bar] = "default"
+      @attributes.env_default[:foo][:bar] = "env_default"
+      @attributes.role_default[:foo][:bar] = "role_default"
+      @attributes.force_default[:foo][:bar] = "force_default"
+      @attributes.normal[:foo][:bar] = "normal"
+      @attributes.override[:foo][:bar] = "override"
+      @attributes.role_override[:foo][:bar] = "role_override"
+      @attributes.env_override[:foo][:bar] = "env_override"
+      @attributes.force_override[:foo][:bar] = "force_override"
+      @attributes.automatic[:foo][:bar] = "automatic"
+    end
+
+    it "gives the value at each level of precedence for a path spec" do
+      expected = [["set_unless_enabled?", false],
+        ["default", "default"],
+        ["env_default", "env_default"],
+        ["role_default", "role_default"],
+        ["force_default", "force_default"],
+        ["normal", "normal"],
+        ["override", "override"],
+        ["role_override", "role_override"],
+        ["env_override", "env_override"],
+        ["force_override", "force_override"],
+        ["automatic", "automatic"]
+      ]
+      @attributes.debug_value(:foo, :bar).should == expected
+    end
+  end
+
+  describe "when fetching values based on precedence" do
+    before do
+      @attributes.default["default"] = "cookbook default"
+      @attributes.override["override"] = "cookbook override"
+    end
+
+    it "prefers 'forced default' over any other default" do
+      @attributes.default!["default"] = "force default"
+      @attributes.role_default["default"] = "role default"
+      @attributes.env_default["default"] = "environment default"
+      @attributes["default"].should == "force default"
+    end
+
+    it "prefers role_default over environment or cookbook default" do
+      @attributes.role_default["default"] = "role default"
+      @attributes.env_default["default"] = "environment default"
+      @attributes["default"].should == "role default"
+    end
+
+    it "prefers environment default over cookbook default" do
+      @attributes.env_default["default"] = "environment default"
+      @attributes["default"].should == "environment default"
+    end
+
+    it "returns the cookbook default when no other default values are present" do
+      @attributes["default"].should == "cookbook default"
+    end
+
+    it "prefers 'forced overrides' over role or cookbook overrides" do
+      @attributes.override!["override"] = "force override"
+      @attributes.env_override["override"] = "environment override"
+      @attributes.role_override["override"] = "role override"
+      @attributes["override"].should == "force override"
+    end
+
+    it "prefers environment overrides over role or cookbook overrides" do
+      @attributes.env_override["override"] = "environment override"
+      @attributes.role_override["override"] = "role override"
+      @attributes["override"].should == "environment override"
+    end
+
+    it "prefers role overrides over cookbook overrides" do
+      @attributes.role_override["override"] = "role override"
+      @attributes["override"].should == "role override"
+    end
+
+    it "returns cookbook overrides when no other overrides are present" do
+      @attributes["override"].should == "cookbook override"
+    end
+
+    it "merges arrays within the default precedence" do
+      @attributes.role_default["array"] = %w{role}
+      @attributes.env_default["array"] = %w{env}
+      @attributes["array"].should == %w{env role}
+    end
+
+    it "merges arrays within the override precedence" do
+      @attributes.role_override["array"] = %w{role}
+      @attributes.env_override["array"] = %w{env}
+      @attributes["array"].should == %w{role env}
+    end
+
+    it "does not merge arrays between default and normal" do
+      @attributes.role_default["array"] = %w{role}
+      @attributes.normal["array"] = %w{normal}
+      @attributes["array"].should == %w{normal}
+    end
+
+    it "does not merge arrays between normal and override" do
+      @attributes.normal["array"] = %w{normal}
+      @attributes.role_override["array"] = %w{role}
+      @attributes["array"].should == %w{role}
+    end
+
+    it "merges nested hashes between precedence levels" do
+      @attributes = Chef::Node::Attribute.new({}, {}, {}, {})
+      @attributes.env_default = {"a" => {"b" => {"default" => "default"}}}
+      @attributes.normal = {"a" => {"b" => {"normal" => "normal"}}}
+      @attributes.override = {"a" => {"override" => "role"}}
+      @attributes.automatic = {"a" => {"automatic" => "auto"}}
+      @attributes["a"].should == {"b"=>{"default"=>"default", "normal"=>"normal"},
+                                  "override"=>"role",
+                                  "automatic"=>"auto"}
+    end
+  end
+
+  describe "when reading combined default or override values" do
+    before do
+      @attributes.default["cd"] = "cookbook default"
+      @attributes.role_default["rd"] = "role default"
+      @attributes.env_default["ed"] = "env default"
+      @attributes.default!["fd"] = "force default"
+      @attributes.override["co"] = "cookbook override"
+      @attributes.role_override["ro"] = "role override"
+      @attributes.env_override["eo"] = "env override"
+      @attributes.override!["fo"] = "force override"
     end
 
-    it "should return true if we pass it something that responds to has_key?" do
-      hashy = mock("Hashlike", :has_key? => true)
-      @attributes.hash_and_not_cna?(hashy).should == true
+    it "merges all types of overrides into a combined override" do
+      @attributes.combined_override["co"].should == "cookbook override"
+      @attributes.combined_override["ro"].should == "role override"
+      @attributes.combined_override["eo"].should == "env override"
+      @attributes.combined_override["fo"].should == "force override"
     end
+
+    it "merges all types of defaults into a combined default" do
+      @attributes.combined_default["cd"].should == "cookbook default"
+      @attributes.combined_default["rd"].should == "role default"
+      @attributes.combined_default["ed"].should == "env default"
+      @attributes.combined_default["fd"].should == "force default"
+    end
+
   end
 
   describe "[]" do
@@ -282,67 +423,31 @@ describe Chef::Node::Attribute do
 
     it "should return the merged hash if all three have values" do
       result = @attributes["music"]
-      result["mars_volta"] = "cicatriz"
-      result["jimmy_eat_world"] = "nice"
-      result["mastodon"] = "rocks"
-    end
-  end
-
-  describe "auto_vivifiy" do
-    it "should set the hash key to a mash if it does not exist" do
-      @attributes.auto_vivifiy({}, "one")["one"].should be_a_kind_of(Mash)
-    end
-
-    it "should raise an exception if the key does exist and does not respond to has_key?" do
-      lambda { @attributes.auto_vivifiy({ "one" => "value" }) }.should raise_error(ArgumentError)
-    end
-
-    it "should not alter the value if the key exists and responds to has_key?" do
-      @attributes.auto_vivifiy({ "one" => { "will" => true } }, "one")["one"].should have_key("will")
+      result["mars_volta"].should == "cicatriz"
+      result["jimmy_eat_world"].should == "nice"
+      result["mastodon"].should == "rocks"
     end
   end
 
-  describe "set_value" do
-    it "should set the value for a top level key" do
-      to_check = {}
-      @attributes.set_value(to_check, "one", "some value")
-      to_check["one"].should == "some value"
-    end
-
-    it "should set the value for a second level key" do
-      to_check = {}
-      @attributes[ "one" ]
-      @attributes.set_value(to_check, "two", "some value")
-      to_check["one"]["two"].should == "some value"
-    end
-
-    it "should set the value for a very deep key" do
-      to_check = {}
-      attributes = Chef::Node::Attribute.new({}, {}, {}, {}, %w{one two three four five})
-      attributes.set_value(to_check, "six", "some value")
-      to_check["one"]["two"]["three"]["four"]["five"]["six"].should == "some value"
+  describe "[]=" do
+    it "should error out when the type of attribute to set has not been specified" do
+      @attributes.normal["the_ghost"] = {  }
+      lambda { @attributes["the_ghost"]["exterminate"] = false }.should raise_error(Chef::Exceptions::ImmutableAttributeModification)
     end
-  end
 
-  describe "[]=" do
     it "should let you set an attribute value when another hash has an intermediate value" do
       @attributes.normal["the_ghost"] = { "exterminate" => "the future" }
-      @attributes.set_type = :default
-      @attributes.auto_vivifiy_on_read = true
-      lambda { @attributes["the_ghost"]["exterminate"]["tomorrow"] = false }.should_not raise_error(NoMethodError)
+      lambda { @attributes.normal["the_ghost"]["exterminate"]["tomorrow"] = false }.should_not raise_error(NoMethodError)
     end
 
     it "should set the attribute value" do
-      @attributes["longboard"] = "surfing"
-      @attributes["longboard"].should == "surfing"
-      @attributes.attribute["longboard"].should == "surfing"
+      @attributes.normal["longboard"] = "surfing"
+      @attributes.normal["longboard"].should == "surfing"
+      @attributes.normal["longboard"].should == "surfing"
     end
 
-    it "should set deeply nested attribute value when auto_vivifiy_on_read is true" do
-      @attributes.set_type = :normal
-      @attributes.auto_vivifiy_on_read = true
-      @attributes["deftones"]["hunters"]["nap"] = "surfing"
-      @attributes.reset
+    it "should set deeply nested attribute values when a precedence level is specified" do
+      @attributes.normal["deftones"]["hunters"]["nap"] = "surfing"
       @attributes.normal["deftones"]["hunters"]["nap"].should == "surfing"
     end
 
@@ -351,45 +456,23 @@ describe Chef::Node::Attribute do
     end
 
     it "should let you set attributes manually without vivification" do
-      @attributes["foo"] = Mash.new
-      @attributes["foo"]["bar"] = :baz
-      @attributes["foo"]["bar"].should == :baz
+      @attributes.normal["foo"] = Mash.new
+      @attributes.normal["foo"]["bar"] = :baz
+      @attributes.normal["foo"]["bar"].should == :baz
     end
 
     it "should optionally skip setting the value if one already exists" do
       @attributes.set_unless_value_present = true
-      @attributes["hostname"] = "bar"
+      @attributes.normal["hostname"] = "bar"
       @attributes["hostname"].should == "latte"
     end
 
-    it "should write to an attribute that has been read before properly" do
-      @attributes["foo"] = Mash.new
-      @attributes["foo"]["bar"] ||= "stop the world"
-      @attributes["foo"]["bar"].should == "stop the world"
-    end
-  end
-
-  describe "get_value" do
-    it "should get a value from a top level key" do
-      @attributes.get_value(@default_hash, "domain").should == "opscode.com"
-    end
-
-    it "should return nil for a top level key that does not exist" do
-      @attributes.get_value(@default_hash, "domainz").should == nil
-    end
-
-    it "should get a value based on the state of the object" do
-      @attributes.auto_vivifiy_on_read = true
-      @attributes.set_type = :normal
-      @attributes[:foo][:bar][:baz] = "snack"
-      @attributes.get_value(@attribute_hash, :baz).should == "snack"
-    end
-
-    it "should return nil based on the state of the object if the key does not exist" do
-      @attributes.auto_vivifiy_on_read = true
-      @attributes.set_type = :normal
-      @attributes[:foo][:bar][:baz] = "snack"
-      @attributes.get_value(@attribute_hash, :baznatch).should == nil
+    it "does not support ||= when setting" do
+      # This is a limitation of auto-vivification.
+      # Users who need this behavior can use set_unless and friends
+      @attributes.normal["foo"] = Mash.new
+      @attributes.normal["foo"]["bar"] ||= "stop the world"
+      @attributes.normal["foo"]["bar"].should == {}
     end
   end
 
@@ -403,21 +486,6 @@ describe Chef::Node::Attribute do
       hash.class.should == Hash
       hash["day"].should == "sunday"
     end
-
-    # Regression test for CHEF-4631
-    context "when merging array values" do
-      before do
-        @default_attrs = {"foo" => {"bar" => ["default"]}}
-        @override_attrs = {"foo" => {"bar" => ["override"]}}
-
-        #(normal, default, override, automatic, state=[])
-        @attributes = Chef::Node::Attribute.new({ }, @default_attrs, @override_attrs, { })
-      end
-
-      it "should return the override" do
-        @attributes["foo"].to_hash["bar"].should == [ "override" ]
-      end
-    end
   end
 
   describe "has_key?" do
@@ -438,14 +506,8 @@ describe Chef::Node::Attribute do
     end
 
     it "should return true if an attribute exists but is set to false" do
-      @attributes["music"]
-      @attributes.has_key?("apophis").should == true
-    end
-
-    it "should find keys at the current nesting level" do
-      @attributes["music"]
-      @attributes.has_key?("mastodon").should == true
-      @attributes.has_key?("whitesnake").should == false
+      @attributes.has_key?("music")
+      @attributes["music"].has_key?("apophis").should == true
     end
 
     it "does not find keys above the current nesting level" do
@@ -458,7 +520,7 @@ describe Chef::Node::Attribute do
 
     [:include?, :key?, :member?].each do |method|
       it "should alias the method #{method} to itself" do
-        @attributes.should respond_to(method)
+        @attributes.should respond_to(method) 
       end
 
       it "#{method} should behave like has_key?" do
@@ -476,11 +538,6 @@ describe Chef::Node::Attribute do
       @attributes.attribute?("ninja").should == false
     end
 
-    it "should be looking at the current position of the object" do
-      @attributes["music"]
-      @attributes.attribute?("mastodon").should == true
-      @attributes.attribute?("whitesnake").should == false
-    end
   end
 
   describe "method_missing" do
@@ -488,16 +545,10 @@ describe Chef::Node::Attribute do
       @attributes.music.mastodon.should == "rocks"
     end
 
-    it "should behave like a []= lookup if the last method has an argument" do
-      @attributes.music.mastodon(["dream", "still", "shining"])
-      @attributes.reset
-      @attributes.music.mastodon.should == ["dream", "still", "shining"]
-    end
-
     it "should allow the last method to set a value if it has an = sign on the end" do
-      @attributes.music.mastodon = [ "dream", "still", "shining" ]
+      @attributes.normal.music.mastodon = [ "dream", "still", "shining" ]
       @attributes.reset
-      @attributes.music.mastodon.should == [ "dream", "still", "shining" ]
+      @attributes.normal.music.mastodon.should == [ "dream", "still", "shining" ]
     end
   end
 
@@ -531,7 +582,7 @@ describe Chef::Node::Attribute do
       collect.include?("snakes").should == true
       collect.include?("snack").should == true
       collect.include?("place").should == true
-      collect.length.should == 5
+      collect.length.should == 5 
     end
 
     it "should yield lower if we go deeper" do
@@ -542,7 +593,7 @@ describe Chef::Node::Attribute do
       collect.include?("two").should == true
       collect.include?("four").should == true
       collect.include?("six").should == true
-      collect.length.should == 3
+      collect.length.should == 3 
     end
 
     it "should not raise an exception if one of the hashes has a nil value on a deep lookup" do
@@ -616,7 +667,7 @@ describe Chef::Node::Attribute do
       @attributes.each_key do |k|
         collect << k
       end
-
+     
       collect.should include("one")
       collect.should include("snack")
       collect.should include("hut")
@@ -659,7 +710,7 @@ describe Chef::Node::Attribute do
       collect["snack"].should == "cookies"
     end
   end
-
+  
   describe "each_value" do
     before do
       @attributes = Chef::Node::Attribute.new(
@@ -938,8 +989,8 @@ describe Chef::Node::Attribute do
       end
     end
 
-    it "should return an empty array for a block containing nil" do
-      @attributes.select { nil }.should == []
+    it "should return an empty hash/array (ruby-version-dependent) for a block containing nil" do
+      @attributes.select { nil }.should == {}.select { nil }
     end
 
     # sorted for spec clarity
@@ -1013,56 +1064,105 @@ describe Chef::Node::Attribute do
 
   describe "inspect" do
     it "should be readable" do
-      @attributes.inspect.should =~ /@automatic=\{\.\.\.\}/
-      @attributes.inspect.should =~ /@normal=\{\.\.\.\}/
+      # NOTE: previous implementation hid the values, showing @automatic={...}
+      # That is nice and compact, but hides a lot of info, which seems counter
+      # to the point of calling #inspect...
+      @attributes.inspect.should =~ /@automatic=\{.*\}/
+      @attributes.inspect.should =~ /@normal=\{.*\}/
     end
   end
 
-  describe "when a value has been set at all four precedence levels" do
-    before do
-      @default_attrs = {"foo" => {"bar" => "default_value"}}
-      @normal_attrs = {"foo" => {"bar" => "normal_value"}}
-      @override_attrs = {"foo" => {"bar" => "override_value"}}
-      @automatic_attrs = {"foo" => {"bar" => "automatic_value"}}
+  # For expedience, this test is implementation-heavy.
+  describe "when a component attribute is mutated" do
+    [
+      :clear,
+      :shift
+    ].each do |mutator|
+      it "resets the cache when the mutator #{mutator} is called" do
+        @attributes.should_receive(:reset_cache)
+        @attributes.default.send(mutator)
+      end
+    end
 
-                                            #(normal, default, override, automatic, state=[])
-      @attributes = Chef::Node::Attribute.new(@normal_attrs, @default_attrs, @override_attrs, @automatic_attrs)
+    it "resets the cache when the mutator delete is called" do
+      @attributes.should_receive(:reset_cache)
+      @attributes.default.delete(:music)
     end
 
-    it "deletes a key from all precedence levels" do
-      @attributes["foo"].delete("bar")
-      @attributes.reset
-      @attributes["foo"].should_not have_key("bar")
-      @default_attrs["foo"].should_not have_key("bar")
-      @normal_attrs["foo"].should_not have_key("bar")
-      @override_attrs["foo"].should_not have_key("bar")
-      @automatic_attrs["foo"].should_not have_key("bar")
+    [
+      :merge!,
+      :update,
+      :replace
+    ].each do |mutator|
+      it "resets the cache when the mutator #{mutator} is called" do
+        # Implementation of Mash means that this could get called many times. That's okay.
+        @attributes.should_receive(:reset_cache).at_least(1).times
+        @attributes.default.send(mutator, {:foo => :bar})
+      end
     end
 
-    it "returns the automatic (highest precedence) value when deleting a key" do
-      @attributes["foo"].delete("bar").should == "automatic_value"
+    [
+      :delete_if,
+      :keep_if,
+      :reject!,
+      :select!,
+    ].each do |mutator|
+      it "resets the cache when the mutator #{mutator} is called" do
+        # Implementation of Mash means that this could get called many times. That's okay.
+        @attributes.should_receive(:reset_cache).at_least(1).times
+        block = lambda {|k,v| true }
+        @attributes.default.send(mutator, &block)
+      end
     end
   end
 
-  describe "regression test for CHEF-4631" do
-    before(:each) do
-      @default_attrs = {"foo" => {"bar" => ["default"]}}
-      @override_attrs = {"foo" => {"bar" => ["override"]}}
+  describe "when not mutated" do
 
-      #(normal, default, override, automatic, state=[])
-      @attributes = Chef::Node::Attribute.new({ }, @default_attrs, @override_attrs, { })
+    it "does not reset the cache when dup'd [CHEF-3680]" do
+      @attributes.default[:foo][:bar] = "set on original"
+      subtree = @attributes[:foo]
+      @attributes.default[:foo].dup[:bar] = "set on dup"
+      subtree[:bar].should == "set on original"
     end
 
-    it "array values in the role default attributes should be concatanated to the nodes default attributes" do
-      @default_attrs = {"foo" => {"bar" => ["1", "2"]}}
-      @attributes = Chef::Node::Attribute.new({ }, @default_attrs, { }, { })
+  end
 
-      expansion = mock("Expansion", :default_attrs => { "foo" => {"bar" => ["3", "2"]}}, :override_attributes => { })
+  describe "when setting a component attribute to a new value" do
+    it "converts the input in to a VividMash tree (default)" do
+      @attributes.default = {}
+      @attributes.default.foo = "bar"
+      @attributes.merged_attributes[:foo].should == "bar"
+    end
 
+    it "converts the input in to a VividMash tree (normal)" do
+      @attributes.normal = {}
+      @attributes.normal.foo = "bar"
+      @attributes.merged_attributes[:foo].should == "bar"
     end
 
-    it "array values in the role override attributes should override the nodes default attributes" do
+    it "converts the input in to a VividMash tree (override)" do
+      @attributes.override = {}
+      @attributes.override.foo = "bar"
+      @attributes.merged_attributes[:foo].should == "bar"
+    end
+
+    it "converts the input in to a VividMash tree (automatic)" do
+      @attributes.automatic = {}
+      @attributes.automatic.foo = "bar"
+      @attributes.merged_attributes[:foo].should == "bar"
     end
   end
 
+  describe "when attemping to write without specifying precedence" do
+    it "raises an error when using []=" do
+      lambda { @attributes[:new_key] = "new value" }.should raise_error(Chef::Exceptions::ImmutableAttributeModification)
+    end
+
+    it "raises an error when using `attr=value`" do
+      lambda { @attributes.new_key = "new value" }.should raise_error(Chef::Exceptions::ImmutableAttributeModification)
+    end
+
+  end
+
 end
+