#
# 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 "should let you use untag as a convince method for the tags attribute" do
        node.normal["tags"] = %w{one two three four}
        node.untag("three", "four")
        expect(node["tags"]).to eq(%w{one two})
      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
