activity_notification 2.4.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f81f1308188c8ac3e07332a40b1fab62c5af3a43dbbe135a71303e31d403285
-  data.tar.gz: db55d9f9811dcceecd1f562feaf33949faf716ce6ab07e45f0f35b077b032923
+  metadata.gz: 7ac9e17e63d801b74604936ea099825e1eedd68c5f743b35c01e7af9e73d90ab
+  data.tar.gz: 07db03884cf03f86db283a7b5cbd92f7629277ea5f4f5a910629924471ff62e3
 SHA512:
-  metadata.gz: b4287ae97e4d9f3f3788a5d0fc36b9eb9837880d1ed4289a2e881d32e8a61baecfcd9dc1f9f8e0846214a87fdd4a808e042a3ae77a283a2eb5d4d4bffa4f6411
-  data.tar.gz: 2be55085563ca99a32c029bcc5ecf5e3a025d42a72326ef0f40f218f123af478d2adf760bf5cb51a142a6e326d0bf6c33374c9116e2cd39f0d1b248d3e69b5bd
+  metadata.gz: 91e6206957623ce19971e581afa07fe3b464b02273a968c17bbf145da5836aecbd9b0919b05fae844f912a003a9eeb0d2d4a1df011889ba6bcfb7d752c632346
+  data.tar.gz: 0efe5572854a47c271f6b79b1e0ad649b0d491c1ba4b5370a09a78a0876b4f684bf841069fbaba26fff24e3735ae6b11eeb9bf92ce75f359776d59fd526519ce

data/README.md

@@ -24,6 +24,7 @@
 * Grouping notifications (grouping like *"Kevin and 7 other users posted comments to this article"*)
 * Email notification
 * Batch email notification (event driven or periodical email notification, daily or weekly etc)
