active_delivery 1.1.0 → 1.2.0

data/lib/.rbnext/3.2/active_delivery/lines/base.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+unless "".respond_to?(:safe_constantize)
+  require "active_delivery/ext/string_constantize"
+  using ActiveDelivery::Ext::StringConstantize
+end
+
+module ActiveDelivery
+  module Lines
+    class Base
+      attr_reader :id, :options
+      attr_accessor :owner
+      attr_accessor :handler_class_name
+
+      def initialize(id:, owner:, **options)
+        @id = id
+        @owner = owner
+        @options = options.tap(&:freeze)
+        @resolver = options[:resolver] || build_pattern_resolver(options[:resolver_pattern])
+      end
+
+      def dup_for(new_owner)
+        self.class.new(id:, **options, owner: new_owner)
+      end
+
+      def resolve_class(name)
+        resolver&.call(name)
+      end
+
+      def notify?(method_name)
+        handler_class&.respond_to?(method_name)
+      end
+
+      def notify_now(handler, mid, ...)
+      end
+
+      def notify_later(handler, mid, ...)
+      end
+
+      def notify_later_with_options(handler, enqueue_options, mid, ...)
+        notify_later(handler, mid, ...)
+      end
+
+      def notify(mid, *__rest__, params:, sync:, enqueue_options:, **__kwrest__)
+        clazz = params.empty? ? handler_class : handler_class.with(**params)
+        if sync
+          return notify_now(clazz, mid, *__rest__, **__kwrest__)
+        end
+
+        if enqueue_options.empty?
+          notify_later(clazz, mid, *__rest__, **__kwrest__)
+        else
+          notify_later_with_options(clazz, enqueue_options, mid, *__rest__, **__kwrest__)
+        end
+      end
+
+      def handler_class
+        if ::ActiveDelivery.cache_classes
+          return @handler_class if instance_variable_defined?(:@handler_class)
+        end
+
+        return @handler_class = nil if owner.abstract_class?
+
+        superline = owner.superclass.delivery_lines[id] if owner.superclass.respond_to?(:delivery_lines) && owner.superclass.delivery_lines[id]
+
+        # If an explicit class name has been specified somewhere in the ancestor chain, use it.
+        class_name = @handler_class_name || superline&.handler_class_name
+
+        @handler_class =
+          if class_name
+            class_name.is_a?(Class) ? class_name : class_name.safe_constantize
+          else
+            resolve_class(owner) || superline&.handler_class
+          end
+      end
+
+      private
+
+      attr_reader :resolver
+
+      def build_pattern_resolver(pattern)
+        return unless pattern
+
+        proc do |delivery|
+          delivery_class = delivery.name
+
+          next unless delivery_class
+
+          *namespace, delivery_name = delivery_class.split("::")
+
+          delivery_namespace = ""
+          delivery_namespace = "#{namespace.join("::")}::" unless namespace.empty?
+
+          delivery_name = delivery_name.sub(/Delivery$/, "")
+
+          (pattern % {delivery_class:, delivery_name:, delivery_namespace:}).safe_constantize
+        end
+      end
+    end
+  end
+end

data/lib/.rbnext/3.2/active_delivery/lines/notifier.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+unless "".respond_to?(:safe_constantize)
+  require "active_delivery/ext/string_constantize"
+  using ActiveDelivery::Ext::StringConstantize
+end
+
+module ActiveDelivery
+  module Lines
+    # AbstractNotifier line for Active Delivery.
+    #
+    # You must provide custom `resolver` to infer notifier class
+    # (if String#safe_constantize is defined, we convert "*Delivery" -> "*Notifier").
+    #
+    # Resolver is a callable object.
+    class Notifier < ActiveDelivery::Lines::Base
+      DEFAULT_SUFFIX = "Notifier"
+
+      def initialize(**opts)
+        super
+        @resolver ||= build_resolver(options.fetch(:suffix, DEFAULT_SUFFIX))
+      end
+
+      def resolve_class(klass)
+        resolver&.call(klass)
+      end
+
+      def notify?(method_name)
+        return unless handler_class
+        handler_class.action_methods.include?(method_name.to_s)
+      end
+
+      def notify_now(handler, mid, *__rest__)
+        handler.public_send(mid, *__rest__).notify_now
+      end
+
+      def notify_later(handler, mid, *__rest__)
+        handler.public_send(mid, *__rest__).notify_later
+      end
+
+      def notify_later_with_options(handler, enqueue_options, mid, *__rest__)
+        handler.public_send(mid, *__rest__).notify_later(**enqueue_options)
+      end
+
+      private
+
+      attr_reader :resolver
+
+      def build_resolver(suffix)
+        lambda do |klass|
+          klass_name = klass.name
+          klass_name&.sub(/Delivery\z/, suffix)&.safe_constantize
+        end
+      end
+    end
+  end
+end

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

@@ -22,8 +22,8 @@ module AbstractNotifier
         job.set(queue:).perform_later(...)
       end
 
-      def enqueue_delivery(delivery, **opts)
-        job.set(queue:, **opts).perform_later(
+      def enqueue_delivery(delivery, **)
+        job.set(queue:, **).perform_later(
           delivery.notifier_class.name,
           delivery.action_name,
           **delivery.delivery_params

data/lib/abstract_notifier/base.rb

@@ -23,9 +23,9 @@ module AbstractNotifier
 
     alias_method :notification, :processed
 
-    def notify_later(**opts)
+    def notify_later(**)
       if notifier_class.async_adapter.respond_to?(:enqueue_delivery)
-        notifier_class.async_adapter.enqueue_delivery(self, **opts)
+        notifier_class.async_adapter.enqueue_delivery(self, **)
       else
         notifier_class.async_adapter.enqueue(notifier_class.name, action_name, params:, args:, kwargs:)
       end
@@ -73,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(**opts)
+      def notify_later(**)
         return super unless AbstractNotifier.test?
 
         payload = notification.payload
 
-        Driver.enqueue_notification payload.merge(via: notifier.class, **opts)
+        Driver.enqueue_notification payload.merge(via: notifier.class, **)
       end
     end
   end

data/lib/active_delivery/base.rb

@@ -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,7 +211,7 @@ module ActiveDelivery
         end
       CODE
 
-      public_send(mid, *args, **kwargs)
+      public_send(mid, *, **)
     end
 
     protected

data/lib/active_delivery/lines/base.rb

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

data/lib/active_delivery/lines/notifier.rb

@@ -30,16 +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, *args)
-        handler.public_send(mid, *args).notify_later(**enqueue_options)
+      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.1.0"
+  VERSION = "1.2.0"
 end