mongoid7-rspec-callbacks 1.0.0.pre.816289031

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in evostream-event.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright (c) 2013 Luis Ciudad
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/README.md

@@ -0,0 +1,65 @@
+# Mongoid::Rspec::Callbacks
+  [![RSpec](https://github.com/dazzl-tv/mongoid-rspec-callbacks/actions/workflows/rspec.yml/badge.svg?branch=develop&event=pull_request)](https://github.com/dazzl-tv/mongoid-rspec-callbacks/actions/workflows/rspec.yml)
+  [![Linter](https://github.com/dazzl-tv/mongoid-rspec-callbacks/actions/workflows/linter.yml/badge.svg)](https://github.com/dazzl-tv/mongoid-rspec-callbacks/actions/workflows/linter.yml)
+  [![Gem Version](https://badge.fury.io/rb/mongoid-rspec-callbacks.svg)](https://badge.fury.io/rb/mongoid-rspec-callbacks)
+  [![Docs](https://inch-ci.org/github/dazzl-tv/mongoid-rspec-callbacks.svg)](https://inch-ci.org/github/dazzl-tv/mongoid-rspec-callbacks)
+  [![Maintainability](https://api.codeclimate.com/v1/badges/2538546ea7419c1d5ea1/maintainability)](https://codeclimate.com/github/dazzl-tv/mongoid-rspec-callbacks/maintainability)
+  [![Test Coverage](https://api.codeclimate.com/v1/badges/2538546ea7419c1d5ea1/test_coverage)](https://codeclimate.com/github/dazzl-tv/mongoid-rspec-callbacks/test_coverage)
+  [![Known Vulnerabilities](https://snyk.io/test/github/dazzl-tv/mongoid-rspec-callbacks/badge.svg)](https://snyk.io/test/github/dazzl-tv/mongoid-rspec-callbacks)
+
+http://rubygems.org/gems/mongoid-rspec-callbacks
+
+RSpec Callbacks matchers for Mongoid 7.x and ActiveSupport 6.x
+
+This gem is meant to be use with [mongoid-rpsec](http://rubygems.org/gems/mongoid-rspec), altought it works by itself.
+
+Syntax is the same as [shoulda-callback-matchers](https://github.com/beatrichartz/shoulda-callback-matchers).
+
+By now, only ``on`` option is supported.
+
+## Installation
+
+Add to your Gemfile
+
+```
+gem 'mongoid-rspec-callbacks'
+```
+
+Drop in existing or dedicated support file in spec/support (spec/support/mongoid.rb)
+
+```
+RSpec.configure do |configuration|
+  configuration.include Mongoid::Matchers
+end
+```
+
+## Callbacks Matchers
+
+```
+describe User do
+  it { should callback(:method).before(:save) }
+  it { should callback(:method).after(:save) }
+  it { should callback(:method, :method2).before(:validation) }
+  it { should callback(:method).after(:validation).on(:create) }
+end
+```
+
+## Set Callbacks Matchers
+
+```
+describe User do
+  it { is_expected.to set_callback(:save, :arround)  }
+  it { is_expected.to set_callback(:validation, :after)  }
+end
+```
+
+## Association Callbacks Matchers
+
+```
+describe User do
+  it { is_expected.to association_callback(:has_many,
+                                           :add,
+                                           :after,
+                                           :send_email_to_subscribers)  }
+end
+```

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/matchers/association_callbacks.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Matchers
+    # Create an matcher for set_callback method
+    #
+    # Usage:
+    #
+    # it { is_expected.to association_callback(:has_many,
+    #                                          :add,
+    #                                          :after,
+    #                                          :send_email_to_subscribers)  }
+    class HaveAssociationCallbackMatcher
+      CONTEXTS = %i[before after].freeze
+      OPERATIONS = %i[add remove].freeze
+      RELATIONS = %i[embeds_many has_many and has_and_belongs_to_many].freeze
+
+      def initialize(*args)
+        @relation = args[0]
+        @type = args[1]
+        @hook = args[2]
+        @method = args[3]
+      end
+
+      def matches?(klass)
+        @model = klass
+
+        return false unless \
+          relation_is_correct? ||
+          context_is_correct? ||
+          operation_is_correct? ||
+          callback_is_correct?
+
+        testings_presence_method_callback
+      end
+
+      def description
+        "be association_callback(:#{@type}, :#{@hook})"
+      end
+
+      def failure_message
+        message_error
+      end
+
+      def failure_message_when_negated
+        message_error
+      end
+
+      private
+
+      def relation_is_correct?
+        RELATIONS.include?(@relation)
+      end
+
+      def context_is_correct?
+        CONTEXTS.include?(@hook)
+      end
+
+      def operation_is_correct?
+        OPERATIONS.include?(@type)
+      end
+
+      def callback_is_correct?
+        @model.class.respond_to?(:"_#{@type}_callbacks")
+      end
+
+      def testings_presence_method_callback
+        @model.methods.include?(:"#{@method}")
+      end
+
+      def message_error
+        <<-ERROR
+  expected #{@model} have method callback to association :
+    has_many <relation>, #{@hook}: :#{@method}
+
+    def #{@method}
+    end
+        ERROR
+      end
+    end
+
+    def association_callback(*args)
+      HaveAssociationCallbackMatcher.new(*args)
+    end
+  end
+end

data/lib/matchers/callbacks.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Matchers
+    # Create an matcher for callback method
+    #
+    # Usage:
+    #
+    # it { is_expected.to callback(:callback1).before(:save) }
+    # it { is_expected.to callback(:callback2).after(:save) }
+    # it { is_expected.to callback(:callback1, :callback2).before(:validation) }
+    # it { is_expected.to callback(:callback3).after(:validation).on(:create) }
+    class HaveCallbackMatcher
+      KINDS = %w[before around after].freeze
+
+      # Set methods to look for
+      def initialize(*args)
+        @methods = args || []
+      end
+
+      # Set when callback is fired using @kind and @operation
+      KINDS.each do |kind|
+        define_method(kind.to_sym) do |op|
+          @operation = op
+          @kind = kind.to_sym
+          self
+        end
+      end
+
+      # Set on condition
+      def on(action)
+        @context = action
+        self
+      end
+
+      def matches?(klass)
+        return false unless @kind
+        if @no_op == !klass.class.respond_to?(:"_#{@operation}_callbacks")
+          return false
+        end
+
+        @guess = nil
+        @methods.each do |method|
+          filter = filters_method(klass, method)
+
+          return false unless filter
+        end
+      end
+
+      def failure_message
+        message(true)
+      end
+
+      def failure_message_when_negated
+        message(false)
+      end
+
+      def description
+        methods = @methods
+
+        "be callback(:#{methods.join(', ')})#{expl_operation}#{expl_context}"
+      end
+
+      protected
+
+      def expl_operation
+        @operation ? ".#{@kind}(:#{@operation})" : ''
+      end
+
+      def expl_context
+        @context ? ".on(:#{@context})" : ''
+      end
+
+      def message(should)
+        return msg_op_invalid if @no_op
+
+        @kind ? message_kind(should) : message_not_kind
+      end
+
+      def msg_op_invalid
+        'Invalid operation. Use :initialize, :build, :validation,' \
+        ':create, :find, :update, :upsert, :save or :destroy'
+      end
+
+      def message_kind(should)
+        <<-MESSAGE
+          Expected method#{@methods.size > 1 ? 's' : ''}#{expr_called(should)}
+            #{"#{@kind}" "#{@operation}" if @operation}
+            #{"on #{@context}" if @context}
+            #{msg_guess}
+            #{"#{@guess.kind}   #{@operation}" if @guess}
+            #{'on another context' if @guess && !@context_match}
+        MESSAGE
+      end
+
+      def expr_called(should)
+        "#{@methods.join(', ')} #{should ? '' : 'not '}to be called"
+      end
+
+      def msg_guess
+        if @guess
+          ", but got method #{@guess.filter} called"
+        else
+          ', but no callback found'
+        end
+      end
+
+      def message_not_kind
+        <<-MESSAGE
+          Callback#{@methods.size > 1 ? 's' : ''} #{@methods.join(', ')} can
+          not be tested against undefined lifecycle.
+          Use .before, .after or .around
+        MESSAGE
+      end
+
+      private
+
+      def filters_method(klass, method)
+        klass.class.send(:"_#{@operation}_callbacks").detect do |callback|
+          # Save callback instance in order to print information
+          # about it in case of failure
+          @guess = callback if callback.filter == method
+          check_filter?(callback,
+                        method) and check_kind?(callback,
+                                                @kind) and check_context?(
+                                                  callback, @context
+                                                )
+        end
+      end
+
+      def check_filter?(callback, method)
+        callback.filter == method
+      end
+
+      def check_kind?(callback, kind)
+        callback.kind == kind
+      end
+
+      def check_context?(callback, context)
+        return true unless context
+
+        options = callback.instance_variable_get(:@if)
+        @context_match = options.select { |option| option.is_a?(Proc) }
+
+        @context_match.detect do |option|
+          option.call(ValidationContext.new(context))
+        end
+      end
+    end
+
+    ValidationContext = Struct.new :validation_context
+
+    def callback(*args)
+      HaveCallbackMatcher.new(*args)
+    end
+  end
+end

data/lib/matchers/set_callbacks.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Matchers
+    # Create an matcher for set_callback method
+    #
+    # Usage:
+    #
+    # it { is_expected.to set_callback(:save, :arround)  }
+    # it { is_expected.to set_callback(:validation, :after)  }
+    class HaveSetCallbackMatcher
+      CONTEXTS = %i[before arround after].freeze
+      OPERATIONS = %i[initialize build validation create
+                      find update upsert save destroy].freeze
+
+      def initialize(*args)
+        @type = args[0]
+        @hook = args[1]
+      end
+
+      def matches?(klass)
+        @model = klass
+
+        return false unless \
+          context_is_correct? ||
+          operation_is_correct? ||
+          callback_is_correct?
+
+        testings_presence_callback
+      end
+
+      def description
+        "be set_callback(:#{@type}, :#{@hook})"
+      end
+
+      def failure_message
+        message_error
+      end
+
+      def failure_message_when_negated
+        message_error
+      end
+
+      private
+
+      def context_is_correct?
+        CONTEXTS.include?(@hook)
+      end
+
+      def operation_is_correct?
+        OPERATIONS.include?(@type)
+      end
+
+      def callback_is_correct?
+        @model.class.respond_to?(:"_#{@type}_callbacks")
+      end
+
+      def testings_presence_callback
+        @model.class.send("_#{@type}_callbacks".to_sym).select do |cb|
+          cb.filter.eql?(@hook.to_sym)
+        end
+      end
+
+      def message_error
+        <<-ERROR
+  expected #{@model} have method callback :
+    set_callback(:#{@type}, :#{@hook}) |document|
+      # My callback execution ...
+    end
+        ERROR
+      end
+    end
+
+    def set_callback(*args)
+      HaveSetCallbackMatcher.new(*args)
+    end
+  end
+end

data/lib/mongoid-rspec-callbacks/info.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Rspec
+    module Callbacks
+      # Define version to gem
+      VERSION = '1.0.0'
+
+      # Name to gem
+      GEM_NAME = 'mongoid7-rspec-callbacks'
+
+      # Authors
+      AUTHORS = ['VAILLANT Jeremy'].freeze
+
+      # Emails
+      EMAILS = ['jeremy@dazzl.tv'].freeze
+
+      # Licence
+      LICENSE = 'GPL-3.0'
+
+      # Define a summary description to gem
+      SUMMARY = 'RSpec Callbacks matchers for Mongoid'
+
+      # Define a long description to gem
+      DESCRIPTION = <<-DESC
+      This gem is meant to be use with mongoid-rpsec,
+      altought it works by itself. Syntax is the same
+      as shoulda-callback-matchers.
+      DESC
+
+      # Define homepage
+      HOMEPAGE = 'http://github.com/dazzl-tv/mongoid-rspec-callbacks'
+    end
+  end
+end