chef 10.34.6 → 11.0.0.beta.0

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

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
 
@@ -366,40 +368,5 @@ 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/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

@@ -44,6 +44,125 @@ describe Chef::Mixin::Template, "render_template" do
     end
   end
 
+  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'
+
+      @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 = {}
+      @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
+    end
+
+    it "should render local files" do
+      begin
+        tf = Tempfile.new("partial")
+        tf.puts "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
+      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)
+
+      @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
+    end
+
+    it "should render using the source argument if provided" do
+      begin
+        tf = Tempfile.new("partial")
+        tf.puts "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
+      ensure
+        tf.close
+      end
+    end
+
+    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
+    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
+    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
+    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
+    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
+
+      @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
+    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"
+      end
+    end
+  end
+
   describe "when an exception is raised in the template" do
     def do_raise
       @context = {:chef => "cool"}

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,93 @@ 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 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 "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 "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
+
+  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 "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 +345,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"
+      result["mars_volta"].should == "cicatriz"
+      result["jimmy_eat_world"].should == "nice"
+      result["mastodon"].should == "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")
-    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 +378,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 +408,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 +428,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 +442,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 +460,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 +467,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 +504,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 +515,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 +589,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 +632,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 +911,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 +986,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 "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 "array values in the role override attributes should override the nodes default attributes" do
+    it "raises an error when using `attr=value`" do
+      lambda { @attributes.new_key = "new value" }.should raise_error(Chef::Exceptions::ImmutableAttributeModification)
     end
+
   end
 
 end
+