chefspec 7.0.0 → 9.3.8

data/lib/chefspec/api/link.rb

@@ -1,102 +1,28 @@
-module ChefSpec::API
-  # @since 1.1.0
-  module LinkMatchers
-    ChefSpec.define_matcher :link
+module ChefSpec
+  module API
+    module Link
+      #
+      # Assert that a symlink links to a specific path. This is really
+      # syntactic sugar for the following:
+      #
+      #       expect(chef_run).to create_link('/tmp/thing').with(to: '/tmp/other_thing')
+      #
+      # @example Using +link_to+ with a String path
+      #   link = chef_run.link('/tmp/thing')
+      #   expect(link).to link_to('/tmp/other_thing')
+      #
+      # @example Using +link_to+ with a regular expression
+      #   expect(link).to link_to(/\/tmp/(.+)/)
+      #
+      # @param [String, Regex] path
+      #   the path to link to
+      #
+      # @return [ChefSpec::Matchers::LinkToMatcher]
+      #
+      def link_to(path)
+        ChefSpec::Matchers::LinkToMatcher.new(path)
+      end
 
-    #
-    # Assert that a +link+ resource exists in the Chef run with the
-    # action +:create+. Given a Chef Recipe that creates "/tmp" as a
-    # +link+:
-    #
-    #     link '/tmp' do
-    #       action :create
-    #     end
-    #
-    # The Examples section demonstrates the different ways to test a
-    # +link+ resource with ChefSpec.
-    #
-    # @example Assert that a +link+ was created
-    #   expect(chef_run).to create_link('/tmp')
-    #
-    # @example Assert that a +link+ was created with predicate matchers
-    #   expect(chef_run).to create_link('/tmp').with_link_type(:hard)
-    #
-    # @example Assert that a +link+ was created with attributes
-    #   expect(chef_run).to create_link('/tmp').with(link_type: :hard)
-    #
-    # @example Assert that a +link+ was created using a regex
-    #   expect(chef_run).to create_link('/tmp').with(link_type: Symbol)
-    #
-    # @example Assert that a +link+ was _not_ created
-    #   expect(chef_run).to_not create_link('/tmp')
-    #
-    #
-    # @param [String, Regex] resource_name
-    #   the name of the resource to match
-    #
-    # @return [ChefSpec::Matchers::ResourceMatcher]
-    #
-    def create_link(resource_name)
-      ChefSpec::Matchers::ResourceMatcher.new(:link, :create, resource_name)
-    end
-
-    #
-    # Assert that a +link+ resource exists in the Chef run with the
-    # action +:delete+. Given a Chef Recipe that deletes "/tmp" as a
-    # +link+:
-    #
-    #     link '/tmp' do
-    #       action :delete
-    #     end
-    #
-    # The Examples section demonstrates the different ways to test a
-    # +link+ resource with ChefSpec.
-    #
-    # @example Assert that a +link+ was deleted
-    #   expect(chef_run).to delete_link('/tmp')
-    #
-    # @example Assert that a +link+ was deleted with predicate matchers
-    #   expect(chef_run).to delete_link('/tmp').with_link_type(:hard)
-    #
-    # @example Assert that a +link+ was deleted with attributes
-    #   expect(chef_run).to delete_link('/tmp').with(link_type: :hard)
-    #
-    # @example Assert that a +link+ was deleted using a regex
-    #   expect(chef_run).to delete_link('/tmp').with(link_type: Symbol)
-    #
-    # @example Assert that a +link+ was _not_ deleted
-    #   expect(chef_run).to_not delete_link('/tmp')
-    #
-    #
-    # @param [String, Regex] resource_name
-    #   the name of the resource to match
-    #
-    # @return [ChefSpec::Matchers::ResourceMatcher]
-    #
-    def delete_link(resource_name)
-      ChefSpec::Matchers::ResourceMatcher.new(:link, :delete, resource_name)
-    end
-
-    #
-    # Assert that a symlink links to a specific path. This is really
-    # syntactic sugar for the following:
-    #
-    #       expect(chef_run).to create_link('/tmp/thing').with(to: '/tmp/other_thing')
-    #
-    # @example Using +link_to+ with a String path
-    #   link = chef_run.link('/tmp/thing')
-    #   expect(link).to link_to('/tmp/other_thing')
-    #
-    # @example Using +link_to+ with a regular expression
-    #   expect(link).to link_to(/\/tmp/(.+)/)
-    #
-    # @param [String, Regex] path
-    #   the path to link to
-    #
-    # @return [ChefSpec::Matchers::LinkToMatcher]
-    #
-    def link_to(path)
-      ChefSpec::Matchers::LinkToMatcher.new(path)
     end
   end
 end

