noticed 1.2.20 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5b998072ed72c9844842d8610a9ffcea75cf16f958296aa3d53e1a3c050b6db
-  data.tar.gz: 589f43985b3dc7740977730d10917d0b111706fe56c4daafedbacc08e7f2ce84
+  metadata.gz: 5b24f360d71aca5620ed10866864570642c49d36d21e5068d3e92e02b56538a5
+  data.tar.gz: f22998f215bc9e75f14380bfabe5da7117476496395ecdb07da9f08952210bf6
 SHA512:
-  metadata.gz: 9f4a336ed688008a5abc3f91099a5ecc4128361beffd216e0e2e0bc0a1670286e607577d2f4ce13f1e36c2fb2fff3d93fbab9a10914d0321a2d1e0c2449ea715
-  data.tar.gz: b4a67b79dcf34892dcd11b56ad83e2c393a2da49c3eb38e3e911411164b4150ec27a836e53d1d7875ea40141276a398878e8c23304c326287299b26bafebacba
+  metadata.gz: f1e02acbbcf4826441afa5ea04d30f949c528643e306fbc179320e76dfcf658c64b0db9c9f4ec8783aa624e49027ccc62108e5930fd003103378b4691215b87a
+  data.tar.gz: df2b7c0ddf9e13a6e059352a065ea8b3ea2e5c881499ae5227b32ebe5b645087829fd64e2c5cd48390c649075e1f3fe26eaa7e50d0ccea72dd18bc6a2dbeb3ae

data/README.md

@@ -265,7 +265,7 @@ Sends a Teams notification via webhook.
 
 * `format: :format_for_teams` - *Optional*
 
-  Use a custom method to define the payload sent to slack. Method should return a Hash.
+  Use a custom method to define the payload sent to Microsoft Teams. Method should return a Hash.
   Documentation for posting via Webhooks available at: https://docs.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook
 
   ```ruby
@@ -354,6 +354,33 @@ Sends an SMS notification via Vonage / Nexmo.
   }
   ```
 
+### Fallback Notifications
+
+A common pattern is to deliver a notification via the database and then, after some time has passed, email the user if they have not yet read the notification. You can implement this functionality by combining multiple delivery methods, the `delay` option, and the conditional `if` / `unless` option.
+
+```ruby
+class CommentNotification < Noticed::Base
+  deliver_by :database
+  deliver_by :email, mailer: 'CommentMailer', delay: 15.minutes, unless: :read?
+end
+```
+
+Here a notification will be created immediately in the database (for display directly in your app). If the notification has not been read after 15 minutes, the email notification will be sent. If the notification has already been read in the app, the email will be skipped.
+
+You can also configure multiple fallback options:
+
+```ruby
+class CriticalSystemNotification < Noticed::Base
+  deliver_by :slack
+  deliver_by :email, mailer: 'CriticalSystemMailer', delay: 10.minutes, unless: :read?
+  deliver_by :twilio, delay: 20.minutes, unless: :read?
+end
+```
+
+In this scenario, you can create an escalating notification that starts with a ping in Slack, then emails the team, and then finally sends an SMS to the on-call phone.
+
+You can mix and match the options and delivery methods to suit your application specific needs.
+
 ### 🚚 Custom Delivery Methods
 
 To generate a custom delivery method, simply run
@@ -444,13 +471,13 @@ Rails 6.1+ can serialize Class and Module objects as arguments to ActiveJob. The
   deliver_by DeliveryMethods::Discord
 ```
 
-For Rails 6.0, you must pass strings of the class names in the `deliver_by` options.
+For Rails 5.2 and 6.0, you must pass strings of the class names in the `deliver_by` options.
 
 ```ruby
   deliver_by :discord, class: "DeliveryMethods::Discord"
 ```
 
-We recommend the Rails 6.0 compatible options to prevent confusion.
+We recommend using a string in order to prevent confusion.
 
 ### 📦 Database Model
 
@@ -507,57 +534,55 @@ Adding notification associations to your models makes querying and deleting noti
 
 For example, in most cases, you'll want to delete notifications for records that are destroyed.
 
-##### JSON Columns
+We'll need two associations for this:
 
-If you're using MySQL or Postgresql, the `params` column on the notifications table is in `json` or `jsonb` format and can be queried against directly.
+1. Notifications where the record is the recipient
+2. Notifications where the record is in the notification params
 
 For example,  we can query the notifications and delete them on destroy like so:
 
 ```ruby
 class Post < ApplicationRecord
