activity_notification 1.0.0 → 1.0.1

data/lib/activity_notification/models/notification.rb

@@ -50,31 +50,55 @@ module ActivityNotification
     # Selects group owner notifications only.
     # @scope class
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :group_owners_only,                 ->        { where(group_owner_id: nil) }
+    scope :group_owners_only,                 -> { where(group_owner_id: nil) }
 
     # Selects group member notifications only.
     # @scope class
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :group_members_only,                ->        { where.not(group_owner_id: nil) }
+    scope :group_members_only,                -> { where.not(group_owner_id: nil) }
+
+    # Selects all notification index.
+    #   ActivityNotification::Notification.all_index!
+    # is defined same as
+    #   ActivityNotification::Notification.group_owners_only.latest_order
+    # @example Get all notification index of the @user
+    #   @notifications = @user.notifications.all_index!
+    #   @notifications = @user.notifications.group_owners_only.latest_order
+    # @scope class
+    # @param [Boolean] reverse If notification index will be ordered as earliest first
+    # @param [Boolean] with_group_members If notification index will include group members
+    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
+    scope :all_index!,                        ->(reverse = false, with_group_members = false) {
+      target_index = with_group_members ? self : group_owners_only
+      reverse ? target_index.earliest_order : target_index.latest_order
+    }
 
     # Selects unopened notifications only.
     # @scope class
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :unopened_only,                     ->        { where(opened_at: nil) }
+    scope :unopened_only,                     -> { where(opened_at: nil) }
 
     # Selects unopened notification index.
-    # Defined same as `unopened_only.group_owners_only.latest_order`.
+    #   ActivityNotification::Notification.unopened_index
+    # is defined same as
+    #   ActivityNotification::Notification.unopened_only.group_owners_only.latest_order
     # @example Get unopened notificaton index of the @user
-    #   @notifications = @user.unopened_index
+    #   @notifications = @user.notifications.unopened_index
+    #   @notifications = @user.notifications.unopened_only.group_owners_only.latest_order
     # @scope class
+    # @param [Boolean] reverse If notification index will be ordered as earliest first
+    # @param [Boolean] with_group_members If notification index will include group members
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :unopened_index,                    ->        { unopened_only.group_owners_only.latest_order }
+    scope :unopened_index,                    ->(reverse = false, with_group_members = false) {
+      target_index = with_group_members ? unopened_only : unopened_only.group_owners_only
+      reverse ? target_index.earliest_order : target_index.latest_order
+    }
 
     # Selects opened notifications only without limit.
     # Be careful to get too many records with this method.
     # @scope class
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :opened_only!,                      ->        { where.not(opened_at: nil) }
+    scope :opened_only!,                      -> { where.not(opened_at: nil) }
 
     # Selects opened notifications only with limit.
     # @scope class
@@ -83,16 +107,26 @@ module ActivityNotification
     scope :opened_only,                       ->(limit) { opened_only!.limit(limit) }
 
     # Selects unopened notification index.
-    # Defined same as `opened_only(limit).group_owners_only.latest_order`.
+    #   ActivityNotification::Notification.opened_index(limit)
+    # is defined same as
+    #   ActivityNotification::Notification.opened_only(limit).group_owners_only.latest_order
+    # @example Get unopened notificaton index of the @user with limit 10
+    #   @notifications = @user.notifications.opened_index(10)
+    #   @notifications = @user.notifications.opened_only(10).group_owners_only.latest_order
     # @scope class
     # @param [Integer] limit Limit to query for opened notifications
