active_delivery 1.0.0 → 1.2.0

data/lib/.rbnext/3.2/active_delivery/testing/rspec.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  class HaveDeliveredTo < RSpec::Matchers::BuiltIn::BaseMatcher
+    attr_reader :delivery_class, :event, :args, :kwargs, :params, :sync_value
+
+    def initialize(delivery_class, event = nil, *args, **kwargs)
+      @delivery_class = delivery_class
+      @event = event
+      @args = args
+      @kwargs = kwargs
+      set_expected_number(:exactly, 1)
+    end
+
+    def with(params)
+      @params = params
+      self
+    end
+
+    def synchronously
+      @sync_value = true
+      self
+    end
+
+    def exactly(count)
+      set_expected_number(:exactly, count)
+      self
+    end
+
+    def at_least(count)
+      set_expected_number(:at_least, count)
+      self
+    end
+
+    def at_most(count)
+      set_expected_number(:at_most, count)
+      self
+    end
+
+    def times
+      self
+    end
+
+    def once
+      exactly(:once)
+    end
+
+    def twice
+      exactly(:twice)
+    end
+
+    def thrice
+      exactly(:thrice)
+    end
+
+    def supports_block_expectations?
+      true
+    end
+
+    def matches?(proc)
+      raise ArgumentError, "have_delivered_to only supports block expectations" unless Proc === proc
+
+      TestDelivery.enable { proc.call }
+
+      actual_deliveries = TestDelivery.store
+
+      @matching_deliveries, @unmatching_deliveries =
+        actual_deliveries.partition do |(delivery, options)|
+          next false unless delivery_class == delivery.owner.class
+
+          next false if !sync_value.nil? && (options.fetch(:sync, false) != sync_value)
+
+          next false unless params.nil? || params === delivery.owner.params
+
+          next false unless event.nil? || event == delivery.notification
+
+          actual_args = delivery.params
+          actual_kwargs = delivery.options
+
+          next false unless args.each.with_index.all? do |arg, i|
+            arg === actual_args[i]
+          end
+
+          next false unless kwargs.all? do |k, v|
+            v === actual_kwargs[k]
+          end
+
+          true
+        end
+
+      @matching_count = @matching_deliveries.size
+
+      case @expectation_type
+      when :exactly then @expected_number == @matching_count
+      when :at_most then @expected_number >= @matching_count
+      when :at_least then @expected_number <= @matching_count
+      end
+    end
+
+    def failure_message
+      (+"expected to deliver").tap do |msg|
+        msg << " :#{event} notification" if event
+        msg << " via #{delivery_class}#{sync_value ? " (sync)" : ""} with:"
+        msg << "\n - params: #{params_description(params)}" if params
+        msg << "\n - args: #{args.empty? ? "<none>" : args}"
+        msg << "\n#{message_expectation_modifier}, but"
+
+        if @unmatching_deliveries.any?
+          msg << " delivered the following unexpected notifications:"
+          msg << deliveries_description(@unmatching_deliveries)
+        elsif @matching_count.positive?
+          msg << " delivered #{@matching_count} matching notifications" \
+                 " (#{count_failure_message}):"
+          msg << deliveries_description(@matching_deliveries)
+        else
+          msg << " haven't delivered anything"
+        end
+      end
+    end
+
+    private
+
+    def set_expected_number(relativity, count)
+      @expectation_type = relativity
+      @expected_number =
+        case count
+        when :once then 1
+        when :twice then 2
+        when :thrice then 3
+        else Integer(count)
+        end
+    end
+
+    def failure_message_when_negated
+      "expected not to deliver #{event ? " :#{event} notification" : ""} via #{delivery_class}"
+    end
+
+    def message_expectation_modifier
+      number_modifier = (@expected_number == 1) ? "once" : "#{@expected_number} times"
+      case @expectation_type
+      when :exactly then "exactly #{number_modifier}"
+      when :at_most then "at most #{number_modifier}"
+      when :at_least then "at least #{number_modifier}"
+      end
+    end
+
+    def count_failure_message
+      diff = @matching_count - @expected_number
+      if diff.positive?
+        "#{diff} extra item(s)"
+      else
+        "#{diff} missing item(s)"
+      end
+    end
+
+    def deliveries_description(deliveries)
+      deliveries.each.with_object(+"") do |(delivery, options), msg|
+        msg << "\n  :#{delivery.notification} via #{delivery.owner.class}" \
+              "#{options[:sync] ? " (sync)" : ""}" \
+              " with:" \
+              "\n   - params: #{delivery.owner.params.empty? ? "<none>" : delivery.owner.params.inspect}" \
+              "\n   - args: #{delivery.params}" \
+              "\n   - kwargs: #{delivery.options}"
+      end
+    end
+
+    def params_description(data)
+      if data.is_a?(RSpec::Matchers::Composable)
+        data.description
+      else
+        data
+      end
+    end
+  end
+
+  class DeliverVia < RSpec::Matchers::BuiltIn::BaseMatcher
+    attr_reader :lines
+
+    def initialize(*lines)
+      @actual_lines = []
+      @lines = lines.sort
+    end
+
+    def supports_block_expectations?
+      true
+    end
+
+    def matches?(proc)
+      raise ArgumentError, "deliver_via only supports block expectations" unless Proc === proc
+
+      TestDelivery.lines.clear
+
+      proc.call
+
+      @actual_lines = TestDelivery.lines.sort
+
+      lines == @actual_lines
+    end
+
+    private
+
+    def failure_message
+      "expected to deliver via #{lines.join(", ")} lines, but delivered to #{@actual_lines.any? ? @actual_lines.join(", ") : "none"}"
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Module.new do
+    def have_delivered_to(*__rest__)
+      ActiveDelivery::HaveDeliveredTo.new(*__rest__)
+    end
+  end)
+
+  config.include(Module.new do
+    def deliver_via(*__rest__)
+      ActiveDelivery::DeliverVia.new(*__rest__)
+    end
+  end, type: :delivery)
+end
+
+RSpec::Matchers.define_negated_matcher :have_not_delivered_to, :have_delivered_to

