chef 18.8.11 → 18.8.54

data/spec/unit/dsl/declare_resource_spec.rb

@@ -1,374 +0,0 @@
-#
-# 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"
-
-describe Chef::ResourceCollection do
-  let(:run_context) do
-    cookbook_repo = File.expand_path(File.join(__dir__, "..", "..", "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 "mixed in correctly" do
-    it "the resources() method winds up in the right classes" do
-      methods = %i{resources find_resource find_resource! edit_resource edit_resource! delete_resource delete_resource! declare_resource build_resource}
-      expect(Chef::Resource.instance_methods).to include(*methods)
-      expect(Chef::Recipe.instance_methods).to include(*methods)
-      expect(Chef::Provider.instance_methods).to include(*methods)
-    end
-  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 do
-        recipe.edit_resource!(:zen_master, "monkey") do
-          something true
-        end
-      end.to raise_error(Chef::Exceptions::ResourceNotFound)
-    end
-
-    it "raises if nothing is found and no block is given" do
-      expect do
-        recipe.edit_resource!(:zen_master, "monkey")
-      end.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 do
-        recipe.find_resource!(:zen_master, "monkey")
-      end.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 do
-        recipe.find_resource!(:zen_master, "monkey") do
-          something false
-        end
-      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 do
-        recipe.delete_resource!(:zen_master, "monkey")
-      end.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
-
-    it "removes pending delayed notifications" do
-      recipe.declare_resource(:zen_master, "one")
-      recipe.declare_resource(:zen_master, "two") do
-        notifies :win, "zen_master[one]"
-      end
-      recipe.delete_resource(:zen_master, "two")
-      resource = recipe.declare_resource(:zen_master, "two")
-      expect(resource.delayed_notifications).to eql([])
-    end
-
-    it "removes pending immediate notifications" do
-      recipe.declare_resource(:zen_master, "one")
-      recipe.declare_resource(:zen_master, "two") do
-        notifies :win, "zen_master[one]", :immediate
-      end
-      recipe.delete_resource(:zen_master, "two")
-      resource = recipe.declare_resource(:zen_master, "two")
-      expect(resource.immediate_notifications).to eql([])
-    end
-
-    it "removes pending before notifications" do
-      recipe.declare_resource(:zen_master, "one")
-      recipe.declare_resource(:zen_master, "two") do
-        notifies :win, "zen_master[one]", :before
-      end
-      recipe.delete_resource(:zen_master, "two")
-      resource = recipe.declare_resource(:zen_master, "two")
-      expect(resource.before_notifications).to eql([])
-    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

data/spec/unit/dsl/platform_introspection_spec.rb

@@ -1,160 +0,0 @@
-#
-# Author:: Seth Falcon (<seth@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 "chef/dsl/platform_introspection"
-
-class LanguageTester
-  attr_reader :node
-
-  def initialize(node)
-    @node = node
-  end
-  include Chef::DSL::PlatformIntrospection
-end
-
-describe "PlatformIntrospection implementors" do
-
-  let(:node) { Chef::Node.new }
-  let(:platform_introspector) { LanguageTester.new(node) }
-
-  it_behaves_like "a platform introspector"
-
-end
-
-describe Chef::DSL::PlatformIntrospection::PlatformDependentValue do
-  before do
-    platform_hash = {
-      :openbsd => { default: "free, functional, secure" },
-      %i{redhat centos fedora scientific} => { default: '"stable"' },
-      :ubuntu => { "10.04" => "using upstart more", :default => "using init more" },
-      :default => "bork da bork",
-    }
-    @platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformDependentValue.new(platform_hash)
-  end
-
-  it "returns the default value when the platform doesn't match" do
-    expect(@platform_specific_value.value_for_node(platform: :dos)).to eq("bork da bork")
-  end
-
-  it "returns a value for a platform set as a group" do
-    expect(@platform_specific_value.value_for_node(platform: :centos)).to eq('"stable"')
-  end
-
-  it "returns a value for the platform when it was set as a symbol but fetched as a string" do
-    expect(@platform_specific_value.value_for_node(platform: "centos")).to eq('"stable"')
-  end
-
-  it "returns a value for a specific platform version" do
-    node = { platform: "ubuntu", platform_version: "10.04" }
-    expect(@platform_specific_value.value_for_node(node)).to eq("using upstart more")
-  end
-
-  it "returns a platform-default value if the platform version doesn't match an explicit one" do
-    node = { platform: "ubuntu", platform_version: "9.10" }
-    expect(@platform_specific_value.value_for_node(node)).to eq("using init more")
-  end
-
-  it "returns nil if there is no default and no platforms match" do
-    # this matches the behavior in the original implementation.
-    # whether or not it's correct is another matter.
-    platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformDependentValue.new({})
-    expect(platform_specific_value.value_for_node(platform: "foo")).to be_nil
-  end
-
-  it "raises an argument error if the platform hash is not correctly structured" do
-    bad_hash = { ubuntu: :foo } # should be :ubuntu => {:default => 'foo'}
-    expect { Chef::DSL::PlatformIntrospection::PlatformDependentValue.new(bad_hash) }.to raise_error(ArgumentError)
-  end
-
-end
-describe Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue do
-  before do
-    @array_values = %i{stop start reload}
-
-    @platform_family_hash = {
-      "debian" => "debian value",
-      [:rhel, "fedora"] => "redhatty value",
-      "suse" => @array_values,
-      :gentoo => "gentoo value",
-      :default => "default value",
-    }
-
-    @platform_family_value = Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue.new(@platform_family_hash)
-  end
-
-  it "returns the default value when the platform family doesn't match" do
-    expect(@platform_family_value.value_for_node(platform_family: :os2)).to eq("default value")
-  end
-
-  it "returns a value for the platform family when it was set as a string but fetched as a symbol" do
-    expect(@platform_family_value.value_for_node(platform_family: :debian)).to eq("debian value")
-  end
-
-  it "returns a value for the platform family when it was set as a symbol but fetched as a string" do
-    expect(@platform_family_value.value_for_node(platform_family: "gentoo")).to eq("gentoo value")
-  end
-
-  it "returns an array value stored for a platform family" do
-    expect(@platform_family_value.value_for_node(platform_family: "suse")).to eq(@array_values)
-  end
-
-  it "returns a value for the platform family when it was set within an array hash key as a symbol" do
-    expect(@platform_family_value.value_for_node(platform_family: :rhel)).to eq("redhatty value")
-  end
-
-  it "returns a value for the platform family when it was set within an array hash key as a string" do
-    expect(@platform_family_value.value_for_node(platform_family: "fedora")).to eq("redhatty value")
-  end
-
-  it "returns nil if there is no default and no platforms match" do
-    platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue.new({})
-    expect(platform_specific_value.value_for_node(platform_family: "foo")).to be_nil
-  end
-
-end
-
-describe "ChefHelper functions mixed into classes" do
-  METHODS = %i{windows? fedora_derived? bsd_based? rhel? aix? gentoo?}.freeze
-
-  METHODS.each do |method|
-    it "mixes #{method} into Chef::Resource instances" do
-      expect(Chef::Resource.instance_methods.include?(method)).to be true
-    end
-
-    it "mixes #{method} into Chef::Resource classes (provides lines, etc)" do
-      expect(Chef::Resource.respond_to?(method)).to be true
-    end
-
-    it "mixes #{method} into Chef::Provider instances (actions)" do
-      expect(Chef::Provider.instance_methods.include?(method)).to be true
-    end
-
-    it "mixes #{method} into Chef::Provider classes (provides lines, etc)" do
-      expect(Chef::Provider.respond_to?(method)).to be true
-    end
-
-    it "mixes #{method} into Chef::Recipe instances (recipe files)" do
-      expect(Chef::Recipe.instance_methods.include?(method)).to be true
-    end
-
-    it "mixes #{method} into Chef::Node instances (attribute files)" do
-      expect(Chef::Recipe.instance_methods.include?(method)).to be true
-    end
-  end
-end

data/spec/unit/dsl/reboot_pending_spec.rb

@@ -1,87 +0,0 @@
-#
-# Author:: Bryan McLellan <btm@loftninjas.org>
-# 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 "chef/dsl/reboot_pending"
-require "spec_helper"
-
-describe Chef::DSL::RebootPending do
-  describe "reboot_pending?" do
-    describe "in isolation" do
-      let(:recipe) { Object.new.extend(Chef::DSL::RebootPending) }
-
-      before do
-        allow(recipe).to receive(:platform?).and_return(false)
-      end
-
-      context "platform is windows" do
-        before do
-          allow(recipe).to receive(:platform?).with("windows").and_return(true)
-          allow(recipe).to receive(:registry_key_exists?).and_return(false)
-          allow(recipe).to receive(:registry_value_exists?).and_return(false)
-        end
-
-        it 'should return true if "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\PendingFileRenameOperations" exists' do
-          allow(recipe).to receive(:registry_value_exists?).with("HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager", { name: "PendingFileRenameOperations" }).and_return(true)
-          expect(recipe.reboot_pending?).to be_truthy
-        end
-
-        it 'should return true if "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired" exists' do
-          allow(recipe).to receive(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired').and_return(true)
-          expect(recipe.reboot_pending?).to be_truthy
-        end
-
-        it 'should return true if key "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired" exists' do
-          allow(recipe).to receive(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootPending').and_return(true)
-          expect(recipe.reboot_pending?).to be_truthy
-        end
-      end
-
-      context "platform_family is debian" do
-        before do
-          allow(recipe).to receive(:platform_family?).with("debian").and_return(true)
-        end
-
-        it "should return true if /var/run/reboot-required exists" do
-          allow(File).to receive(:exist?).with("/var/run/reboot-required").and_return(true)
-          expect(recipe.reboot_pending?).to be_truthy
-        end
-
-        it "should return false if /var/run/reboot-required does not exist" do
-          allow(File).to receive(:exist?).with("/var/run/reboot-required").and_return(false)
-          expect(recipe.reboot_pending?).to be_falsey
-        end
-      end
-
-    end # describe in isolation
-
-    describe "in a recipe" do
-      it "responds to reboot_pending?" do
-        # Chef::Recipe.new(cookbook_name, recipe_name, run_context(node, cookbook_collection, events))
-        recipe = Chef::Recipe.new(nil, nil, Chef::RunContext.new(Chef::Node.new, {}, nil))
-        expect(recipe).to respond_to(:reboot_pending?)
-      end
-    end # describe in a recipe
-
-    describe "in a resource" do
-      it "responds to reboot_pending?" do
-        resource = Chef::Resource.new("Crackerjack::Timing", nil)
-        expect(resource).to respond_to(:reboot_pending?)
-      end
-    end # describe in a resource
-  end
-end

data/spec/unit/dsl/recipe_spec.rb

@@ -1,76 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@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 "chef/dsl/recipe"
-
-RecipeDSLExampleClass = Struct.new(:cookbook_name, :recipe_name)
-class RecipeDSLExampleClass
-  include Chef::DSL::Recipe
-end
-
-RecipeDSLBaseAPI = Struct.new(:cookbook_name, :recipe_name)
-class RecipeDSLExampleSubclass < RecipeDSLBaseAPI
-  include Chef::DSL::Recipe
-end
-
-# TODO: most of DSL::Recipe's implementation is tested in Chef::Recipe's tests,
-# move those to here.
-describe Chef::DSL::Recipe do
-
-  let(:cookbook_name) { "example_cb" }
-  let(:recipe_name) { "example_recipe" }
-
-  shared_examples_for "A Recipe DSL Implementation" do
-
-    it "responds to cookbook_name" do
-      expect(recipe.cookbook_name).to eq(cookbook_name)
-    end
-
-    it "responds to recipe_name" do
-      expect(recipe.recipe_name).to eq(recipe_name)
-    end
-
-    it "responds to shell_out" do
-      expect(recipe.respond_to?(:shell_out)).to be true
-    end
-
-    it "responds to shell_out" do
-      expect(recipe.respond_to?(:shell_out!)).to be true
-    end
-  end
-
-  context "when included in a class that defines the required interface directly" do
-
-    let(:recipe) { RecipeDSLExampleClass.new(cookbook_name, recipe_name) }
-
-    include_examples "A Recipe DSL Implementation"
-
-  end
-
-  # This is the situation that occurs when the Recipe DSL gets mixed in to a
-  # resource, for example.
-  context "when included in a class that defines the required interface in a superclass" do
-
-    let(:recipe) { RecipeDSLExampleSubclass.new(cookbook_name, recipe_name) }
-
-    include_examples "A Recipe DSL Implementation"
-
-  end
-
-end