+    # @param [Boolean] reverse If notification index will be ordered as earliest first
+    # @param [Boolean] with_group_members If notification index will include group members
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :opened_index,                      ->(limit) { opened_only(limit).group_owners_only.latest_order }
+    scope :opened_index,                      ->(limit, reverse = false, with_group_members = false) {
+      target_index = with_group_members ? opened_only(limit) : opened_only(limit).group_owners_only
+      reverse ? target_index.earliest_order : target_index.latest_order
+    }
 
     # Selects group member notifications in unopened_index.
     # @scope class
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :unopened_index_group_members_only, ->        { where(group_owner_id: unopened_index.map(&:id)) }
+    scope :unopened_index_group_members_only, -> { where(group_owner_id: unopened_index.map(&:id)) }
 
     # Selects group member notifications in opened_index.
     # @scope class
@@ -107,7 +141,15 @@ module ActivityNotification
     # @scope class
     # @param [Object] target Target instance for filter
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :filtered_by_target,   ->(target)             { where(target: target) }
+    scope :filtered_by_target,                ->(target) { where(target: target) }
+
+    # Selects filtered notifications by target_type.
+    # @example Get filtered unopened notificatons of User as target type
+    #   @notifications = ActivityNotification.Notification.unopened_only.filtered_by_target_type('User')
+    # @scope class
+    # @param [String] target_type Target type for filter
+    # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
+    scope :filtered_by_target_type,           ->(target_type) { where(target_type: target_type) }
 
     # Selects filtered notifications by notifiable instance.
     # @example Get filtered unopened notificatons of the @user for @comment as notifiable
@@ -115,7 +157,7 @@ module ActivityNotification
     # @scope class
     # @param [Object] notifiable Notifiable instance for filter
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :filtered_by_instance, ->(notifiable)         { where(notifiable: notifiable) }
+    scope :filtered_by_instance,              ->(notifiable) { where(notifiable: notifiable) }
 
     # Selects filtered notifications by notifiable_type.
     # @example Get filtered unopened notificatons of the @user for Comment notifiable class
@@ -123,7 +165,7 @@ module ActivityNotification
     # @scope class
     # @param [String] notifiable_type Notifiable type for filter
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :filtered_by_type,     ->(notifiable_type)    { where(notifiable_type: notifiable_type) }
+    scope :filtered_by_type,                  ->(notifiable_type) { where(notifiable_type: notifiable_type) }
 
     # Selects filtered notifications by group instance.
     # @example Get filtered unopened notificatons of the @user for @article as group
@@ -131,7 +173,7 @@ module ActivityNotification
     # @scope class
     # @param [Object] group Group instance for filter
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :filtered_by_group,    ->(group)              { where(group: group) }
+    scope :filtered_by_group,                 ->(group) { where(group: group) }
 
     # Selects filtered notifications by key.
     # @example Get filtered unopened notificatons of the @user with key 'comment.reply'
@@ -139,7 +181,7 @@ module ActivityNotification
     # @scope class
     # @param [String] key Key of the notification for filter
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :filtered_by_key,      ->(key)                { where(key: key) }
+    scope :filtered_by_key,                   ->(key) { where(key: key) }
 
     # Selects filtered notifications by notifiable_type, group or key with filter options.
     # @example Get filtered unopened notificatons of the @user for Comment notifiable class
@@ -152,15 +194,18 @@ module ActivityNotification
     #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_key: 'comment.reply' })
     # @example Get filtered unopened notificatons of the @user for Comment notifiable class with key 'comment.reply'
     #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_type: 'Comment', filtered_by_key: 'comment.reply' })
+    # @example Get custom filtered notificatons of the @user
+    #   @notifications = @user.notifications.unopened_only.filtered_by_options({ custom_filter: ["created_at >= ?", time.hour.ago] })
     # @scope class
     # @param [Hash] options Options for filter
