chef 12.15.19-universal-mingw32 → 12.16.42-universal-mingw32

data/spec/unit/http_spec.rb

@@ -74,7 +74,7 @@ describe Chef::HTTP do
       expect(http.create_url("///api/endpoint?url=http://foo.bar")).to eql(URI.parse("http://www.getchef.com/organization/org/api/endpoint?url=http://foo.bar"))
     end
 
-    # As per: https://github.com/opscode/chef/issues/2500
+    # As per: https://github.com/chef/chef/issues/2500
     it "should treat scheme part of the URI in a case-insensitive manner" do
       http = Chef::HTTP.allocate # Calling Chef::HTTP::new sets @url, don't want that.
       expect { http.create_url("HTTP://www1.chef.io/") }.not_to raise_error

data/spec/unit/knife/core/gem_glob_loader_spec.rb

@@ -78,7 +78,7 @@ describe Chef::Knife::SubcommandLoader::GemGlobLoader do
     expect(loader.site_subcommands).to include(expected_command)
   end
 
-  # https://github.com/opscode/chef-dk/issues/227
+  # https://github.com/chef/chef-dk/issues/227
   #
   # `knife` in ChefDK isn't from a gem install, it's directly run from a clone
   # of the source, but there can be one or more versions of chef also installed

data/spec/unit/knife/core/ui_spec.rb

@@ -28,6 +28,7 @@ describe Chef::Knife::UI do
       :verbosity => 0,
       :yes => nil,
       :format => "summary",
+      :field_separator => ".",
     }
     @ui = Chef::Knife::UI.new(@out, @err, @in, @config)
     Chef::Config[:treat_deprecation_warnings_as_errors] = false
@@ -410,6 +411,15 @@ EOM
         @ui.config[:attribute] = non_existing_path
         expect(@ui.format_for_display(input)).to eq({ "sample-data-bag-item" => { non_existing_path => nil } })
       end
+
+      describe "when --field-separator is passed" do
+        it "honors that separator" do
+          input = { "keys" => { "with spaces" => { "open" => { "doors" => { "with many.dots" => "when asked" } } } } }
+          @ui.config[:field_separator] = ";"
+          @ui.config[:attribute] = "keys;with spaces;open;doors;with many.dots"
+          expect(@ui.format_for_display(input)).to eq({ nil => { "keys;with spaces;open;doors;with many.dots" => "when asked" } })
+        end
+      end
     end
 
     describe "with --run-list passed" do

data/spec/unit/knife/ssl_fetch_spec.rb

@@ -108,6 +108,24 @@ E
 
   end
 
+  describe "#cn_of" do
+    let(:certificate) { double("Certificate", subject: subject) }
+
+    describe "when the certificate has a common name" do
+      let(:subject) { [["CN", "common name"]] }
+      it "returns the common name" do
+        expect(ssl_fetch.cn_of(certificate)).to eq("common name")
+      end
+    end
+
+    describe "when the certificate does not have a common name" do
+      let(:subject) { [] }
+      it "returns nil" do
+        expect(ssl_fetch.cn_of(certificate)).to eq(nil)
+      end
+    end
+  end
+
   describe "fetching the remote cert chain" do
 
     let(:name_args) { %w{https://foo.example.com:8443} }
@@ -180,5 +198,25 @@ ERROR_TEXT
 
     end
 
+    describe "when the certificate does not have a CN" do
+      let(:self_signed_crt_path) { File.join(CHEF_SPEC_DATA, "trusted_certs", "example_no_cn.crt") }
+      let(:self_signed_crt) { OpenSSL::X509::Certificate.new(File.read(self_signed_crt_path)) }
+
+      before do
+        expect(ssl_fetch).to receive(:proxified_socket).with("foo.example.com", 8443).and_return(tcp_socket)
+        expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, ssl_fetch.noverify_peer_ssl_context).and_return(ssl_socket)
+        expect(ssl_socket).to receive(:connect)
+        expect(ssl_socket).to receive(:peer_cert_chain).and_return([self_signed_crt])
+        expect(Time).to receive(:new).and_return(1)
+      end
+
+      it "fetches the certificate and writes it to a file in the trusted_certs_dir" do
+        run
+        stored_cert_path = File.join(trusted_certs_dir, "foo.example.com_1.crt")
+        expect(File).to exist(stored_cert_path)
+        expect(File.read(stored_cert_path)).to eq(File.read(self_signed_crt_path))
+      end
+    end
+
   end
 end

data/spec/unit/knife_spec.rb

@@ -349,6 +349,37 @@ describe Chef::Knife do
         expect { knife.run_with_pretty_exceptions }.to raise_error(Exception)
       end
     end
+
+    describe "setting arbitrary configuration with --config-option" do
+
+      let(:stdout) { StringIO.new }
+
+      let(:stderr) { StringIO.new }
+
+      let(:stdin) { StringIO.new }
+
+      let(:ui) { Chef::Knife::UI.new(stdout, stderr, stdin, disable_editing: true) }
+
+      let(:subcommand) do
+        KnifeSpecs::TestYourself.options = Chef::Application::Knife.options.merge(KnifeSpecs::TestYourself.options)
+        KnifeSpecs::TestYourself.new(%w{--config-option badly_formatted_arg}).tap do |cmd|
+          cmd.ui = ui
+        end
+      end
+
+      it "sets arbitrary configuration via --config-option" do
+        Chef::Knife.run(%w{test yourself --config-option arbitrary_config_thing=hello}, Chef::Application::Knife.options)
+        expect(Chef::Config[:arbitrary_config_thing]).to eq("hello")
+      end
+
+      it "handles errors in arbitrary configuration" do
+        expect(subcommand).to receive(:exit).with(1)
+        subcommand.configure_chef
+        expect(stderr.string).to include("ERROR: Unparsable config option \"badly_formatted_arg\"")
+        expect(stdout.string).to include(subcommand.opt_parser.to_s)
+      end
+    end
+
   end
 
   describe "when first created" do

data/spec/unit/mixin/powershell_out_spec.rb

@@ -18,7 +18,7 @@
 require "spec_helper"
 require "chef/mixin/powershell_out"
 
-describe Chef::Mixin::PowershellOut do
+describe Chef::Mixin::PowershellOut, :windows_only do
   let(:shell_out_class) { Class.new { include Chef::Mixin::PowershellOut } }
   subject(:object) { shell_out_class.new }
   let(:architecture) { "something" }
@@ -44,6 +44,18 @@ describe Chef::Mixin::PowershellOut do
       ).and_return(ret)
       expect(object.powershell_out("Get-Process", timeout: 600)).to eql(ret)
     end
