chef 12.11.18-universal-mingw32 → 12.12.13-universal-mingw32

data/spec/unit/data_collector_spec.rb

@@ -20,6 +20,7 @@
 
 require "spec_helper"
 require "chef/data_collector"
+require "chef/resource_builder"
 
 describe Chef::DataCollector do
   describe ".register_reporter?" do
@@ -193,10 +194,32 @@ describe Chef::DataCollector::Reporter do
     end
   end
 
+  describe '#converge_start' do
+    it "stashes the run_context for later use" do
+      reporter.converge_start("test_context")
+      expect(reporter.run_context).to eq("test_context")
+    end
+  end
+
+  describe '#converge_complete' do
+    it "detects and processes any unprocessed resources" do
+      expect(reporter).to receive(:detect_unprocessed_resources)
+      reporter.converge_complete
+    end
+  end
+
+  describe '#converge_failed' do
+    it "detects and processes any unprocessed resources" do
+      expect(reporter).to receive(:detect_unprocessed_resources)
+      reporter.converge_failed("exception")
+    end
+  end
+
   describe '#resource_current_state_loaded' do
     let(:new_resource)     { double("new_resource") }
     let(:action)           { double("action") }
     let(:current_resource) { double("current_resource") }
+    let(:resource_report)  { double("resource_report") }
 
     context "when resource is a nested resource" do
       it "does not update the resource report" do
@@ -207,14 +230,12 @@ describe Chef::DataCollector::Reporter do
     end
 
     context "when resource is not a nested resource" do
-      it "updates the resource report" do
+      it "creates the resource report and stores it as the current one" do
         allow(reporter).to receive(:nested_resource?).and_return(false)
-        expect(Chef::DataCollector::ResourceReport).to receive(:new).with(
-          new_resource,
-          action,
-          current_resource)
-        .and_return("resource_report")
-        expect(reporter).to receive(:update_current_resource_report).with("resource_report")
+        expect(reporter).to receive(:create_resource_report)
+          .with(new_resource, action, current_resource)
+          .and_return(resource_report)
+        expect(reporter).to receive(:update_current_resource_report).with(resource_report)
         reporter.resource_current_state_loaded(new_resource, action, current_resource)
       end
     end
@@ -226,17 +247,11 @@ describe Chef::DataCollector::Reporter do
     let(:resource_report) { double("resource_report") }
 
     before do
-      allow(reporter).to receive(:increment_resource_count)
       allow(reporter).to receive(:nested_resource?)
       allow(reporter).to receive(:current_resource_report).and_return(resource_report)
       allow(resource_report).to receive(:up_to_date)
     end
 
-    it "increments the resource count" do
-      expect(reporter).to receive(:increment_resource_count)
-      reporter.resource_up_to_date(new_resource, action)
-    end
-
     context "when the resource is a nested resource" do
       it "does not mark the resource report as up-to-date" do
         allow(reporter).to receive(:nested_resource?).with(new_resource).and_return(true)
@@ -261,17 +276,11 @@ describe Chef::DataCollector::Reporter do
     let(:resource_report) { double("resource_report") }
 
     before do
-      allow(reporter).to receive(:increment_resource_count)
       allow(reporter).to receive(:nested_resource?)
-      allow(reporter).to receive(:current_resource_report).and_return(resource_report)
+      allow(reporter).to receive(:create_resource_report).and_return(resource_report)
       allow(resource_report).to receive(:skipped)
     end
 
-    it "increments the resource count" do
-      expect(reporter).to receive(:increment_resource_count)
-      reporter.resource_skipped(new_resource, action, conditional)
-    end
-
     context "when the resource is a nested resource" do
       it "does not mark the resource report as skipped" do
         allow(reporter).to receive(:nested_resource?).with(new_resource).and_return(true)
@@ -281,13 +290,12 @@ describe Chef::DataCollector::Reporter do
     end
 
     context "when the resource is not a nested resource" do
-      it "updates the resource report" do
+      it "creates the resource report and stores it as the current one" do
         allow(reporter).to receive(:nested_resource?).and_return(false)
