chefspec-chef 9.3.4

data/lib/chefspec/api/stubs.rb

@@ -0,0 +1,183 @@
+module ChefSpec
+  module API
+    module Stubs
+      #
+      # Stub a shell command to return a particular value without
+      # shelling out to the system.
+      #
+      # @example stubbing a command to return true
+      #   stub_command('test -f /tmp/bacon').and_return(true)
+      #
+      # @example stubbing a block that is evaluated at runtime
+      #   stub_command('test -f /tmp/bacon') { MyClass.check? }
+      #
+      # @example stubbing a command that matches a pattern
+      #   stub_command(/test \-f/).and_return(true)
+      #
+      # @example stubbing a command that raises an exception
+      #   stub_command('test -f /tmp/bacon').and_raise(SomeException)
+      #
+      #
+      # @param [String, Regexp] command
+      #   the command to stub
+      #
+      # @return [ChefSpec::CommandStub]
+      #
+      def stub_command(command, &block)
+        ChefSpec::Stubs::CommandRegistry.register(ChefSpec::Stubs::CommandStub.new(command, &block))
+      end
+
+      #
+      # Stub a Chef call to load a data_bag.
+      #
+      # @example stubbing a data_bag to return an empty Array
+      #   stub_data_bag('users').and_return([])
+      #
+      # @example stubbing a data_bag with a block that is evaluated at runtime
+      #   stub_data_bag('users') { JSON.parse(File.read('fixtures/data_bag.json')) }
+      #
+      # @example stubbing a data_bag to return an Array of Hashes
+      #   stub_data_bag('users').and_return([
+      #     { id: 'bacon', comment: 'delicious' },
+      #     { id: 'ham', comment: 'also good' }
+      #   ])
+      #
+      # @example stubbing a data_bag to raise an exception
+      #   stub_data_bag('users').and_raise(Chef::Exceptions::PrivateKeyMissing)
+      #
+      #
+      # @param [String, Symbol] bag
+      #   the name of the data bag to stub
+      #
+      # @return [ChefSpec::DataBagStub]
+      #
+      def stub_data_bag(bag, &block)
+        ChefSpec::Stubs::DataBagRegistry.register(ChefSpec::Stubs::DataBagStub.new(bag, &block))
+      end
+
+      #
+      # Stub a Chef data_bag call.
+      #
+      # @example stubbing a data_bag_item to return a Hash of data
+      #   stub_data_bag_item('users', 'svargo').and_return({
+      #     id: 'svargo',
+      #     name: 'Seth Vargo'
+      #   })
+      #
+      # @example stubbing a data_bag_item with a block that is evaluated at runtime
+      #   stub_data_bag_item('users', 'svargo') { JSON.parse(File.read('fixtures/data_bag_item.json')) }
+      #
+      # @example stubbing a data_bag_item to raise an exception
+      #   stub_data_bag('users', 'svargo').and_raise(Chef::Exceptions::PrivateKeyMissing)
+      #
+      #
+      # @param [String, Symbol] bag
+      #   the name of the data bag to find the item in
+      # @param [String] id
+      #   the id of the data bag item to stub
+      #
+      # @return [ChefSpec::DataBagItemStub]
+      #
+      def stub_data_bag_item(bag, id, &block)
+        ChefSpec::Stubs::DataBagItemRegistry.register(ChefSpec::Stubs::DataBagItemStub.new(bag, id, &block))
+      end
+
+      #
+      # Creates a fake Chef::Node for use in testing.
+      #
+      # @example mocking a simple node
+      #   stub_node('mynode.example')
+      #
+      # @example mocking a specific platform and version
+      #   stub_node('mynode.example', platform: 'ubuntu', version: '18.04')
+      #
+      # @example overriding a specific ohai attribute
+      #   stub_node('mynode.example', ohai: { ipaddress: '1.2.3.4' })
+      #
+      # @example stubbing a node based on a JSON fixture
+      #   stub_node('mynode.example', path: File.join('fixtures', 'nodes', 'default.json'))
+      #
+      # @example setting specific attributes
+      #   stub_node('mynode.example') do |node|
+      #     node.default['attribute']['thing'] = 'value'
+      #   end
+      #
+      #
+      # @param [String] name
+      #   the name of the node
+      # @param [Hash] options
+      #   the list of options for the node
+      #
+      # @option options [Symbol] :platform
+      #   the platform to mock
+      # @option options [Symbol] :version
+      #   the version of the platform to mock
+      # @option options [Symbol] :path
+      #   filepath to a JSON file to pull a node from
+      # @option options [Hash] :ohai
+      #   a Hash of Ohai attributes to mock on the node
+      #
+      # @return [Chef::Node]
+      #
+      def stub_node(*args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        name    = args.first || "node.example"
+
+        fauxhai = Fauxhai.mock(options).data
+        fauxhai = fauxhai.merge(options[:ohai] || {})
+        fauxhai = Mash.new(fauxhai)
+
+        node = Chef::Node.new
+        node.name(name)
+        node.automatic_attrs = fauxhai
+        node.instance_eval(&block) if block_given?
+        node
+      end
+
+      #
+      # Stub a Chef search to return pre-defined data. When providing a value,
+      # the value is automatically mashified (to the best of ChefSpec's abilities)
+      # to ease in use.
+      #
+      # @example stubbing a search to return nothing
+      #   stub_search(:node)
+      #
+      # @example stubbing a search with a query
+      #   stub_search(:node, 'name:*')
+      #
+      # @example stubbing a search with a query as a regex
+      #   stub_search(:node, /name:(.+)/)
+      #
+      # @example stubbing a search with a block that is evaluated at runtime
+      #   stub_search(:node) { JSON.parse(File.read('fixtures/nodes.json')) }
+      #
+      # @example stubbing a search to return a fixed value
+      #   stub_search(:node).and_return([ { a: 'b' } ])
+      #
+      # @example stubbing a search to raise an exception
+      #   stub_search(:node).and_raise(Chef::Exceptions::PrivateKeyMissing)
+      #
+      #
+      # @param [String, Symbol] type
+      #   the type to search to stub
+      # @param [String, Symbol, nil] query
+      #   the query to stub
+      #
+      # @return [ChefSpec::SearchStub]
+      #
+      def stub_search(type, query = "*:*", &block)
+        ChefSpec::Stubs::SearchRegistry.register(ChefSpec::Stubs::SearchStub.new(type, query, &block))
+      end
+
+      # Automatically clear all stubs after each test.
+      extend RSpec::SharedContext
+      after(:each) do
+        ChefSpec::Stubs::CommandRegistry.reset!
+        ChefSpec::Stubs::DataBagRegistry.reset!
+        ChefSpec::Stubs::DataBagItemRegistry.reset!
+        ChefSpec::Stubs::SearchRegistry.reset!
+      end
+
+    end
+  end
+end

data/lib/chefspec/api/stubs_for.rb

@@ -0,0 +1,139 @@
+require "chef/version"
+require "mixlib/shellout" unless defined?(Mixlib::ShellOut)
+
+module ChefSpec
+  module API
+    module StubsFor
+      # Pull in the needed machinery to use `before` here.
+      extend RSpec::SharedContext
+
+      # Which version to use the shell_out_compacted hook on.
+      HAS_SHELLOUT_COMPACTED = Gem::Requirement.create("> 14.2")
+
+      # Hook used in the monkey patches to set up a place to inject stubs when
+      # needed for a resource or provider.
+      #
+      # @api private
+      # @param object [Chef::Resource, Chef::Provider] Resource or provider to inject
+      # @param type [Symbol] Type of object to register stubs on
+      # @return [void]
+      def self.setup_stubs_for(object, type)
+        # This space left intentionally blank, real implementation is below.
+      end
+
+      # Place to hold any stubs which should be active for this example.
+      let(:_chefspec_stubs_for_registry) do
+        # Auto-vivify for things like _chefspec_stubs_for_registry[:resource]['my_resource'] == [].
+        Hash.new do |hash, key|
+          hash[key] = Hash.new do |inner_hash, inner_key|
+            inner_hash[inner_key] = []
+          end
+        end
+      end
+
+      # Take over from the default, no-op implementation of {.setup_stubs_for}.
+      before do
+        allow(StubsFor).to receive(:setup_stubs_for) do |object, type|
+          type_stubs = _chefspec_stubs_for_registry[type]
+          resource_object = object.respond_to?(:new_resource) ? object.new_resource : object
+          stubs = type_stubs[nil] + type_stubs[resource_object.resource_name.to_s] + type_stubs[resource_object.to_s]
+          stubs.each do |stub|
+            instance_exec(object, &stub)
+          end
+        end
+      end
+
+      # Register stubs for resource objects.
+      #
+      # The `target` parameter can select either a resource string like `'package[foo]'`,
+      # a resource name like `'package'`, or `nil` for all resources.
+      #
+      # @example Setting method stub on a single resource
+      #   it "does a thing" do
+      #     stubs_for_resource("my_resource[foo]") do |res|
+      #       expect(res).to receive_shell_out.with("my_command").and_return(stdout: "asdf")
+      #     end
+      #     expect(subject.some_method).to eq "asdf"
+      #   end
+      # @param target [String, nil] Resource name to inject, or nil for all resources.
+      # @param current_value [Boolean] If true, also register stubs for current_value objects on the same target.
+      # @param block [Proc] A block taking the resource object as a parameter.
+      # @return [void]
+      def stubs_for_resource(target = nil, current_value: true, current_resource: true, &block)
+        current_value = false unless current_resource
+        _chefspec_stubs_for_registry[:resource][target] << block
+        stubs_for_current_value(target, &block) if current_value
+      end
+
+      # Register stubs for current_value objects.
+      #
+      # @see #stubs_for_resource
+      # @param target [String, nil] Resource name to inject, or nil for all resources.
+      # @param block [Proc] A block taking the resource object as a parameter.
+      # @return [void]
+      def stubs_for_current_value(target = nil, &block)
+        _chefspec_stubs_for_registry[:current_value][target] << block
+      end
+      alias_method :stubs_for_current_resource, :stubs_for_current_value
+
+      # Register stubs for provider objects.
+      #
+      # @see #stubs_for_resource
+      # @param target [String, nil] Resource name to inject, or nil for all providers.
+      # @param block [Proc] A block taking the resource object as a parameter.
+      # @return [void]
+      def stubs_for_provider(target = nil, &block)
+        _chefspec_stubs_for_registry[:provider][target] << block
+      end
+
+      def receive_shell_out(*cmd, stdout: "", stderr: "", exitstatus: 0, **opts)
+        # Ruby does not allow constructing an actual exitstatus object from Ruby code. Really.
+        fake_exitstatus = double(exitstatus: exitstatus)
+        fake_cmd = Mixlib::ShellOut.new(*cmd)
+        fake_cmd.define_singleton_method(:run_command) {} # Do nothing, just in case.
+        # Inject our canned data.
+        fake_cmd.instance_exec do
+          @stdout = stdout
+          @stderr = stderr
+          @status = fake_exitstatus
+        end
+        # On newer Chef, we can intercept using the new, better shell_out_compact hook point.
+        shell_out_method ||= if HAS_SHELLOUT_COMPACTED.satisfied_by?(Gem::Version.create(Chef::VERSION))
+                               :shell_out_compacted
+                             else
+                               :shell_out
+                             end
+        with_args = cmd + (opts.empty? ? [any_args] : [hash_including(opts)])
+        receive(shell_out_method).with(*with_args).and_return(fake_cmd)
+      end
+
+      module ClassMethods
+        # (see StubsFor#stubs_for_resource)
+        def stubs_for_resource(*args, **kwargs, &block)
+          before { stubs_for_resource(*args, **kwargs, &block) }
+        end
+
+        # (see StubsFor#stubs_for_current_value)
+        def stubs_for_current_value(*args, &block)
+          before { stubs_for_current_value(*args, &block) }
+        end
+        alias_method :stubs_for_current_resource, :stubs_for_current_value
+
+        # (see StubsFor#stubs_for_provider)
+        def stubs_for_provider(*args, &block)
+          before { stubs_for_provider(*args, &block) }
+        end
+
+        # @api private
+        def included(klass)
+          super
+          # Inject classmethods into the group.
+          klass.extend(ClassMethods)
+        end
+      end
+
+      extend ClassMethods
+
+    end
+  end
+end

data/lib/chefspec/api/subscriptions.rb

@@ -0,0 +1,37 @@
+module ChefSpec
+  module API
+    module Subscriptions
+      #
+      # Assert that a resource subscribes to another. Given a Chef Recipe that
+      # subscribes a template resource to restart apache:
+      #
+      #     service 'apache2' do
+      #       subscribes :create, 'template[/etc/apache2/config]'
+      #     end
+      #
+      # The Examples section demonstrates the different ways to test a
+      # subscription on a resource with ChefSpec.
+      #
+      # @example Assert a basic subscription
+      #   service = chef_run.service('apache2')
+      #   expect(service).to subscribe_to('template[/etc/apache2/config]')
+      #
+      # @example Assert a subscription with specified action
+      #   expect(service).to subscribe_to('template[/etc/apache2/config]').on(:restart)
+      #
+      # @example Assert a subscription with specified action and timing
+      #   expect(service).to subscribe_to('template[/etc/apache2/config]').on(:restart).immediately
+      #
+      #
+      # @param [String] signature
+      #   the signature of the notification to match
+      #
+      # @return [ChefSpec::Matchers::NotificationsMatcher]
+      #
+      def subscribe_to(signature)
+        ChefSpec::Matchers::SubscribesMatcher.new(signature)
+      end
+
+    end
+  end
+end

data/lib/chefspec/api/user.rb

@@ -0,0 +1,230 @@
+module ChefSpec
+  module API
+    module User
+      ChefSpec.define_matcher :user
+
+      #
+      # Assert that a +user+ resource exists in the Chef run with the
+      # action +:create+. Given a Chef Recipe that creates "apache2" as a
+      # +user+:
+      #
+      #     user 'apache2' do
+      #       action :create
+      #     end
+      #
+      # The Examples section demonstrates the different ways to test a
+      # +user+ resource with ChefSpec.
+      #
+      # @example Assert that a +user+ was created
+      #   expect(chef_run).to create_user('apache2')
+      #
+      # @example Assert that a +user+ was created with predicate matchers
+      #   expect(chef_run).to create_user('apache2').with_uid(1234)
+      #
+      # @example Assert that a +user+ was created with attributes
+      #   expect(chef_run).to create_user('apache2').with(uid: 1234)
+      #
+      # @example Assert that a +user+ was created using a regex
+      #   expect(chef_run).to create_user('apache2').with(uid: /\d+/)
+      #
+      # @example Assert that a +user+ was _not_ created
+      #   expect(chef_run).to_not create_user('apache2')
+      #
+      #
+      # @param [String, Regex] resource_name
+      #   the name of the resource to match
+      #
+      # @return [ChefSpec::Matchers::ResourceMatcher]
+      #
+      def create_user(resource_name)
+        ChefSpec::Matchers::ResourceMatcher.new(:user, :create, resource_name)
+      end
+
+      #
+      # Assert that a +user+ resource exists in the Chef run with the
+      # action +:remove+. Given a Chef Recipe that removes "apache2" as a
+      # +user+:
+      #
+      #     user 'apache2' do
+      #       action :remove
+      #     end
+      #
+      # The Examples section demonstrates the different ways to test a
+      # +user+ resource with ChefSpec.
+      #
+      # @example Assert that a +user+ was remove
+      #   expect(chef_run).to remove_user('apache2')
+      #
+      # @example Assert that a +user+ was remove with predicate matchers
+      #   expect(chef_run).to remove_user('apache2').with_uid(1234)
+      #
+      # @example Assert that a +user+ was remove with attributes
+      #   expect(chef_run).to remove_user('apache2').with(uid: 1234)
+      #
+      # @example Assert that a +user+ was remove using a regex
+      #   expect(chef_run).to remove_user('apache2').with(uid: /\d+/)
+      #
+      # @example Assert that a +user+ was _not_ remove
+      #   expect(chef_run).to_not remove_user('apache2')
+      #
+      #
+      # @param [String, Regex] resource_name
+      #   the name of the resource to match
+      #
+      # @return [ChefSpec::Matchers::ResourceMatcher]
+      #
+      def remove_user(resource_name)
+        ChefSpec::Matchers::ResourceMatcher.new(:user, :remove, resource_name)
+      end
+
+      #
+      # Assert that a +user+ resource exists in the Chef run with the
+      # action +:modify+. Given a Chef Recipe that modifies "apache2" as a
+      # +user+:
+      #
+      #     user 'apache2' do
+      #       action :modify
+      #     end
+      #
+      # The Examples section demonstrates the different ways to test a
+      # +user+ resource with ChefSpec.
+      #
+      # @example Assert that a +user+ was modified
+      #   expect(chef_run).to modify_user('apache2')
+      #
+      # @example Assert that a +user+ was modified with predicate matchers
+      #   expect(chef_run).to modify_user('apache2').with_uid(1234)
+      #
+      # @example Assert that a +user+ was modified with attributes
+      #   expect(chef_run).to modify_user('apache2').with(uid: 1234)
+      #
+      # @example Assert that a +user+ was modified using a regex
+      #   expect(chef_run).to modify_user('apache2').with(uid: /\d+/)
+      #
+      # @example Assert that a +user+ was _not_ modified
+      #   expect(chef_run).to_not modify_user('apache2')
+      #
+      #
+      # @param [String, Regex] resource_name
+      #   the name of the resource to match
+      #
+      # @return [ChefSpec::Matchers::ResourceMatcher]
+      #
+      def modify_user(resource_name)
+        ChefSpec::Matchers::ResourceMatcher.new(:user, :modify, resource_name)
+      end
+
+      #
+      # Assert that a +user+ resource exists in the Chef run with the
+      # action +:manage+. Given a Chef Recipe that manages "apache2" as a
+      # +user+:
+      #
+      #     user 'apache2' do
+      #       action :manage
+      #     end
+      #
+      # The Examples section demonstrates the different ways to test a
+      # +user+ resource with ChefSpec.
+      #
+      # @example Assert that a +user+ was managed
+      #   expect(chef_run).to manage_user('apache2')
+      #
+      # @example Assert that a +user+ was managed with predicate matchers
+      #   expect(chef_run).to manage_user('apache2').with_uid(1234)
+      #
+      # @example Assert that a +user+ was managed with attributes
+      #   expect(chef_run).to manage_user('apache2').with(uid: 1234)
+      #
+      # @example Assert that a +user+ was managed using a regex
+      #   expect(chef_run).to manage_user('apache2').with(uid: /\d+/)
+      #
+      # @example Assert that a +user+ was _not_ managed
+      #   expect(chef_run).to_not manage_user('apache2')
+      #
+      #
+      # @param [String, Regex] resource_name
+      #   the name of the resource to match
+      #
+      # @return [ChefSpec::Matchers::ResourceMatcher]
+      #
+      def manage_user(resource_name)
+        ChefSpec::Matchers::ResourceMatcher.new(:user, :manage, resource_name)
+      end
+
+      #
+      # Assert that a +user+ resource exists in the Chef run with the
+      # action +:lock+. Given a Chef Recipe that locks "apache2" as a
+      # +user+:
+      #
+      #     user 'apache2' do
+      #       action :lock
+      #     end
+      #
+      # The Examples section demonstrates the different ways to test a
+      # +user+ resource with ChefSpec.
+      #
+      # @example Assert that a +user+ was locked
+      #   expect(chef_run).to lock_user('apache2')
+      #
+      # @example Assert that a +user+ was locked with predicate matchers
+      #   expect(chef_run).to lock_user('apache2').with_uid(1234)
+      #
+      # @example Assert that a +user+ was locked with attributes
+      #   expect(chef_run).to lock_user('apache2').with(uid: 1234)
+      #
+      # @example Assert that a +user+ was locked using a regex
+      #   expect(chef_run).to lock_user('apache2').with(uid: /\d+/)
+      #
+      # @example Assert that a +user+ was _not_ locked
+      #   expect(chef_run).to_not lock_user('apache2')
+      #
+      #
+      # @param [String, Regex] resource_name
+      #   the name of the resource to match
+      #
+      # @return [ChefSpec::Matchers::ResourceMatcher]
+      #
+      def lock_user(resource_name)
+        ChefSpec::Matchers::ResourceMatcher.new(:user, :lock, resource_name)
+      end
+
+      #
+      # Assert that a +user+ resource exists in the Chef run with the
+      # action +:unlock+. Given a Chef Recipe that unlocks "apache2" as a
+      # +user+:
+      #
+      #     user 'apache2' do
+      #       action :unlock
+      #     end
+      #
+      # The Examples section demonstrates the different ways to test a
+      # +user+ resource with ChefSpec.
+      #
+      # @example Assert that a +user+ was unlocked
+      #   expect(chef_run).to unlock_user('apache2')
+      #
+      # @example Assert that a +user+ was unlocked with predicate matchers
+      #   expect(chef_run).to unlock_user('apache2').with_uid(1234)
+      #
+      # @example Assert that a +user+ was unlocked with attributes
+      #   expect(chef_run).to unlock_user('apache2').with(uid: 1234)
+      #
+      # @example Assert that a +user+ was unlocked using a regex
+      #   expect(chef_run).to unlock_user('apache2').with(uid: /\d+/)
+      #
+      # @example Assert that a +user+ was _not_ unlocked
+      #   expect(chef_run).to_not unlock_user('apache2')
+      #
+      #
+      # @param [String, Regex] resource_name
+      #   the name of the resource to match
+      #
+      # @return [ChefSpec::Matchers::ResourceMatcher]
+      #
+      def unlock_user(resource_name)
+        ChefSpec::Matchers::ResourceMatcher.new(:user, :unlock, resource_name)
+      end
+
+    end
+  end
+end

data/lib/chefspec/api.rb

@@ -0,0 +1,39 @@
+module ChefSpec
+  module API
+    autoload :Core, "chefspec/api/core"
+    autoload :Described, "chefspec/api/described"
+    autoload :DoNothing, "chefspec/api/do_nothing"
+    autoload :IncludeAnyRecipe, "chefspec/api/include_any_recipe"
+    autoload :IncludeRecipe, "chefspec/api/include_recipe"
+    autoload :Link, "chefspec/api/link"
+    autoload :Notifications, "chefspec/api/notifications"
+    autoload :Reboot, "chefspec/api/reboot"
+    autoload :RenderFile, "chefspec/api/render_file"
+    autoload :StateAttrs, "chefspec/api/state_attrs"
+    autoload :Stubs, "chefspec/api/stubs"
+    autoload :StubsFor, "chefspec/api/stubs_for"
+    autoload :Subscriptions, "chefspec/api/subscriptions"
+    autoload :User, "chefspec/api/user"
+
+    def self.included(klass)
+      # non-resources
+      klass.include(ChefSpec::API::Core)
+      klass.include(ChefSpec::API::Described)
+      klass.include(ChefSpec::API::DoNothing)
+      klass.include(ChefSpec::API::IncludeAnyRecipe)
+      klass.include(ChefSpec::API::IncludeRecipe)
+      klass.include(ChefSpec::API::DoNothing)
+      klass.include(ChefSpec::API::RenderFile)
+      klass.include(ChefSpec::API::StateAttrs)
+      klass.include(ChefSpec::API::Notifications)
+      klass.include(ChefSpec::API::Stubs)
+      klass.include(ChefSpec::API::StubsFor)
+      klass.include(ChefSpec::API::Subscriptions)
+
+      # hacks and sugar for resources that don't follow the normal pattern
+      klass.include(ChefSpec::API::User)
+      klass.include(ChefSpec::API::Link)
+      klass.include(ChefSpec::API::Reboot)
+    end
+  end
+end

data/lib/chefspec/berkshelf.rb

@@ -0,0 +1,63 @@
+begin
+  require "berkshelf"
+rescue LoadError
+  raise ChefSpec::Error::GemLoadError.new(gem: "berkshelf", name: "Berkshelf")
+end
+
+module ChefSpec
+  class Berkshelf
+    class << self
+      extend Forwardable
+      def_delegators :instance, :setup!, :teardown!
+    end
+
+    include Singleton
+
+    def initialize
+      @tmpdir = Dir.mktmpdir
+    end
+
+    #
+    # Setup and install the necessary dependencies in the temporary directory.
+    #
+    def setup!
+      # Get the list of Berkshelf options
+      opts = RSpec.configuration.berkshelf_options
+      unless opts.is_a?(Hash)
+        raise InvalidBerkshelfOptions(value: opts.inspect)
+      end
+
+      berksfile = ::Berkshelf::Berksfile.from_options(opts)
+
+      # Grab a handle to tmpdir, since Berkshelf 2 modifies it a bit
+      tmpdir = File.join(@tmpdir, "cookbooks")
+
+      ::Berkshelf.ui.mute do
+        if ::Berkshelf::Berksfile.method_defined?(:vendor)
+          # Berkshelf 3.0 requires the directory to not exist
+          FileUtils.rm_rf(tmpdir)
+          berksfile.vendor(tmpdir)
+        else
+          berksfile.install(path: tmpdir)
+        end
+      end
+
+      filter = Coverage::BerkshelfFilter.new(berksfile)
+      Coverage.add_filter(filter)
+
+      ::RSpec.configure { |config| config.cookbook_path = tmpdir }
+    end
+
+    #
+    # Destroy the installed Berkshelf at the temporary directory.
+    #
+    def teardown!
+      FileUtils.rm_rf(@tmpdir) if File.exist?(@tmpdir)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:suite) { ChefSpec::Berkshelf.setup! }
+  config.after(:suite)  { ChefSpec::Berkshelf.teardown! }
+end