+
+    context "when double quote is passed in the powershell command" do
+      it "passes if double quote is appended with single escape" do
+        result = object.powershell_out("Write-Verbose \"Some String\" -Verbose")
+        expect(result.stderr).to be == ""
+        expect(result.stdout).to be == "VERBOSE: Some String\n"
+      end
+
+      it "suppresses error if double quote is passed with double escape characters" do
+        expect { object.powershell_out("Write-Verbose \\\"Some String\\\" -Verbose") }.not_to raise_error
+      end
+    end
   end
 
   describe "#powershell_out!" do
@@ -66,5 +78,17 @@ describe Chef::Mixin::PowershellOut do
       expect(mixlib_shellout).to receive(:error!)
       expect(object.powershell_out!("Get-Process", timeout: 600)).to eql(mixlib_shellout)
     end
+
+    context "when double quote is passed in the powershell command" do
+      it "passes if double quote is appended with single escape" do
+        result = object.powershell_out!("Write-Verbose \"Some String\" -Verbose")
+        expect(result.stderr).to be == ""
+        expect(result.stdout).to be == "VERBOSE: Some String\n"
+      end
+
+      it "raises error if double quote is passed with double escape characters" do
+        expect { object.powershell_out!("Write-Verbose \\\"Some String\\\" -Verbose") }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
+      end
+    end
   end
 end

data/spec/unit/node/attribute_spec.rb

@@ -21,7 +21,11 @@ require "spec_helper"
 require "chef/node/attribute"
 
 describe Chef::Node::Attribute do
+  let(:events) { instance_double(Chef::EventDispatch::Dispatcher) }
+  let(:run_context) { instance_double(Chef::RunContext, :events => events) }
+  let(:node) { instance_double(Chef::Node, :run_context => run_context) }
   before(:each) do
+    allow(events).to receive(:attribute_changed)
     @attribute_hash =
       { "dmi" => {},
         "command" => { "ps" => "ps -ef" },
@@ -166,7 +170,7 @@ describe Chef::Node::Attribute do
       },
     }
     @automatic_hash = { "week" => "friday" }
-    @attributes = Chef::Node::Attribute.new(@attribute_hash, @default_hash, @override_hash, @automatic_hash)
+    @attributes = Chef::Node::Attribute.new(@attribute_hash, @default_hash, @override_hash, @automatic_hash, node)
   end
 
   describe "initialize" do
@@ -1196,4 +1200,45 @@ describe Chef::Node::Attribute do
       expect(@attributes["foo"]["baz"]["bar"]).to be true
     end
   end
