chefspec 7.2.1 → 7.3.0

data/lib/chefspec/api/stubs_for.rb

@@ -0,0 +1,134 @@
+require "chef/version"
+
+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.is_a?(Chef::Provider) ? 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_resource [Boolean] If true, also register stubs for current_resource 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_resource: true, &block)
+        _chefspec_stubs_for_registry[:resource][target] << block
+        stubs_for_current_resource(target, &block) if current_resource
+      end
+
+      # Register stubs for current_resource 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_resource(target=nil, &block)
+        _chefspec_stubs_for_registry[:current_resource][target] << block
+      end
+
+      # 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, **opts)
+        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
+        receive(shell_out_method).with(*cmd).and_return(fake_cmd)
+      end
+
+      module ClassMethods
+        # (see StubsFor#stubs_for_resource)
+        def stubs_for_resource(*args, &block)
+          before { stubs_for_resource(*args, &block) }
+        end
+
+        # (see StubsFor#stubs_for_current_resource)
+        def stubs_for_current_resource(*args, &block)
+          before { stubs_for_current_resource(*args, &block) }
+        end
+
+        # (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

@@ -1,32 +1,37 @@
-module ChefSpec::API
-  #
-  # 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)
+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

@@ -1,225 +1,230 @@
-module ChefSpec::API
-  ChefSpec.define_matcher :user
+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 +: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 +: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 +: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 +: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 +: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
 
-  #
-  # 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