-  def notifications
-    # Exact match
-    @notifications ||= Notification.where(params: { post: self })
-
-    # Or Postgres syntax to query the post key in the JSON column
-    # @notifications ||= Notification.where("params->'post' = ?", Noticed::Coder.dump(self).to_json)
-  end
+  # Standard association for deleting notifications when you're the recipient
+  has_many :notifications, as: :recipient, dependent: :destroy
 
-  before_destroy :destroy_notifications
+  # Helper for associating and destroying Notification records where(params: {post: self})
+  has_noticed_notifications
 
-  def destroy_notifications
-    notifications.destroy_all
-  end
+  # You can override the param_name, the notification model name, or disable the before_destroy callback
+  has_noticed_notifications param_name: :parent, destroy: false, model: "Notification"
 end
-```
-
-##### Polymorphic Association
 
-If your notification is only associated with one model or you're using a `text` column for your params column , then a polymorphic association is what you'll want to use.
+# Create a CommentNotification with a post param
+CommentNotification.with(post: @post).deliver(user)
+# Lookup Notifications where params: {post: @post}
+@post.notifications_as_post
 
-1. Add a polymorphic association to the Notification model. `rails g migration AddNotifiableToNotifications notifiable:belongs_to{polymorphic}`
-
-2. Add `has_many :notifications, as: :notifiable, dependent: :destroy` to each model
+CommentNotification.with(parent: @post).deliver(user)
+@post.notifications_as_parent
+```
 
-3. Customize database `format: ` option to write the `notifiable` attribute(s) when saving the notification
+#### Handling Deleted Records
 
