chef 18.0.169-x64-mingw-ucrt

data/spec/unit/node_spec.rb

@@ -0,0 +1,2032 @@
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Copyright:: Copyright (c) Chef Software 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 "ostruct"
+
+describe Chef::Node do
+
+  let(:node) { Chef::Node.new }
+  let(:platform_introspector) { node }
+
+  it_behaves_like "a platform introspector"
+
+  it "creates a node and assigns it a name" do
+    node = Chef::Node.build("solo-node")
+    expect(node.name).to eq("solo-node")
+  end
+
+  it "should validate the name of the node" do
+    expect { Chef::Node.build("solo node") }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "should be sortable" do
+    n1 = Chef::Node.build("alpha")
+    n2 = Chef::Node.build("beta")
+    n3 = Chef::Node.build("omega")
+    expect([n3, n1, n2].sort).to eq([n1, n2, n3])
+  end
+
+  it "should share identity only with others of the same name" do
+    n1 = Chef::Node.build("foo")
+    n2 = Chef::Node.build("foo")
+    n3 = Chef::Node.build("bar")
+    expect(n1).to eq(n2)
+    expect(n1).not_to eq(n3)
+  end
+
+  describe "when the node does not exist on the server" do
+    before do
+      response = OpenStruct.new(code: "404")
+      exception = Net::HTTPClientException.new("404 not found", response)
+      allow(Chef::Node).to receive(:load).and_raise(exception)
+      node.name("created-node")
+    end
+
+    it "creates a new node for find_or_create" do
+      allow(Chef::Node).to receive(:new).and_return(node)
+      expect(node).to receive(:create).and_return(node)
+      node = Chef::Node.find_or_create("created-node")
+      expect(node.name).to eq("created-node")
+      expect(node).to equal(node)
+    end
+  end
+
+  describe "when the node exists on the server" do
+    before do
+      node.name("existing-node")
+      allow(Chef::Node).to receive(:load).and_return(node)
+    end
+
+    it "loads the node via the REST API for find_or_create" do
+      expect(Chef::Node.find_or_create("existing-node")).to equal(node)
+    end
+  end
+
+  describe "run_state" do
+    it "is an empty hash" do
+      expect(node.run_state).to respond_to(:keys)
+      expect(node.run_state).to be_empty
+    end
+  end
+
+  describe "initialize" do
+    it "should default to the '_default' chef_environment" do
+      n = Chef::Node.new
+      expect(n.chef_environment).to eq("_default")
+    end
+  end
+
+  describe "name" do
+    it "should allow you to set a name with name(something)" do
+      expect { node.name("latte") }.not_to raise_error
+    end
+
+    it "should return the name with name()" do
+      node.name("latte")
+      expect(node.name).to eql("latte")
+    end
+
+    it "should always have a string for name" do
+      expect { node.name({}) }.to raise_error(ArgumentError)
+    end
+
+    it "cannot be blank" do
+      expect { node.name("") }.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+
+    it "should not accept name doesn't match /^[\-[:alnum:]_:.]+$/" do
+      expect { node.name("space in it") }.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+  end
+
+  describe "chef_environment" do
+    it "should set an environment with chef_environment(something)" do
+      expect { node.chef_environment("latte") }.not_to raise_error
+    end
+
+    it "should return the chef_environment with chef_environment()" do
+      node.chef_environment("latte")
+      expect(node.chef_environment).to eq("latte")
+    end
+
+    it "should disallow non-strings" do
+      expect { node.chef_environment({}) }.to raise_error(ArgumentError)
+      expect { node.chef_environment(42) }.to raise_error(ArgumentError)
+    end
+
+    it "cannot be blank" do
+      expect { node.chef_environment("") }.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+  end
+
+  describe "policy_name" do
+
+    it "defaults to nil" do
+      expect(node.policy_name).to be_nil
+    end
+
+    it "sets policy_name with a regular setter" do
+      node.policy_name = "example-policy"
+      expect(node.policy_name).to eq("example-policy")
+    end
+
+    it "allows policy_name with every valid character" do
+      expect { node.policy_name = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqurstuvwxyz0123456789-_:." }.to_not raise_error
+    end
+
+    it "sets policy_name when given an argument" do
+      node.policy_name("example-policy")
+      expect(node.policy_name).to eq("example-policy")
+    end
+
+    it "sets policy_name to nil when given nil" do
+      node.policy_name = "example-policy"
+      node.policy_name = nil
+      expect(node.policy_name).to be_nil
+    end
+
+    it "disallows non-strings" do
+      expect { node.policy_name({}) }.to raise_error(Chef::Exceptions::ValidationFailed)
+      expect { node.policy_name(42) }.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+
+    it "cannot be blank" do
+      expect { node.policy_name("") }.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+  end
+
+  describe "policy_group" do
+
+    it "defaults to nil" do
+      expect(node.policy_group).to be_nil
+    end
+
+    it "sets policy_group with a regular setter" do
+      node.policy_group = "staging"
+      expect(node.policy_group).to eq("staging")
+    end
+
+    it "allows policy_group with every valid character" do
+      expect { node.policy_group = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqurstuvwxyz0123456789-_:." }.to_not raise_error
+    end
+
+    it "sets a policy_group with policy_group(something)" do
+      node.policy_group("staging")
+      expect(node.policy_group).to eq("staging")
+    end
+
+    it "sets policy_group to nil when given nil" do
+      node.policy_group = "staging"
+      node.policy_group = nil
+      expect(node.policy_group).to be_nil
+    end
+
+    it "disallows non-strings" do
+      expect { node.policy_group({}) }.to raise_error(Chef::Exceptions::ValidationFailed)
+      expect { node.policy_group(42) }.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+
+    it "cannot be blank" do
+      expect { node.policy_group("") }.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+  end
+
+  describe "attributes" do
+    it "should have attributes" do
+      expect(node.attribute).to be_a_kind_of(Hash)
+    end
+
+    it "should allow attributes to be accessed by name or symbol directly on node[]" do
+      node.default["locust"] = "something"
+      expect(node[:locust]).to eql("something")
+      expect(node["locust"]).to eql("something")
+    end
+
+    it "should return nil if it cannot find an attribute with node[]" do
+      expect(node["secret"]).to eql(nil)
+    end
+
+    it "does not allow you to set an attribute via node[]=" do
+      expect { node["secret"] = "shush" }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)
+    end
+
+    it "should allow you to query whether an attribute exists with attribute?" do
+      node.default["locust"] = "something"
+      expect(node.attribute?("locust")).to eql(true)
+      expect(node.attribute?("no dice")).to eql(false)
+    end
+
+    it "should let you go deep with attribute?" do
+      node.normal["battles"]["people"]["wonkey"] = true
+      expect(node["battles"]["people"].attribute?("wonkey")).to eq(true)
+      expect(node["battles"]["people"].attribute?("snozzberry")).to eq(false)
+    end
+
+    it "does not allow modification of node attributes via hash methods" do
+      node.default["h4sh"] = { foo: "bar" }
+      expect { node["h4sh"].delete("foo") }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)
+    end
+
+    it "does not allow modification of node attributes via array methods" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      node.default["array"] = []
+      expect { node["array"] << "boom" }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)
+    end
+
+    it "returns merged immutable attributes for arrays" do
+      node.default["array"] = []
+      expect( node["array"].class ).to eql(Chef::Node::ImmutableArray)
+    end
+
+    it "returns merged immutable attributes for hashes" do
+      node.default["h4sh"] = {}
+      expect( node["h4sh"].class ).to eql(Chef::Node::ImmutableMash)
+    end
+
+    describe "normal attributes" do
+      it "should allow you to set an attribute with set, without pre-declaring a hash" do
+        node.normal[:snoopy][:is_a_puppy] = true
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+
+      it "should allow you to set an attribute with set_unless" do
+        node.normal_unless[:snoopy][:is_a_puppy] = false
+        expect(node[:snoopy][:is_a_puppy]).to eq(false)
+      end
+
+      it "should not allow you to set an attribute with set_unless if it already exists" do
+        node.normal[:snoopy][:is_a_puppy] = true
+        node.normal_unless[:snoopy][:is_a_puppy] = false
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+
+      it "should allow you to set an attribute with set_unless if is a nil value" do
+        node.attributes.normal = { snoopy: { is_a_puppy: nil } }
+        node.normal_unless[:snoopy][:is_a_puppy] = false
+        expect(node[:snoopy][:is_a_puppy]).to eq(false)
+      end
+
+      it "should allow you to set a value after a set_unless" do
+        # this tests for set_unless_present state bleeding between statements CHEF-3806
+        node.normal_unless[:snoopy][:is_a_puppy] = false
+        node.normal[:snoopy][:is_a_puppy] = true
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+
+      it "should let you set a value after a 'dangling' set_unless" do
+        # this tests for set_unless_present state bleeding between statements CHEF-3806
+        node.normal[:snoopy][:is_a_puppy] = "what"
+        node.normal_unless[:snoopy][:is_a_puppy]
+        node.normal[:snoopy][:is_a_puppy] = true
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+
+      it "should let you use tag as a convince method for the tags attribute" do
+        node.normal["tags"] = %w{one two}
+        node.tag("three", "four")
+        expect(node["tags"]).to eq(%w{one two three four})
+      end
+
+      it "normal_unless sets a value even if default or override attrs are set" do
+        node.default[:decontamination] = true
+        node.override[:decontamination] = false
+        node.normal_unless[:decontamination] = "foo"
+        expect(node.normal[:decontamination]).to eql("foo")
+      end
+
+      it "default_unless sets a value even if normal or override attrs are set" do
+        node.normal[:decontamination] = true
+        node.override[:decontamination] = false
+        node.default_unless[:decontamination] = "foo"
+        expect(node.default[:decontamination]).to eql("foo")
+      end
+
+      it "override_unless sets a value even if default or normal attrs are set" do
+        node.default[:decontamination] = true
+        node.normal[:decontamination] = false
+        node.override_unless[:decontamination] = "foo"
+        expect(node.override[:decontamination]).to eql("foo")
+      end
+
+      it "consume_attributes does not exhibit chef/chef/issues/6302 bug" do
+        node.normal["a"]["r1"] = nil
+        node.consume_attributes({ "a" => { "r2" => nil } })
+        expect(node["a"]["r1"]).to be_nil
+        expect(node["a"]["r2"]).to be_nil
+      end
+    end
+
+    describe "default attributes" do
+      it "should be set with default, without pre-declaring a hash" do
+        node.default[:snoopy][:is_a_puppy] = true
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+
+      it "should allow you to set with default_unless without pre-declaring a hash" do
+        node.default_unless[:snoopy][:is_a_puppy] = false
+        expect(node[:snoopy][:is_a_puppy]).to eq(false)
+      end
+
+      it "should not allow you to set an attribute with default_unless if it already exists" do
+        node.default[:snoopy][:is_a_puppy] = true
+        node.default_unless[:snoopy][:is_a_puppy] = false
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+
+      it "should allow you to set a value after a default_unless" do
+        # this tests for set_unless_present state bleeding between statements CHEF-3806
+        node.default_unless[:snoopy][:is_a_puppy] = false
+        node.default[:snoopy][:is_a_puppy] = true
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+
+      it "should allow you to set a value after a 'dangling' default_unless" do
+        # this tests for set_unless_present state bleeding between statements CHEF-3806
+        node.default[:snoopy][:is_a_puppy] = "what"
+        node.default_unless[:snoopy][:is_a_puppy]
+        node.default[:snoopy][:is_a_puppy] = true
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+
+      it "does not exhibit chef/chef/issues/5005 bug" do
+        node.env_default["a"]["r1"]["g"]["u"] = "u1"
+        node.default_unless["a"]["r1"]["g"]["r"] = "r"
+        expect(node["a"]["r1"]["g"]["u"]).to eql("u1")
+      end
+
+      it "default_unless correctly resets the deep merge cache" do
+        node.normal["tags"] = []  # this sets our top-level breadcrumb
+        node.default_unless["foo"]["bar"] = "NK-19V"
+        expect(node["foo"]["bar"]).to eql("NK-19V")
+        node.default_unless["foo"]["baz"] = "NK-33"
+        expect(node["foo"]["baz"]).to eql("NK-33")
+      end
+
+      it "normal_unless correctly resets the deep merge cache" do
+        node.normal["tags"] = []  # this sets our top-level breadcrumb
+        node.normal_unless["foo"]["bar"] = "NK-19V"
+        expect(node["foo"]["bar"]).to eql("NK-19V")
+        node.normal_unless["foo"]["baz"] = "NK-33"
+        expect(node["foo"]["baz"]).to eql("NK-33")
+      end
+
+      it "override_unless correctly resets the deep merge cache" do
+        node.normal["tags"] = []  # this sets our top-level breadcrumb
+        node.override_unless["foo"]["bar"] = "NK-19V"
+        expect(node["foo"]["bar"]).to eql("NK-19V")
+        node.override_unless["foo"]["baz"] = "NK-33"
+        expect(node["foo"]["baz"]).to eql("NK-33")
+      end
+    end
+
+    describe "override attributes" do
+      it "should be set with override, without pre-declaring a hash" do
+        node.override[:snoopy][:is_a_puppy] = true
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+
+      it "should allow you to set with override_unless without pre-declaring a hash" do
+        node.override_unless[:snoopy][:is_a_puppy] = false
+        expect(node[:snoopy][:is_a_puppy]).to eq(false)
+      end
+
+      it "should not allow you to set an attribute with override_unless if it already exists" do
+        node.override[:snoopy][:is_a_puppy] = true
+        node.override_unless[:snoopy][:is_a_puppy] = false
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+
+      it "should allow you to set a value after an override_unless" do
+        # this tests for set_unless_present state bleeding between statements CHEF-3806
+        node.override_unless[:snoopy][:is_a_puppy] = false
+        node.override[:snoopy][:is_a_puppy] = true
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+
+      it "should allow you to set a value after a 'dangling' override_unless" do
+        # this tests for set_unless_present state bleeding between statements CHEF-3806
+        node.override_unless[:snoopy][:is_a_puppy] = "what"
+        node.override_unless[:snoopy][:is_a_puppy]
+        node.override[:snoopy][:is_a_puppy] = true
+        expect(node[:snoopy][:is_a_puppy]).to eq(true)
+      end
+    end
+
+    describe "globally deleting attributes" do
+      context "with hash values" do
+        before do
+          node.role_default["mysql"]["server"]["port"] = 1234
+          node.normal["mysql"]["server"]["port"] = 2345
+          node.override["mysql"]["server"]["port"] = 3456
+        end
+
+        it "deletes all the values and returns the value with the highest precedence" do
+          expect( node.rm("mysql", "server", "port") ).to eql(3456)
+          expect( node["mysql"]["server"]["port"] ).to be_nil
+          expect( node["mysql"]["server"] ).to eql({})
+        end
+
+        it "deletes nested things correctly" do
+          node.default["mysql"]["client"]["client_setting"] = "foo"
+          expect( node.rm("mysql", "server") ).to eql( { "port" => 3456 } )
+          expect( node["mysql"] ).to eql( { "client" => { "client_setting" => "foo" } } )
+        end
+
+        it "returns nil if the node attribute does not exist" do
+          expect( node.rm("no", "such", "thing") ).to be_nil
+        end
+
+        it "can delete the entire tree" do
+          expect( node.rm("mysql") ).to eql({ "server" => { "port" => 3456 } })
+        end
+      end
+
+      context "when trying to delete through a thing that isn't an array-like or hash-like object" do
+        before do
+          node.default["mysql"] = true
+        end
+
+        it "returns nil when you're two levels deeper" do
+          expect( node.rm("mysql", "server", "port") ).to eql(nil)
+        end
+
+        it "returns nil when you're one level deeper" do
+          expect( node.rm("mysql", "server") ).to eql(nil)
+        end
+
+        it "correctly deletes at the top level" do
+          expect( node.rm("mysql") ).to eql(true)
+        end
+      end
+
+      context "with array indexes" do
+        before do
+          node.role_default["mysql"]["server"][0]["port"] = 1234
+          node.normal["mysql"]["server"][0]["port"] = 2345
+          node.override["mysql"]["server"][0]["port"] = 3456
+          node.override["mysql"]["server"][1]["port"] = 3456
+        end
+
+        it "deletes the array element" do
+          expect( node.rm("mysql", "server", 0, "port") ).to eql(3456)
+          expect( node["mysql"]["server"][0]["port"] ).to be_nil
+          expect( node["mysql"]["server"][1]["port"] ).to eql(3456)
+        end
+      end
+
+      context "with real arrays" do
+        before do
+          node.role_default["mysql"]["server"] = [ {
+            "port" => 1234,
+          } ]
+          node.normal["mysql"]["server"] = [ {
+            "port" => 2345,
+          } ]
+          node.override["mysql"]["server"] = [ {
+            "port" => 3456,
+          } ]
+        end
+
+        it "deletes the array element" do
+          expect( node.rm("mysql", "server", 0, "port") ).to eql(3456)
+          expect( node["mysql"]["server"][0]["port"] ).to be_nil
+        end
+
+        it "when mistaking arrays for hashes, it considers the value removed and does nothing" do
+          node.rm("mysql", "server", "port")
+          expect(node["mysql"]["server"][0]["port"]).to eql(3456)
+        end
+      end
+    end
+
+    describe "granular deleting attributes" do
+      context "when only defaults exist" do
+        before do
+          node.role_default["mysql"]["server"]["port"] = 1234
+          node.default["mysql"]["server"]["port"] = 2345
+          node.force_default["mysql"]["server"]["port"] = 3456
+        end
+
+        it "returns the deleted values" do
+          expect( node.rm_default("mysql", "server", "port") ).to eql(3456)
+        end
+
+        it "returns nil for the combined attributes" do
+          expect( node.rm_default("mysql", "server", "port") ).to eql(3456)
+          expect( node["mysql"]["server"]["port"] ).to eql(nil)
+        end
+
+        it "returns an empty hash for the default attrs" do
+          expect( node.rm_default("mysql", "server", "port") ).to eql(3456)
+          # this auto-vivifies, should it?
+          expect( node.default_attrs["mysql"]["server"]["port"] ).to eql({})
+        end
+
+        it "returns an empty hash after the last key is deleted" do
+          expect( node.rm_default("mysql", "server", "port") ).to eql(3456)
+          expect( node["mysql"]["server"] ).to eql({})
+        end
+      end
+
+      context "when trying to delete through a thing that isn't an array-like or hash-like object" do
+        before do
+          node.default["mysql"] = true
+        end
+
+        it "returns nil when you're two levels deeper" do
+          expect( node.rm_default("mysql", "server", "port") ).to eql(nil)
+        end
+
+        it "returns nil when you're one level deeper" do
+          expect( node.rm_default("mysql", "server") ).to eql(nil)
+        end
+
+        it "correctly deletes at the top level" do
+          expect( node.rm_default("mysql") ).to eql(true)
+        end
+      end
+
+      context "when a higher precedence exists" do
+        before do
+          node.role_default["mysql"]["server"]["port"] = 1234
+          node.default["mysql"]["server"]["port"] = 2345
+          node.force_default["mysql"]["server"]["port"] = 3456
+
+          node.override["mysql"]["server"]["port"] = 9999
+        end
+
+        it "returns the deleted values" do
+          expect( node.rm_default("mysql", "server", "port") ).to eql(3456)
+        end
+
+        it "returns the higher precedence values after the delete" do
+          expect( node.rm_default("mysql", "server", "port") ).to eql(3456)
+          expect( node["mysql"]["server"]["port"] ).to eql(9999)
+        end
+
+        it "returns an empty has for the default attrs" do
+          expect( node.rm_default("mysql", "server", "port") ).to eql(3456)
+          # this auto-vivifies, should it?
+          expect( node.default_attrs["mysql"]["server"]["port"] ).to eql({})
+        end
+      end
+
+      context "when a lower precedence exists" do
+        before do
+          node.default["mysql"]["server"]["port"] = 2345
+          node.override["mysql"]["server"]["port"] = 9999
+          node.role_override["mysql"]["server"]["port"] = 9876
+          node.force_override["mysql"]["server"]["port"] = 6669
+        end
+
+        it "returns the deleted values" do
+          expect( node.rm_override("mysql", "server", "port") ).to eql(6669)
+        end
+
+        it "returns the lower precedence levels after the delete" do
+          expect( node.rm_override("mysql", "server", "port") ).to eql(6669)
+          expect( node["mysql"]["server"]["port"] ).to eql(2345)
+        end
+
+        it "returns an empty has for the override attrs" do
+          expect( node.rm_override("mysql", "server", "port") ).to eql(6669)
+          # this auto-vivifies, should it?
+          expect( node.override_attrs["mysql"]["server"]["port"] ).to eql({})
+        end
+      end
+
+      it "rm_default returns nil on deleting non-existent values" do
+        expect( node.rm_default("no", "such", "thing") ).to be_nil
+      end
+
+      it "rm_normal returns nil on deleting non-existent values" do
+        expect( node.rm_normal("no", "such", "thing") ).to be_nil
+      end
+
+      it "rm_override returns nil on deleting non-existent values" do
+        expect( node.rm_override("no", "such", "thing") ).to be_nil
+      end
+    end
+
+    describe "granular replacing attributes" do
+      it "removes everything at the level of the last key" do
+        node.default["mysql"]["server"]["port"] = 2345
+
+        node.default!["mysql"]["server"] = { "data_dir" => "/my_raid_volume/lib/mysql" }
+
+        expect( node["mysql"]["server"] ).to eql({ "data_dir" => "/my_raid_volume/lib/mysql" })
+      end
+
+      it "replaces a value at the cookbook sub-level of the attributes only" do
+        node.default["mysql"]["server"]["port"] = 2345
+        node.default["mysql"]["server"]["service_name"] = "fancypants-sql"
+        node.role_default["mysql"]["server"]["port"] = 1234
+        node.force_default["mysql"]["server"]["port"] = 3456
+
+        node.default!["mysql"]["server"] = { "data_dir" => "/my_raid_volume/lib/mysql" }
+
+        expect( node["mysql"]["server"]["port"] ).to eql(3456)
+        expect( node["mysql"]["server"]["service_name"] ).to be_nil
+        expect( node["mysql"]["server"]["data_dir"] ).to eql("/my_raid_volume/lib/mysql")
+        expect( node["mysql"]["server"] ).to eql({ "port" => 3456, "data_dir" => "/my_raid_volume/lib/mysql" })
+      end
+
+      it "higher precedence values aren't removed" do
+        node.role_default["mysql"]["server"]["port"] = 1234
+        node.default["mysql"]["server"]["port"] = 2345
+        node.force_default["mysql"]["server"]["port"] = 3456
+        node.override["mysql"]["server"]["service_name"] = "fancypants-sql"
+
+        node.default!["mysql"]["server"] = { "data_dir" => "/my_raid_volume/lib/mysql" }
+
+        expect( node["mysql"]["server"]["port"] ).to eql(3456)
+        expect( node["mysql"]["server"]["data_dir"] ).to eql("/my_raid_volume/lib/mysql")
+        expect( node["mysql"]["server"] ).to eql({ "service_name" => "fancypants-sql", "port" => 3456, "data_dir" => "/my_raid_volume/lib/mysql" })
+      end
+    end
+
+    describe "granular force replacing attributes" do
+      it "removes everything at the level of the last key" do
+        node.force_default["mysql"]["server"]["port"] = 2345
+
+        node.force_default!["mysql"]["server"] = {
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        }
+
+        expect( node["mysql"]["server"] ).to eql({
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        })
+      end
+
+      it "removes all values from the precedence level when setting" do
+        node.role_default["mysql"]["server"]["port"] = 1234
+        node.default["mysql"]["server"]["port"] = 2345
+        node.force_default["mysql"]["server"]["port"] = 3456
+
+        node.force_default!["mysql"]["server"] = {
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        }
+
+        expect( node["mysql"]["server"]["port"] ).to be_nil
+        expect( node["mysql"]["server"]["data_dir"] ).to eql("/my_raid_volume/lib/mysql")
+        expect( node["mysql"]["server"] ).to eql({
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        })
+      end
+
+      it "higher precedence levels are not removed" do
+        node.role_default["mysql"]["server"]["port"] = 1234
+        node.default["mysql"]["server"]["port"] = 2345
+        node.force_default["mysql"]["server"]["port"] = 3456
+        node.override["mysql"]["server"]["service_name"] = "fancypants-sql"
+
+        node.force_default!["mysql"]["server"] = {
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        }
+
+        expect( node["mysql"]["server"]["port"] ).to be_nil
+        expect( node["mysql"]["server"]["data_dir"] ).to eql("/my_raid_volume/lib/mysql")
+        expect( node["mysql"]["server"] ).to eql({
+          "service_name" => "fancypants-sql",
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        })
+      end
+
+      it "will autovivify" do
+        node.force_default!["mysql"]["server"] = {
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        }
+        expect( node["mysql"]["server"]["data_dir"] ).to eql("/my_raid_volume/lib/mysql")
+      end
+
+      it "lower precedence levels aren't removed" do
+        node.role_override["mysql"]["server"]["port"] = 1234
+        node.override["mysql"]["server"]["port"] = 2345
+        node.force_override["mysql"]["server"]["port"] = 3456
+        node.default["mysql"]["server"]["service_name"] = "fancypants-sql"
+
+        node.force_override!["mysql"]["server"] = {
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        }
+
+        expect( node["mysql"]["server"]["port"] ).to be_nil
+        expect( node["mysql"]["server"]["data_dir"] ).to eql("/my_raid_volume/lib/mysql")
+        expect( node["mysql"]["server"] ).to eql({
+          "service_name" => "fancypants-sql",
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        })
+      end
+
+      it "when overwriting a non-hash/array" do
+        node.override["mysql"] = false
+        node.force_override["mysql"] = true
+        node.force_override!["mysql"]["server"] = {
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        }
+        expect( node["mysql"]["server"]["data_dir"] ).to eql("/my_raid_volume/lib/mysql")
+      end
+
+      it "when overwriting an array with a hash" do
+        node.force_override["mysql"][0] = true
+        node.force_override!["mysql"]["server"] = {
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        }
+        expect( node["mysql"]["server"] ).to eql({
+          "data_dir" => "/my_raid_volume/lib/mysql",
+        })
+      end
+    end
+
+    # In Chef-12.0 there is a deep_merge cache on the top level attribute which had a bug
+    # where it cached node[:foo] separate from node['foo'].  These tests exercise those edge conditions.
+    #
+    # https://github.com/chef/chef/issues/2700
+    # https://github.com/chef/chef/issues/2712
+    # https://github.com/chef/chef/issues/2745
+    #
+    describe "deep merge attribute cache edge conditions" do
+      it "does not error with complicated attribute substitution" do
+        node.default["chef_attribute_hell"]["attr1"] = "attribute1"
+        node.default["chef_attribute_hell"]["attr2"] = "#{node[:chef_attribute_hell][:attr1]}/attr2"
+        expect { node.default["chef_attribute_hell"]["attr3"] = "#{node[:chef_attribute_hell][:attr2]}/attr3" }.not_to raise_error
+      end
+
+      it "caches both strings and symbols correctly" do
+        node.force_default[:solr][:version] = "4.10.2"
+        node.force_default[:solr][:data_dir] = "/opt/solr-#{node["solr"][:version]}/example/solr"
+        node.force_default[:solr][:xms] = "512M"
+        expect(node[:solr][:xms]).to eql("512M")
+        expect(node["solr"][:xms]).to eql("512M")
+      end
+
+      it "method interpolation syntax also works" do
+        Chef::Config[:treat_deprecation_warnings_as_errors] = false
+        node.default["passenger"]["version"]     = "4.0.57"
+        node.default["passenger"]["root_path"]   = "passenger-#{node["passenger"]["version"]}"
+        node.default["passenger"]["root_path_2"] = "passenger-#{node[:passenger]["version"]}"
+        expect(node["passenger"]["root_path_2"]).to eql("passenger-4.0.57")
+        expect(node[:passenger]["root_path_2"]).to eql("passenger-4.0.57")
+      end
+    end
+
+    it "should raise an ArgumentError if you ask for an attribute that doesn't exist via method_missing" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
+      expect { node.sunshine }.to raise_error(NoMethodError)
+    end
+
+    it "should allow you to iterate over attributes with each_attribute" do
+      node.default["sunshine"] = "is bright"
+      node.default["canada"] = "is a nice place"
+      seen_attributes = {}
+      node.each_attribute do |a, v|
+        seen_attributes[a] = v
+      end
+      expect(seen_attributes).to have_key("sunshine")
+      expect(seen_attributes).to have_key("canada")
+      expect(seen_attributes["sunshine"]).to eq("is bright")
+      expect(seen_attributes["canada"]).to eq("is a nice place")
+    end
+
+    describe "functional attribute API" do
+      # deeper functional testing of this API is in the VividMash spec tests
+      it "should have an exist? function" do
+        node.default["foo"]["bar"] = "baz"
+        expect(node.exist?("foo", "bar")).to be true
+        expect(node.exist?("bar", "foo")).to be false
+      end
+
+      it "should have a read function" do
+        node.override["foo"]["bar"] = "baz"
+        expect(node.read("foo", "bar")).to eql("baz")
+        expect(node.read("bar", "foo")).to eql(nil)
+      end
+
+      it "should have a read! function" do
+        node.override["foo"]["bar"] = "baz"
+        expect(node.read!("foo", "bar")).to eql("baz")
+        expect { node.read!("bar", "foo") }.to raise_error(Chef::Exceptions::NoSuchAttribute)
+      end
+
+      it "delegates write(:level) to node.level.write()" do
+        node.write(:default, "foo", "bar", "baz")
+        expect(node.default["foo"]["bar"]).to eql("baz")
+      end
+
+      it "delegates write!(:level) to node.level.write!()" do
+        node.write!(:default, "foo", "bar", "baz")
+        expect(node.default["foo"]["bar"]).to eql("baz")
+        node.default["bar"] = true
+        expect { node.write!(:default, "bar", "foo", "baz") }.to raise_error(Chef::Exceptions::AttributeTypeMismatch)
+      end
+
+      it "delegates unlink(:level) to node.level.unlink()" do
+        node.default["foo"]["bar"] = "baz"
+        expect(node.unlink(:default, "foo", "bar")).to eql("baz")
+        expect(node.unlink(:default, "bar", "foo")).to eql(nil)
+      end
+
+      it "delegates unlink!(:level) to node.level.unlink!()" do
+        node.default["foo"]["bar"] = "baz"
+        expect(node.unlink!(:default, "foo", "bar")).to eql("baz")
+        expect { node.unlink!(:default, "bar", "foo") }.to raise_error(Chef::Exceptions::NoSuchAttribute)
+      end
+    end
+  end
+
+  describe "consuming json" do
+
+    before do
+      @ohai_data = { platform: "foo", platform_version: "bar" }
+    end
+
+    it "consumes the run list portion of a collection of attributes and returns the remainder" do
+      attrs = { "run_list" => [ "role[base]", "recipe[chef::server]" ], "foo" => "bar" }
+      expect(node.consume_run_list(attrs)).to eq({ "foo" => "bar" })
+      expect(node.run_list).to eq([ "role[base]", "recipe[chef::server]" ])
+    end
+
+    it "sets the node chef_environment" do
+      attrs = { "chef_environment" => "foo_environment", "bar" => "baz" }
+      expect(node.consume_chef_environment(attrs)).to eq({ "bar" => "baz" })
+      expect(node.chef_environment).to eq("foo_environment")
+      expect(node["chef_environment"]).to be nil
+    end
+
+    it "should overwrites the run list with the run list it consumes" do
+      node.consume_run_list "recipes" => %w{one two}
+      node.consume_run_list "recipes" => [ "three" ]
+      expect(node.run_list).to eq([ "three" ])
+    end
+
+    it "should not add duplicate recipes from the json attributes" do
+      node.run_list << "one"
+      node.consume_run_list "recipes" => %w{one two three}
+      expect(node.run_list).to eq(%w{one two three})
+    end
+
+    it "doesn't change the run list if no run_list is specified in the json" do
+      node.run_list << "role[database]"
+      node.consume_run_list "foo" => "bar"
+      expect(node.run_list).to eq(["role[database]"])
+    end
+
+    it "raises an exception if you provide both recipe and run_list attributes, since this is ambiguous" do
+      expect { node.consume_run_list "recipes" => "stuff", "run_list" => "other_stuff" }.to raise_error(Chef::Exceptions::AmbiguousRunlistSpecification)
+    end
+
+    it "should add json attributes to the node" do
+      node.consume_external_attrs(@ohai_data, { "one" => "two", "three" => "four" })
+      expect(node["one"]).to eql("two")
+      expect(node["three"]).to eql("four")
+    end
+
+    it "should set the tags attribute to an empty array if it is not already defined" do
+      node.consume_external_attrs(@ohai_data, {})
+      expect(node.tags).to eql([])
+    end
+
+    it "should not set the tags attribute to an empty array if it is already defined" do
+      node.tag("radiohead")
+      node.consume_external_attrs(@ohai_data, {})
+      expect(node.tags).to eql([ "radiohead" ])
+    end
+
+    it "should set the tags attribute to an empty array if it is nil" do
+      node.attributes.normal = { "tags" => nil }
+      node.consume_external_attrs(@ohai_data, {})
+      expect(node.tags).to eql([])
+    end
+
+    it "should return an array if it is fed a string" do
+      node.normal[:tags] = "string"
+      node.consume_external_attrs(@ohai_data, {})
+      expect(node.tags).to eql(["string"])
+    end
+
+    it "should return an array if it is fed a hash" do
+      node.normal[:tags] = {}
+      node.consume_external_attrs(@ohai_data, {})
+      expect(node.tags).to eql([])
+    end
+
+    it "deep merges attributes instead of overwriting them" do
+      node.consume_external_attrs(@ohai_data, "one" => { "two" => { "three" => "four" } })
+      expect(node["one"].to_hash).to eq({ "two" => { "three" => "four" } })
+      node.consume_external_attrs(@ohai_data, "one" => { "abc" => "123" })
+      node.consume_external_attrs(@ohai_data, "one" => { "two" => { "foo" => "bar" } })
+      expect(node["one"].to_hash).to eq({ "two" => { "three" => "four", "foo" => "bar" }, "abc" => "123" })
+    end
+
+    it "gives attributes from JSON priority when deep merging" do
+      node.consume_external_attrs(@ohai_data, "one" => { "two" => { "three" => "four" } })
+      expect(node["one"].to_hash).to eq({ "two" => { "three" => "four" } })
+      node.consume_external_attrs(@ohai_data, "one" => { "two" => { "three" => "forty-two" } })
+      expect(node["one"].to_hash).to eq({ "two" => { "three" => "forty-two" } })
+    end
+
+    it "converts the platform_version to a Chef::VersionString" do
+      node.consume_external_attrs(@ohai_data, {})
+      expect(node["platform_version"]).to be_kind_of(Chef::VersionString)
+    end
+  end
+
+  describe "merging ohai data" do
+    before do
+      @ohai_data = { platform: "foo", platform_version: "bar" }
+    end
+
+    it "converts the platform_version to a Chef::VersionString" do
+      node.consume_external_attrs(@ohai_data, {})
+      node.consume_ohai_data({ "platform_version" => "6.3" })
+      expect(node["platform_version"]).to be_kind_of(Chef::VersionString)
+      expect(node["platform_version"] =~ "~> 6.1").to be true
+    end
+  end
+
+  describe "preparing for a chef client run" do
+    before do
+      @ohai_data = { platform: "foobuntu", platform_version: "23.42" }
+    end
+
+    it "sets its platform according to platform detection" do
+      node.consume_external_attrs(@ohai_data, {})
+      expect(node.automatic_attrs[:platform]).to eq("foobuntu")
+      expect(node.automatic_attrs[:platform_version]).to eq("23.42")
+    end
+
+    it "consumes the run list from provided json attributes" do
+      node.consume_external_attrs(@ohai_data, { "run_list" => ["recipe[unicorn]"] })
+      expect(node.run_list).to eq(["recipe[unicorn]"])
+    end
+
+    it "saves non-runlist json attrs for later" do
+      expansion = Chef::RunList::RunListExpansion.new("_default", [])
+      allow(node.run_list).to receive(:expand).and_return(expansion)
+      node.consume_external_attrs(@ohai_data, { "foo" => "bar" })
+      node.expand!
+      expect(node.normal_attrs).to eq({ "foo" => "bar", "tags" => [] })
+    end
+
+    it "converts the platform_version to a Chef::VersionString" do
+      node.consume_external_attrs(@ohai_data, {})
+      expect(node.automatic_attrs[:platform_version]).to be_a_kind_of(Chef::VersionString)
+      expect(node[:platform_version]).to be_a_kind_of(Chef::VersionString)
+      expect(node[:platform_version] =~ "~> 23.6").to be true
+    end
+
+  end
+
+  describe "when expanding its run list and merging attributes" do
+    before do
+      @environment = Chef::Environment.new.tap do |e|
+        e.name("rspec_env")
+        e.default_attributes("env default key" => "env default value")
+        e.override_attributes("env override key" => "env override value")
+      end
+      expect(Chef::Environment).to receive(:load).with("rspec_env").and_return(@environment)
+      @expansion = Chef::RunList::RunListExpansion.new("rspec_env", [])
+      node.chef_environment("rspec_env")
+      allow(node.run_list).to receive(:expand).and_return(@expansion)
+    end
+
+    it "sets the 'recipes' automatic attribute to the recipes in the expanded run_list" do
+      @expansion.recipes << "recipe[chef::client]" << "recipe[nginx::default]"
+      node.expand!
+      expect(node.automatic_attrs[:recipes]).to eq(["recipe[chef::client]", "recipe[nginx::default]"])
+    end
+
+    it "sets the 'roles' automatic attribute to the expanded role list" do
+      @expansion.instance_variable_set(:@applied_roles, { "arf" => nil, "countersnark" => nil })
+      node.expand!
+      expect(node.automatic_attrs[:roles].sort).to eq(%w{arf countersnark})
+    end
+
+    it "applies default attributes from the environment as environment defaults" do
+      node.expand!
+      expect(node.attributes.env_default["env default key"]).to eq("env default value")
+    end
+
+    it "applies override attributes from the environment as env overrides" do
+      node.expand!
+      expect(node.attributes.env_override["env override key"]).to eq("env override value")
+    end
+
+    it "applies default attributes from roles as role defaults" do
+      @expansion.default_attrs["role default key"] = "role default value"
+      node.expand!
+      expect(node.attributes.role_default["role default key"]).to eq("role default value")
+    end
+
+    it "applies override attributes from roles as role overrides" do
+      @expansion.override_attrs["role override key"] = "role override value"
+      node.expand!
+      expect(node.attributes.role_override["role override key"]).to eq("role override value")
+    end
+  end
+
+  describe "loaded_recipe" do
+    it "should not add a recipe that is already in the recipes list" do
+      node.automatic_attrs[:recipes] = [ "nginx::module" ]
+      node.loaded_recipe(:nginx, "module")
+      expect(node.automatic_attrs[:recipes].length).to eq(1)
+    end
+
+    it "should add a recipe that is not already in the recipes list" do
+      node.automatic_attrs[:recipes] = [ "nginx::other_module" ]
+      node.loaded_recipe(:nginx, "module")
+      expect(node.automatic_attrs[:recipes].length).to eq(2)
+      expect(node.recipe?("nginx::module")).to be true
+      expect(node.recipe?("nginx::other_module")).to be true
+    end
+  end
+
+  describe "when querying for recipes in the run list" do
+    context "when a recipe is in the top level run list" do
+      before do
+        node.run_list << "recipe[nginx::module]"
+      end
+
+      it "finds the recipe" do
+        expect(node.recipe?("nginx::module")).to be true
+      end
+
+      it "does not find a recipe not in the run list" do
+        expect(node.recipe?("nginx::other_module")).to be false
+      end
+    end
+    context "when a recipe is in the expanded run list only" do
+      before do
+        node.run_list << "role[base]"
+        node.automatic_attrs[:recipes] = [ "nginx::module" ]
+      end
+
+      it "finds a recipe in the expanded run list" do
+        expect(node.recipe?("nginx::module")).to be true
+      end
+
+      it "does not find a recipe that's not in the run list" do
+        expect(node.recipe?("nginx::other_module")).to be false
+      end
+    end
+  end
+
+  describe "when clearing computed state at the beginning of a run" do
+    before do
+      node.default[:foo] = "default"
+      node.normal[:foo] = "normal"
+      node.override[:foo] = "override"
+      node.reset_defaults_and_overrides
+    end
+
+    it "removes default attributes" do
+      expect(node.default).to be_empty
+    end
+
+    it "removes override attributes" do
+      expect(node.override).to be_empty
+    end
+
+    it "leaves normal level attributes untouched" do
+      expect(node[:foo]).to eq("normal")
+    end
+
+  end
+
+  describe "when merging environment attributes" do
+    before do
+      node.chef_environment = "rspec"
+      @expansion = Chef::RunList::RunListExpansion.new("rspec", [])
+      @expansion.default_attrs.replace({ default: "from role", d_role: "role only" })
+      @expansion.override_attrs.replace({ override: "from role", o_role: "role only" })
+
+      @environment = Chef::Environment.new
+      @environment.default_attributes = { default: "from env", d_env: "env only" }
+      @environment.override_attributes = { override: "from env", o_env: "env only" }
+      allow(Chef::Environment).to receive(:load).and_return(@environment)
+      node.apply_expansion_attributes(@expansion)
+    end
+
+    it "does not nuke role-only default attrs" do
+      expect(node[:d_role]).to eq("role only")
+    end
+
+    it "does not nuke role-only override attrs" do
+      expect(node[:o_role]).to eq("role only")
+    end
+
+    it "does not nuke env-only default attrs" do
+      expect(node[:o_env]).to eq("env only")
+    end
+
+    it "does not nuke role-only override attrs" do
+      expect(node[:o_env]).to eq("env only")
+    end
+
+    it "gives role defaults precedence over env defaults" do
+      expect(node[:default]).to eq("from role")
+    end
+
+    it "gives env overrides precedence over role overrides" do
+      expect(node[:override]).to eq("from env")
+    end
+  end
+
+  describe "when evaluating attributes files" do
+    before do
+      @cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
+      @cookbook_loader = Chef::CookbookLoader.new(@cookbook_repo)
+      @cookbook_loader.load_cookbooks
+
+      @cookbook_collection = Chef::CookbookCollection.new(@cookbook_loader.cookbooks_by_name)
+
+      @events = Chef::EventDispatch::Dispatcher.new
+      @run_context = Chef::RunContext.new(node, @cookbook_collection, @events)
+
+      node.include_attribute("openldap::default")
+      node.include_attribute("openldap::smokey")
+    end
+
+    it "sets attributes from the files" do
+      expect(node["ldap_server"]).to eql("ops1prod")
+      expect(node["ldap_basedn"]).to eql("dc=hjksolutions,dc=com")
+      expect(node["ldap_replication_password"]).to eql("forsure")
+      expect(node["smokey"]).to eql("robinson")
+    end
+
+    it "gives a sensible error when attempting to load a missing attributes file" do
+      expect { node.include_attribute("nope-this::doesnt-exist") }.to raise_error(Chef::Exceptions::CookbookNotFound)
+    end
+  end
+
+  describe "roles" do
+    it "should allow you to query whether or not it has a recipe applied with role?" do
+      node.automatic["roles"] = %w{sunrise}
+      expect(node.role?("sunrise")).to eql(true)
+      expect(node.role?("not at home")).to eql(false)
+    end
+
+    it "should allow you to set roles with arguments" do
+      node.automatic["roles"] = %w{one two}
+      expect(node.role?("one")).to eql(true)
+      expect(node.role?("two")).to eql(true)
+      expect(node.role?("three")).to eql(false)
+    end
+  end
+
+  describe "run_list" do
+    it "should have a Chef::RunList of recipes and roles that should be applied" do
+      expect(node.run_list).to be_a_kind_of(Chef::RunList)
+    end
+
+    it "should allow you to query the run list with arguments" do
+      node.run_list "recipe[baz]"
+      expect(node.run_list?("recipe[baz]")).to eql(true)
+    end
+
+    it "should allow you to set the run list with arguments" do
+      node.run_list "recipe[baz]", "role[foo]"
+      expect(node.run_list?("recipe[baz]")).to eql(true)
+      expect(node.run_list?("role[foo]")).to eql(true)
+    end
+  end
+
+  describe "from file" do
+    it "should load a node from a ruby file" do
+      node.from_file(File.expand_path(File.join(CHEF_SPEC_DATA, "nodes", "test.rb")))
+      expect(node.name).to eql("test.example.com-short")
+      expect(node["sunshine"]).to eql("in")
+      expect(node["something"]).to eql("else")
+      expect(node.run_list).to eq(%w{operations-master operations-monitoring})
+    end
+
+    it "should raise an exception if the file cannot be found or read" do
+      expect { node.from_file("/tmp/monkeydiving") }.to raise_error(IOError)
+    end
+  end
+
+  describe "update_from!" do
+    before(:each) do
+      node.name("orig")
+      node.chef_environment("dev")
+      node.default_attrs = { "one" => { "two" => "three", "four" => "five", "eight" => "nine" } }
+      node.override_attrs = { "one" => { "two" => "three", "four" => "six" } }
+      node.normal_attrs = { "one" => { "two" => "seven" } }
+      node.run_list << "role[marxist]"
+      node.run_list << "role[leninist]"
+      node.run_list << "recipe[stalinist]"
+
+      @example = Chef::Node.new
+      @example.name("newname")
+      @example.chef_environment("prod")
+      @example.default_attrs = { "alpha" => { "bravo" => "charlie", "delta" => "echo" } }
+      @example.override_attrs = { "alpha" => { "bravo" => "foxtrot", "delta" => "golf" } }
+      @example.normal_attrs = { "alpha" => { "bravo" => "hotel" } }
+      @example.run_list << "role[comedy]"
+      @example.run_list << "role[drama]"
+      @example.run_list << "recipe[mystery]"
+    end
+
+    it "allows update of everything except name" do
+      node.update_from!(@example)
+      expect(node.name).to eq("orig")
+      expect(node.chef_environment).to eq(@example.chef_environment)
+      expect(node.default_attrs).to eq(@example.default_attrs)
+      expect(node.override_attrs).to eq(@example.override_attrs)
+      expect(node.normal_attrs).to eq(@example.normal_attrs)
+      expect(node.run_list).to eq(@example.run_list)
+    end
+
+    it "should not update the name of the node" do
+      expect(node).not_to receive(:name).with(@example.name)
+      node.update_from!(@example)
+    end
+  end
+
+  describe "to_hash" do
+    it "should serialize itself as a hash" do
+      node.chef_environment("dev")
+      node.default_attrs = { "one" => { "two" => "three", "four" => "five", "eight" => "nine" } }
+      node.override_attrs = { "one" => { "two" => "three", "four" => "six" } }
+      node.normal_attrs = { "one" => { "two" => "seven" } }
+      node.run_list << "role[marxist]"
+      node.run_list << "role[leninist]"
+      node.run_list << "recipe[stalinist]"
+      h = node.to_hash
+      expect(h["one"]["two"]).to eq("three")
+      expect(h["one"]["four"]).to eq("six")
+      expect(h["one"]["eight"]).to eq("nine")
+      expect(h["role"]).to be_include("marxist")
+      expect(h["role"]).to be_include("leninist")
+      expect(h["run_list"]).to be_include("role[marxist]")
+      expect(h["run_list"]).to be_include("role[leninist]")
+      expect(h["run_list"]).to be_include("recipe[stalinist]")
+      expect(h["chef_environment"]).to eq("dev")
+    end
+
+    it "should return an empty array for empty run_list" do
+      expect(node.to_hash["run_list"]).to eq([])
+    end
+  end
+
+  describe "converting to or from json" do
+    it "should serialize itself as json", json: true do
+      node.from_file(File.expand_path("nodes/test.example.com.rb", CHEF_SPEC_DATA))
+      json = Chef::JSONCompat.to_json(node)
+      expect(json).to match(/json_class/)
+      expect(json).to match(/name/)
+      expect(json).to match(/chef_environment/)
+      expect(json).to match(/normal/)
+      expect(json).to match(/default/)
+      expect(json).to match(/override/)
+      expect(json).to match(/run_list/)
+    end
+
+    it "should serialize valid json with a run list", json: true do
+      # This test came about because activesupport mucks with Chef json serialization
+      # Test should pass with and without Activesupport
+      node.run_list << { "type" => "role", "name" => "Cthulu" }
+      node.run_list << { "type" => "role", "name" => "Hastur" }
+      json = Chef::JSONCompat.to_json(node)
+      expect(json).to match(/\"run_list\":\[\"role\[Cthulu\]\",\"role\[Hastur\]\"\]/)
+    end
+
+    it "should serialize the correct run list", json: true do
+      node.run_list << "role[marxist]"
+      node.run_list << "role[leninist]"
+      node.override_runlist << "role[stalinist]"
+      expect(node.run_list).to be_include("role[stalinist]")
+      json = Chef::JSONCompat.to_json(node)
+      expect(json).to match(/\"run_list\":\[\"role\[marxist\]\",\"role\[leninist\]\"\]/)
+    end
+
+    it "merges the override components into a combined override object" do
+      node.attributes.role_override["role override"] = "role override"
+      node.attributes.env_override["env override"] = "env override"
+      node_for_json = node.for_json
+      expect(node_for_json["override"]["role override"]).to eq("role override")
+      expect(node_for_json["override"]["env override"]).to eq("env override")
+    end
+
+    it "merges the default components into a combined default object" do
+      node.attributes.role_default["role default"] = "role default"
+      node.attributes.env_default["env default"] = "env default"
+      node_for_json = node.for_json
+      expect(node_for_json["default"]["role default"]).to eq("role default")
+      expect(node_for_json["default"]["env default"]).to eq("env default")
+    end
+
+    it "should deserialize itself from json", json: true do
+      node.from_file(File.expand_path("nodes/test.example.com.rb", CHEF_SPEC_DATA))
+      json = Chef::JSONCompat.to_json(node)
+      serialized_node = Chef::Node.from_hash(Chef::JSONCompat.parse(json))
+      expect(serialized_node).to be_a_kind_of(Chef::Node)
+      expect(serialized_node.name).to eql(node.name)
+      expect(serialized_node.chef_environment).to eql(node.chef_environment)
+      node.each_attribute do |k, v|
+        expect(serialized_node[k]).to eql(v)
+      end
+      expect(serialized_node.run_list).to eq(node.run_list)
+    end
+
+    context "when policyfile attributes are not present" do
+
+      it "does not have a policy_name key in the json" do
+        expect(node.for_json.keys).to_not include("policy_name")
+      end
+
+      it "does not have a policy_group key in the json" do
+        expect(node.for_json.keys).to_not include("policy_name")
+      end
+    end
+
+    context "when policyfile attributes are present" do
+
+      before do
+        node.policy_name = "my-application"
+        node.policy_group = "staging"
+      end
+
+      it "includes policy_name key in the json" do
+        expect(node.for_json).to have_key("policy_name")
+        expect(node.for_json["policy_name"]).to eq("my-application")
+      end
+
+      it "includes a policy_group key in the json" do
+        expect(node.for_json).to have_key("policy_group")
+        expect(node.for_json["policy_group"]).to eq("staging")
+      end
+
+      it "parses policyfile attributes from JSON" do
+        round_tripped_node = Chef::Node.from_hash(node.for_json)
+
+        expect(round_tripped_node.policy_name).to eq("my-application")
+        expect(round_tripped_node.policy_group).to eq("staging")
+        expect(round_tripped_node.chef_environment).to eq("staging")
+      end
+
+    end
+
+    include_examples "to_json equivalent to Chef::JSONCompat.to_json" do
+      let(:jsonable) do
+        node.from_file(File.expand_path("nodes/test.example.com.rb", CHEF_SPEC_DATA))
+        node
+      end
+    end
+  end
+
+  describe "to_s" do
+    it "should turn into a string like node[name]" do
+      node.name("airplane")
+      expect(node.to_s).to eql("node[airplane]")
+    end
+  end
+
+  describe "api model" do
+    before(:each) do
+      @rest = double("Chef::ServerAPI")
+      allow(Chef::ServerAPI).to receive(:new).and_return(@rest)
+      @query = double("Chef::Search::Query")
+      allow(Chef::Search::Query).to receive(:new).and_return(@query)
+    end
+
+    describe "list" do
+      describe "inflated" do
+        it "should return a hash of node names and objects" do
+          n1 = double("Chef::Node", name: "one")
+          allow(n1).to receive(:is_a?).with(Chef::Node) { true }
+          expect(@query).to receive(:search).with(:node).and_yield(n1)
+          r = Chef::Node.list(true)
+          expect(r["one"]).to eq(n1)
+        end
+      end
+
+      it "should return a hash of node names and urls" do
+        expect(@rest).to receive(:get).and_return({ "one" => "http://foo" })
+        r = Chef::Node.list
+        expect(r["one"]).to eq("http://foo")
+      end
+    end
+
+    describe "load" do
+      it "should load a node by name" do
+        node.from_file(File.expand_path("nodes/test.example.com.rb", CHEF_SPEC_DATA))
+        json = Chef::JSONCompat.to_json(node)
+        parsed = Chef::JSONCompat.parse(json)
+        expect(@rest).to receive(:get).with("nodes/test.example.com").and_return(parsed)
+        serialized_node = Chef::Node.load("test.example.com")
+        expect(serialized_node).to be_a_kind_of(Chef::Node)
+        expect(serialized_node.name).to eql(node.name)
+      end
+    end
+
+    describe "destroy" do
+      it "should destroy a node" do
+        expect(@rest).to receive(:delete).with("nodes/monkey").and_return("foo")
+        node.name("monkey")
+        node.destroy
+      end
+    end
+
+    describe "save" do
+      it "should update a node if it already exists" do
+        node.name("monkey")
+        allow(node).to receive(:data_for_save).and_return({})
+        expect(@rest).to receive(:put).with("nodes/monkey", {}).and_return("foo")
+        node.save
+      end
+
+      it "should not try and create if it can update" do
+        node.name("monkey")
+        allow(node).to receive(:data_for_save).and_return({})
+        expect(@rest).to receive(:put).with("nodes/monkey", {}).and_return("foo")
+        expect(@rest).not_to receive(:post)
+        node.save
+      end
+
+      it "should create if it cannot update" do
+        node.name("monkey")
+        allow(node).to receive(:data_for_save).and_return({})
+        exception = double("404 error", code: "404")
+        expect(@rest).to receive(:put).and_raise(Net::HTTPClientException.new("foo", exception))
+        expect(@rest).to receive(:post).with("nodes", {})
+        node.save
+      end
+
+      describe "when whyrun mode is enabled" do
+        before do
+          Chef::Config[:why_run] = true
+        end
+        after do
+          Chef::Config[:why_run] = false
+        end
+        it "should not save" do
+          node.name("monkey")
+          expect(@rest).not_to receive(:put)
+          expect(@rest).not_to receive(:post)
+          node.save
+        end
+      end
+
+      context "with allowed attributes configured" do
+        it "should only save allowed attributes (and subattributes)" do
+          Chef::Config[:allowed_default_attributes] = [
+            ["filesystem", "/dev/disk0s2"],
+            "network/interfaces/eth0",
+          ]
+
+          node.default = {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                  "eth1" => {},
+                },
+              },
+            }
+          node.automatic = {}
+          node.normal = {}
+          node.override = {}
+
+          selected_data = {
+            "default" => {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                },
+              },
+            },
+            "automatic" => {}, "normal" => {}, "override" => {}
+          }
+
+          node.name("picky-monkey")
+          expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
+          node.save
+        end
+
+        it "should save false-y allowed attributes" do
+          Chef::Config[:allowed_default_attributes] = [
+            "foo/bar/baz",
+          ]
+
+          node.default = {
+              "foo" => {
+                "bar" => {
+                  "baz" => false,
+                },
+                "other" => {
+                  "stuff" => true,
+                },
+              },
+            }
+
+          node.automatic = {}
+          node.normal = {}
+          node.override = {}
+
+          selected_data = {
+            "default" => {
+              "foo" => {
+                "bar" => {
+                  "baz" => false,
+                },
+              },
+            },
+          }
+
+          node.name("falsey-monkey")
+          expect(@rest).to receive(:put).with("nodes/falsey-monkey", hash_including(selected_data)).and_return("foo")
+          node.save
+        end
+
+        it "should not save any attributes if the allowed is empty" do
+          Chef::Config[:allowed_default_attributes] = []
+
+          node.default = {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" },
+              },
+            }
+          node.automatic = {}
+          node.normal = {}
+          node.override = {}
+
+          selected_data = {
+            "automatic" => {}, "default" => {}, "normal" => {}, "override" => {}
+          }
+
+          node.name("picky-monkey")
+          expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
+          node.save
+        end
+      end
+
+      context "with deprecated whitelist attributes configured" do
+        it "should only save allowed attributes (and subattributes)" do
+          Chef::Config[:default_attribute_whitelist] = [
+            ["filesystem", "/dev/disk0s2"],
+            "network/interfaces/eth0",
+          ]
+
+          node.default = {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                  "eth1" => {},
+                },
+              },
+            }
+          node.automatic = {}
+          node.normal = {}
+          node.override = {}
+
+          selected_data = {
+            "default" => {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                },
+              },
+            },
+            "automatic" => {}, "normal" => {}, "override" => {}
+          }
+
+          node.name("picky-monkey")
+          Chef::Config[:treat_deprecation_warnings_as_errors] = false
+          expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
+          node.save
+        end
+      end
+
+      context "with deprecated blacklist attributes configured" do
+        it "should only save non-blocklisted attributes (and subattributes)" do
+          Chef::Config[:default_attribute_blacklist] = [
+            ["filesystem", "/dev/disk0s2"],
+            "network/interfaces/eth0",
+          ]
+
+          node.default = {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                  "eth1" => {},
+                },
+              },
+            }
+          node.automatic = {}
+          node.normal = {}
+          node.override = {}
+
+          selected_data = {
+            "default" => {
+              "filesystem" => {
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth1" => {},
+                },
+              },
+            },
+            "automatic" => {}, "normal" => {}, "override" => {}
+          }
+          node.name("picky-monkey")
+          Chef::Config[:treat_deprecation_warnings_as_errors] = false
+          expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
+          node.save
+        end
+      end
+
+      context "with blocklisted attributes configured" do
+        it "should only save non-blocklisted attributes (and subattributes)" do
+          Chef::Config[:blocked_default_attributes] = [
+            ["filesystem", "/dev/disk0s2"],
+            "network/interfaces/eth0",
+          ]
+
+          node.default = {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                  "eth1" => {},
+                },
+              },
+            }
+          node.automatic = {}
+          node.normal = {}
+          node.override = {}
+
+          selected_data = {
+            "default" => {
+              "filesystem" => {
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth1" => {},
+                },
+              },
+            },
+            "automatic" => {}, "normal" => {}, "override" => {}
+          }
+          node.name("picky-monkey")
+          expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
+          node.save
+        end
+
+        it "should save all attributes if the blocklist is empty" do
+          Chef::Config[:blocked_default_attributes] = []
+
+          node.default = {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" },
+              },
+            }
+          node.automatic = {}
+          node.normal = {}
+          node.override = {}
+
+          selected_data = {
+            "default" => {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" },
+              },
+            },
+            "automatic" => {}, "normal" => {}, "override" => {}
+          }
+
+          node.name("picky-monkey")
+          expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
+          node.save
+        end
+      end
+
+      context "when policyfile attributes are present" do
+
+        before do
+          node.name("example-node")
+          node.policy_name = "my-application"
+          node.policy_group = "staging"
+        end
+
+        context "and the server supports policyfile attributes in node JSON" do
+
+          it "creates the object normally" do
+            expect(@rest).to receive(:post).with("nodes", node.for_json)
+            node.create
+          end
+
+          it "saves the node object normally" do
+            expect(@rest).to receive(:put).with("nodes/example-node", node.for_json)
+            node.save
+          end
+        end
+
+        # Chef Server before 12.3
+        context "and the Chef Server does not support policyfile attributes in node JSON" do
+
+          let(:response_body) { %q[{"error":["Invalid key policy_name in request body"]}] }
+
+          let(:response) do
+            Net::HTTPResponse.send(:response_class, "400").new("1.0", "400", "Bad Request").tap do |r|
+              allow(r).to receive(:body).and_return(response_body)
+            end
+          end
+
+          let(:http_exception) do
+
+            response.error!
+          rescue => e
+            e
+
+          end
+
+          let(:trimmed_node) do
+            node.for_json.tap do |j|
+              j.delete("policy_name")
+              j.delete("policy_group")
+            end
+
+          end
+
+          it "lets the 400 pass through" do
+            expect(@rest).to receive(:put).and_raise(http_exception)
+            expect { node.save }.to raise_error(http_exception)
+          end
+
+        end
+
+      end
+
+    end
+  end
+
+  describe "method_missing handling" do
+    it "should have an #empty? method via Chef::Node::Attribute" do
+      node.default["foo"] = "bar"
+      expect(node.empty?).to be false
+    end
+
+    it "it should correctly implement #respond_to?" do
+      expect(node.respond_to?(:empty?)).to be true
+    end
+
+    it "it should correctly retrieve the method with #method" do
+      expect(node.method(:empty?)).to be_kind_of(Method)
+    end
+  end
+
+  describe "path tracking via __path__" do
+    it "works through hash keys" do
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      expect(node["foo"]["bar"].__path__).to eql(%w{foo bar})
+    end
+
+    it "works through the default level" do
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      expect(node.default["foo"]["bar"].__path__).to eql(%w{foo bar})
+    end
+
+    it "works through arrays" do
+      node.default["foo"] = [ { "bar" => { "baz" => "qux" } } ]
+      expect(node["foo"][0].__path__).to eql(["foo", 0])
+      expect(node["foo"][0]["bar"].__path__).to eql(["foo", 0, "bar"])
+    end
+
+    it "works through arrays at the default level" do
+      node.default["foo"] = [ { "bar" => { "baz" => "qux" } } ]
+      expect(node.default["foo"][0].__path__).to eql(["foo", 0])
+      expect(node.default["foo"][0]["bar"].__path__).to eql(["foo", 0, "bar"])
+    end
+
+    # if we set __path__ in the initializer we'd get this wrong, this is why we
+    # update the path on every #[] or #[]= operator
+    it "works on access when the node has been rearranged" do
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      a = node.default["foo"]
+      node.default["fizz"] = a
+      expect(node["fizz"]["bar"].__path__).to eql(%w{fizz bar})
+      expect(node["foo"]["bar"].__path__).to eql(%w{foo bar})
+    end
+
+    # We have a problem because the __path__ is stored on in each node, but the
+    # node can be wired up at multiple locations in the tree via pointers.  One
+    # solution would be to deep-dup the value in `#[]=(key, value)` and fix the
+    # __path__ on all the dup'd nodes.  The problem is that this would create an
+    # unusual situation where after assignment, you couldn't mutate the thing you
+    # hand a handle on.  I'm not entirely positive this behavior is the correct
+    # thing to support, but it is more hash-like (although if we start with a hash
+    # then convert_value does its thing and we *do* get dup'd on assignment).  This
+    # behavior likely makes any implementation of a deep merge cache built over the
+    # top of __path__ tracking have edge conditions where it will fail.
+    #
+    # Removing this support would be a breaking change.  The test is included here
+    # because it seems most likely that someone would break this behavior while trying
+    # to fix __path__ behavior.
+    it "does not dup in the background when a node is assigned" do
+      # get a handle on a vividmash (can't be a hash or else we convert_value it)
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      a = node.default["foo"]
+      # assign that somewhere else in the tree
+      node.default["fizz"] = a
+      # now update the source
+      a["duptest"] = true
+      # the tree should have been updated
+      expect(node.default["fizz"]["duptest"]).to be true
+      expect(node["fizz"]["duptest"]).to be true
+    end
+  end
+
+  describe "root tracking via __root__" do
+    it "works through hash keys" do
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      expect(node["foo"]["bar"].__root__).to eql(node.attributes)
+    end
+
+    it "works through the default level" do
+      node.default["foo"] = { "bar" => { "baz" => "qux" } }
+      expect(node.default["foo"]["bar"].__root__).to eql(node.attributes)
+    end
+
+    it "works through arrays" do
+      node.default["foo"] = [ { "bar" => { "baz" => "qux" } } ]
+      expect(node["foo"][0].__root__).to eql(node.attributes)
+      expect(node["foo"][0]["bar"].__root__).to eql(node.attributes)
+    end
+
+    it "works through arrays at the default level" do
+      node.default["foo"] = [ { "bar" => { "baz" => "qux" } } ]
+      expect(node.default["foo"][0].__root__).to eql(node.attributes)
+      expect(node.default["foo"][0]["bar"].__root__).to eql(node.attributes)
+    end
+  end
+
+  describe "ways of abusing Chef 12 node state" do
+    # these tests abuse the top_level_breadcrumb state in Chef 12
+    it "derived attributes work correctly" do
+      node.default["v1"] = 1
+      expect(node["a"]).to eql(nil)
+      node.default["a"] = node["v1"]
+      expect(node["a"]).to eql(1)
+    end
+
+    it "works when saving nodes to variables" do
+      a = node.default["a"]
+      expect(node["a"]).to eql({})
+      node.default["b"] = 0
+      a["key"] = 1
+
+      expect(node["a"]["key"]).to eql(1)
+    end
+  end
+
+  describe "when abusing the deep merge cache" do
+    # https://github.com/chef/chef/issues/7738
+    it "do not corrupt VividMashes that are part of the merge set and not the merge_onto set" do
+      # need to have a merge two-deep (not at the top-level) between at least two default (or two override)
+      # levels where the lowest priority one is the one that is going to be corrupted
+      node.default["foo"]["bar"]["baz"] = "fizz"
+      node.env_default["foo"]["bar"]["quux"] = "buzz"
+      node.default["foo"]["bar"].tap do |bar|
+        bar["test"] = "wrong"
+        # this triggers a deep merge
+        node["foo"]["bar"]["test"]
+        # this should correctly write and dirty the cache so the next read does another deep merge on the correct __root__
+        bar["test"] = "right"
+      end
+      expect(node["foo"]["bar"]["test"]).to eql("right")
+    end
+
+    it "do not corrupt VividMashes that are part of the merge set and not the merge_onto set (when priorities are reversed)" do
+      # need to have a merge two-deep (not at the top-level) between at least two default (or two override)
+      # levels where the *HIGHEST* priority one is the one that is going to be corrupted
+      node.env_default["foo"]["bar"]["baz"] = "fizz"
+      node.default["foo"]["bar"]["quux"] = "buzz"
+      node.env_default["foo"]["bar"].tap do |bar|
+        bar["test"] = "wrong"
+        # this triggers a deep merge
+        node["foo"]["bar"]["test"]
+        # this should correctly write and dirty the cache so the next read does another deep merge on the correct __root__
+        bar["test"] = "right"
+      end
+      expect(node["foo"]["bar"]["test"]).to eql("right")
+    end
+  end
+
+  describe "lazy values" do
+    it "supports lazy values in attributes" do
+      node.instance_eval do
+        default["foo"]["bar"] = lazy { node["fizz"]["buzz"] }
+        default["fizz"]["buzz"] = "works"
+      end
+      expect(node["foo"]["bar"]).to eql("works")
+    end
+
+    it "lazy values maintain laziness" do
+      node.instance_eval do
+        default["foo"]["bar"] = lazy { node["fizz"]["buzz"] }
+        default["fizz"]["buzz"] = "works"
+      end
+      expect(node["foo"]["bar"]).to eql("works")
+      node.default["fizz"]["buzz"] = "still works"
+      expect(node["foo"]["bar"]).to eql("still works")
+    end
+
+    it "supports recursive lazy values in attributes" do
+      node.instance_eval do
+        default["cool"]["beans"] = lazy { node["foo"]["bar"] }
+        default["foo"]["bar"] = lazy { node["fizz"]["buzz"] }
+        default["fizz"]["buzz"] = "works"
+      end
+      expect(node["cool"]["beans"]).to eql("works")
+      node.default["fizz"]["buzz"] = "still works"
+      expect(node["cool"]["beans"]).to eql("still works")
+    end
+
+    it "supports top level lazy values in attributes" do
+      # due to the top level deep merge cache these are special cases
+      node.instance_eval do
+        default["cool"] = lazy { node["foo"] }
+        default["foo"] = lazy { node["fizz"] }
+        default["fizz"] = "works"
+      end
+      expect(node["cool"]).to eql("works")
+      node.default["fizz"] = "still works"
+      expect(node["cool"]).to eql("still works")
+    end
+
+    it "supports deep merged values in attributes" do
+      node.instance_eval do
+        override["bar"]["cool"] = lazy { node["bar"]["foo"] }
+        override["bar"]["foo"] = lazy { node["bar"]["fizz"] }
+        override["bar"]["fizz"] = "works"
+      end
+      expect(node["bar"]["cool"]).to eql("works")
+      node.override["bar"]["fizz"] = "still works"
+      expect(node["bar"]["cool"]).to eql("still works")
+    end
+
+    it "supports overridden deep merged values in attributes (deep_merge)" do
+      node.instance_eval do
+        role_override["bar"] = { "cool" => "bad", "foo" => "bad", "fizz" => "bad" }
+        force_override["bar"]["cool"] = lazy { node["bar"]["foo"] }
+        force_override["bar"]["foo"] = lazy { node["bar"]["fizz"] }
+        force_override["bar"]["fizz"] = "works"
+      end
+      expect(node["bar"]["cool"]).to eql("works")
+      node.force_override["bar"]["fizz"] = "still works"
+      expect(node["bar"]["cool"]).to eql("still works")
+    end
+
+    it "supports overridden deep merged values in attributes (hash_only_merge)" do
+      node.instance_eval do
+        default["bar"] = { "cool" => "bad", "foo" => "bad", "fizz" => "bad" }
+        override["bar"]["cool"] = lazy { node["bar"]["foo"] }
+        override["bar"]["foo"] = lazy { node["bar"]["fizz"] }
+        override["bar"]["fizz"] = "works"
+      end
+      expect(node["bar"]["cool"]).to eql("works")
+      node.override["bar"]["fizz"] = "still works"
+      expect(node["bar"]["cool"]).to eql("still works")
+    end
+  end
+end