data/lib/abstract_notifier/async_adapters/active_job.rb

@@ -11,14 +11,23 @@ module AbstractNotifier
 
       DEFAULT_QUEUE = "notifiers"
 
-      attr_reader :job
+      attr_reader :job, :queue
 
       def initialize(queue: DEFAULT_QUEUE, job: DeliveryJob)
-        @job = job.set(queue: queue)
+        @job = job
+        @queue = queue
       end
 
       def enqueue(...)
-        job.perform_later(...)
+        job.set(queue:).perform_later(...)
+      end
+
+      def enqueue_delivery(delivery, **)
+        job.set(queue:, **).perform_later(
+          delivery.notifier_class.name,
+          delivery.action_name,
+          **delivery.delivery_params
+        )
       end
     end
   end

data/lib/abstract_notifier/base.rb

@@ -5,10 +5,10 @@ module AbstractNotifier
   # information about the current notifier class
   # and knows how to trigger the delivery
   class NotificationDelivery
-    attr_reader :action_name
+    attr_reader :action_name, :notifier_class
 
-    def initialize(owner_class, action_name, params: {}, args: [], kwargs: {})
-      @owner_class = owner_class
+    def initialize(notifier_class, action_name, params: {}, args: [], kwargs: {})
+      @notifier_class = notifier_class
       @action_name = action_name
       @params = params
       @args = args
@@ -23,8 +23,12 @@ module AbstractNotifier
 
     alias_method :notification, :processed
 
-    def notify_later
-      owner_class.async_adapter.enqueue(owner_class.name, action_name, params:, args:, kwargs:)
+    def notify_later(**)
+      if notifier_class.async_adapter.respond_to?(:enqueue_delivery)
+        notifier_class.async_adapter.enqueue_delivery(self, **)
+      else
+        notifier_class.async_adapter.enqueue(notifier_class.name, action_name, params:, args:, kwargs:)
+      end
     end
 
     def notify_now
@@ -33,12 +37,14 @@ module AbstractNotifier
       notifier.deliver!(notification)
     end
 
+    def delivery_params = {params:, args:, kwargs:}
+
     private
 
-    attr_reader :owner_class, :params, :args, :kwargs
+    attr_reader :params, :args, :kwargs
 
     def notifier