-    # @option options [String] :filtered_by_type       (nil) Notifiable type for filter
-    # @option options [Object] :filtered_by_group      (nil) Group instance for filter
-    # @option options [String] :filtered_by_group_type (nil) Group type for filter, valid with :filtered_by_group_id
-    # @option options [String] :filtered_by_group_id   (nil) Group instance id for filter, valid with :filtered_by_group_type
-    # @option options [String] :filtered_by_key        (nil) Key of the notification for filter 
+    # @option options [String]     :filtered_by_type       (nil) Notifiable type for filter
+    # @option options [Object]     :filtered_by_group      (nil) Group instance for filter
+    # @option options [String]     :filtered_by_group_type (nil) Group type for filter, valid with :filtered_by_group_id
+    # @option options [String]     :filtered_by_group_id   (nil) Group instance id for filter, valid with :filtered_by_group_type
+    # @option options [String]     :filtered_by_key        (nil) Key of the notification for filter 
+    # @option options [Array|Hash] :custom_filter          (nil) Custom notification filter (e.g. ["created_at >= ?", time.hour.ago])
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Array or database query of filtered notifications
-    scope :filtered_by_options,  ->(options = {})       {
+    scope :filtered_by_options,               ->(options = {}) {
       options = ActivityNotification.cast_to_indifferent_hash(options)
       filtered_notifications = all
       if options.has_key?(:filtered_by_type)
@@ -176,40 +221,51 @@ module ActivityNotification
       if options.has_key?(:filtered_by_key)
         filtered_notifications = filtered_notifications.filtered_by_key(options[:filtered_by_key])
       end
+      if options.has_key?(:custom_filter)
+        filtered_notifications = filtered_notifications.where(options[:custom_filter])
+      end
       filtered_notifications
     }
 
     # Includes target instance with query for notifications.
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with target
-    scope :with_target,                       ->        { includes(:target) }
+    scope :with_target,                       -> { includes(:target) }
 
     # Includes notifiable instance with query for notifications.
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with notifiable
-    scope :with_notifiable,                   ->        { includes(:notifiable) }
+    scope :with_notifiable,                   -> { includes(:notifiable) }
 
     # Includes group instance with query for notifications.
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with group
-    scope :with_group,                        ->        { includes(:group) }
+    scope :with_group,                        -> { includes(:group) }
+
+    # Includes group owner instances with query for notifications.
+    # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with group owner
+    scope :with_group_owner,                 -> { includes(:group_owner) }
+
+    # Includes group member instances with query for notifications.
+    # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with group members
+    scope :with_group_members,                -> { includes(:group_members) }
 
     # Includes notifier instance with query for notifications.
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications with notifier
-    scope :with_notifier,                     ->        { includes(:notifier) }
+    scope :with_notifier,                     -> { includes(:notifier) }
 
     # Orders by latest (newest) first as created_at: :desc.
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications ordered by latest first
-    scope :latest_order,                      ->        { order(created_at: :desc) }
+    scope :latest_order,                      -> { order(created_at: :desc) }
 
     # Orders by earliest (older) first as created_at: :asc.
     # @return [ActiveRecord_AssociationRelation<Notificaion>] Database query of notifications ordered by earliest first
-    scope :earliest_order,                    ->        { order(created_at: :asc) }
+    scope :earliest_order,                    -> { order(created_at: :asc) }
 
     # Returns latest notification instance.
     # @return [Notification] Latest notification instance
-    scope :latest,                            ->        { latest_order.first }
+    scope :latest,                            -> { latest_order.first }
 
     # Returns earliest notification instance.
     # @return [Notification] Earliest notification instance
-    scope :earliest,                          ->        { earliest_order.first }
+    scope :earliest,                          -> { earliest_order.first }
 
   end
 end

data/lib/activity_notification/roles/acts_as_target.rb

@@ -87,6 +87,7 @@ module ActivityNotification
       # @param [Hash] options Options for notifiable model configuration
       # @option options [Symbol, Proc, String]  :email           (nil) Email address to send notification email
       # @option options [Symbol, Proc, Boolean] :email_allowed   (ActivityNotification.config.email_enabled) Whether activity_notification sends notification email to this target
+      # @option options [Symbol, Proc, Boolean] :email_allowed   (ActivityNotification.config.email_enabled) Whether activity_notification sends batch notification email to this target
       # @option options [Symbol, Proc, Object]  :devise_resource (nil) Integrated resource with devise authentication
       # @option options [Symbol, Proc, String]  :printable_name  (ActivityNotification::Common.printable_name) Printable notification target name
       # @return [Hash] Configured parameters as target model
@@ -94,15 +95,16 @@ module ActivityNotification
         include Target
 
         options[:printable_notification_target_name] ||= options.delete(:printable_name)
+        options[:batch_notification_email_allowed] ||= options.delete(:batch_email_allowed)
         set_acts_as_parameters([:email, :email_allowed, :devise_resource], options, "notification_")
-          .merge set_acts_as_parameters([:printable_notification_target_name], options)
+          .merge set_acts_as_parameters([:batch_notification_email_allowed, :printable_notification_target_name], options)
       end
       alias_method :acts_as_notification_target, :acts_as_target
 
       # Returns array of available target options in acts_as_target.
       # @return [Array<Symbol>] Array of available target options
       def available_target_options
-        [:email, :email_allowed, :devise_resource, :printable_notification_target_name, :printable_name].freeze
+        [:email, :email_allowed, :batch_email_allowed, :devise_resource, :printable_notification_target_name, :printable_name].freeze
       end
     end
   end

data/lib/activity_notification/version.rb

@@ -1,3 +1,3 @@
 module ActivityNotification
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/spec/concerns/apis/notification_api_spec.rb

@@ -412,6 +412,36 @@ shared_examples_for :notification_api do
       end
     end
 
+    describe ".send_batch_notification_email" do
+      context "as default" do
+        it "sends batch notification email later" do
+          expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
+          expect {
+            perform_enqueued_jobs do
+              described_class.send_batch_notification_email(test_instance.target, [test_instance])
+            end
+          }.to change { ActivityNotification::Mailer.deliveries.size }.by(1)
+          expect(ActivityNotification::Mailer.deliveries.size).to eq(1)
+          expect(ActivityNotification::Mailer.deliveries.first.to[0]).to eq(test_instance.target.email)
+        end
+
+        it "sends batch notification email with active job queue" do
+          expect {
+            described_class.send_batch_notification_email(test_instance.target, [test_instance])
+          }.to change(ActiveJob::Base.queue_adapter.enqueued_jobs, :size).by(1)
+        end
+      end
+
+      context "with send_later false" do
+        it "sends notification email now" do
+          expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
+          described_class.send_batch_notification_email(test_instance.target, [test_instance], send_later: false)
+          expect(ActivityNotification::Mailer.deliveries.size).to eq(1)
+          expect(ActivityNotification::Mailer.deliveries.first.to[0]).to eq(test_instance.target.email)
+        end
+      end
+    end
+
     describe ".available_options" do
       it "returns list of available options in notify api" do
         expect(described_class.available_options)
@@ -1035,6 +1065,22 @@ shared_examples_for :notification_api do
       end
     end
 
+    describe "#latest_group_member" do
+      context "with group member" do
+        it "returns latest group member" do
+          member1 = create(test_class_name, target: test_instance.target, group_owner: test_instance)
+          member2 = create(test_class_name, target: test_instance.target, group_owner: test_instance)
+          expect(test_instance.latest_group_member).to eq(member2)
+        end
+      end
+
+      context "without group members" do
+        it "returns group owner self" do
+          expect(test_instance.latest_group_member).to eq(test_instance)
+        end
+      end
+    end
+
     describe "#notifiable_path" do
       it "returns notifiable.notifiable_path" do
         expect(test_instance.notifiable_path)

data/spec/concerns/models/target_spec.rb

@@ -30,6 +30,75 @@ shared_examples_for :target do
         expect(described_class._printable_notification_target_name).to eq(:printable_name)
       end
     end    
+
+    describe ".notification_index_map" do
+      it "returns notifications of this target type group by target" do
+        ActivityNotification::Notification.delete_all
+        target_1 = create(test_class_name)
+        target_2 = create(test_class_name)
+        notification_1 = create(:notification, target: target_1)
+        notification_2 = create(:notification, target: target_1)
+        notification_3 = create(:notification, target: target_1)
+        notification_4 = create(:notification, target: target_2)
+        notification_5 = create(:notification, target: target_2)
+        notification_6 = create(:notification, target: test_notifiable)
+
+        expect(described_class.notification_index_map.size).to eq(2)
+        expect(described_class.notification_index_map[target_1].size).to eq(3)
+        expect(described_class.notification_index_map[target_2].size).to eq(2)
+      end
+    end
+
+    describe ".unopened_notification_index_map" do
+      it "returns unopened notifications of this target type group by target" do
+        ActivityNotification::Notification.delete_all
+        target_1 = create(test_class_name)
+        target_2 = create(test_class_name)
+        target_3 = create(test_class_name)
+        notification_1 = create(:notification, target: target_1)
+        notification_2 = create(:notification, target: target_1)
+        notification_3 = create(:notification, target: target_1)
+        notification_3.open!
+        notification_4 = create(:notification, target: target_2)
+        notification_5 = create(:notification, target: target_2)
+        notification_5.open!
+        notification_6 = create(:notification, target: target_3)
+        notification_6.open!
+        notification_7 = create(:notification, target: test_notifiable)
+
+        index_map = described_class.unopened_notification_index_map
+        expect(index_map.size).to eq(2)
+        expect(index_map[target_1].size).to eq(2)
+        expect(index_map[target_2].size).to eq(1)
+        expect(index_map.has_key?(target_3)).to be_falsey
+      end
+    end
+
+    describe ".send_batch_unopened_notification_email" do
+      it "sends batch notification email to this type targets with unopened notifications" do
+        ActivityNotification::Notification.delete_all
+        target_1 = create(test_class_name)
+        target_2 = create(test_class_name)
+        target_3 = create(test_class_name)
+        notification_1 = create(:notification, target: target_1)
+        notification_2 = create(:notification, target: target_1)
+        notification_3 = create(:notification, target: target_1)
+        notification_3.open!
+        notification_4 = create(:notification, target: target_2)
+        notification_5 = create(:notification, target: target_2)
+        notification_5.open!
+        notification_6 = create(:notification, target: target_3)
+        notification_6.open!
+        notification_7 = create(:notification, target: test_notifiable)
+
+        expect(ActivityNotification::Notification).to receive(:send_batch_notification_email).at_least(:once)
+        sent_email_map = described_class.send_batch_unopened_notification_email
+        expect(sent_email_map.size).to eq(2)
+        expect(sent_email_map.has_key?(target_1)).to be_truthy
+        expect(sent_email_map.has_key?(target_2)).to be_truthy
+        expect(sent_email_map.has_key?(target_3)).to be_falsey
+      end
+    end
   end
 
   describe "as public instance methods" do
@@ -248,9 +317,14 @@ shared_examples_for :target do
 
       context "when the target has unopened notifications" do
         before do
-          create(:notification, target: test_instance)
-          create(:notification, target: test_instance)
-          create(:notification, target: test_instance).open!
+          @notifiable    = create(:article)
+          @group         = create(:article)
+          @key           = 'test.key.1'
+          @notification2 = create(:notification, target: test_instance, notifiable: @notifiable)
+          @notification1 = create(:notification, target: test_instance, notifiable: create(:comment), group: @group)
+          @member1       = create(:notification, target: test_instance, notifiable: create(:comment), group_owner: @notification1)
+          @notification3 = create(:notification, target: test_instance, notifiable: create(:article), key: @key)
+          @notification3.open!
         end
 
         it "calls unopened_notification_index" do
@@ -258,11 +332,11 @@ shared_examples_for :target do
           test_instance.notification_index
         end
 
-        context "without limit" do
+        context "without any options" do
           it "returns the combined array of unopened_notification_index and opened_notification_index" do
-            expect(test_instance.notification_index[0]).to eq(test_instance.unopened_notification_index[0])
-            expect(test_instance.notification_index[1]).to eq(test_instance.unopened_notification_index[1])
-            expect(test_instance.notification_index[2]).to eq(test_instance.opened_notification_index[0])
+            expect(test_instance.notification_index[0]).to eq(@notification1)
+            expect(test_instance.notification_index[1]).to eq(@notification2)
+            expect(test_instance.notification_index[2]).to eq(@notification3)
             expect(test_instance.notification_index.size).to eq(3)
           end
         end
@@ -270,7 +344,86 @@ shared_examples_for :target do
         context "with limit" do
           it "returns the same as unopened_notification_index with limit" do
             options = { limit: 1 }
-            expect(test_instance.notification_index(options)).to eq(test_instance.unopened_notification_index(options))
+            expect(test_instance.notification_index(options)[0]).to eq(@notification1)
+            expect(test_instance.notification_index(options).size).to eq(1)
+          end
+        end
+
+        context "with reverse" do
+          it "returns the earliest order" do
+            options = { reverse: true }
+            expect(test_instance.notification_index(options)[0]).to eq(@notification2)
+            expect(test_instance.notification_index(options)[1]).to eq(@notification1)
+            expect(test_instance.notification_index(options)[2]).to eq(@notification3)
+            expect(test_instance.notification_index(options).size).to eq(3)
+          end
+        end
+
+        context "with with_group_members" do
+          it "returns the index with group members" do
+            options = { with_group_members: true }
+            expect(test_instance.notification_index(options)[0]).to eq(@member1)
+            expect(test_instance.notification_index(options)[1]).to eq(@notification1)
+            expect(test_instance.notification_index(options)[2]).to eq(@notification2)
+            expect(test_instance.notification_index(options)[3]).to eq(@notification3)
+            expect(test_instance.notification_index(options).size).to eq(4)
+          end
+        end
+
+        context "with as_latest_group_member" do
+          it "returns the index as latest group member" do
+            options = { as_latest_group_member: true }
+            expect(test_instance.notification_index(options)[0]).to eq(@member1)
+            expect(test_instance.notification_index(options)[1]).to eq(@notification2)
+            expect(test_instance.notification_index(options)[2]).to eq(@notification3)
+            expect(test_instance.notification_index(options).size).to eq(3)
+          end
+        end
+
+        context 'with filtered_by_type options' do
+          it "returns filtered notifications only" do
+            options = { filtered_by_type: 'Article' }
+            expect(test_instance.notification_index(options)[0]).to eq(@notification2)
+            expect(test_instance.notification_index(options)[1]).to eq(@notification3)
+            expect(test_instance.notification_index(options).size).to eq(2)
+            options = { filtered_by_type: 'Comment' }
+            expect(test_instance.notification_index(options)[0]).to eq(@notification1)
+            expect(test_instance.notification_index(options).size).to eq(1)
+          end
+        end
+
+        context 'with filtered_by_group options' do
+          it "returns filtered notifications only" do
+            options = { filtered_by_group: @group }
+            expect(test_instance.notification_index(options)[0]).to eq(@notification1)
+            expect(test_instance.notification_index(options).size).to eq(1)
+          end
+        end
+
+        context 'with filtered_by_group_type and :filtered_by_group_id options' do
+          it "returns filtered notifications only" do
+            options = { filtered_by_group_type: 'Article', filtered_by_group_id: @group.id.to_s }
+            expect(test_instance.notification_index(options)[0]).to eq(@notification1)
+            expect(test_instance.notification_index(options).size).to eq(1)
+          end
+        end
+
+        context 'with filtered_by_key options' do
+          it "returns filtered notifications only" do
+            options = { filtered_by_key: @key }
+            expect(test_instance.notification_index(options)[0]).to eq(@notification3)
+            expect(test_instance.notification_index(options).size).to eq(1)
+          end
+        end
+
+        context 'with custom_filter options' do
+          it "returns filtered notifications only" do
+            options = { custom_filter: ["key = ?", @key] }
+            expect(test_instance.notification_index(options)[0]).to eq(@notification3)
+            expect(test_instance.notification_index(options).size).to eq(1)
+
+            options = { custom_filter: { key: @key } }
+            expect(test_instance.notification_index(options)[0]).to eq(@notification3)
             expect(test_instance.notification_index(options).size).to eq(1)
           end
         end
@@ -453,9 +606,13 @@ shared_examples_for :target do
 
       context "when the target has unopened notifications" do
         before do
-          create(:notification, target: test_instance)
-          create(:notification, target: test_instance)
-          create(:notification, target: test_instance).open!
+          @notifiable    = create(:article)
+          @group         = create(:article)
+          @key           = 'test.key.1'
+          @notification2 = create(:notification, target: test_instance, notifiable: @notifiable)
+          @notification1 = create(:notification, target: test_instance, notifiable: create(:comment), group: @group)
+          @notification3 = create(:notification, target: test_instance, notifiable: create(:article), key: @key)
+          @notification3.open!
         end
 
         it "calls unopened_notification_index_with_attributes" do
@@ -463,19 +620,65 @@ shared_examples_for :target do
           test_instance.notification_index_with_attributes
         end
 
-        context "without limit" do
-          it "returns the combined array of unopened_notification_index and opened_notification_index" do
-            expect(test_instance.notification_index_with_attributes[0]).to eq(test_instance.unopened_notification_index[0])
-            expect(test_instance.notification_index_with_attributes[1]).to eq(test_instance.unopened_notification_index[1])
-            expect(test_instance.notification_index_with_attributes[2]).to eq(test_instance.opened_notification_index[0])
-            expect(test_instance.notification_index.size).to eq(3)
+        context "without any options" do
+          it "returns the combined array of unopened_notification_index_with_attributes and opened_notification_index_with_attributes" do
+            expect(test_instance.notification_index_with_attributes[0]).to eq(@notification1)
+            expect(test_instance.notification_index_with_attributes[1]).to eq(@notification2)
+            expect(test_instance.notification_index_with_attributes[2]).to eq(@notification3)
+            expect(test_instance.notification_index_with_attributes.size).to eq(3)
           end
         end
 
         context "with limit" do
           it "returns the same as unopened_notification_index_with_attributes with limit" do
             options = { limit: 1 }
-            expect(test_instance.notification_index_with_attributes(options)).to eq(test_instance.unopened_notification_index_with_attributes(options))
+            expect(test_instance.notification_index_with_attributes(options)[0]).to eq(@notification1)
+            expect(test_instance.notification_index_with_attributes(options).size).to eq(1)
+          end
+        end
+
+        context "with reverse" do
+          it "returns the earliest order" do
+            options = { reverse: true }
+            expect(test_instance.notification_index_with_attributes(options)[0]).to eq(@notification2)
+            expect(test_instance.notification_index_with_attributes(options)[1]).to eq(@notification1)
+            expect(test_instance.notification_index_with_attributes(options)[2]).to eq(@notification3)
+            expect(test_instance.notification_index_with_attributes(options).size).to eq(3)
+          end
+        end
+
+        context 'with filtered_by_type options' do
+          it "returns filtered notifications only" do
+            options = { filtered_by_type: 'Article' }
+            expect(test_instance.notification_index_with_attributes(options)[0]).to eq(@notification2)
+            expect(test_instance.notification_index_with_attributes(options)[1]).to eq(@notification3)
+            expect(test_instance.notification_index_with_attributes(options).size).to eq(2)
+            options = { filtered_by_type: 'Comment' }
+            expect(test_instance.notification_index_with_attributes(options)[0]).to eq(@notification1)
+            expect(test_instance.notification_index_with_attributes(options).size).to eq(1)
+          end
+        end
+
+        context 'with filtered_by_group options' do
+          it "returns filtered notifications only" do
+            options = { filtered_by_group: @group }
+            expect(test_instance.notification_index_with_attributes(options)[0]).to eq(@notification1)
+            expect(test_instance.notification_index_with_attributes(options).size).to eq(1)
+          end
+        end
+
+        context 'with filtered_by_group_type and :filtered_by_group_id options' do
+          it "returns filtered notifications only" do
+            options = { filtered_by_group_type: 'Article', filtered_by_group_id: @group.id.to_s }
+            expect(test_instance.notification_index_with_attributes(options)[0]).to eq(@notification1)
+            expect(test_instance.notification_index_with_attributes(options).size).to eq(1)
+          end
+        end
+
+        context 'with filtered_by_key options' do
+          it "returns filtered notifications only" do
+            options = { filtered_by_key: @key }
+            expect(test_instance.notification_index_with_attributes(options)[0]).to eq(@notification3)
             expect(test_instance.notification_index_with_attributes(options).size).to eq(1)
           end
         end
@@ -510,8 +713,8 @@ shared_examples_for :target do
     end
 
     describe "#unopened_notification_index_with_attributes" do
-      it "calls unopened_notification_index" do
-        expect(test_instance).to receive(:unopened_notification_index)
+      it "calls _unopened_notification_index" do
+        expect(test_instance).to receive(:_unopened_notification_index)
         test_instance.unopened_notification_index_with_attributes
       end
 
@@ -568,8 +771,8 @@ shared_examples_for :target do
     end
 
     describe "#opened_notification_index_with_attributes" do
-      it "calls opened_notification_index" do
-        expect(test_instance).to receive(:opened_notification_index)
+      it "calls _opened_notification_index" do
+        expect(test_instance).to receive(:_opened_notification_index)
         test_instance.opened_notification_index_with_attributes
       end
 
@@ -625,6 +828,62 @@ shared_examples_for :target do
       end
     end
 
+    describe "#send_notification_email" do
+      context "with right target of notification" do
+        before do
+          @notification = create(:notification, target: test_instance)
+        end
+
+        it "calls notification.send_notification_email" do
+          expect(@notification).to receive(:send_notification_email).at_least(:once)
+          test_instance.send_notification_email(@notification)
+        end
+      end
+
+      context "with wrong target of notification" do
+        before do
+          @notification = create(:notification, target: create(:user))
+        end
+
+        it "does not call notification.send_notification_email" do
+          expect(@notification).not_to receive(:send_notification_email)
+          test_instance.send_notification_email(@notification)
+        end
+
+        it "returns nil" do
+          expect(test_instance.send_notification_email(@notification)).to be_nil
+        end
+      end
+    end
+
+    describe "#send_batch_notification_email" do
+      context "with right target of notification" do
+        before do
+          @notifications = [create(:notification, target: test_instance), create(:notification, target: test_instance)]
+        end
+
+        it "calls ActivityNotification::Notification.send_batch_notification_email" do
+          expect(ActivityNotification::Notification).to receive(:send_batch_notification_email).at_least(:once)
+          test_instance.send_batch_notification_email(@notifications)
+        end
+      end
+
+      context "with wrong target of notification" do
+        before do
+          notifications = [create(:notification, target: test_instance), create(:notification, target: create(:user))]
+        end
+
+        it "does not call ActivityNotification::Notification.send_batch_notification_email" do
+          expect(ActivityNotification::Notification).not_to receive(:send_batch_notification_email)
+          test_instance.send_batch_notification_email(@notifications)
+        end
+
+        it "returns nil" do
+          expect(test_instance.send_batch_notification_email(@notifications)).to be_nil
+        end
+      end
+    end
+
   end
 
 end