-        expect(Chef::DataCollector::ResourceReport).to receive(:new).with(
-          new_resource,
-          action)
-        .and_return("resource_report")
-        expect(reporter).to receive(:update_current_resource_report).with("resource_report")
+        expect(reporter).to receive(:create_resource_report)
+          .with(new_resource, action)
+          .and_return(resource_report)
+        expect(reporter).to receive(:update_current_resource_report).with(resource_report)
         reporter.resource_skipped(new_resource, action, conditional)
       end
 
@@ -307,11 +315,6 @@ describe Chef::DataCollector::Reporter do
       allow(resource_report).to receive(:updated)
     end
 
-    it "increments the resource count" do
-      expect(reporter).to receive(:increment_resource_count)
-      reporter.resource_updated("new_resource", "action")
-    end
-
     it "marks the resource report as updated" do
       expect(resource_report).to receive(:updated)
       reporter.resource_updated("new_resource", "action")
@@ -326,7 +329,6 @@ describe Chef::DataCollector::Reporter do
     let(:resource_report) { double("resource_report") }
 
     before do
-      allow(reporter).to receive(:increment_resource_count)
       allow(reporter).to receive(:update_error_description)
       allow(reporter).to receive(:current_resource_report).and_return(resource_report)
       allow(resource_report).to receive(:failed)
@@ -334,11 +336,6 @@ describe Chef::DataCollector::Reporter do
       allow(error_mapper).to receive(:for_json)
     end
 