+
+  describe "node state" do
+    it "sets __root__ correctly" do
+      @attributes.default["foo"]["bar"]["baz"] = "quux"
+      expect(@attributes["foo"].__root__).to eql(@attributes)
+      expect(@attributes["foo"]["bar"].__root__).to eql(@attributes)
+      expect(@attributes.default["foo"].__root__).to eql(@attributes)
+      expect(@attributes.default["foo"]["bar"].__root__).to eql(@attributes)
+    end
+
+    it "sets __node__ correctly" do
+      @attributes.default["foo"]["bar"]["baz"] = "quux"
+      expect(@attributes["foo"].__node__).to eql(node)
+      expect(@attributes["foo"]["bar"].__node__).to eql(node)
+      expect(@attributes.default["foo"].__node__).to eql(node)
+      expect(@attributes.default["foo"]["bar"].__node__).to eql(node)
+    end
+
+    it "sets __path__ correctly" do
+      @attributes.default["foo"]["bar"]["baz"] = "quux"
+      expect(@attributes["foo"].__path__).to eql(["foo"])
+      expect(@attributes["foo"]["bar"].__path__).to eql(%w{foo bar})
+      expect(@attributes.default["foo"].__path__).to eql(["foo"])
+      expect(@attributes.default["foo"]["bar"].__path__).to eql(%w{foo bar})
+    end
+
+    it "sets __precedence__ correctly" do
+      @attributes.default["foo"]["bar"]["baz"] = "quux"
+      expect(@attributes["foo"].__precedence__).to eql(:merged)
+      expect(@attributes["foo"]["bar"].__precedence__).to eql(:merged)
+      expect(@attributes.default["foo"].__precedence__).to eql(:default)
+      expect(@attributes.default["foo"]["bar"].__precedence__).to eql(:default)
+    end
+
+    it "notifies on attribute changes" do
+      expect(events).to receive(:attribute_changed).with(:default, ["foo"], {})
+      expect(events).to receive(:attribute_changed).with(:default, %w{foo bar}, {})
+      expect(events).to receive(:attribute_changed).with(:default, %w{foo bar baz}, "quux")
+      @attributes.default["foo"]["bar"]["baz"] = "quux"
+    end
+  end
 end

data/spec/unit/node/vivid_mash_spec.rb

@@ -19,36 +19,46 @@ 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(:root) { instance_double(Chef::Node::Attribute) }
 
   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 }