data/lib/chefspec/api/notifications.rb

@@ -1,38 +1,40 @@
-module ChefSpec::API
-  # @since 0.9.0
-  module NotificationsMatchers
-    #
-    # Assert that a resource notifies another. Given a Chef Recipe that
-    # notifies a template resource to restart apache:
-    #
-    #     template '/etc/apache2/config' do
-    #       notifies :restart, 'service[apache2]'
-    #     end
-    #
-    # The Examples section demonstrates the different ways to test an
-    # notifications on a resource with ChefSpec.
-    #
-    # @example Assert the template notifies apache of something
-    #   template = chef_run.template('/etc/apache2.conf')
-    #   expect(template).to notify('service[apache2]')
-    #
-    # @example Assert the template notifies apache to restart
-    #   expect(template).to notify('service[apache2]').to(:restart)
-    #
-    # @example Assert the template notifies apache to restart immediately
-    #   expect(template).to notify('service[apache2]').to(:restart).immediately
-    #
-    # @example Assert the template notifies apache to restart delayed
-    #   expect(template).to notify('service[apache2]').to(:restart).delayed
-    #
-    #
-    # @param [String] signature
-    #   the signature of the notification to match
-    #
-    # @return [ChefSpec::Matchers::NotificationsMatcher]
-    #
-    def notify(signature)
-      ChefSpec::Matchers::NotificationsMatcher.new(signature)
+module ChefSpec
+  module API
+    module Notifications
+      #
+      # Assert that a resource notifies another. Given a Chef Recipe that
+      # notifies a template resource to restart apache:
+      #
+      #     template '/etc/apache2/config' do
+      #       notifies :restart, 'service[apache2]'
+      #     end
+      #
+      # The Examples section demonstrates the different ways to test an
+      # notifications on a resource with ChefSpec.
+      #
+      # @example Assert the template notifies apache of something
+      #   template = chef_run.template('/etc/apache2.conf')
+      #   expect(template).to notify('service[apache2]')
+      #
+      # @example Assert the template notifies apache to restart
+      #   expect(template).to notify('service[apache2]').to(:restart)
+      #
+      # @example Assert the template notifies apache to restart immediately
+      #   expect(template).to notify('service[apache2]').to(:restart).immediately
+      #
+      # @example Assert the template notifies apache to restart delayed
+      #   expect(template).to notify('service[apache2]').to(:restart).delayed
+      #
+      #
+      # @param [String] signature
+      #   the signature of the notification to match
+      #
+      # @return [ChefSpec::Matchers::NotificationsMatcher]
+      #
+      def notify(signature)
+        ChefSpec::Matchers::NotificationsMatcher.new(signature)
+      end
+
     end
   end
 end

data/lib/chefspec/api/reboot.rb

@@ -1,18 +1,14 @@
-module ChefSpec::API
-  # @since 0.5.0
-  module RebootMatchers
-    ChefSpec.define_matcher :reboot
+module ChefSpec
+  module API
+    module Reboot
+      def now_reboot(resource_name)
+        ChefSpec::Matchers::ResourceMatcher.new(:reboot, :reboot_now, resource_name)
+      end
 
-    def now_reboot(resource_name)
-      ChefSpec::Matchers::ResourceMatcher.new(:reboot, :reboot_now, resource_name)
-    end
-
-    def request_reboot(resource_name)
-      ChefSpec::Matchers::ResourceMatcher.new(:reboot, :request_reboot, resource_name)
-    end
+      def request_reboot(resource_name)
+        ChefSpec::Matchers::ResourceMatcher.new(:reboot, :request_reboot, resource_name)
+      end
 
-    def cancel_reboot(resource_name)
-      ChefSpec::Matchers::ResourceMatcher.new(:reboot, :cancel, resource_name)
     end
   end
 end

data/lib/chefspec/api/render_file.rb