-    it "increments the resource count" do
-      expect(reporter).to receive(:increment_resource_count)
-      reporter.resource_failed(new_resource, action, exception)
-    end
-
     it "updates the error description" do
       expect(Chef::Formatters::ErrorMapper).to receive(:resource_failed).with(
         new_resource,
@@ -372,15 +369,16 @@ describe Chef::DataCollector::Reporter do
     let(:resource_report) { double("resource_report") }
 
     before do
-      allow(reporter).to receive(:add_updated_resource)
       allow(reporter).to receive(:update_current_resource_report)
+      allow(reporter).to receive(:add_resource_report)
+      allow(reporter).to receive(:current_resource_report)
       allow(resource_report).to receive(:finish)
     end
 
     context "when there is no current resource report" do
-      it "does not add the updated resource" do
+      it "does not touch the current resource report" do
         allow(reporter).to receive(:current_resource_report).and_return(nil)
-        expect(reporter).not_to receive(:add_updated_resource)
+        expect(reporter).not_to receive(:update_current_resource_report)
         reporter.resource_completed(new_resource)
       end
     end
@@ -391,9 +389,9 @@ describe Chef::DataCollector::Reporter do
       end
 
       context "when the resource is a nested resource" do
-        it "does not add the updated resource" do
+        it "does not mark the resource as finished" do
           allow(reporter).to receive(:nested_resource?).with(new_resource).and_return(true)
-          expect(reporter).not_to receive(:add_updated_resource)
+          expect(resource_report).not_to receive(:finish)
           reporter.resource_completed(new_resource)
         end
       end
@@ -408,11 +406,6 @@ describe Chef::DataCollector::Reporter do
           reporter.resource_completed(new_resource)
         end
 
-        it "adds the resource to the updated resource list" do
-          expect(reporter).to receive(:add_updated_resource).with(resource_report)
-          reporter.resource_completed(new_resource)
-        end
-
         it "nils out the current resource report" do
           expect(reporter).to receive(:update_current_resource_report).with(nil)
           reporter.resource_completed(new_resource)

data/spec/unit/knife/cookbook_create_spec.rb

@@ -22,6 +22,7 @@ require "tmpdir"
 describe Chef::Knife::CookbookCreate do
   before(:each) do
     Chef::Config[:node_name] = "webmonkey.example.com"
+    Chef::Config[:treat_deprecation_warnings_as_errors] = false
     @knife = Chef::Knife::CookbookCreate.new
     @knife.config = {}
     @knife.name_args = ["foobar"]

data/spec/unit/knife/cookbook_site_download_spec.rb

@@ -38,6 +38,7 @@ describe Chef::Knife::CookbookSiteDownload do
       expect(@noauth_rest).to receive(:get).
         with("#{@cookbook_api_url}/apache2").
         and_return(@current_data)
+      @knife.configure_chef
     end
 
     context "when the cookbook is deprecated and not forced" do

data/spec/unit/knife/node_environment_set_spec.rb

@@ -52,29 +52,5 @@ describe Chef::Knife::NodeEnvironmentSet do
       @knife.run
     end
 
-    describe "with no environment" do
-      # Set up outputs for inspection later
-      before(:each) do
-        @stdout = StringIO.new
-        @stderr = StringIO.new
-
-        allow(@knife.ui).to receive(:stdout).and_return(@stdout)
-        allow(@knife.ui).to receive(:stderr).and_return(@stderr)
-      end
-
-      it "should exit" do
-        @knife.name_args = [ "adam" ]
-        expect { @knife.run }.to raise_error SystemExit
-      end
-
-      it "should show the user the usage and an error" do
-        @knife.name_args = [ "adam" ]
-
-        begin ; @knife.run ; rescue SystemExit ; end
-
-        expect(@stdout.string).to eq "USAGE: knife node environment set NODE ENVIRONMENT\n"
-        expect(@stderr.string).to eq "FATAL: You must specify a node name and an environment.\n"
-      end
-    end
   end
 end

data/spec/unit/knife/node_run_list_set_spec.rb

@@ -111,30 +111,5 @@ describe Chef::Knife::NodeRunListSet do
       end
     end
 
-    describe "with no role or recipe" do
-      # Set up outputs for inspection later
-      before(:each) do
-        @stdout = StringIO.new
-        @stderr = StringIO.new
-
-        allow(@knife.ui).to receive(:stdout).and_return(@stdout)
-        allow(@knife.ui).to receive(:stderr).and_return(@stderr)
-      end
-
-      it "should exit" do
-        @knife.name_args = [ "adam" ]
-        expect { @knife.run }.to raise_error SystemExit
-      end
-
-      it "should show the user" do
-        @knife.name_args = [ "adam" ]
-
-        begin ; @knife.run ; rescue SystemExit ; end
-
-        expect(@stdout.string).to eq "USAGE: knife node run_list set NODE ENTRIES (options)\n"
-        expect(@stderr.string).to eq "FATAL: You must supply both a node name and a run list.\n"
-      end
-    end
-
   end
 end

data/spec/unit/node/attribute_spec.rb

@@ -218,7 +218,7 @@ describe Chef::Node::Attribute do
     end
 
     it "gives the value at each level of precedence for a path spec" do
-      expected = [["set_unless_enabled?", false],
+      expected = [
         %w{default default},
         %w{env_default env_default},
         %w{role_default role_default},
@@ -417,12 +417,6 @@ describe Chef::Node::Attribute do
       expect(@attributes.normal["foo"]["bar"]).to eq(:baz)
     end
 
-    it "should optionally skip setting the value if one already exists" do
-      @attributes.set_unless_value_present = true
-      @attributes.normal["hostname"] = "bar"
-      expect(@attributes["hostname"]).to eq("latte")
-    end
-
     it "does not support ||= when setting" do
       # This is a limitation of auto-vivification.
       # Users who need this behavior can use set_unless and friends
@@ -493,6 +487,7 @@ describe Chef::Node::Attribute do
     end
 
     it "should return true if an attribute exists but is set to nil using dot notation" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
       expect(@attributes.music.deeper.has_key?("gates_of_ishtar")).to eq(true)
     end
 
@@ -533,10 +528,12 @@ describe Chef::Node::Attribute do
 
   describe "method_missing" do
     it "should behave like a [] lookup" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
       expect(@attributes.music.mastodon).to eq("rocks")
     end
 
     it "should allow the last method to set a value if it has an = sign on the end" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
       @attributes.normal.music.mastodon = %w{dream still shining}
       expect(@attributes.normal.music.mastodon).to eq(%w{dream still shining})
     end
@@ -577,7 +574,7 @@ describe Chef::Node::Attribute do
 
     it "should yield lower if we go deeper" do
       collect = Array.new
-      @attributes.one.keys.each do |k|
+      @attributes["one"].keys.each do |k|
         collect << k
       end
       expect(collect.include?("two")).to eq(true)
@@ -587,7 +584,7 @@ describe Chef::Node::Attribute do
     end
 
     it "should not raise an exception if one of the hashes has a nil value on a deep lookup" do
-      expect { @attributes.place.keys { |k| } }.not_to raise_error
+      expect { @attributes["place"].keys { |k| } }.not_to raise_error
     end
   end
 
@@ -1171,6 +1168,7 @@ describe Chef::Node::Attribute do
     end
 
     it "raises an error when using `attr=value`" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
       expect { @attributes.new_key = "new value" }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)
     end
 

data/spec/unit/node/immutable_collections_spec.rb

@@ -95,6 +95,10 @@ describe Chef::Node::ImmutableMash do
     :replace,
     :select!,
     :shift,
+    :write,
+    :write!,
+    :unlink,
+    :unlink!,
   ].each do |mutator|
     it "doesn't allow mutation via `#{mutator}'" do
       expect { @immutable_mash.send(mutator) }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)

