chefspec 7.0.0 → 9.3.8

data/lib/chefspec/api/subscriptions.rb

@@ -1,35 +1,37 @@
-module ChefSpec::API
-  # @since 3.2.0
-  module SubscriptionsMatchers
-    #
-    # 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,228 +1,230 @@
-module ChefSpec::API
-  # @since 0.3.0
-  module UserMatchers
-    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

data/lib/chefspec/api.rb

@@ -1,96 +1,39 @@
 module ChefSpec
   module API
-    extend self
+    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(base)
-      submodules.each do |child|
-        base.send(:include, child)
-      end
-    end
-
-    private
+    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)
 
-    #
-    # WARNING: This is metaprogramming madness. Find all modules who are
-    # nested beneath this module.
-    #
-    # @return [Array<Module>]
-    #
-    def submodules
-      self.constants
-        .map { |name| const_get(name) }
-        .select { |const| const.class == Module }
+      # 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
-
-require_relative 'api/apt_package'
-require_relative 'api/apt_update'
-require_relative 'api/apt_repository'
-require_relative 'api/bff_package'
-require_relative 'api/batch'
-require_relative 'api/cab_package'
-require_relative 'api/chef_gem'
-require_relative 'api/chocolatey_package'
-require_relative 'api/cookbook_file'
-require_relative 'api/cron'
-require_relative 'api/deploy'
-require_relative 'api/directory'
-require_relative 'api/dnf_package'
-require_relative 'api/dpkg_package'
-require_relative 'api/do_nothing'
-require_relative 'api/dsc_resource'
-require_relative 'api/dsc_script'
-require_relative 'api/easy_install_package'
-require_relative 'api/env'
-require_relative 'api/erl_call'
-require_relative 'api/execute'
-require_relative 'api/file'
-require_relative 'api/freebsd_package'
-require_relative 'api/gem_package'
-require_relative 'api/git'
-require_relative 'api/group'
-require_relative 'api/homebrew_package'
-require_relative 'api/http_request'
-require_relative 'api/ifconfig'
-require_relative 'api/include_recipe'
-require_relative 'api/ips_package'
-require_relative 'api/launchd'
-require_relative 'api/link'
-require_relative 'api/log'
-require_relative 'api/macports_package'
-require_relative 'api/mdadm'
-require_relative 'api/mount'
-require_relative 'api/msu_package'
-require_relative 'api/notifications'
-require_relative 'api/ohai'
-require_relative 'api/openbsd_package'
-require_relative 'api/osx_profile'
-require_relative 'api/package'
-require_relative 'api/pacman_package'
-require_relative 'api/paludis_package'
-require_relative 'api/portage_package'
-require_relative 'api/powershell_script'
-require_relative 'api/reboot'
-require_relative 'api/registry_key'
-require_relative 'api/remote_directory'
-require_relative 'api/remote_file'
-require_relative 'api/render_file'
-require_relative 'api/route'
-require_relative 'api/rpm_package'
-require_relative 'api/ruby_block'
-require_relative 'api/script'
-require_relative 'api/service'
-require_relative 'api/smartos_package'
-require_relative 'api/solaris_package'
-require_relative 'api/state_attrs'
-require_relative 'api/subscriptions'
-require_relative 'api/subversion'
-require_relative 'api/systemd_unit'
-require_relative 'api/template'
-require_relative 'api/user'
-require_relative 'api/windows_package'
-require_relative 'api/windows_service'
-require_relative 'api/yum_package'
-require_relative 'api/yum_repository'
-require_relative 'api/zypper_package'