-   ```ruby
-   class ExampleNotification < Noticed::Base
-     deliver_by :database, format: :format_for_database
+If you create a notification but delete the associated record and forgot `has_noticed_notifications` on the model, the jobs for sending the notification will not be able to find the record when ActiveJob deserializes. You can discord the job on these errors by adding the following to `ApplicationJob`:
 
-     def format_for_database
-       {
-         notifiable: params.delete(:post),
-         type: self.class.name,
-         params: params
-       }
-     end
-   end
-   ```
+```ruby
+class ApplicationJob < ActiveJob::Base
+  discard_on ActiveJob::DeserializationError
+end
+```
 
 ## 🙏 Contributing
 
 This project uses [Standard](https://github.com/testdouble/standard) for formatting Ruby code. Please make sure to run `standardrb` before submitting pull requests.
 
+Running tests against multiple databases locally:
+
+```
+DATABASE_URL=sqlite3:noticed_test rails test
+DATABASE_URL=mysql2://root:@127.0.0.1/noticed_test rails test
+DATABASE_URL=postgres://127.0.0.1/noticed_test rails test
+```
+
 ## 📝 License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/generators/noticed/model_generator.rb

@@ -42,13 +42,20 @@ module Noticed
       end
 
       def params_column
-        case ActiveRecord::Base.configurations.configs_for(spec_name: "primary").config["adapter"]
-        when "mysql2"
-          "params:json"
+        case current_adapter
         when "postgresql"
           "params:jsonb"
         else
-          "params:text"
+          # MySQL and SQLite both support json
+          "params:json"
+        end
+      end
+
+      def current_adapter
+        if ActiveRecord::Base.respond_to?(:connection_db_config)
+          ActiveRecord::Base.connection_db_config.adapter
+        else
+          ActiveRecord::Base.connection_config[:adapter]
         end
       end
     end

data/lib/noticed.rb

@@ -5,6 +5,7 @@ require "noticed/engine"
 module Noticed
   autoload :Base, "noticed/base"
   autoload :Coder, "noticed/coder"
+  autoload :HasNotifications, "noticed/has_notifications"
   autoload :Model, "noticed/model"
   autoload :TextCoder, "noticed/text_coder"
   autoload :Translation, "noticed/translation"

data/lib/noticed/base.rb

@@ -12,6 +12,8 @@ module Noticed
     # Gives notifications access to the record and recipient when formatting for delivery
     attr_accessor :record, :recipient
 
+    delegate :read?, :unread?, to: :record
+
     class << self
       def deliver_by(name, options = {})
         delivery_methods.push(name: name, options: options)
@@ -96,11 +98,14 @@ module Noticed
       run_callbacks delivery_method[:name] do
         method = delivery_method_for(delivery_method[:name], delivery_method[:options])
 
+        # If the queue is `nil`, ActiveJob will use a default queue name.
+        queue = delivery_method.dig(:options, :queue)
+
         # Always perfrom later if a delay is present
         if (delay = delivery_method.dig(:options, :delay))
-          method.set(wait: delay).perform_later(args)
+          method.set(wait: delay, queue: queue).perform_later(args)
         elsif enqueue
-          method.perform_later(args)
+          method.set(queue: queue).perform_later(args)
         else
           method.perform_now(args)
         end

data/lib/noticed/delivery_methods/email.rb

@@ -18,14 +18,12 @@ module Noticed
       end
 
       def format
-        if (method = options[:format])
+        params = if (method = options[:format])
           notification.send(method)
         else
-          notification.params.merge(
-            recipient: recipient,
-            record: record
-          )
+          notification.params
         end
+        params.merge(recipient: recipient, record: record)
       end
     end
   end

data/lib/noticed/engine.rb

@@ -1,4 +1,13 @@
 module Noticed
   class Engine < ::Rails::Engine
+    initializer "noticed.has_notifications" do
+      ActiveSupport.on_load(:active_record) do
+        include Noticed::HasNotifications
+      end
+    end
+
+    initializer "noticed.rails_5_2_support" do
+      require "rails_6_polyfills/base" if Rails::VERSION::MAJOR < 6
+    end
   end
 end

data/lib/noticed/has_notifications.rb

@@ -0,0 +1,49 @@
+module Noticed
+  module HasNotifications
+    # Defines a method for the association and a before_destory callback to remove notifications
+    # where this record is a param
+    #
+    #    class User < ApplicationRecord
+    #      has_noticed_notifications
+    #      has_noticed_notifications param_name: :owner, destroy: false, model: "Notification"
+    #    end
+    #
+    #    @user.notifications_as_user
+    #    @user.notifications_as_owner
+
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def has_noticed_notifications(param_name: model_name.singular, **options)
+        define_method "notifications_as_#{param_name}" do
+          model = options.fetch(:model_name, "Notification").constantize
+          case current_adapter
+          when "postgresql"
+            model.where("params @> ?", Noticed::Coder.dump(param_name.to_sym => self).to_json)
+          when "mysql2"
+            model.where("JSON_CONTAINS(params, ?)", Noticed::Coder.dump(param_name.to_sym => self).to_json)
+          when "sqlite3"
+            model.where("json_extract(params, ?) = ?", "$.#{param_name}", Noticed::Coder.dump(self).to_json)
+          else
+            # This will perform an exact match which isn't ideal
+            model.where(params: {param_name.to_sym => self})
+          end
+        end
+
+        if options.fetch(:destroy, true)
+          before_destroy do
+            send("notifications_as_#{param_name}").destroy_all
+          end
+        end
+      end
+    end
+
+    def current_adapter
+      if ActiveRecord::Base.respond_to?(:connection_db_config)
+        ActiveRecord::Base.connection_db_config.adapter
+      else
+        ActiveRecord::Base.connection_config[:adapter]
+      end
+    end
+  end
+end

data/lib/noticed/model.rb

@@ -24,12 +24,16 @@ module Noticed
       end
 
       def noticed_coder
+        return Noticed::TextCoder unless table_exists?
+
         case attribute_types["params"].type
         when :json, :jsonb
           Noticed::Coder
         else
           Noticed::TextCoder
         end
+      rescue ActiveRecord::NoDatabaseError
+        Noticed::TextCoder
       end
     end
 

data/lib/noticed/version.rb

@@ -1,3 +1,3 @@
 module Noticed
-  VERSION = "1.2.20"
+  VERSION = "1.4.1"
 end

data/lib/rails_6_polyfills/actioncable/test_adapter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "action_cable/subscription_adapter/base"
+require "action_cable/subscription_adapter/subscriber_map"
+require "action_cable/subscription_adapter/async"
+
+module ActionCable
+  module SubscriptionAdapter
+    # == Test adapter for Action Cable
+    #
+    # The test adapter should be used only in testing. Along with
+    # <tt>ActionCable::TestHelper</tt> it makes a great tool to test your Rails application.
+    #
+    # To use the test adapter set +adapter+ value to +test+ in your +config/cable.yml+ file.
+    #
+    # NOTE: Test adapter extends the <tt>ActionCable::SubscriptionsAdapter::Async</tt> adapter,
+    # so it could be used in system tests too.
+    class Test < Async
+      def broadcast(channel, payload)
+        broadcasts(channel) << payload
+        super
+      end
+
+      def broadcasts(channel)
+        channels_data[channel] ||= []
+      end
+
+      def clear_messages(channel)
+        channels_data[channel] = []
+      end
+
+      def clear
+        @channels_data = nil
+      end
+
+      private
+
+      def channels_data
+        @channels_data ||= {}
+      end
+    end
+  end
+
+  # Update how broadcast_for determines the channel name so it's consistent with the Rails 6 way
+  module Channel
+    module Broadcasting
+      delegate :broadcast_to, to: :class
+      module ClassMethods
+        def broadcast_to(model, message)
+          ActionCable.server.broadcast(broadcasting_for(model), message)
+        end
+
+        def broadcasting_for(model)
+          serialize_broadcasting([channel_name, model])
+        end
+
+        def serialize_broadcasting(object) #:nodoc:
+          case # standard:disable Style/EmptyCaseCondition
+          when object.is_a?(Array)
+            object.map { |m| serialize_broadcasting(m) }.join(":")
+          when object.respond_to?(:to_gid_param)
+            object.to_gid_param
+          else
+            object.to_param
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_6_polyfills/actioncable/test_helper.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module ActionCable
+  # Have ActionCable pick its Test SubscriptionAdapter when it's called for in cable.yml
+  module Server
+    class Configuration
+      def pubsub_adapter
+        cable["adapter"] == "test" ? ActionCable::SubscriptionAdapter::Test : super
+      end
+    end
+  end
+
+  # Provides helper methods for testing Action Cable broadcasting
+  module TestHelper
+    def before_setup # :nodoc:
+      server = ActionCable.server
+      test_adapter = ActionCable::SubscriptionAdapter::Test.new(server)
+
+      @old_pubsub_adapter = server.pubsub
+
+      server.instance_variable_set(:@pubsub, test_adapter)
+      super
+    end
+
+    def after_teardown # :nodoc:
+      super
+      ActionCable.server.instance_variable_set(:@pubsub, @old_pubsub_adapter)
+    end
+
+    # Asserts that the number of broadcasted messages to the stream matches the given number.
+    #
+    #   def test_broadcasts
+    #     assert_broadcasts 'messages', 0
+    #     ActionCable.server.broadcast 'messages', { text: 'hello' }
+    #     assert_broadcasts 'messages', 1
+    #     ActionCable.server.broadcast 'messages', { text: 'world' }
+    #     assert_broadcasts 'messages', 2
+    #   end
+    #
+    # If a block is passed, that block should cause the specified number of
+    # messages to be broadcasted.
+    #
+    #   def test_broadcasts_again
+    #     assert_broadcasts('messages', 1) do
+    #       ActionCable.server.broadcast 'messages', { text: 'hello' }
+    #     end
+    #
+    #     assert_broadcasts('messages', 2) do
+    #       ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #       ActionCable.server.broadcast 'messages', { text: 'how are you?' }
+    #     end
+    #   end
+    #
+    def assert_broadcasts(stream, number)
+      if block_given?
+        original_count = broadcasts_size(stream)
+        yield
+        new_count = broadcasts_size(stream)
+        actual_count = new_count - original_count
+      else
+        actual_count = broadcasts_size(stream)
+      end
+
+      assert_equal number, actual_count, "#{number} broadcasts to #{stream} expected, but #{actual_count} were sent"
+    end
+
+    # Asserts that no messages have been sent to the stream.
+    #
+    #   def test_no_broadcasts
+    #     assert_no_broadcasts 'messages'
+    #     ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #     assert_broadcasts 'messages', 1
+    #   end
+    #
+    # If a block is passed, that block should not cause any message to be sent.
+    #
+    #   def test_broadcasts_again
+    #     assert_no_broadcasts 'messages' do
+    #       # No job messages should be sent from this block
+    #     end
+    #   end
+    #
+    # Note: This assertion is simply a shortcut for:
+    #
+    #   assert_broadcasts 'messages', 0, &block
+    #
+    def assert_no_broadcasts(stream, &block)
+      assert_broadcasts stream, 0, &block
+    end
+
+    # Asserts that the specified message has been sent to the stream.
+    #
+    #   def test_assert_transmitted_message
+    #     ActionCable.server.broadcast 'messages', text: 'hello'
+    #     assert_broadcast_on('messages', text: 'hello')
+    #   end
+    #
+    # If a block is passed, that block should cause a message with the specified data to be sent.
+    #
+    #   def test_assert_broadcast_on_again
+    #     assert_broadcast_on('messages', text: 'hello') do
+    #       ActionCable.server.broadcast 'messages', text: 'hello'
+    #     end
+    #   end
+    #
+    def assert_broadcast_on(stream, data)
+      # Encode to JSON and back–we want to use this value to compare
+      # with decoded JSON.
+      # Comparing JSON strings doesn't work due to the order of the keys.
+      serialized_msg =
+        ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(data))
+
+      new_messages = broadcasts(stream)
+      if block_given?
+        old_messages = new_messages
+        clear_messages(stream)
+
+        yield
+        new_messages = broadcasts(stream)
+        clear_messages(stream)
+
+        # Restore all sent messages
+        (old_messages + new_messages).each { |m| pubsub_adapter.broadcast(stream, m) }
+      end
+
+      message = new_messages.find { |msg| ActiveSupport::JSON.decode(msg) == serialized_msg }
+
+      assert message, "No messages sent with #{data} to #{stream}"
+    end
+
+    def pubsub_adapter # :nodoc:
+      ActionCable.server.pubsub
+    end
+
+    delegate :broadcasts, :clear_messages, to: :pubsub_adapter
+
+    private
+
+    def broadcasts_size(channel)
+      broadcasts(channel).size
+    end
+  end
+end