+    Chef::Node::VividMash.new(
+      { "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil },
+      root
     )
   end
 
-  def with_breadcrumb(key)
-    expect(root).to receive(:top_level_breadcrumb=).with(nil).at_least(:once).and_call_original
-    expect(root).to receive(:top_level_breadcrumb=).with(key).at_least(:once).and_call_original
+  context "without a root node" do
+    let(:vivid) do
+      Chef::Node::VividMash.new(
+        { "one" => { "two" => { "three" => "four" } }, "array" => [ 0, 1, 2 ], "nil" => nil }
+      )
+    end
+
+    it "sets the root to the root object" do
+      expect(vivid["one"]["two"].__root__).to eql(vivid)
+    end
+
+    it "does not send reset cache" do
+      # if we setup the expectation here then the object winds up responding to :reset_cache and then it fails...
+      #   expect(vivid).not_to receive(:reset_cache)
+      # but even so we expect to blow up here with NoMethodError if we screw up and send :reset_cache to a root VividMash
+      vivid["one"]["foo"] = "bar"
+    end
   end
 
   context "#[]=" do
     it "deep converts values through arrays" do
-      allow(root).to receive(:reset_cache)
-      vivid[:foo] = [ { :bar => true } ]
+      expect(root).to receive(:reset_cache).with("foo")
+      vivid["foo"] = [ { :bar => true } ]
       expect(vivid["foo"].class).to eql(Chef::Node::AttrArray)
       expect(vivid["foo"][0].class).to eql(Chef::Node::VividMash)
       expect(vivid["foo"][0]["bar"]).to be true
     end
 
     it "deep converts values through nested arrays" do
-      allow(root).to receive(:reset_cache)
-      vivid[:foo] = [ [ { :bar => true } ] ]
+      expect(root).to receive(:reset_cache).with("foo")
+      vivid["foo"] = [ [ { :bar => true } ] ]
       expect(vivid["foo"].class).to eql(Chef::Node::AttrArray)
       expect(vivid["foo"][0].class).to eql(Chef::Node::AttrArray)
       expect(vivid["foo"][0][0].class).to eql(Chef::Node::VividMash)
@@ -56,8 +66,8 @@ describe Chef::Node::VividMash do
     end
 
     it "deep converts values through hashes" do
-      allow(root).to receive(:reset_cache)
-      vivid[:foo] = { baz: { :bar => true } }
+      expect(root).to receive(:reset_cache).with("foo")
+      vivid["foo"] = { baz: { :bar => true } }
       expect(vivid["foo"]).to be_an_instance_of(Chef::Node::VividMash)
       expect(vivid["foo"]["baz"]).to be_an_instance_of(Chef::Node::VividMash)
       expect(vivid["foo"]["baz"]["bar"]).to be true
@@ -66,182 +76,144 @@ describe Chef::Node::VividMash do
 
   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
-      with_breadcrumb("one")
       expect(vivid.read("one", "two", "three")).to eql("four")
     end
 
     it "does not trainwreck when hitting hash keys that do not exist" do
-      with_breadcrumb("one")
       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
-      with_breadcrumb("array")
       expect(vivid.read("array", 5, "one")).to eql(nil)
     end
 
     it "does not trainwreck when hitting an array with a string key" do
-      with_breadcrumb("array")
       expect(vivid.read("array", "one", "two")).to eql(nil)
     end
 
     it "does not trainwreck when traversing a nil" do
-      with_breadcrumb("nil")
       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
-      with_breadcrumb("one")
       expect(vivid.exist?("one", "two", "three")).to be true
     end
 
     it "true for intermediate hashes" do
-      with_breadcrumb("one")
       expect(vivid.exist?("one")).to be true
     end
 
     it "true for arrays that exist" do
-      with_breadcrumb("array")
       expect(vivid.exist?("array", 1)).to be true
     end
 
     it "true when the value of the key is nil" do
-      with_breadcrumb("nil")
       expect(vivid.exist?("nil")).to be true
     end
 
     it "false when attributes don't exist" do
-      with_breadcrumb("one")
       expect(vivid.exist?("one", "five", "six")).to be false
     end
 
     it "false when traversing a non-container" do
-      with_breadcrumb("one")
       expect(vivid.exist?("one", "two", "three", "four")).to be false
     end
 
     it "false when an array index does not exist" do
-      with_breadcrumb("array")
       expect(vivid.exist?("array", 3)).to be false
     end
 
     it "false when traversing a nil" do
-      with_breadcrumb("nil")
       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
-      with_breadcrumb("one")
       expect(vivid.read!("one", "two", "three")).to eql("four")
     end
 
     it "reads arrays deeply" do
-      with_breadcrumb("array")
       expect(vivid.read!("array", 1)).to eql(1)
     end
 
     it "throws an exception when attributes do not exist" do
-      with_breadcrumb("one")
       expect { vivid.read!("one", "five", "six") }.to raise_error(Chef::Exceptions::NoSuchAttribute)
     end
 
     it "throws an exception when traversing a non-container" do
-      with_breadcrumb("one")
       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
-      with_breadcrumb("array")
       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
-      with_breadcrumb("one")
       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
-      with_breadcrumb("one")
       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
-      with_breadcrumb("array")
       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
-      with_breadcrumb("array")
       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
-      with_breadcrumb("one")
       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
-      with_breadcrumb("one")
       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
-      with_breadcrumb("nil")
       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
-      with_breadcrumb("nil")
       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
-      with_breadcrumb("one")
       expect(root).to receive(:reset_cache).at_least(:once).with("one")
       vivid.write("one", "five") { "six" }
       expect(vivid["one"]["five"]).to eql("six")
@@ -249,69 +221,55 @@ describe Chef::Node::VividMash do
   end
 
   context "#write!" do
-    before do
-      vivid
-      expect(root).not_to receive(:reset_cache).with(nil)
-    end
-
     it "should write into hashes" do
-      with_breadcrumb("one")
       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
-      with_breadcrumb("one")
       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
-      with_breadcrumb("array")
       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
-      with_breadcrumb("array")
       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
-      with_breadcrumb("one")
       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
-      with_breadcrumb("one")
       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
-      with_breadcrumb("nil")
       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
-      with_breadcrumb("nil")
       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
-      with_breadcrumb("one")
       expect(root).to receive(:reset_cache).at_least(:once).with("one")
       vivid.write!("one", "five") { "six" }
       expect(vivid["one"]["five"]).to eql("six")
@@ -319,41 +277,31 @@ describe Chef::Node::VividMash do
   end
 
   context "#unlink" do
-    before do
-      vivid
-      expect(root).not_to receive(:reset_cache).with(nil)
-    end
-
     it "should return nil if the keys don't already exist" do
-      expect(root).to receive(:top_level_breadcrumb=).with(nil).at_least(:once).and_call_original
       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
-      with_breadcrumb("one")
       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
-      with_breadcrumb("array")
       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
-      with_breadcrumb("nil")
       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
-      with_breadcrumb("nil")
       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 })
@@ -361,41 +309,31 @@ describe Chef::Node::VividMash do
   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 don't already exist" do
-      expect(root).to receive(:top_level_breadcrumb=).with(nil).at_least(:once).and_call_original
       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
-      with_breadcrumb("one")
       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
-      with_breadcrumb("array")
       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
-      with_breadcrumb("nil")
       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
-      with_breadcrumb("nil")
       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 })