data/spec/unit/node/vivid_mash_spec.rb

@@ -0,0 +1,344 @@
+#
+# Copyright:: Copyright 2016, 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 "chef/node/attribute_collections"
+
+describe Chef::Node::VividMash do
+  class Root
+    attr_accessor :top_level_breadcrumb
+  end
+
+  let(:root) { Root.new }
+
+  let(:vivid) do
+    expect(root).to receive(:reset_cache).at_least(:once).with(nil)
+    Chef::Node::VividMash.new(root,
+      { "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil }
+    )
+  end
+
+  context "#read" do
+    before do
+      # vivify the vividmash, then we're read-only so the cache should never be cleared afterwards
+      vivid
+      expect(root).not_to receive(:reset_cache)
+    end
+
+    it "reads hashes deeply" do
+      expect(root).to receive(:top_level_breadcrumb=).with("one").and_call_original
+      expect(vivid.read("one", "two", "three")).to eql("four")
+    end
+
+    it "does not trainwreck when hitting hash keys that do not exist" do
+      expect(root).to receive(:top_level_breadcrumb=).with("one").and_call_original
+      expect(vivid.read("one", "five", "six")).to eql(nil)
+    end
+
+    it "does not trainwreck when hitting an array with an out of bounds index" do
+      expect(root).to receive(:top_level_breadcrumb=).with("array").and_call_original
+      expect(vivid.read("array", 5, "one")).to eql(nil)
+    end
+
+    it "does not trainwreck when hitting an array with a string key" do
+      expect(root).to receive(:top_level_breadcrumb=).with("array").and_call_original
+      expect(vivid.read("array", "one", "two")).to eql(nil)
+    end
+
+    it "does not trainwreck when traversing a nil" do
+      expect(root).to receive(:top_level_breadcrumb=).with("nil").and_call_original
+      expect(vivid.read("nil", "one", "two")).to eql(nil)
+    end
+  end
+
+  context "#exist?" do
+    before do
+      # vivify the vividmash, then we're read-only so the cache should never be cleared afterwards
+      vivid
+      expect(root).not_to receive(:reset_cache)
+    end
+
+    it "true if there's a hash key there" do
+      expect(root).to receive(:top_level_breadcrumb=).with("one").and_call_original
+      expect(vivid.exist?("one", "two", "three")).to be true
+    end
+
+    it "true for intermediate hashes" do
+      expect(root).to receive(:top_level_breadcrumb=).with("one").and_call_original
+      expect(vivid.exist?("one")).to be true
+    end
+
+    it "true for arrays that exist" do
+      expect(root).to receive(:top_level_breadcrumb=).with("array").and_call_original
+      expect(vivid.exist?("array", 1)).to be true
+    end
+
+    it "true when the value of the key is nil" do
+      expect(root).to receive(:top_level_breadcrumb=).with("nil").and_call_original
+      expect(vivid.exist?("nil")).to be true
+    end
+
+    it "false when attributes don't exist" do
+      expect(root).to receive(:top_level_breadcrumb=).with("one").and_call_original
+      expect(vivid.exist?("one", "five", "six")).to be false
+    end
+
+    it "false when traversing a non-container" do
+      expect(root).to receive(:top_level_breadcrumb=).with("one").and_call_original
+      expect(vivid.exist?("one", "two", "three", "four")).to be false
+    end
+
+    it "false when an array index does not exist" do
+      expect(root).to receive(:top_level_breadcrumb=).with("array").and_call_original
+      expect(vivid.exist?("array", 3)).to be false
+    end
+
+    it "false when traversing a nil" do
+      expect(root).to receive(:top_level_breadcrumb=).with("nil").and_call_original
+      expect(vivid.exist?("nil", "foo", "bar")).to be false
+    end
+  end
+
+  context "#read!" do
+    before do
+      # vivify the vividmash, then we're read-only so the cache should never be cleared afterwards
+      vivid
+      expect(root).not_to receive(:reset_cache)
+    end
+
+    it "reads hashes deeply" do
+      expect(root).to receive(:top_level_breadcrumb=).with("one").and_call_original
+      expect(vivid.read!("one", "two", "three")).to eql("four")
+    end
+
+    it "reads arrays deeply" do
+      expect(root).to receive(:top_level_breadcrumb=).with("array").and_call_original
+      expect(vivid.read!("array", 1)).to eql(1)
+    end
+
+    it "throws an exception when attributes do not exist" do
+      expect(root).to receive(:top_level_breadcrumb=).with("one").and_call_original
+      expect { vivid.read!("one", "five", "six") }.to raise_error(Chef::Exceptions::NoSuchAttribute)
+    end
+
+    it "throws an exception when traversing a non-container" do
+      expect(root).to receive(:top_level_breadcrumb=).with("one").and_call_original
+      expect { vivid.read!("one", "two", "three", "four") }.to raise_error(Chef::Exceptions::NoSuchAttribute)
+    end
+
+    it "throws an exception when an array element does not exist" do
+      expect(root).to receive(:top_level_breadcrumb=).with("array").and_call_original
+      expect { vivid.read!("array", 3) }.to raise_error(Chef::Exceptions::NoSuchAttribute)
+    end
+  end
+
+  context "#write" do
+    before do
+      vivid
+      expect(root).not_to receive(:reset_cache).with(nil)
+    end
+
+    it "should write into hashes" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("one")
+      vivid.write("one", "five", "six")
+      expect(vivid["one"]["five"]).to eql("six")
+    end
+
+    it "should deeply autovivify" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("one")
+      vivid.write("one", "five", "six", "seven", "eight", "nine", "ten")
+      expect(vivid["one"]["five"]["six"]["seven"]["eight"]["nine"]).to eql("ten")
+    end
+
+    it "should raise an exception if you overwrite an array with a hash" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("array")
+      vivid.write("array", "five", "six")
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => { "five" => "six" }, "nil" => nil })
+    end
+
+    it "should raise an exception if you traverse through an array with a hash" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("array")
+      vivid.write("array", "five", "six", "seven")
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => { "five" => { "six" => "seven" } }, "nil" => nil })
+    end
+
+    it "should raise an exception if you overwrite a string with a hash" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("one")
+      vivid.write("one", "two", "three", "four", "five")
+      expect(vivid).to eql({ "one" => { "two" => { "three" => { "four" => "five" } } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "should raise an exception if you traverse through a string with a hash" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("one")
+      vivid.write("one", "two", "three", "four", "five", "six")
+      expect(vivid).to eql({ "one" => { "two" => { "three" => { "four" => { "five" => "six" } } } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "should raise an exception if you overwrite a nil with a hash" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("nil")
+      vivid.write("nil", "one", "two")
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => { "one" => "two" } })
+    end
+
+    it "should raise an exception if you traverse through a nil with a hash" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("nil")
+      vivid.write("nil", "one", "two", "three")
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => { "one" => { "two" => "three" } } })
+    end
+
+    it "writes with a block" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("one")
+      vivid.write("one", "five") { "six" }
+      expect(vivid["one"]["five"]).to eql("six")
+    end
+  end
+
+  context "#write!" do
+    before do
+      vivid
+      expect(root).not_to receive(:reset_cache).with(nil)
+    end
+
+    it "should write into hashes" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("one")
+      vivid.write!("one", "five", "six")
+      expect(vivid["one"]["five"]).to eql("six")
+    end
+
+    it "should deeply autovivify" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("one")
+      vivid.write!("one", "five", "six", "seven", "eight", "nine", "ten")
+      expect(vivid["one"]["five"]["six"]["seven"]["eight"]["nine"]).to eql("ten")
+    end
+
+    it "should raise an exception if you overwrite an array with a hash" do
+      expect(root).not_to receive(:reset_cache)
+      expect { vivid.write!("array", "five", "six") }.to raise_error(Chef::Exceptions::AttributeTypeMismatch)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "should raise an exception if you traverse through an array with a hash" do
+      expect(root).not_to receive(:reset_cache)
+      expect { vivid.write!("array", "five", "six", "seven") }.to raise_error(Chef::Exceptions::AttributeTypeMismatch)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "should raise an exception if you overwrite a string with a hash" do
+      expect(root).not_to receive(:reset_cache)
+      expect { vivid.write!("one", "two", "three", "four", "five") }.to raise_error(Chef::Exceptions::AttributeTypeMismatch)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "should raise an exception if you traverse through a string with a hash" do
+      expect(root).not_to receive(:reset_cache)
+      expect { vivid.write!("one", "two", "three", "four", "five", "six") }.to raise_error(Chef::Exceptions::AttributeTypeMismatch)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "should raise an exception if you overwrite a nil with a hash" do
+      expect(root).not_to receive(:reset_cache)
+      expect { vivid.write!("nil", "one", "two") }.to raise_error(Chef::Exceptions::AttributeTypeMismatch)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "should raise an exception if you traverse through a nil with a hash" do
+      expect(root).not_to receive(:reset_cache)
+      expect { vivid.write!("nil", "one", "two", "three") }.to raise_error(Chef::Exceptions::AttributeTypeMismatch)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "writes with a block" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("one")
+      vivid.write!("one", "five") { "six" }
+      expect(vivid["one"]["five"]).to eql("six")
+    end
+  end
+
+  context "#unlink" do
+    before do
+      vivid
+      expect(root).not_to receive(:reset_cache).with(nil)
+    end
+
+    it "should return nil if the keys already don't exist" do
+      expect(root).not_to receive(:reset_cache)
+      expect(vivid.unlink("five", "six", "seven", "eight")).to eql(nil)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "should unlink hashes" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("one")
+      expect( vivid.unlink("one") ).to eql({ "two" => { "three" => "four" } })
+      expect(vivid).to eql({ "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "should unlink array elements" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("array")
+      expect(vivid.unlink("array", 2)).to eql(2)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1 ], "nil" => nil })
+    end
+
+    it "should unlink nil" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("nil")
+      expect(vivid.unlink("nil")).to eql(nil)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ] })
+    end
+
+    it "should traverse a nil and safely do nothing" do
+      expect(root).not_to receive(:reset_cache)
+      expect(vivid.unlink("nil", "foo")).to eql(nil)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+  end
+
+  context "#unlink!" do
+    before do
+      vivid
+      expect(root).not_to receive(:reset_cache).with(nil)
+    end
+
+    it "should raise an exception if the keys already don't exist" do
+      expect(root).not_to receive(:reset_cache)
+      expect { vivid.unlink!("five", "six", "seven", "eight") }.to raise_error(Chef::Exceptions::NoSuchAttribute)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "should unlink! hashes" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("one")
+      expect( vivid.unlink!("one") ).to eql({ "two" => { "three" => "four" } })
+      expect(vivid).to eql({ "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+
+    it "should unlink! array elements" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("array")
+      expect(vivid.unlink!("array", 2)).to eql(2)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1 ], "nil" => nil })
+    end
+
+    it "should unlink! nil" do
+      expect(root).to receive(:reset_cache).at_least(:once).with("nil")
+      expect(vivid.unlink!("nil")).to eql(nil)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ] })
+    end
+
+    it "should raise an exception if it traverses a nil" do
+      expect(root).not_to receive(:reset_cache)
+      expect { vivid.unlink!("nil", "foo") }.to raise_error(Chef::Exceptions::NoSuchAttribute)
+      expect(vivid).to eql({ "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil })
+    end
+  end
+end