data/lib/rails_6_polyfills/activejob/serializers.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+# First add Rails 6.0 ActiveJob Serializers support, and then the
+# DurationSerializer and SymbolSerializer.
+module ActiveJob
+  module Arguments
+    # :nodoc:
+    OBJECT_SERIALIZER_KEY = "_aj_serialized"
+
+    def serialize_argument(argument)
+      case argument
+      when *TYPE_WHITELIST
+        argument
+      when GlobalID::Identification
+        convert_to_global_id_hash(argument)
+      when Array
+        argument.map { |arg| serialize_argument(arg) }
+      when ActiveSupport::HashWithIndifferentAccess
+        serialize_indifferent_hash(argument)
+      when Hash
+        symbol_keys = argument.each_key.grep(Symbol).map(&:to_s)
+        result = serialize_hash(argument)
+        result[SYMBOL_KEYS_KEY] = symbol_keys
+        result
+      when ->(arg) { arg.respond_to?(:permitted?) }
+        serialize_indifferent_hash(argument.to_h)
+      else # Add Rails 6 support for Serializers
+        Serializers.serialize(argument)
+      end
+    end
+
+    def deserialize_argument(argument)
+      case argument
+      when String
+        argument
+      when *TYPE_WHITELIST
+        argument
+      when Array
+        argument.map { |arg| deserialize_argument(arg) }
+      when Hash
+        if serialized_global_id?(argument)
+          deserialize_global_id argument
+        elsif custom_serialized?(argument)
+          Serializers.deserialize(argument)
+        else
+          deserialize_hash(argument)
+        end
+      else
+        raise ArgumentError, "Can only deserialize primitive arguments: #{argument.inspect}"
+      end
+    end
+
+    def custom_serialized?(hash)
+      hash.key?(OBJECT_SERIALIZER_KEY)
+    end
+  end
+
+  # The <tt>ActiveJob::Serializers</tt> module is used to store a list of known serializers
+  # and to add new ones. It also has helpers to serialize/deserialize objects.
+  module Serializers # :nodoc:
+    # Base class for serializing and deserializing custom objects.
+    #
+    # Example:
+    #
+    #   class MoneySerializer < ActiveJob::Serializers::ObjectSerializer
+    #     def serialize(money)
+    #       super("amount" => money.amount, "currency" => money.currency)
+    #     end
+    #
+    #     def deserialize(hash)
+    #       Money.new(hash["amount"], hash["currency"])
+    #     end
+    #
+    #     private
+    #
+    #       def klass
+    #         Money
+    #       end
+    #   end
+    class ObjectSerializer
+      include Singleton
+
+      class << self
+        delegate :serialize?, :serialize, :deserialize, to: :instance
+      end
+
+      # Determines if an argument should be serialized by a serializer.
+      def serialize?(argument)
+        argument.is_a?(klass)
+      end
+
+      # Serializes an argument to a JSON primitive type.
+      def serialize(hash)
+        {Arguments::OBJECT_SERIALIZER_KEY => self.class.name}.merge!(hash)
+      end
+
+      # Deserializes an argument from a JSON primitive type.
+      def deserialize(_argument)
+        raise NotImplementedError
+      end
+
+      private
+
+      # The class of the object that will be serialized.
+      def klass
+        raise NotImplementedError
+      end
+    end
+
+    class DurationSerializer < ObjectSerializer # :nodoc:
+      def serialize(duration)
+        super("value" => duration.value, "parts" => Arguments.serialize(duration.parts.each_with_object({}) { |v, s| s[v.first.to_s] = v.last }))
+      end
+
+      def deserialize(hash)
+        value = hash["value"]
+        parts = Arguments.deserialize(hash["parts"])
+
+        klass.new(value, parts)
+      end
+
+      private
+
+      def klass
+        ActiveSupport::Duration
+      end
+    end
+
+    class SymbolSerializer < ObjectSerializer # :nodoc:
+      def serialize(argument)
+        super("value" => argument.to_s)
+      end
+
+      def deserialize(argument)
+        argument["value"].to_sym
+      end
+
+      private
+
+      def klass
+        Symbol
+      end
+    end
+
+    # -----------------------------
+
+    mattr_accessor :_additional_serializers
+    self._additional_serializers = Set.new
+
+    class << self
+      # Returns serialized representative of the passed object.
+      # Will look up through all known serializers.
+      # Raises <tt>ActiveJob::SerializationError</tt> if it can't find a proper serializer.
+      def serialize(argument)
+        serializer = serializers.detect { |s| s.serialize?(argument) }
+        raise SerializationError.new("Unsupported argument type: #{argument.class.name}") unless serializer
+        serializer.serialize(argument)
+      end
+
+      # Returns deserialized object.
+      # Will look up through all known serializers.
+      # If no serializer found will raise <tt>ArgumentError</tt>.
+      def deserialize(argument)
+        serializer_name = argument[Arguments::OBJECT_SERIALIZER_KEY]
+        raise ArgumentError, "Serializer name is not present in the argument: #{argument.inspect}" unless serializer_name
+
+        serializer = serializer_name.safe_constantize
+        raise ArgumentError, "Serializer #{serializer_name} is not known" unless serializer
+
+        serializer.deserialize(argument)
+      end
+
+      # Returns list of known serializers.
+      def serializers
+        self._additional_serializers # standard:disable Style/RedundantSelf
+      end
+
+      # Adds new serializers to a list of known serializers.
+      def add_serializers(*new_serializers)
+        self._additional_serializers += new_serializers.flatten
+      end
+    end
+
+    add_serializers DurationSerializer,
+      SymbolSerializer
+    # The full set of 6 serializers that Rails 6.0 normally adds here -- feel free to include any others if you wish:
+    # SymbolSerializer,
+    # DurationSerializer, # (The one that we've added above in order to support testing)
+    # DateTimeSerializer,
+    # DateSerializer,
+    # TimeWithZoneSerializer,
+    # TimeSerializer
+  end
+
+  # Is the updated version of perform_enqueued_jobs from Rails 6.0 missing from ActionJob's TestHelper?
+  unless TestHelper.private_instance_methods.include?(:flush_enqueued_jobs)
+    module TestHelper
+      def perform_enqueued_jobs(only: nil, except: nil, queue: nil)
+        return flush_enqueued_jobs(only: only, except: except, queue: queue) unless block_given?
+
+        super
+      end
+
+      private
+
+      def jobs_with(jobs, only: nil, except: nil, queue: nil)
+        validate_option(only: only, except: except)
+
+        jobs.count do |job|
+          job_class = job.fetch(:job)
+
+          if only
+            next false unless filter_as_proc(only).call(job)
+          elsif except
+            next false if filter_as_proc(except).call(job)
+          end
+
+          if queue
+            next false unless queue.to_s == job.fetch(:queue, job_class.queue_name)
+          end
+
+          yield job if block_given?
+
+          true
+        end
+      end
+
+      def enqueued_jobs_with(only: nil, except: nil, queue: nil, &block)
+        jobs_with(enqueued_jobs, only: only, except: except, queue: queue, &block)
+      end
+
+      def flush_enqueued_jobs(only: nil, except: nil, queue: nil)
+        enqueued_jobs_with(only: only, except: except, queue: queue) do |payload|
+          instantiate_job(payload).perform_now
+          queue_adapter.performed_jobs << payload
+        end
+      end
+    end
+  end
+end

