microwave 1.0.4 → 11.400.2

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

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

@@ -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

@@ -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 "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 "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 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"
+  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
 
-    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"
-    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
 
@@ -423,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
@@ -461,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
@@ -473,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
 
@@ -923,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
@@ -998,36 +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 "when not mutated" do
+
+    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
+
+  end
+
+  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 "raises an error when using `attr=value`" do
+      lambda { @attributes.new_key = "new value" }.should raise_error(Chef::Exceptions::ImmutableAttributeModification)
     end
 
   end
 
 end
+