-      @notifier ||= owner_class.new(action_name, **params)
+      @notifier ||= notifier_class.new(action_name, **params)
     end
   end
 
@@ -67,8 +73,8 @@ module AbstractNotifier
       end
       # rubocop:enable Style/MethodMissingSuper
 
-      def respond_to_missing?(*args)
-        notifier_class.respond_to_missing?(*args)
+      def respond_to_missing?(*)
+        notifier_class.respond_to_missing?(*)
       end
     end
 

data/lib/abstract_notifier/testing/minitest.rb

@@ -19,7 +19,7 @@ module AbstractNotifier
 
     def assert_notifications_enqueued(count, params)
       yield
-      assert_equal enqueued_deliveries.count, count
+      assert_equal count, enqueued_deliveries.count
       count.times do |i|
         delivery = enqueued_deliveries[0 - i]
         if !params[:via]

data/lib/abstract_notifier/testing/rspec.rb

@@ -153,12 +153,12 @@ end
 
 RSpec.configure do |config|
   config.include(Module.new do
-    def have_sent_notification(*args)
-      AbstractNotifier::HaveSentNotification.new(*args)
+    def have_sent_notification(*)
+      AbstractNotifier::HaveSentNotification.new(*)
     end
 
-    def have_enqueued_notification(*args)
-      AbstractNotifier::HaveEnqueuedNotification.new(*args)
+    def have_enqueued_notification(*)
+      AbstractNotifier::HaveEnqueuedNotification.new(*)
     end
   end)
 end

data/lib/abstract_notifier/testing.rb

@@ -36,12 +36,12 @@ module AbstractNotifier
         Driver.send_notification payload.merge(via: notifier.class)
       end
 
-      def notify_later
+      def notify_later(**)
         return super unless AbstractNotifier.test?
 
         payload = notification.payload
 
-        Driver.enqueue_notification payload.merge(via: notifier.class)
+        Driver.enqueue_notification payload.merge(via: notifier.class, **)
       end
     end
   end

data/lib/active_delivery/base.rb

@@ -12,9 +12,9 @@ module ActiveDelivery
       @metadata = metadata.freeze
     end
 
-    def deliver_later = owner.perform_notify(self)
+    def deliver_later(**opts) = owner.perform_notify(self, enqueue_options: opts)
 
-    def deliver_now = owner.perform_notify(self, sync: true)
+    def deliver_now(**opts) = owner.perform_notify(self, sync: true)
 
     def delivery_class = owner.class
   end
@@ -77,8 +77,8 @@ module ActiveDelivery
 
       # The same as .notify but delivers synchronously
       # (i.e. #deliver_now for mailers)
-      def notify!(mid, *args, **hargs)
-        notify(mid, *args, **hargs, sync: true)
+      def notify!(mid, *, **hargs)
+        notify(mid, *, **hargs, sync: true)
       end
 
       alias_method :notify_now, :notify!
@@ -93,7 +93,7 @@ module ActiveDelivery
         end
       end
 
-      def register_line(line_id, line_class = nil, notifier: nil, **options)
+      def register_line(line_id, line_class = nil, notifier: nil, **)
         raise ArgumentError, "A line class or notifier configuration must be provided" if line_class.nil? && notifier.nil?
 
         # Configure Notifier
@@ -101,7 +101,7 @@ module ActiveDelivery
           line_class = ActiveDelivery::Lines::Notifier
         end
 
-        delivery_lines[line_id] = line_class.new(id: line_id, owner: self, **options)
+        delivery_lines[line_id] = line_class.new(id: line_id, owner: self, **)
 
         instance_eval <<~CODE, __FILE__, __LINE__ + 1
           def #{line_id}(val)
@@ -152,13 +152,13 @@ module ActiveDelivery
         super
       end
 
-      def method_missing(mid, *args, **kwargs)
+      def method_missing(mid, *, **)
         return super unless respond_to_missing?(mid)
 
         # Lazily define a class method to avoid lookups
         delivers(mid)
 
-        public_send(mid, *args, **kwargs)
+        public_send(mid, *, **)
       end
     end
 
@@ -197,7 +197,7 @@ module ActiveDelivery
       super
     end
 