data/lib/rails_6_polyfills/base.rb

@@ -0,0 +1,18 @@
+# The following implements polyfills for Rails < 6.0
+module ActionCable
+  # If the Rails 6.0 ActionCable::TestHelper is missing then allow it to autoload
+  unless ActionCable.const_defined? "TestHelper"
+    autoload :TestHelper, "rails_6_polyfills/actioncable/test_helper.rb"
+  end
+  # If the Rails 6.0 test SubscriptionAdapter is missing then allow it to autoload
+  unless ActionCable.const_defined? "SubscriptionAdapter::Test"
+    module SubscriptionAdapter
+      autoload :Test, "rails_6_polyfills/actioncable/test_adapter.rb"
+    end
+  end
+end
+
+# If the Rails 6.0 ActionJob Serializers are missing then load support for them
+unless Object.const_defined?("ActiveJob::Serializers")
+  require "rails_6_polyfills/activejob/serializers"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: noticed
 version: !ruby/object:Gem::Version
-  version: 1.2.20
+  version: 1.4.1
 platform: ruby
 authors:
 - Chris Oliver
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-23 00:00:00.000000000 Z
+date: 2021-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 5.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 5.2.0
 - !ruby/object:Gem::Dependency
   name: http
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Database, browser, realtime ActionCable, Email, SMS, Slack notifications,
   and more for Rails apps
 email:
@@ -124,11 +138,16 @@ files:
 - lib/noticed/delivery_methods/twilio.rb
 - lib/noticed/delivery_methods/vonage.rb
 - lib/noticed/engine.rb
+- lib/noticed/has_notifications.rb
 - lib/noticed/model.rb
 - lib/noticed/notification_channel.rb
 - lib/noticed/text_coder.rb
 - lib/noticed/translation.rb
 - lib/noticed/version.rb
+- lib/rails_6_polyfills/actioncable/test_adapter.rb
+- lib/rails_6_polyfills/actioncable/test_helper.rb
+- lib/rails_6_polyfills/activejob/serializers.rb
+- lib/rails_6_polyfills/base.rb
 - lib/tasks/noticed_tasks.rake
 homepage: https://github.com/excid3/noticed
 licenses: