chef 12.9.41-universal-mingw32 → 12.10.24-universal-mingw32

data/spec/functional/tiny_server_spec.rb

@@ -26,7 +26,7 @@ describe TinyServer::API do
   end
 
   it "is a Singleton" do
-    expect { TinyServer::API.new }.to raise_error
+    expect { TinyServer::API.new }.to raise_error NoMethodError
   end
 
   it "clears the router" do

data/spec/functional/util/powershell/cmdlet_spec.rb

@@ -105,7 +105,7 @@ describe Chef::Util::Powershell::Cmdlet, :windows_powershell_dsc_only do
   context "when constructor is given invalid arguments" do
     let(:cmd_output_format) { :invalid }
     it "throws an exception if an invalid format is passed to the constructor" do
-      expect(lambda { simple_cmdlet }).to raise_error
+      expect(lambda { simple_cmdlet }).to raise_error(ArgumentError)
     end
   end
 end

data/spec/functional/win32/registry_spec.rb

@@ -243,7 +243,7 @@ describe "Chef::Win32::Registry", :windows_only do
     end
 
     it "throws an exception when trying to cast an array to an int for a dword" do
-      expect { @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", { :name => "ShouldThrow", :type => :dword, :data => %w{one two} }) }.to raise_error
+      expect { @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", { :name => "ShouldThrow", :type => :dword, :data => %w{one two} }) }.to raise_error NoMethodError
     end
 
     # we are validating that the data gets .to_s called on it when type is a :string
@@ -261,11 +261,11 @@ describe "Chef::Win32::Registry", :windows_only do
     # we are validating that the data gets .to_a called on it when type is a :multi_string
 
     it "throws an exception when a multi-string is passed a number" do
-      expect { @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", { :name => "ShouldThrow", :type => :multi_string, :data => 65535 }) }.to raise_error
+      expect { @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", { :name => "ShouldThrow", :type => :multi_string, :data => 65535 }) }.to raise_error NoMethodError
     end
 
     it "throws an exception when a multi-string is passed a string" do
-      expect { @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", { :name => "ShouldBeWat", :type => :multi_string, :data => "foo" }) }.to raise_error
+      expect { @registry.set_value("HKCU\\Software\\Root\\Branch\\Flower", { :name => "ShouldBeWat", :type => :multi_string, :data => "foo" }) }.to raise_error NoMethodError
     end
   end
 

data/spec/integration/solo/solo_spec.rb

@@ -112,7 +112,7 @@ EOM
       file "cookbooks/x/recipes/default.rb", <<EOM
 ruby_block "sleeping" do
   block do
-    sleep 5
+    sleep 10
   end
 end
 EOM
@@ -134,7 +134,7 @@ EOM
 -l debug -L #{path_to('logs/runs.log')}", :chdir => chef_dir)
 
           # Give it some time to progress
-          sleep 1
+          sleep 5
 
           # Instantiate the second chef-solo run
           s2 = Process.spawn("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default' \

data/spec/support/shared/functional/securable_resource.rb

@@ -309,7 +309,7 @@ shared_examples_for "a securable resource without existing target" do
     end
 
     it "fails to set owner when owner has invalid characters" do
-      expect { resource.owner 'Lance "The Nose" Glindenberry III' }.to raise_error#(Chef::Exceptions::ValidationFailed)
+      expect { resource.owner 'Lance "The Nose" Glindenberry III' }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
 
     it "sets owner when owner is specified with a \\" do

data/spec/support/shared/unit/provider/file.rb

@@ -586,14 +586,14 @@ shared_examples_for Chef::Provider::File do
       it "raises an exception when the content object returns a tempfile with a nil path" do
         tempfile = double("Tempfile", :path => nil)
         expect(provider.send(:content)).to receive(:tempfile).at_least(:once).and_return(tempfile)
-        expect { provider.send(:do_contents_changes) }.to raise_error
+        expect { provider.send(:do_contents_changes) }.to raise_error(RuntimeError)
       end
 
       it "raises an exception when the content object returns a tempfile that does not exist" do
         tempfile = double("Tempfile", :path => "/tmp/foo-bar-baz")
         expect(provider.send(:content)).to receive(:tempfile).at_least(:once).and_return(tempfile)
         expect(File).to receive(:exists?).with("/tmp/foo-bar-baz").and_return(false)
-        expect { provider.send(:do_contents_changes) }.to raise_error
+        expect { provider.send(:do_contents_changes) }.to raise_error(RuntimeError)
       end
     end
 
@@ -712,7 +712,7 @@ shared_examples_for Chef::Provider::File do
         it "should not try to backup or delete the file, and should not be updated by last action" do
           expect(provider).not_to receive(:do_backup)
           expect(File).not_to receive(:delete)
-          expect { provider.run_action(:delete) }.to raise_error()
+          expect { provider.run_action(:delete) }.to raise_error(Chef::Exceptions::InsufficientPermissions)
           expect(resource).not_to be_updated_by_last_action
         end
       end

data/spec/support/shared/unit/windows_script_resource.rb

@@ -64,7 +64,7 @@ shared_examples_for "a Windows script resource" do
       it "should raise an exception if the guard_interpreter is overridden from its default value" do
         @resource.guard_interpreter :bash
         @resource.only_if { true }
-        expect { @resource.should_skip?(:run) }.to raise_error
+        expect { @resource.should_skip?(:run) }.to raise_error(ArgumentError)
       end
     end
   end

data/spec/unit/application/apply_spec.rb

@@ -22,6 +22,7 @@ describe Chef::Application::Apply do
   before do
     @app = Chef::Application::Apply.new
     allow(@app).to receive(:configure_logging).and_return(true)
+    allow(Chef::Log).to receive(:debug).with("FIPS mode is enabled.")
     @recipe_text = "package 'nyancat'"
     Chef::Config[:solo] = true
   end

data/spec/unit/chef_fs/file_system/repository/base_file_spec.rb

@@ -0,0 +1,128 @@
+#
+# Copyright:: Copyright 2012-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/chef_fs/file_system/repository/base_file"
+require "chef/chef_fs/file_system/repository/directory"
+require "chef/chef_fs/file_system/base_fs_object"
+require "chef/chef_fs/file_system/exceptions"
+require "chef/chef_fs/file_system/nonexistent_fs_object"
+
+describe Chef::ChefFS::FileSystem::Repository::BaseFile do
+  let(:root) do
+    Chef::ChefFS::FileSystem::BaseFSDir.new("", nil)
+  end
+
+  let(:tmp_dir) { Dir.mktmpdir }
+
+  let(:parent) do
+    Chef::ChefFS::FileSystem::Repository::Directory.new("test", root, tmp_dir)
+  end
+
+  let(:file) do
+    file = described_class.new("test_file.json", parent)
+    file.write_pretty_json = false
+    file
+  end
+
+  let(:content) { '"name": "canteloup"' }
+  let(:file_path) { File.join(tmp_dir, "test_file.json") }
+
+  after do
+    FileUtils.rm_f(file_path)
+  end
+
+  context "#is_json_file?" do
+    it "returns false when the file is not json" do
+      file = described_class.new("test_file.dpkg", parent)
+      expect(file.is_json_file?).to be_falsey
+    end
+
+    it "returns true when the file is json" do
+      expect(file.is_json_file?).to be_truthy
+    end
+  end
+
+  context "#name_valid?" do
+    it "rejects dotfiles" do
+      file = described_class.new(".test_file.json", parent)
+      expect(file.name_valid?).to be_falsey
+    end
+
+    it "rejects non json files" do
+      file = described_class.new("test_file.dpkg", parent)
+      expect(file.name_valid?).to be_falsey
+    end
+
+    it "allows correctly named files" do
+      expect(file.name_valid?).to be_truthy
+    end
+  end
+
+  context "#fs_entry_valid?" do
+    it "rejects invalid names" do
+      file = described_class.new("test_file.dpkg", parent)
+      expect(file.fs_entry_valid?).to be_falsey
+    end
+
+    it "rejects missing files" do
+      FileUtils.rm_f(file_path)
+      expect(file.fs_entry_valid?).to be_falsey
+    end
+
+    it "allows present and properly named files" do
+      FileUtils.touch(file_path)
+      expect(file.fs_entry_valid?).to be_truthy
+    end
+  end
+
+  context "#create" do
+    it "doesn't create an existing file" do
+      FileUtils.touch(file_path)
+      expect { file.create('"name": "canteloup"') }.to raise_error(Chef::ChefFS::FileSystem::AlreadyExistsError)
+    end
+
+    it "creates a new file" do
+      expect(file).to receive(:write).with(content)
+      expect { file.create(content) }.to_not raise_error
+    end
+
+  end
+
+  context "#write" do
+    context "minimises a json object" do
+      it "not if pretty json is off" do
+        expect(file).to_not receive(:minimize)
+        file.write(content)
+      end
+
+      it "not if it's not a json file" do
+        file = described_class.new("test_file.dpkg", parent)
+        file.write_pretty_json = true
+        expect(file).to_not receive(:minimize)
+        file.write(content)
+      end
+
+      it "correctly" do
+        file = described_class.new("test_file.json", parent)
+        file.write_pretty_json = true
+        expect(file).to receive(:minimize).with(content, file).and_return(content)
+        file.write(content)
+      end
+    end
+  end
+end

data/spec/unit/chef_fs/file_system/repository/directory_spec.rb

@@ -0,0 +1,174 @@
+#
+# Author:: Thom May (<thom@chef.io>)
+# Copyright:: Copyright 2012-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/chef_fs/file_system/repository/directory"
+require "chef/chef_fs/file_system/base_fs_object"
+require "chef/chef_fs/file_system/exceptions"
+require "chef/chef_fs/file_system/nonexistent_fs_object"
+
+CHILD_FILES = %w{ test1.json test2.json skip test3.json skip2 test4 }
+
+class TestDirectory < Chef::ChefFS::FileSystem::Repository::Directory
+  def make_child_entry(name)
+    TestFile.new(name, self)
+  end
+
+  def can_have_child?(name, is_dir)
+    !is_dir && File.extname(name) == ".json"
+  end
+
+  def dir_ls
+    CHILD_FILES
+  end
+end
+
+class TestFile < Chef::ChefFS::FileSystem::BaseFSObject
+  def fs_entry_valid?
+    name.start_with? "test"
+  end
+
+  def name_valid?
+    true
+  end
+end
+
+describe Chef::ChefFS::FileSystem::Repository::Directory do
+  let(:root) do
+    Chef::ChefFS::FileSystem::BaseFSDir.new("", nil)
+  end
+
+  let(:tmp_dir) { Dir.mktmpdir }
+
+  let(:directory) do
+    described_class.new("test", root, tmp_dir)
+  end
+
+  let(:test_directory) do
+    TestDirectory.new("test", root, tmp_dir)
+  end
+
+  let(:file_double) do
+    double(TestFile, create: true, exists?: false)
+  end
+
+  context "#make_child_entry" do
+    it "raises if not implemented" do
+      expect { directory.send(:make_child_entry, "test") }.to raise_error("Not Implemented")
+    end
+  end
+
+  context "#create_child" do
+    it "creates a new TestFile" do
+      expect(TestFile).to receive(:new).with("test_child", test_directory).and_return(file_double)
+      expect(file_double).to receive(:write).with("test")
+      test_directory.create_child("test_child", "test")
+    end
+  end
+
+  context "#child" do
+    it "returns a child if it's valid" do
+      expect(test_directory.child("test")).to be_an_instance_of(TestFile)
+    end
+
+    it "returns a non existent object otherwise" do
+      file_double = instance_double(TestFile, :name_valid? => false)
+      expect(TestFile).to receive(:new).with("test_child", test_directory).and_return(file_double)
+      expect(test_directory.child("test_child")).to be_an_instance_of(Chef::ChefFS::FileSystem::NonexistentFSObject)
+    end
+  end
+
+  context "#children" do
+    before do
+      CHILD_FILES.sort.each do |child|
+        expect(TestFile).to receive(:new).with(child, test_directory).and_call_original
+      end
+    end
+
+    it "creates a child for each name" do
+      test_directory.children
+    end
+
+    it "filters invalid names" do
+      expect(test_directory.children.map { |c| c.name }).to eql %w{ test1.json test2.json test3.json }
+    end
+  end
+
+  context "#empty?" do
+    it "is true if there are no children" do
+      expect(test_directory).to receive(:children).and_return([])
+      expect(test_directory.empty?).to be_truthy
+    end
+
+    it "is false if there are children" do
+      expect(test_directory.empty?).to be_falsey
+    end
+  end
+
+  describe "checks entry validity" do
+    it "rejects dotfiles" do
+      dir = described_class.new(".test", root, tmp_dir)
+      expect(dir.name_valid?).to be_falsey
+    end
+
+    it "rejects files" do
+      Tempfile.open("test") do |file|
+        dir = described_class.new("test", root, file.path)
+        expect(dir.name_valid?).to be_truthy
+        expect(dir.fs_entry_valid?).to be_falsey
+      end
+    end
+
+    it "accepts directories" do
+      expect(directory.name_valid?).to be_truthy
+    end
+  end
+
+  describe "creates directories" do
+    it "doesn't create an existing directory" do
+      expect { directory.create }.to raise_error(Chef::ChefFS::FileSystem::AlreadyExistsError)
+    end
+
+    it "creates a new directory" do
+      FileUtils.rmdir(tmp_dir)
+      expect(Dir).to receive(:mkdir).with(tmp_dir)
+      expect { directory.create }.to_not raise_error
+    end
+
+    after do
+      FileUtils.rmdir(tmp_dir)
+    end
+  end
+
+  describe "deletes directories" do
+    it "won't delete a non-existant directory" do
+      FileUtils.rmdir(tmp_dir)
+      expect { directory.delete(true) }.to raise_error(Chef::ChefFS::FileSystem::NotFoundError)
+    end
+
+    it "must delete recursively" do
+      expect { directory.delete(false) }.to raise_error(Chef::ChefFS::FileSystem::MustDeleteRecursivelyError)
+    end
+
+    it "deletes a directory" do
+      expect(FileUtils).to receive(:rm_r).with(tmp_dir)
+      expect { directory.delete(true) }.to_not raise_error
+    end
+  end
+
+end

data/spec/unit/cookbook/metadata_spec.rb

@@ -707,7 +707,7 @@ describe Chef::Cookbook::Metadata do
       }
       expect {
         metadata.attribute("test_cookbook/test", options)
-      }.to raise_error
+      }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
 
     it "should error if default used with calculated" do

data/spec/unit/dsl/declare_resource_spec.rb

@@ -0,0 +1,335 @@
+#
+# Copyright:: Copyright 2008-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"
+
+describe Chef::ResourceCollection do
+  let(:run_context) do
+    cookbook_repo = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "data", "cookbooks"))
+    cookbook_loader = Chef::CookbookLoader.new(cookbook_repo)
+    cookbook_loader.load_cookbooks
+    node = Chef::Node.new
+    cookbook_collection = Chef::CookbookCollection.new(cookbook_loader)
+    events = Chef::EventDispatch::Dispatcher.new
+    Chef::RunContext.new(node, cookbook_collection, events)
+  end
+
+  let(:recipe) do
+    Chef::Recipe.new("hjk", "test", run_context)
+  end
+
+  describe "#declare_resource" do
+    before do
+      recipe.declare_resource(:zen_master, "monkey") do
+        something true
+      end
+    end
+
+    it "inserts into the resource collection" do
+      expect(run_context.resource_collection.first.to_s).to eql("zen_master[monkey]")
+    end
+
+    it "sets the property from the block" do
+      expect(run_context.resource_collection.first.something).to be true
+    end
+  end
+
+  describe "#edit_resource!" do
+    it "raises if nothing is found" do
+      expect {
+        recipe.edit_resource!(:zen_master, "monkey") do
+          something true
+        end
+      }.to raise_error(Chef::Exceptions::ResourceNotFound)
+    end
+
+    it "raises if nothing is found and no block is given" do
+      expect {
+        recipe.edit_resource!(:zen_master, "monkey")
+      }.to raise_error(Chef::Exceptions::ResourceNotFound)
+    end
+
+    it "edits the resource if it finds one" do
+      resource = recipe.declare_resource(:zen_master, "monkey") do
+        something false
+      end
+      expect(
+        recipe.edit_resource!(:zen_master, "monkey") do
+          something true
+        end
+      ).to eql(resource)
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(run_context.resource_collection.first.something).to be true
+    end
+
+    it "acts like find_resource! if not given a block and the resource exists" do
+      resource = recipe.declare_resource(:zen_master, "monkey") do
+        something false
+      end
+      expect(
+        recipe.edit_resource!(:zen_master, "monkey")
+      ).to eql(resource)
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(run_context.resource_collection.first.something).to be false
+    end
+  end
+
+  describe "#edit_resource" do
+    it "inserts a resource if nothing is found" do
+      resource = recipe.edit_resource(:zen_master, "monkey") do
+        something true
+      end
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(run_context.resource_collection.first).to eql(resource)
+      expect(run_context.resource_collection.first.something).to be true
+    end
+
+    it "inserts a resource even if not given a block" do
+      resource = recipe.edit_resource(:zen_master, "monkey")
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(run_context.resource_collection.first).to eql(resource)
+    end
+
+    it "edits the resource if it finds one" do
+      resource = recipe.declare_resource(:zen_master, "monkey") do
+        something false
+      end
+      expect(
+        recipe.edit_resource(:zen_master, "monkey") do
+          something true
+        end
+      ).to eql(resource)
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(run_context.resource_collection.first.something).to be true
+    end
+
+    it "acts like find_resource if not given a block and the resource exists" do
+      resource = recipe.declare_resource(:zen_master, "monkey") do
+        something false
+      end
+      expect(
+        recipe.edit_resource(:zen_master, "monkey")
+      ).to eql(resource)
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(run_context.resource_collection.first.something).to be false
+    end
+  end
+
+  describe "#find_resource!" do
+    it "raises if nothing is found" do
+      expect {
+        recipe.find_resource!(:zen_master, "monkey")
+      }.to raise_error(Chef::Exceptions::ResourceNotFound)
+    end
+
+    it "raises if given a block" do
+      resource = recipe.declare_resource(:zen_master, "monkey") do
+        something false
+      end
+      expect {
+        recipe.find_resource!(:zen_master, "monkey") do
+          something false
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+    it "returns the resource if it finds one" do
+      resource = recipe.declare_resource(:zen_master, "monkey") do
+        something false
+      end
+      expect(
+        recipe.find_resource!(:zen_master, "monkey")
+      ).to eql(resource)
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(run_context.resource_collection.first.something).to be false
+    end
+  end
+
+  describe "#find_resource without block" do
+    it "returns nil if nothing is found" do
+      expect(recipe.find_resource(:zen_master, "monkey")).to be nil
+      expect(run_context.resource_collection.all_resources.size).to eql(0)
+    end
+
+    it "returns the resource if it finds one" do
+      resource = recipe.declare_resource(:zen_master, "monkey") do
+        something false
+      end
+      expect(
+        recipe.find_resource(:zen_master, "monkey")
+      ).to eql(resource)
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(run_context.resource_collection.first.something).to be false
+    end
+  end
+
+  describe "#find_resource with block" do
+    it "inserts a resource if nothing is found" do
+      resource = recipe.find_resource(:zen_master, "monkey") do
+        something true
+      end
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(run_context.resource_collection.first).to eql(resource)
+      expect(run_context.resource_collection.first.something).to be true
+    end
+
+    it "returns the resource if it finds one" do
+      resource = recipe.declare_resource(:zen_master, "monkey") do
+        something false
+      end
+      expect(
+        recipe.find_resource(:zen_master, "monkey") do
+          something true
+        end
+      ).to eql(resource)
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(run_context.resource_collection.first.something).to be false
+    end
+  end
+
+  describe "#delete_resource" do
+    it "returns nil if nothing is found" do
+      expect(
+        recipe.delete_resource(:zen_master, "monkey")
+      ).to be nil
+    end
+
+    it "deletes and returns the resource if it finds one" do
+      resource = recipe.declare_resource(:zen_master, "monkey") do
+        something false
+      end
+      expect(
+        recipe.delete_resource(:zen_master, "monkey")
+      ).to eql(resource)
+      expect(run_context.resource_collection.all_resources.size).to eql(0)
+    end
+  end
+
+  describe "#delete_resource!" do
+    it "raises if nothing is found" do
+      expect {
+        recipe.delete_resource!(:zen_master, "monkey")
+      }.to raise_error(Chef::Exceptions::ResourceNotFound)
+    end
+
+    it "deletes and returns the resource if it finds one" do
+      resource = recipe.declare_resource(:zen_master, "monkey") do
+        something false
+      end
+      expect(
+        recipe.delete_resource!(:zen_master, "monkey")
+      ).to eql(resource)
+      expect(run_context.resource_collection.all_resources.size).to eql(0)
+    end
+  end
+
+  describe "run_context helpers" do
+
+    let(:parent_run_context) do
+      run_context.create_child
+    end
+
+    let(:child_run_context) do
+      parent_run_context.create_child
+    end
+
+    let(:parent_recipe) do
+      Chef::Recipe.new("hjk", "parent", parent_run_context)
+    end
+
+    let(:child_recipe) do
+      Chef::Recipe.new("hjk", "child", child_run_context)
+    end
+
+    before do
+      # wire up our outer run context to the root Chef.run_context
+      allow(Chef).to receive(:run_context).and_return(run_context)
+    end
+
+    it "our tests have correct separation" do
+      child_resource = child_recipe.declare_resource(:zen_master, "child") do
+        something false
+      end
+      parent_resource = parent_recipe.declare_resource(:zen_master, "parent") do
+        something false
+      end
+      root_resource = recipe.declare_resource(:zen_master, "root") do
+        something false
+      end
+      expect(run_context.resource_collection.first).to eql(root_resource)
+      expect(run_context.resource_collection.first.to_s).to eql("zen_master[root]")
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(parent_run_context.resource_collection.first).to eql(parent_resource)
+      expect(parent_run_context.resource_collection.first.to_s).to eql("zen_master[parent]")
+      expect(parent_run_context.resource_collection.all_resources.size).to eql(1)
+      expect(child_run_context.resource_collection.first).to eql(child_resource)
+      expect(child_run_context.resource_collection.first.to_s).to eql("zen_master[child]")
+      expect(child_run_context.resource_collection.all_resources.size).to eql(1)
+    end
+
+    it "with_run_context with :parent lets us build resources in the parent run_context from the child" do
+      child_recipe.instance_eval do
+        with_run_context(:parent) do
+          declare_resource(:zen_master, "parent") do
+            something false
+          end
+        end
+      end
+      expect(run_context.resource_collection.all_resources.size).to eql(0)
+      expect(parent_run_context.resource_collection.all_resources.size).to eql(1)
+      expect(parent_run_context.resource_collection.first.to_s).to eql("zen_master[parent]")
+      expect(child_run_context.resource_collection.all_resources.size).to eql(0)
+    end
+
+    it "with_run_context with :root lets us build resources in the root run_context from the child" do
+      child_recipe.instance_eval do
+        with_run_context(:root) do
+          declare_resource(:zen_master, "root") do
+            something false
+          end
+        end
+      end
+      expect(run_context.resource_collection.first.to_s).to eql("zen_master[root]")
+      expect(run_context.resource_collection.all_resources.size).to eql(1)
+      expect(parent_run_context.resource_collection.all_resources.size).to eql(0)
+      expect(child_run_context.resource_collection.all_resources.size).to eql(0)
+    end
+
+    it "with_run_context also takes a RunContext object as an argument" do
+      child_recipe.instance_exec(parent_run_context) do |parent_run_context|
+        with_run_context(parent_run_context) do
+          declare_resource(:zen_master, "parent") do
+            something false
+          end
+        end
+      end
+      expect(run_context.resource_collection.all_resources.size).to eql(0)
+      expect(parent_run_context.resource_collection.all_resources.size).to eql(1)
+      expect(parent_run_context.resource_collection.first.to_s).to eql("zen_master[parent]")
+      expect(child_run_context.resource_collection.all_resources.size).to eql(0)
+    end
+
+    it "with_run_context returns the return value of the block" do
+      child_recipe.instance_eval do
+        ret = with_run_context(:root) do
+          "return value"
+        end
+        raise "failed" unless ret == "return value"
+      end
+    end
+  end
+end