+* Cascading notifications (progressive notification escalation through multiple channels with time delays)
 * Push notification with [Action Cable](https://guides.rubyonrails.org/action_cable_overview.html)
 * Subscription management (subscribing and unsubscribing for each target and notification type)
 * REST API backend and [OpenAPI Specification](https://github.com/OAI/OpenAPI-Specification)
@@ -31,22 +32,6 @@
 * Activity notifications stream integrated into cloud computing using [Amazon DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html)
 * Optional notification targets (Configurable optional notification targets like [Amazon SNS](https://aws.amazon.com/sns), [Slack](https://slack.com), SMS and so on)
 
-### Online Demo
-
-You can see an actual application using this gem here:
-* **https://activity-notification-example.herokuapp.com/**
-
-Login as the following test users to experience user activity notifications:
-
-| Email | Password | Admin? |
-|:---:|:---:|:---:|
-| ichiro@example.com  | changeit | Yes |
-| stephen@example.com | changeit |     |
-| klay@example.com    | changeit |     |
-| kevin@example.com   | changeit |     |
-
-The deployed demo application is included in this gem's source code as a test application here: *[/spec/rails_app](/spec/rails_app/)*
-
 ### Notification index and plugin notifications
 
 <kbd>![plugin-notifications-image](https://raw.githubusercontent.com/simukappu/activity_notification/images/activity_notification_plugin_focus_with_subscription.png)</kbd>
@@ -70,16 +55,12 @@ The deployed demo application is included in this gem's source code as a test ap
 REST API reference as OpenAPI Specification is published in SwaggerHub here:
 * **https://app.swaggerhub.com/apis-docs/simukappu/activity-notification/**
 
-You can see sample single page application using [Vue.js](https://vuejs.org) as a part of example Rails application here:
-* **https://activity-notification-example.herokuapp.com/spa/**
-
-This sample application works with *activity_notification* REST API backend.
+You can see sample single page application using [Vue.js](https://vuejs.org) as a part of example Rails application in *[/spec/rails_app](/spec/rails_app/)*. This sample application works with *activity_notification* REST API backend.
 
 
 ## Table of Contents
 
 - [About](#about)
-  - [Online Demo](#online-demo)
   - [Public REST API reference as OpenAPI Specification](#public-rest-apu-reference-as-openapi-specification)
 - [Getting Started](#getting-started)
 - [Setup](/docs/Setup.md#Setup)
@@ -124,6 +105,7 @@ This sample application works with *activity_notification* REST API backend.
     - [Batch email subject](/docs/Functions.md#batch-email-subject)
     - [i18n for batch email](/docs/Functions.md#i18n-for-batch-email)
   - [Grouping notifications](/docs/Functions.md#grouping-notifications)
+  - [Cascading notifications](/docs/Functions.md#cascading-notifications)
   - [Subscription management](/docs/Functions.md#subscription-management)
     - [Configuring subscriptions](/docs/Functions.md#configuring-subscriptions)
     - [Managing subscriptions](/docs/Functions.md#managing-subscriptions)
@@ -155,6 +137,7 @@ This sample application works with *activity_notification* REST API backend.
   - [Testing gem alone](/docs/Testing.md#testing-gem-alone)
 - [Documentation](#documentation)
 - [Common Examples](#common-examples)
+  - [Example Rails application](/docs/Testing.md#example-rails-application)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -184,6 +167,24 @@ $ bin/rails generate activity_notification:install
 
 The generator will install an initializer which describes all configuration options of *activity_notification*.
 
+#### ORM Dependencies
+
+By default, *activity_notification* uses **ActiveRecord** as the ORM and no additional ORM gems are required.
+
+If you intend to use **Mongoid** support, you need to add the `mongoid` gem separately to your Gemfile:
+
+```ruby
+gem 'activity_notification'
+gem 'mongoid', '>= 4.0.0', '< 10.0'
+```
+
+If you intend to use **Dynamoid** support for Amazon DynamoDB, you need to add the `dynamoid` gem separately to your Gemfile:
+
+```ruby
+gem 'activity_notification'
+gem 'dynamoid', '>= 3.11.0', '< 4.0'
+```
+
 ### Database setup
 
 When you use *activity_notification* with ActiveRecord ORM as default configuration,
@@ -326,9 +327,9 @@ See [Testing](/docs/Testing.md#Testing).
 
 ## Documentation
 
-See [API Reference](http://www.rubydoc.info/github/simukappu/activity_notification/index) for more details.
+`docs/` contains documentation for users to read. These files are included in the distributed Gem. `ai-docs/` contains AI-generated and design documents. These files are not included in the distributed Gem.
 
-RubyDoc.info does not support parsing methods in *included* and *class_methods* of *ActiveSupport::Concern* currently.
+See [API Reference](http://www.rubydoc.info/github/simukappu/activity_notification/index) for more details. RubyDoc.info does not support parsing methods in *included* and *class_methods* of *ActiveSupport::Concern* currently.
 To read complete documents, please generate YARD documents on your local environment:
 ```console
 $ git pull https://github.com/simukappu/activity_notification.git
@@ -342,12 +343,7 @@ Then you can see the documents at <http://localhost:8808/docs/index>.
 
 ## Common Examples
 
-See example Rails application in *[/spec/rails_app](/spec/rails_app)*.
-
-You can also try this example Rails application as Online Demo here:
-* **https://activity-notification-example.herokuapp.com/**
-
-You can login as test users to experience user activity notifications. For more details, see [Online Demo](#online-demo).
+See example Rails application in *[/spec/rails_app](/spec/rails_app)*. You can login as test users to experience user activity notifications. For more details, see [Example Rails application](/docs/Testing.md#example-rails-application).
 
 
 ## Contributing

data/app/jobs/activity_notification/cascading_notification_job.rb

@@ -0,0 +1,123 @@
+if defined?(ActiveJob)
+  # Job to handle cascading notifications with time delays and read status checking.
+  # This job enables sequential delivery of notifications through different channels
+  # based on whether previous notifications were read.
+  #
+  # @example Basic usage
+  #   cascade_config = [
+  #     { delay: 10.minutes, target: :slack },
+  #     { delay: 10.minutes, target: :email }
+  #   ]
+  #   CascadingNotificationJob.perform_later(notification.id, cascade_config, 0)
+  class ActivityNotification::CascadingNotificationJob < ActivityNotification.config.parent_job.constantize
+    queue_as ActivityNotification.config.active_job_queue
+  
+    # Performs a single step in the cascading notification chain.
+    # Checks if the notification is still unread, and if so, triggers the next optional target
+    # and schedules the next step in the cascade.
+    #
+    # @param [Integer] notification_id ID of the notification to check
+    # @param [Array<Hash>] cascade_config Array of cascade step configurations
+    # @option cascade_config [ActiveSupport::Duration] :delay Time to wait before checking and sending
+    # @option cascade_config [Symbol, String] :target Name of the optional target to trigger (e.g., :slack, :email)
+    # @option cascade_config [Hash] :options Optional parameters to pass to the optional target
+    # @param [Integer] step_index Current step index in the cascade chain (0-based)
+    # @return [Hash, nil] Result of triggering the optional target, or nil if notification was read or not found
+    def perform(notification_id, cascade_config, step_index = 0)
+      # Find the notification using ORM-appropriate method
+      # :nocov:
+      notification = case ActivityNotification.config.orm
+                     when :dynamoid
+                       ActivityNotification::Notification.find(notification_id, raise_error: false)
+                     when :mongoid
+                       begin
+                         ActivityNotification::Notification.find(notification_id)
+                       rescue Mongoid::Errors::DocumentNotFound
+                         nil
+                       end
+                     else
+                       ActivityNotification::Notification.find_by(id: notification_id)
+                     end
+      # :nocov:
+      
+      # Return early if notification not found or has been opened (read)
+      return nil if notification.nil? || notification.opened?
+      
+      # Get current step configuration
+      current_step = cascade_config[step_index]
+      return nil if current_step.nil?
+      
+      # Extract step parameters
+      target_name = current_step[:target] || current_step['target']
+      target_options = current_step[:options] || current_step['options'] || {}
+      
+      # Trigger the optional target for this step
+      result = trigger_optional_target(notification, target_name, target_options)
+      
+      # Schedule next step if available and notification is still unread
+      next_step_index = step_index + 1
+      if next_step_index < cascade_config.length
+        next_step = cascade_config[next_step_index]
+        delay = next_step[:delay] || next_step['delay']
+        
+        if delay.present?
+          # Schedule the next step with the specified delay
+          self.class.set(wait: delay).perform_later(
+            notification_id,
+            cascade_config,
+            next_step_index
+          )
+        end
+      end
+      
+      result
+    end
+    
+    private
+    
+    # Triggers a specific optional target for the notification
+    # @param [Notification] notification The notification instance
+    # @param [Symbol, String] target_name Name of the optional target
+    # @param [Hash] options Options to pass to the optional target
+    # @return [Hash] Result of triggering the target
+    def trigger_optional_target(notification, target_name, options = {})
+      target_name_sym = target_name.to_sym
+      
+      # Get all configured optional targets for this notification
+      optional_targets = notification.notifiable.optional_targets(
+        notification.target.to_resources_name,
+        notification.key
+      )
+      
+      # Find the matching optional target
+      optional_target = optional_targets.find do |ot|
+        ot.to_optional_target_name == target_name_sym
+      end
+      
+      if optional_target.nil?
+        Rails.logger.warn("Optional target '#{target_name}' not found for notification #{notification.id}")
+        return { target_name_sym => :not_configured }
+      end
+      
+      # Check subscription status
+      unless notification.optional_target_subscribed?(target_name_sym)
+        Rails.logger.info("Target not subscribed to optional target '#{target_name}' for notification #{notification.id}")
+        return { target_name_sym => :not_subscribed }
+      end
+      
+      # Trigger the optional target
+      begin
+        optional_target.notify(notification, options)
+        Rails.logger.info("Successfully triggered optional target '#{target_name}' for notification #{notification.id}")
+        { target_name_sym => :success }
+      rescue => e
+        Rails.logger.error("Failed to trigger optional target '#{target_name}' for notification #{notification.id}: #{e.message}")
+        if ActivityNotification.config.rescue_optional_target_errors
+          { target_name_sym => e }
+        else
+          raise e
+        end
+      end
+    end
+  end
+end

data/docs/Functions.md

@@ -99,7 +99,7 @@ If you use i18n for email, you can configure email subject in your locale files.
 
 #### Other header fields
 
-Similarly to the [Email subject](#email-subject), the `From`, `Reply-To` and `Message-ID` headers are configurable per notifiable model. From and reply to will override the `config.mailer_sender` config setting.
+Similarly to the [Email subject](#email-subject), the `From`, `Reply-To`, `CC` and `Message-ID` headers are configurable per notifiable model. From and reply to will override the `config.mailer_sender` config setting.
 
 ```ruby
 class Comment < ActiveRecord::Base
@@ -120,12 +120,88 @@ class Comment < ActiveRecord::Base
     "no-reply.article+comment-#{self.id}@example.com"
   end
 
+  def overriding_notification_email_cc(target, key)
+    # CC the article author on comment notifications
+    if key == "comment.create"
+      article.user.email
+    else
+      nil
+    end
+  end
+
   def overriding_notification_email_message_id(target, key)
     "https://www.example.com/article/#{article.id}@example.com/"
   end
 end
 ```
 
+#### CC (Carbon Copy) configuration
+
+*activity_notification* supports CC (Carbon Copy) email addresses at three levels with the following priority order:
+
+1. **Notifiable model override** (highest priority) - using `overriding_notification_email_cc` method
+2. **Target model method** - using `mailer_cc` method  
+3. **Global configuration** - using `config.mailer_cc` setting
+
+##### Global CC configuration
+
+You can configure global CC recipients in *activity_notification.rb* initializer as *String*, *Array*, or *Proc*:
+
+```ruby
+# Single CC recipient for all notifications
+config.mailer_cc = 'admin@example.com'
+
+# Multiple CC recipients for all notifications
+config.mailer_cc = ['admin@example.com', 'support@example.com']
+
+# Dynamic CC based on notification key
+config.mailer_cc = ->(key) {
+  if key.include?('urgent')
+    ['urgent@example.com', 'manager@example.com']
+  else
+    'admin@example.com'
+  end
+}
+```
+
+##### Target-level CC configuration
+
+You can define `mailer_cc` method in your target model to set CC recipients for that specific target:
+
+```ruby
+class User < ActiveRecord::Base
+  acts_as_target
+  belongs_to :team_lead, class_name: 'User'
+
+  # Return single or multiple CC addresses
+  def mailer_cc
+    team_lead.present? ? team_lead.email : 'admin@example.com'
+  end
+end
+```
+
+##### Notifiable-level CC override
+
+For the most granular control, implement `overriding_notification_email_cc` in your notifiable model to set CC per notification type:
+
+```ruby
+class Article < ActiveRecord::Base
+  acts_as_notifiable :users,
+    targets: ->(article, key) { [article.user] }
+
+  def overriding_notification_email_cc(target, key)
+    case key
+    when 'article.published'
+      ['editor@example.com', 'marketing@example.com']
+    when 'article.flagged'
+      'moderation@example.com'
+    else
+      nil # Falls back to target's mailer_cc or global config
+    end
+  end
+end
+```
+
 #### i18n for email
 
 The subject of notification email can be put in your locale *.yml* files as **mail_subject** field:
@@ -263,6 +339,126 @@ notification:
 
 Then, you will see *"Kevin and 7 other users posted 10 comments to your article"*.
 
+### Cascading notifications
+
+*activity_notification* provides cascading notifications that enable progressive notification escalation through multiple channels with time delays. This ensures important notifications are not missed while avoiding unnecessary interruptions when users have already engaged with earlier notification channels.
+
+#### How cascading notifications work
+
+Cascading notifications automatically send notifications through different channels (Slack, Email, SMS, etc.) with configurable time delays, but only if the user hasn't already read the notification:
+
+1. User gets an in-app notification
+2. ⏱️ Wait 10 minutes → Still unread? Send Slack message  
+3. ⏱️ Wait 10 more minutes → Still unread? Send Email
+4. ⏱️ Wait 30 more minutes → Still unread? Send SMS
+
+If the user reads the notification at any point, the cascade stops automatically.
+
+#### Basic usage
+
+```ruby
+# Create a notification
+notification = Notification.create!(
+  target: user,
+  notifiable: comment,
+  key: 'comment.reply'
+)
+
+# Setup cascade: Slack after 10 min, Email after another 10 min
+cascade_config = [
+  { delay: 10.minutes, target: :slack },
+  { delay: 10.minutes, target: :email }
+]
+
+# Start the cascade
+notification.cascade_notify(cascade_config)
+```
+
+#### Configuration options
+
+Each step in the cascade requires:
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `delay` | Duration | Yes | How long to wait (e.g., `10.minutes`, `1.hour`) |
+| `target` | Symbol/String | Yes | Optional target name (`:slack`, `:email`, etc.) |
+| `options` | Hash | No | Custom options to pass to the target |
+
+#### Advanced usage
+
+**Immediate first notification:**
+```ruby
+# Send Slack immediately, then email if still unread
+cascade_config = [
+  { delay: 5.minutes, target: :slack },
+  { delay: 10.minutes, target: :email }
+]
+
+notification.cascade_notify(cascade_config, trigger_first_immediately: true)
+```
+
+**With custom options:**
+```ruby
+cascade_config = [
+  { 
+    delay: 5.minutes, 
+    target: :slack,
+    options: { channel: '#urgent' }
+  },
+  { 
+    delay: 10.minutes, 
+    target: :email
+  }
+]
+
+notification.cascade_notify(cascade_config)
+```
+
+**Integration with notification creation:**
+```ruby
+# In your controller
+comment = Comment.create!(comment_params)
+
+# Create notifications
+comment.notify(:users, key: 'comment.new')
+
+# Add cascade to all created notifications
+comment.notifications.each do |notification|
+  cascade_config = [
+    { delay: 10.minutes, target: :slack },
+    { delay: 30.minutes, target: :email }
+  ]
+  notification.cascade_notify(cascade_config)
+end
+```
+
+#### Prerequisites
+
+Before using cascading notifications, ensure:
+
+1. **Optional targets are configured** on your notifiable models
+2. **ActiveJob is configured** (default in Rails)
+3. **Job queue is running** (Sidekiq, Delayed Job, etc.)
+
+#### Common patterns
+
+**Urgent notifications (fast escalation):**
+```ruby
+URGENT_CASCADE = [
+  { delay: 2.minutes, target: :slack },
+  { delay: 5.minutes, target: :email },
+  { delay: 10.minutes, target: :sms }
+].freeze
+```
+
+**Normal notifications (gentle escalation):**
+```ruby
+NORMAL_CASCADE = [
+  { delay: 30.minutes, target: :slack },
+  { delay: 1.hour, target: :email }
+].freeze
+```
+
 
 ### Subscription management
 
@@ -381,8 +577,6 @@ end
 
 Then, you can access *users/1/subscriptions* and use *[ActivityNotification::SubscriptionsController](/app/controllers/activity_notification/subscriptions_controller.rb)* or *[ActivityNotification::SubscriptionsWithDeviseController](/app/controllers/activity_notification/subscriptions_with_devise_controller.rb)* to manage the subscriptions.
 
-You can see sample subscription management view in demo application here: *https://activity-notification-example.herokuapp.com/users/1/subscriptions*
-
 If you would like to customize subscription controllers or views, you can use generators like notifications:
 
 * Customize subscription controllers
@@ -436,8 +630,6 @@ You can see [sample single page application](/spec/rails_app/app/javascript/) us
 
 *activity_notification* provides API reference as [OpenAPI Specification](https://github.com/OAI/OpenAPI-Specification).
 
-OpenAPI Specification in [online demo](https://activity-notification-example.herokuapp.com/) is published here: **https://activity-notification-example.herokuapp.com/api/v2/apidocs**
-
 Public API reference is also hosted in [SwaggerHub](https://swagger.io/tools/swaggerhub/) here: **https://app.swaggerhub.com/apis-docs/simukappu/activity-notification/**
 
 You can also publish OpenAPI Specification in your own application using *[ActivityNotification::ApidocsController](/app/controllers/activity_notification/apidocs_controller.rb)* like this:
@@ -588,7 +780,7 @@ end
 To sign in and get *access-token* from Devise Token Auth, call *sign_in* API which you configured by *mount_devise_token_auth_for* method:
 
 ```console
-$ curl -X POST -H "Content-Type: application/json" -D - -d '{"email": "ichiro@example.com","password": "changeit"}' https://activity-notification-example.herokuapp.com/api/v2/auth/sign_in
+$ curl -X POST -H "Content-Type: application/json" -D - -d '{"email": "ichiro@example.com","password": "changeit"}' https://localhost:3000/api/v2/auth/sign_in
 
 
 HTTP/1.1 200 OK
@@ -615,7 +807,7 @@ uid: ichiro@example.com
 Then, call *activity_notification* API with returned *access-token*, *client* and *uid* as HTTP headers:
 
 ```console
-$ curl -X GET -H "Content-Type: application/json" -H "access-token: ZiDvw8vJGtbESy5Qpw32Kw" -H "client: W0NkGrTS88xeOx4VDOS-Xg" -H "uid: ichiro@example.com" -D - https://activity-notification-example.herokuapp.com/api/v2/notifications
+$ curl -X GET -H "Content-Type: application/json" -H "access-token: ZiDvw8vJGtbESy5Qpw32Kw" -H "client: W0NkGrTS88xeOx4VDOS-Xg" -H "uid: ichiro@example.com" -D - https://localhost:3000/api/v2/notifications
 
 HTTP/1.1 200 OK
 ...
@@ -631,7 +823,7 @@ HTTP/1.1 200 OK
 Without valid *access-token*, API returns *401 Unauthorized*:
 
 ```console
-$ curl -X GET -H "Content-Type: application/json" -D - https://activity-notification-example.herokuapp.com/api/v2/notifications
+$ curl -X GET -H "Content-Type: application/json" -D - https://localhost:3000/api/v2/notifications
 
 HTTP/1.1 401 Unauthorized
 ...
@@ -646,7 +838,7 @@ HTTP/1.1 401 Unauthorized
 When you request restricted resources of unauthorized targets, *activity_notification* API returns *403 Forbidden*:
 
 ```console
-$ curl -X GET -H "Content-Type: application/json" -H "access-token: ZiDvw8vJGtbESy5Qpw32Kw" -H "client: W0NkGrTS88xeOx4VDOS-Xg" -H "uid: ichiro@example.com" -D - https://activity-notification-example.herokuapp.com/api/v2/notifications/1
+$ curl -X GET -H "Content-Type: application/json" -H "access-token: ZiDvw8vJGtbESy5Qpw32Kw" -H "client: W0NkGrTS88xeOx4VDOS-Xg" -H "uid: ichiro@example.com" -D - https://localhost:3000/api/v2/notifications/1
 
 HTTP/1.1 403 Forbidden
 ...
@@ -1141,6 +1333,4 @@ user.find_or_create_subscription('comment.reply').subscribe_to_optional_target(:
 user.find_or_create_subscription('comment.reply').unsubscribe_to_optional_target(:slack)
 ```
 
-You can also manage subscriptions of optional targets by subscriptions REST API. See [REST API backend](#rest-api-backend) for more details.
-
-You can see sample subscription management view in demo application here: *https://activity-notification-example.herokuapp.com/users/1/subscriptions*
+You can also manage subscriptions of optional targets by subscriptions REST API. See [REST API backend](#rest-api-backend) for more details.

data/docs/Setup.md

@@ -22,6 +22,24 @@ $ bin/rails generate activity_notification:install
 The generator will install an initializer which describes all configuration options of *activity_notification*.
 It also generates a i18n based translation file which we can configure the presentation of notifications.
 
+#### ORM Dependencies
+
+By default, *activity_notification* uses **ActiveRecord** as the ORM and no additional ORM gems are required.
+
+If you intend to use **Mongoid** support, you need to add the `mongoid` gem separately to your Gemfile:
+
+```ruby
+gem 'activity_notification'
+gem 'mongoid', '>= 4.0.0', '< 10.0'
+```
+
+If you intend to use **Dynamoid** support for Amazon DynamoDB, you need to add the `dynamoid` gem separately to your Gemfile:
+
+```ruby
+gem 'activity_notification'
+gem 'dynamoid', '>= 3.11.0', '< 4.0'
+```
+
 ### Database setup
 
 #### Using ActiveRecord ORM
@@ -64,7 +82,14 @@ config.yaml_column_permitted_classes << Time
 
 #### Using Mongoid ORM
 
-When you use *activity_notification* with [Mongoid](http://mongoid.org) ORM, set **AN_ORM** environment variable to **mongoid**:
+When you use *activity_notification* with [Mongoid](http://mongoid.org) ORM, you first need to add the `mongoid` gem to your Gemfile:
+
+```ruby
+gem 'activity_notification'
+gem 'mongoid', '>= 4.0.0', '< 10.0'
+```
+
+Then set **AN_ORM** environment variable to **mongoid**:
 
 ```console
 $ export AN_ORM=mongoid
@@ -80,7 +105,14 @@ You need to configure Mongoid in your Rails application for your MongoDB environ
 
 #### Using Dynamoid ORM
 
-When you use *activity_notification* with [Dynamoid](https://github.com/Dynamoid/dynamoid) ORM, set **AN_ORM** environment variable to **dynamoid**:
+When you use *activity_notification* with [Dynamoid](https://github.com/Dynamoid/dynamoid) ORM, you first need to add the `dynamoid` gem to your Gemfile:
+
+```ruby
+gem 'activity_notification'
+gem 'dynamoid', '>= 3.11.0', '< 4.0'
+```
+
+Then set **AN_ORM** environment variable to **dynamoid**:
 
 ```console
 $ export AN_ORM=dynamoid

data/docs/Testing.md

@@ -104,6 +104,17 @@ $ bin/rails server
 ```
 Then, you can access <http://localhost:3000> for the example application.
 
+##### Default test users
+
+Login as the following test users to experience user activity notifications:
+
+| Email | Password | Admin? |
+|:---:|:---:|:---:|
+| ichiro@example.com  | changeit | Yes |
+| stephen@example.com | changeit |     |
+| klay@example.com    | changeit |     |
+| kevin@example.com   | changeit |     |
+
 ##### Run with your local database
 As default, example Rails application runs with local SQLite database in *spec/rails_app/db/development.sqlite3*.
 This application supports to run with your local MySQL, PostgreSQL, MongoDB.
@@ -144,5 +155,5 @@ $ cd spec/rails_app
 $ # You don't need migration when you use MongoDB only (AN_ORM=mongoid and AN_TEST_DB=mongodb)
 $ bin/rake db:migrate
 $ bin/rake db:seed
-$ bin/rails server Puma
+$ bin/rails server
 ```