-    def method_missing(mid, *args, **kwargs)
+    def method_missing(mid, *, **)
       return super unless respond_to_missing?(mid)
 
       # Lazily define a method to avoid future lookups
@@ -211,27 +211,28 @@ module ActiveDelivery
         end
       CODE
 
-      public_send(mid, *args, **kwargs)
+      public_send(mid, *, **)
     end
 
     protected
 
-    def perform_notify(delivery, sync: false)
+    def perform_notify(delivery, sync: false, enqueue_options: {})
       delivery_lines.each do |type, line|
         next unless line.notify?(delivery.notification)
 
-        notify_line(type, line, delivery, sync:)
+        notify_line(type, line, delivery, sync:, enqueue_options:)
       end
     end
 
     private
 
-    def notify_line(type, line, delivery, sync:)
+    def notify_line(type, line, delivery, sync:, enqueue_options:)
       line.notify(
         delivery.notification,
         *delivery.params,
         params:,
         sync:,
+        enqueue_options:,
         **delivery.options
       )
       true

data/lib/active_delivery/lines/base.rb

@@ -37,9 +37,21 @@ module ActiveDelivery
       def notify_later(handler, mid, ...)
       end
 
-      def notify(mid, *args, params:, sync:, **kwargs)
+      def notify_later_with_options(handler, enqueue_options, mid, ...)
+        notify_later(handler, mid, ...)
+      end
+
+      def notify(mid, *, params:, sync:, enqueue_options:, **)
         clazz = params.empty? ? handler_class : handler_class.with(**params)
-        sync ? notify_now(clazz, mid, *args, **kwargs) : notify_later(clazz, mid, *args, **kwargs)
+        if sync
+          return notify_now(clazz, mid, *, **)
+        end
+
+        if enqueue_options.empty?
+          notify_later(clazz, mid, *, **)
+        else
+          notify_later_with_options(clazz, enqueue_options, mid, *, **)
+        end
       end
 
       def handler_class

data/lib/active_delivery/lines/mailer.rb

@@ -19,6 +19,10 @@ module ActiveDelivery
       def notify_later(mailer, mid, ...)
         mailer.public_send(mid, ...).deliver_later
       end
+
+      def notify_later_with_options(mailer, enqueue_options, mid, ...)
+        mailer.public_send(mid, ...).deliver_later(**enqueue_options)
+      end
     end
 
     ActiveDelivery::Base.register_line :mailer, Mailer, resolver: Mailer::DEFAULT_RESOLVER

data/lib/active_delivery/lines/notifier.rb

@@ -30,12 +30,16 @@ module ActiveDelivery
         handler_class.action_methods.include?(method_name.to_s)
       end
 
-      def notify_now(handler, mid, *args)
-        handler.public_send(mid, *args).notify_now
+      def notify_now(handler, mid, *)
+        handler.public_send(mid, *).notify_now
       end
 
-      def notify_later(handler, mid, *args)
-        handler.public_send(mid, *args).notify_later
+      def notify_later(handler, mid, *)
+        handler.public_send(mid, *).notify_later
+      end
+
+      def notify_later_with_options(handler, enqueue_options, mid, *)
+        handler.public_send(mid, *).notify_later(**enqueue_options)
       end
 
       private

data/lib/active_delivery/testing/minitest.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  module TestHelper
+    def assert_deliveries(count)
+      TestDelivery.enable { yield }
+
+      assert_equal TestDelivery.store.count, count, "Expected #{count} deliveries, got #{TestDelivery.store.count}"
+    end
+
+    def assert_no_deliveries(&) = assert_deliveries(0, &)
+
+    def assert_delivery_enqueued(delivery_class, event, count: 1, params: nil, with: nil)
+      TestDelivery.enable { yield }
+
+      deliveries = TestDelivery.store
+
+      if with
+        args = with
+        kwargs = args.pop if args.last.is_a?(Hash)
+      end
+
+      matching_deliveries, _unmatching_deliveries =
+        deliveries.partition do |(delivery, options)|
+          next false if delivery_class != delivery.owner.class
+
+          next false if event != delivery.notification
+
+          next false if params && !hash_include?(delivery.owner.params, params)
+
+          next true unless with
+
+          actual_args = delivery.params
+          actual_kwargs = delivery.options
+
+          next false unless args.each.with_index.all? do |arg, i|
+            arg === actual_args[i]
+          end
+
+          next false unless kwargs.all? do |k, v|
+            v === actual_kwargs[k]
+          end
+
+          true
+        end
+
+      assert_equal count, matching_deliveries.count, "Expected #{count} deliveries, got #{deliveries.count}"
+    end
+
+    private
+
+    def hash_include?(haystack, needle)
+      needle.all? do |k, v|
+        haystack.key?(k) && haystack[k] == v
+      end
+    end
+  end
+end