@@ -1,35 +1,37 @@
-module ChefSpec::API
-  # @since 3.0.0
-  module RenderFileMatchers
-    #
-    # Assert that a file is rendered by the Chef run. This matcher works for
-    # +template+, +file+, and +cookbook_file+ resources. The content from the
-    # resource must be convertable to a string; verifying the content of a
-    # binary file is not permissible at this time.
-    #
-    # @example Assert a template is rendered
-    #   expect(chef_run).to render_file('/etc/foo')
-    #
-    # @example Assert a template is rendered with certain content
-    #   expect(template).to render_file('/etc/foo').with_content('This is a file')
-    #
-    # @example Assert a template is rendered with matching content
-    #   expect(template).to render_file('/etc/foo').with_content(/^This(.+)$/)
-    #
-    # @example Assert a template is rendered with content matching any RSpec matcher
-    #   expect(template).to render_file('/etc/foo').with_content(starts_with('This'))
-    #
-    # @example Assert a partial path to a template is rendered with matching content
-    #   expect(template).to render_file(/\/etc\/foo-(\d+)$/).with_content(/^This(.+)$/)
-    #
-    #
-    # @param [String] path
-    #   the path of the file to render
-    #
-    # @return [ChefSpec::Matchers::RenderFileMatcher]
-    #
-    def render_file(path)
-      ChefSpec::Matchers::RenderFileMatcher.new(path)
+module ChefSpec
+  module API
+    module RenderFile
+      #
+      # Assert that a file is rendered by the Chef run. This matcher works for
+      # +template+, +file+, and +cookbook_file+ resources. The content from the
+      # resource must be convertable to a string; verifying the content of a
+      # binary file is not permissible at this time.
+      #
+      # @example Assert a template is rendered
+      #   expect(chef_run).to render_file('/etc/foo')
+      #
+      # @example Assert a template is rendered with certain content
+      #   expect(template).to render_file('/etc/foo').with_content('This is a file')
+      #
+      # @example Assert a template is rendered with matching content
+      #   expect(template).to render_file('/etc/foo').with_content(/^This(.+)$/)
+      #
+      # @example Assert a template is rendered with content matching any RSpec matcher
+      #   expect(template).to render_file('/etc/foo').with_content(starts_with('This'))
+      #
+      # @example Assert a partial path to a template is rendered with matching content
+      #   expect(template).to render_file(/\/etc\/foo-(\d+)$/).with_content(/^This(.+)$/)
+      #
+      #
+      # @param [String] path
+      #   the path of the file to render
+      #
+      # @return [ChefSpec::Matchers::RenderFileMatcher]
+      #
+      def render_file(path)
+        ChefSpec::Matchers::RenderFileMatcher.new(path)
+      end
+
     end
   end
 end

data/lib/chefspec/api/state_attrs.rb

@@ -1,28 +1,30 @@
-module ChefSpec::API
-  # @since 3.1.0
-  module StateAttrsMatcher
-    #
-    # Assert that a Chef resource has certain state attributes (since Chef
-    # 11.8.0):
-    #
-    #     state_attrs :time, :temperature
-    #
-    # @see https://github.com/opscode/chef/blob/e43d7ebda/lib/chef/resource/file.rb#L32-L37
-    #
-    # The Examples section demonstrates the different ways to test a
-    # resource's +state_attrs+ with ChefSpec.
-    #
-    # @example Assert the +lwrp+ resource has two state attributes
-    #   expect(lwrp).to have_state_attrs(:time, :temperature)
-    #
-    #
-    # @param [Array] state_attrs
-    #   the list of state attributes to assert
-    #
-    # @return [ChefSpec::Matchers::StateAttrsMatcher]
-    #
-    def have_state_attrs(*state_attrs)
-      ChefSpec::Matchers::StateAttrsMatcher.new(state_attrs)
+module ChefSpec
+  module API
+    module StateAttrs
+      #
+      # Assert that a Chef resource has certain state attributes (since Chef
+      # 11.8.0):
+      #
+      #     state_attrs :time, :temperature
+      #
+      # @see https://github.com/opscode/chef/blob/e43d7ebda/lib/chef/resource/file.rb#L32-L37
+      #
+      # The Examples section demonstrates the different ways to test a
+      # resource's +state_attrs+ with ChefSpec.
+      #
+      # @example Assert the +lwrp+ resource has two state attributes
+      #   expect(lwrp).to have_state_attrs(:time, :temperature)
+      #
+      #
+      # @param [Array] state_attrs
+      #   the list of state attributes to assert
+      #
+      # @return [ChefSpec::Matchers::StateAttrsMatcher]
+      #
+      def have_state_attrs(*state_attrs)
+        ChefSpec::Matchers::StateAttrsMatcher.new(state_attrs)
+      end
+
     end
   end
 end

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