data/lib/active_delivery/testing/rspec.rb

@@ -207,14 +207,14 @@ end
 
 RSpec.configure do |config|
   config.include(Module.new do
-    def have_delivered_to(*args)
-      ActiveDelivery::HaveDeliveredTo.new(*args)
+    def have_delivered_to(*)
+      ActiveDelivery::HaveDeliveredTo.new(*)
     end
   end)
 
   config.include(Module.new do
-    def deliver_via(*args)
-      ActiveDelivery::DeliverVia.new(*args)
+    def deliver_via(*)
+      ActiveDelivery::DeliverVia.new(*)
     end
   end, type: :delivery)
 end

data/lib/active_delivery/testing.rb

@@ -60,3 +60,4 @@ end
 ActiveDelivery::Base.prepend ActiveDelivery::TestDelivery
 
 require "active_delivery/testing/rspec" if defined?(RSpec::Core)
+require "active_delivery/testing/minitest" if defined?(Minitest::Assertions)

data/lib/active_delivery/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveDelivery
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_delivery
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-29 00:00:00.000000000 Z
+date: 2024-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,16 +70,16 @@ dependencies:
   name: ruby-next-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.15.0
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.15.0
+        version: '1.0'
 description: Ruby and Rails framework for managing all types of notifications in one
   place
 email:
@@ -94,14 +94,26 @@ files:
 - bin/console
 - bin/setup
 - lib/.rbnext/3.0/abstract_notifier/async_adapters/active_job.rb
+- lib/.rbnext/3.0/abstract_notifier/base.rb
 - lib/.rbnext/3.0/active_delivery/base.rb
 - lib/.rbnext/3.0/active_delivery/callbacks.rb
 - lib/.rbnext/3.0/active_delivery/lines/base.rb
 - lib/.rbnext/3.0/active_delivery/lines/mailer.rb
 - lib/.rbnext/3.0/active_delivery/testing.rb
+- lib/.rbnext/3.0/active_delivery/testing/minitest.rb
+- lib/.rbnext/3.1/abstract_notifier/async_adapters/active_job.rb
 - lib/.rbnext/3.1/abstract_notifier/base.rb
 - lib/.rbnext/3.1/active_delivery/base.rb
 - lib/.rbnext/3.1/active_delivery/lines/base.rb
+- lib/.rbnext/3.1/active_delivery/testing/minitest.rb
+- lib/.rbnext/3.2/abstract_notifier/async_adapters/active_job.rb
+- lib/.rbnext/3.2/abstract_notifier/base.rb
+- lib/.rbnext/3.2/abstract_notifier/testing.rb
+- lib/.rbnext/3.2/abstract_notifier/testing/rspec.rb
+- lib/.rbnext/3.2/active_delivery/base.rb
+- lib/.rbnext/3.2/active_delivery/lines/base.rb
+- lib/.rbnext/3.2/active_delivery/lines/notifier.rb
+- lib/.rbnext/3.2/active_delivery/testing/rspec.rb
 - lib/abstract_notifier.rb
 - lib/abstract_notifier/async_adapters.rb
 - lib/abstract_notifier/async_adapters/active_job.rb
@@ -120,6 +132,7 @@ files:
 - lib/active_delivery/lines/notifier.rb
 - lib/active_delivery/raitie.rb
 - lib/active_delivery/testing.rb
+- lib/active_delivery/testing/minitest.rb
 - lib/active_delivery/testing/rspec.rb
 - lib/active_delivery/version.rb
 homepage: https://github.com/palkan/active_delivery
@@ -146,7 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.8
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: Ruby and Rails framework for managing all types of notifications in one place