activity_notification 2.4.1 → 2.5.0

data/spec/concerns/models/target_spec.rb

@@ -1,1285 +0,0 @@
-shared_examples_for :target do
-  let(:test_class_name) { described_class.to_s.underscore.split('/').last.to_sym }
-  let(:test_instance) { create(test_class_name) }
-  let(:test_notifiable) { create(:dummy_notifiable) }
-
-  describe "with association" do
-    it "has many notifications" do
-      notification_1 = create(:notification, target: test_instance)
-      notification_2 = create(:notification, target: test_instance, created_at: notification_1.created_at + 10.second)
-      expect(test_instance.notifications.count).to    eq(2)
-      expect(test_instance.notifications.earliest).to eq(notification_1)
-      expect(test_instance.notifications.latest).to   eq(notification_2)
-      expect(test_instance.notifications.to_a).to     eq(ActivityNotification::Notification.filtered_by_target(test_instance).to_a)
-    end
-  end    
-
-  describe "as public class methods" do
-    describe ".available_as_target?" do
-      it "returns true" do
-        expect(described_class.available_as_target?).to be_truthy
-      end
-    end
-
-    describe ".set_target_class_defaults" do
-      it "set parameter fields as default" do
-        described_class.set_target_class_defaults
-        expect(described_class._notification_email).to                    eq(nil)
-        expect(described_class._notification_email_allowed).to            eq(ActivityNotification.config.email_enabled)
-        expect(described_class._batch_notification_email_allowed).to      eq(ActivityNotification.config.email_enabled)
-        expect(described_class._notification_subscription_allowed).to     eq(ActivityNotification.config.subscription_enabled)
-        expect(described_class._notification_action_cable_allowed).to     eq(ActivityNotification.config.action_cable_enabled)
-        expect(described_class._notification_action_cable_with_devise).to eq(ActivityNotification.config.action_cable_with_devise)
-        expect(described_class._notification_devise_resource).to          be_a_kind_of(Proc)
-        expect(described_class._notification_current_devise_target).to    be_a_kind_of(Proc)
-        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)
-
-        index_map = described_class.notification_index_map
-        expect(index_map.size).to eq(2)
-        expect(index_map[target_1].size).to eq(3)
-        expect(described_class.notification_index_map[target_2].size).to eq(2)
-      end
-
-      context "with :filtered_by_status" do
-        context "as :opened" do
-          it "returns opened 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_2.open!
-            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_7 = create(:notification, target: test_notifiable)
-    
-            index_map = described_class.notification_index_map(filtered_by_status: :opened)
-            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
-
-        context "as :unopened" 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.notification_index_map(filtered_by_status: :unopened)
-            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
-      end
-
-      context "with :as_latest_group_member" do
-        before 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, created_at: notification_1.created_at + 10.second)
-          notification_3  = create(:notification, target: @target_1, group_owner: @notification_2, created_at: notification_1.created_at + 20.second)
-          @notification_4 = create(:notification, target: @target_1, group_owner: @notification_2, created_at: notification_1.created_at + 30.second)
-          notification_5  = create(:notification, target: @target_2, created_at: notification_1.created_at + 40.second)
-          notification_6  = create(:notification, target: @target_2, created_at: notification_1.created_at + 50.second)
-          notification_6.open!
-          notification_7  = create(:notification, target: @target_3, created_at: notification_1.created_at + 60.second)
-          notification_7.open!
-          notification_8  = create(:notification, target: test_notifiable, created_at: notification_1.created_at + 70.second)
-        end
-
-        context "as default" do
-          it "returns earliest group members" do
-            index_map = described_class.notification_index_map(filtered_by_status: :unopened)
-            expect(index_map.size).to eq(2)
-            expect(index_map[@target_1].size).to eq(2)
-            expect(index_map[@target_1].first).to eq(@notification_2)
-            expect(index_map[@target_2].size).to eq(1)
-            expect(index_map.has_key?(@target_3)).to be_falsey
-          end
-        end
-
-        context "as true" do
-          it "returns latest group members" do
-            index_map = described_class.notification_index_map(filtered_by_status: :unopened, as_latest_group_member: true)
-            expect(index_map.size).to eq(2)
-            expect(index_map[@target_1].size).to eq(2)
-            expect(index_map[@target_1].first).to eq(@notification_4)
-            expect(index_map[@target_2].size).to eq(1)
-            expect(index_map.has_key?(@target_3)).to be_falsey
-          end
-        end
-      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
-
-    describe "subscription_enabled?" do
-      context "with true as _notification_subscription_allowed" do
-        it "returns true" do
-          described_class._notification_subscription_allowed = true
-          expect(described_class.subscription_enabled?).to eq(true)
-        end
-      end
-
-      context "with false as _notification_subscription_allowed" do
-        it "returns false" do
-          described_class._notification_subscription_allowed = false
-          expect(described_class.subscription_enabled?).to eq(false)
-        end
-      end
-
-      context "with lambda configuration as _notification_subscription_allowed" do
-        it "returns true (even if configured lambda function returns false)" do
-          described_class._notification_subscription_allowed = ->(target, key){ false }
-          expect(described_class.subscription_enabled?).to eq(true)
-        end
-      end
-    end
-  end
-
-  describe "as public instance methods" do
-    before do
-      ActivityNotification::Notification.delete_all
-      described_class.set_target_class_defaults
-    end
-
-    describe "#mailer_to" do
-      context "without any configuration" do
-        it "returns nil" do
-          expect(test_instance.mailer_to).to be_nil
-        end
-      end
-
-      context "configured with a field" do
-        it "returns specified value" do
-          described_class._notification_email = 'test@example.com'
-          expect(test_instance.mailer_to).to eq('test@example.com')
-        end
-
-        it "returns specified symbol of field" do
-          described_class._notification_email = :email
-          expect(test_instance.mailer_to).to eq(test_instance.email)
-        end
-
-        it "returns specified symbol of method" do
-          module AdditionalMethods
-            def custom_notification_email
-              'test@example.com'
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          described_class._notification_email = :custom_notification_email
-          expect(test_instance.mailer_to).to eq('test@example.com')
-        end
-
-        it "returns specified lambda with single target argument" do
-          described_class._notification_email = ->(target){ 'test@example.com' }
-          expect(test_instance.mailer_to).to eq('test@example.com')
-        end
-      end
-    end
-
-    describe "#notification_email_allowed?" do
-      context "without any configuration" do
-        it "returns ActivityNotification.config.email_enabled" do
-          expect(test_instance.notification_email_allowed?(test_notifiable, 'dummy_key'))
-            .to eq(ActivityNotification.config.email_enabled)
-        end
-
-        it "returns false as default" do
-          expect(test_instance.notification_email_allowed?(test_notifiable, 'dummy_key')).to be_falsey
-        end
-      end
-
-      context "configured with a field" do
-        it "returns specified value" do
-          described_class._notification_email_allowed = true
-          expect(test_instance.notification_email_allowed?(test_notifiable, 'dummy_key')).to eq(true)
-        end
-
-        it "returns specified symbol without argument" do
-          module AdditionalMethods
-            def custom_notification_email_allowed?
-              true
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          described_class._notification_email_allowed = :custom_notification_email_allowed?
-          expect(test_instance.notification_email_allowed?(test_notifiable, 'dummy_key')).to eq(true)
-        end
-
-        it "returns specified symbol with notifiable
-         and key arguments" do
-          module AdditionalMethods
-            def custom_notification_email_allowed?(notifiable, key)
-              true
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          described_class._notification_email_allowed = :custom_notification_email_allowed?
-          expect(test_instance.notification_email_allowed?(test_notifiable, 'dummy_key')).to eq(true)
-        end
-
-        it "returns specified lambda with single target argument" do
-          described_class._notification_email_allowed = ->(target){ true }
-          expect(test_instance.notification_email_allowed?(test_notifiable, 'dummy_key')).to eq(true)
-        end
-
-        it "returns specified lambda with target, notifiable and key arguments" do
-          described_class._notification_email_allowed = ->(target, notifiable, key){ true }
-          expect(test_instance.notification_email_allowed?(test_notifiable, 'dummy_key')).to eq(true)
-        end
-      end
-    end
-
-    describe "#batch_notification_email_allowed?" do
-      context "without any configuration" do
-        it "returns ActivityNotification.config.email_enabled" do
-          expect(test_instance.batch_notification_email_allowed?('dummy_key'))
-            .to eq(ActivityNotification.config.email_enabled)
-        end
-
-        it "returns false as default" do
-          expect(test_instance.batch_notification_email_allowed?('dummy_key')).to be_falsey
-        end
-      end
-
-      context "configured with a field" do
-        it "returns specified value" do
-          described_class._batch_notification_email_allowed = true
-          expect(test_instance.batch_notification_email_allowed?('dummy_key')).to eq(true)
-        end
-
-        it "returns specified symbol without argument" do
-          module AdditionalMethods
-            def custom_batch_notification_email_allowed?
-              true
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          described_class._batch_notification_email_allowed = :custom_batch_notification_email_allowed?
-          expect(test_instance.batch_notification_email_allowed?('dummy_key')).to eq(true)
-        end
-
-        it "returns specified symbol with target and key arguments" do
-          module AdditionalMethods
-            def custom_batch_notification_email_allowed?(key)
-              true
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          described_class._batch_notification_email_allowed = :custom_batch_notification_email_allowed?
-          expect(test_instance.batch_notification_email_allowed?('dummy_key')).to eq(true)
-        end
-
-        it "returns specified lambda with single target argument" do
-          described_class._batch_notification_email_allowed = ->(target){ true }
-          expect(test_instance.batch_notification_email_allowed?('dummy_key')).to eq(true)
-        end
-
-        it "returns specified lambda with target and key arguments" do
-          described_class._batch_notification_email_allowed = ->(target, key){ true }
-          expect(test_instance.batch_notification_email_allowed?('dummy_key')).to eq(true)
-        end
-      end
-    end
-
-    describe "#subscription_allowed?" do
-      context "without any configuration" do
-        it "returns ActivityNotification.config.subscription_enabled" do
-          expect(test_instance.subscription_allowed?('dummy_key'))
-            .to eq(ActivityNotification.config.subscription_enabled)
-        end
-
-        it "returns false as default" do
-          expect(test_instance.subscription_allowed?('dummy_key')).to be_falsey
-        end
-      end
-
-      context "configured with a field" do
-        it "returns specified value" do
-          described_class._notification_subscription_allowed = true
-          expect(test_instance.subscription_allowed?('dummy_key')).to eq(true)
-        end
-
-        it "returns specified symbol without argument" do
-          module AdditionalMethods
-            def custom_subscription_allowed?
-              true
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          described_class._notification_subscription_allowed = :custom_subscription_allowed?
-          expect(test_instance.subscription_allowed?('dummy_key')).to eq(true)
-        end
-
-        it "returns specified symbol with key argument" do
-          module AdditionalMethods
-            def custom_subscription_allowed?(key)
-              true
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          described_class._notification_subscription_allowed = :custom_subscription_allowed?
-          expect(test_instance.subscription_allowed?('dummy_key')).to eq(true)
-        end
-
-        it "returns specified lambda with single target argument" do
-          described_class._notification_subscription_allowed = ->(target){ true }
-          expect(test_instance.subscription_allowed?('dummy_key')).to eq(true)
-        end
-
-        it "returns specified lambda with target and key arguments" do
-          described_class._notification_subscription_allowed = ->(target, key){ true }
-          expect(test_instance.subscription_allowed?('dummy_key')).to eq(true)
-        end
-      end
-    end
-
-    describe "#notification_action_cable_allowed?" do
-      context "without any configuration" do
-        it "returns ActivityNotification.config.action_cable_enabled without arguments" do
-          expect(test_instance.notification_action_cable_allowed?)
-            .to eq(ActivityNotification.config.action_cable_enabled)
-        end
-
-        it "returns ActivityNotification.config.action_cable_enabled with arguments" do
-          expect(test_instance.notification_action_cable_allowed?(test_notifiable, 'dummy_key'))
-            .to eq(ActivityNotification.config.action_cable_enabled)
-        end
-
-        it "returns false as default" do
-          expect(test_instance.notification_action_cable_allowed?).to be_falsey
-        end
-      end
-
-      context "configured with a field" do
-        it "returns specified value" do
-          described_class._notification_action_cable_allowed = true
-          expect(test_instance.notification_action_cable_allowed?).to eq(true)
-        end
-
-        it "returns specified symbol without argument" do
-          module AdditionalMethods
-            def custom_notification_action_cable_allowed?
-              true
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          described_class._notification_action_cable_allowed = :custom_notification_action_cable_allowed?
-          expect(test_instance.notification_action_cable_allowed?).to eq(true)
-        end
-
-        it "returns specified symbol with notifiable and key arguments" do
-          module AdditionalMethods
-            def custom_notification_action_cable_allowed?(notifiable, key)
-              true
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          described_class._notification_action_cable_allowed = :custom_notification_action_cable_allowed?
-          expect(test_instance.notification_action_cable_allowed?(test_notifiable, 'dummy_key')).to eq(true)
-        end
-
-        it "returns specified lambda with single target argument" do
-          described_class._notification_action_cable_allowed = ->(target){ true }
-          expect(test_instance.notification_action_cable_allowed?(test_notifiable, 'dummy_key')).to eq(true)
-        end
-
-        it "returns specified lambda with target, notifiable and key arguments" do
-          described_class._notification_action_cable_allowed = ->(target, notifiable, key){ true }
-          expect(test_instance.notification_action_cable_allowed?(test_notifiable, 'dummy_key')).to eq(true)
-        end
-      end
-    end
-
-    describe "#notification_action_cable_with_devise?" do
-      context "without any configuration" do
-        it "returns ActivityNotification.config.action_cable_with_devise without arguments" do
-          expect(test_instance.notification_action_cable_with_devise?)
-            .to eq(ActivityNotification.config.action_cable_with_devise)
-        end
-
-        it "returns false as default" do
-          expect(test_instance.notification_action_cable_with_devise?).to be_falsey
-        end
-      end
-
-      context "configured with a field" do
-        it "returns specified value" do
-          described_class._notification_action_cable_with_devise = true
-          expect(test_instance.notification_action_cable_with_devise?).to eq(true)
-        end
-
-        it "returns specified symbol without argument" do
-          module AdditionalMethods
-            def custom_notification_action_cable_with_devise?
-              true
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          described_class._notification_action_cable_with_devise = :custom_notification_action_cable_with_devise?
-          expect(test_instance.notification_action_cable_with_devise?).to eq(true)
-        end
-
-        it "returns specified lambda with single target argument" do
-          described_class._notification_action_cable_with_devise = ->(target){ true }
-          expect(test_instance.notification_action_cable_with_devise?).to eq(true)
-        end
-      end
-    end
-
-    describe "#notification_action_cable_channel_class_name" do
-      context "when custom_notification_action_cable_with_devise? returns true" do
-        it "returns ActivityNotification::NotificationWithDeviseChannel" do
-          described_class._notification_action_cable_with_devise = true
-          expect(test_instance.notification_action_cable_channel_class_name).to eq(ActivityNotification::NotificationWithDeviseChannel.name)
-        end
-      end
-
-      context "when custom_notification_action_cable_with_devise? returns false" do
-        it "returns ActivityNotification::NotificationChannel" do
-          described_class._notification_action_cable_with_devise = false
-          expect(test_instance.notification_action_cable_channel_class_name).to eq(ActivityNotification::NotificationChannel.name)
-        end
-      end
-    end
-
-    describe "#authenticated_with_devise?" do
-      context "without any configuration" do
-        context "when the current devise resource and called target are different class instance" do
-          it "raises TypeError" do
-            expect { test_instance.authenticated_with_devise?(test_notifiable) }
-              .to raise_error(TypeError, /Different type of .+ has been passed to .+ You have to override .+ /)
-          end
-        end
-  
-        context "when the current devise resource equals called target" do
-          it "returns true" do
-            expect(test_instance.authenticated_with_devise?(test_instance)).to be_truthy
-          end
-        end
-  
-        context "when the current devise resource does not equal called target" do
-          it "returns false" do
-            expect(test_instance.authenticated_with_devise?(create(test_class_name))).to be_falsey
-          end
-        end
-      end
-
-      context "configured with a field" do
-        context "when the current devise resource and called target are different class instance" do
-          it "raises TypeError" do
-            described_class._notification_devise_resource = test_notifiable
-            expect { test_instance.authenticated_with_devise?(test_instance) }
-              .to raise_error(TypeError, /Different type of .+ has been passed to .+ You have to override .+ /)
-          end
-        end
-  
-        context "when the current devise resource equals called target" do
-          it "returns true" do
-            described_class._notification_devise_resource = test_notifiable
-            expect(test_instance.authenticated_with_devise?(test_notifiable)).to be_truthy
-          end
-        end
-  
-        context "when the current devise resource does not equal called target" do
-          it "returns false" do
-            described_class._notification_devise_resource = test_instance
-            expect(test_instance.authenticated_with_devise?(create(test_class_name))).to be_falsey
-          end
-        end
-      end
-    end
-
-    describe "#printable_target_name" do
-      context "without any configuration" do
-        it "returns ActivityNotification::Common.printable_name" do
-          expect(test_instance.printable_target_name).to eq(test_instance.printable_name)
-        end
-      end
-
-      context "configured with a field" do
-        it "returns specified value" do
-          described_class._printable_notification_target_name = 'test_printable_name'
-          expect(test_instance.printable_target_name).to eq('test_printable_name')
-        end
-
-        it "returns specified symbol of field" do
-          described_class._printable_notification_target_name = :name
-          expect(test_instance.printable_target_name).to eq(test_instance.name)
-        end
-
-        it "returns specified symbol of method" do
-          module AdditionalMethods
-            def custom_printable_name
-              'test_printable_name'
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          described_class._printable_notification_target_name = :custom_printable_name
-          expect(test_instance.printable_target_name).to eq('test_printable_name')
-        end
-
-        it "returns specified lambda with single target argument" do
-          described_class._printable_notification_target_name = ->(target){ 'test_printable_name' }
-          expect(test_instance.printable_target_name).to eq('test_printable_name')
-        end
-      end
-    end
-
-    describe "#unopened_notification_count" do
-      it "returns count of unopened notification index" do
-        create(:notification, target: test_instance)
-        create(:notification, target: test_instance)
-        expect(test_instance.unopened_notification_count).to eq(2)
-      end
-
-      it "returns count of unopened notification index (owner only)" do
-        group_owner  = create(:notification, target: test_instance, group_owner: nil)
-                       create(:notification, target: test_instance, group_owner: nil)
-        group_member = create(:notification, target: test_instance, group_owner: group_owner)
-        expect(test_instance.unopened_notification_count).to eq(2)
-      end
-    end
-
-    describe "#has_unopened_notifications?" do
-      context "when the target has no unopened notifications" do
-        it "returns false" do
-          expect(test_instance.has_unopened_notifications?).to be_falsey
-        end
-      end
-
-      context "when the target has unopened notifications" do
-        it "returns true" do
-          create(:notification, target: test_instance)
-          expect(test_instance.has_unopened_notifications?).to be_truthy
-        end
-      end
-    end
-
-    describe "#notification_index" do
-      context "when the target has no notifications" do
-        it "returns empty records" do
-          expect(test_instance.notification_index).to be_empty
-        end
-      end
-
-      context "when the target has unopened notifications" do
-        before do
-          @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, created_at: @notification2.created_at + 10.second)
-          @member1       = create(:notification, target: test_instance, notifiable: create(:comment), group_owner: @notification1, created_at: @notification2.created_at + 20.second)
-          @notification3 = create(:notification, target: test_instance, notifiable: create(:article), key: @key, created_at: @notification2.created_at + 30.second)
-          @notification3.open!
-        end
-
-        it "calls unopened_notification_index" do
-          expect(test_instance).to receive(:unopened_notification_index).at_least(:once)
-          test_instance.notification_index
-        end
-
-        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(@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
-
-        context "with limit" do
-          it "returns the same as unopened_notification_index with limit" do
-            options = { limit: 1 }
-            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 later_than options' do
-          it "returns filtered notifications only" do
-            options = { later_than: (@notification1.created_at.in_time_zone + 0.001).iso8601(3) }
-            expect(test_instance.notification_index(options)[0]).to eq(@notification3)
-            expect(test_instance.notification_index(options).size).to eq(1)
-          end
-        end
-
-        context 'with earlier_than options' do
-          it "returns filtered notifications only" do
-            options = { earlier_than: @notification1.created_at.iso8601(3) }
-            expect(test_instance.notification_index(options)[0]).to eq(@notification2)
-            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)
-          end
-
-          it "returns filtered notifications only with filter depending on ORM" do
-            options =
-              case ActivityNotification.config.orm
-              when :active_record then { custom_filter: ["notifications.key = ?", @key] }
-              when :mongoid       then { custom_filter: { key: {'$eq': @key} } }
-              when :dynamoid      then { custom_filter: {'key.begins_with': @key} }
-              end
-            expect(test_instance.notification_index(options)[0]).to eq(@notification3)
-            expect(test_instance.notification_index(options).size).to eq(1)
-          end
-        end
-      end
-
-      context "when the target has no unopened notifications" do
-        before do
-          notification = create(:notification, target: test_instance, opened_at: Time.current)
-          create(:notification, target: test_instance, opened_at: Time.current, created_at: notification.created_at + 10.second)
-        end
-
-        it "calls unopened_notification_index" do
-          expect(test_instance).to receive(:opened_notification_index).at_least(:once)
-          test_instance.notification_index
-        end
-
-        context "without limit" do
-          it "returns the same as opened_notification_index" do
-            expect(test_instance.notification_index).to eq(test_instance.opened_notification_index)
-            expect(test_instance.notification_index.size).to eq(2)
-          end
-        end
-
-        context "with limit" do
-          it "returns the same as opened_notification_index with limit" do
-            options = { limit: 1 }
-            expect(test_instance.notification_index(options)).to eq(test_instance.opened_notification_index(options))
-            expect(test_instance.notification_index(options).size).to eq(1)
-          end
-        end
-      end
-    end
-
-    describe "#unopened_notification_index" do
-      context "when the target has no notifications" do
-        it "returns empty records" do
-          expect(test_instance.unopened_notification_index).to be_empty
-        end
-      end
-
-      context "when the target has unopened notifications" do
-        before do
-          @notification_1 = create(:notification, target: test_instance)
-          @notification_2 = create(:notification, target: test_instance, created_at: @notification_1.created_at + 10.second)
-        end
-
-        context "without limit" do
-          it "returns unopened notification index" do
-            expect(test_instance.unopened_notification_index.size).to eq(2)
-            expect(test_instance.unopened_notification_index.last).to  eq(@notification_1)
-            expect(test_instance.unopened_notification_index.first).to eq(@notification_2)
-          end
-
-          it "returns unopened notification index (owner only)" do
-            group_member   = create(:notification, target: test_instance, group_owner: @notification_1)
-            expect(test_instance.unopened_notification_index.size).to eq(2)
-            expect(test_instance.unopened_notification_index.last).to  eq(@notification_1)
-            expect(test_instance.unopened_notification_index.first).to eq(@notification_2)
-          end
-
-          it "returns unopened notification index (unopened only)" do
-            notification_3 = create(:notification, target: test_instance, opened_at: Time.current)
-            expect(test_instance.unopened_notification_index.size).to eq(2)
-            expect(test_instance.unopened_notification_index.last).to  eq(@notification_1)
-            expect(test_instance.unopened_notification_index.first).to eq(@notification_2)
-          end
-        end
-
-        context "with limit" do
-          it "returns unopened notification index with limit" do
-            options = { limit: 1 }
-            expect(test_instance.unopened_notification_index(options).size).to eq(1)
-            expect(test_instance.unopened_notification_index(options).first).to eq(@notification_2)
-          end
-        end
-      end
-
-      context "when the target has no unopened notifications" do
-        before do
-          create(:notification, target: test_instance, group_owner: nil, opened_at: Time.current)
-          create(:notification, target: test_instance, group_owner: nil, opened_at: Time.current)
-        end
-
-        it "returns empty records" do
-          expect(test_instance.unopened_notification_index).to be_empty
-        end
-      end
-    end
-
-    describe "#opened_notification_index" do
-      context "when the target has no notifications" do
-        it "returns empty records" do
-          expect(test_instance.opened_notification_index).to be_empty
-        end
-      end
-
-      context "when the target has opened notifications" do
-        before do
-          @notification_1 = create(:notification, target: test_instance, opened_at: Time.current)
-          @notification_2 = create(:notification, target: test_instance, opened_at: Time.current, created_at: @notification_1.created_at + 10.second)
-        end
-
-        context "without limit" do
-          it "uses ActivityNotification.config.opened_index_limit as limit" do
-            configured_opened_index_limit = ActivityNotification.config.opened_index_limit
-            ActivityNotification.config.opened_index_limit = 1
-            expect(test_instance.opened_notification_index.size).to eq(1)
-            expect(test_instance.opened_notification_index.first).to eq(@notification_2)
-            ActivityNotification.config.opened_index_limit = configured_opened_index_limit
-          end
-
-          it "returns opened notification index" do
-            expect(test_instance.opened_notification_index.size).to eq(2)
-            expect(test_instance.opened_notification_index.last).to  eq(@notification_1)
-            expect(test_instance.opened_notification_index.first).to eq(@notification_2)
-          end
-
-          it "returns opened notification index (owner only)" do
-            group_member   = create(:notification, target: test_instance, group_owner: @notification_1, opened_at: Time.current)
-            expect(test_instance.opened_notification_index.size).to eq(2)
-            expect(test_instance.opened_notification_index.last).to  eq(@notification_1)
-            expect(test_instance.opened_notification_index.first).to eq(@notification_2)
-          end
-
-          it "returns opened notification index (opened only)" do
-            notification_3 = create(:notification, target: test_instance)
-            expect(test_instance.opened_notification_index.size).to eq(2)
-            expect(test_instance.opened_notification_index.last).to  eq(@notification_1)
-            expect(test_instance.opened_notification_index.first).to eq(@notification_2)
-          end
-        end
-
-        context "with limit" do
-          it "returns opened notification index with limit" do
-            options = { limit: 1 }
-            expect(test_instance.opened_notification_index(options).size).to eq(1)
-            expect(test_instance.opened_notification_index(options).first).to eq(@notification_2)
-          end
-        end
-      end
-
-      context "when the target has no opened notifications" do
-        before do
-          create(:notification, target: test_instance, group_owner: nil)
-          create(:notification, target: test_instance, group_owner: nil)
-        end
-
-        it "returns empty records" do
-          expect(test_instance.opened_notification_index).to be_empty
-        end
-      end
-    end
-
-
-    # Wrapper methods of Notification class methods
-
-    describe "#receive_notification_of" do
-      it "is an alias of ActivityNotification::Notification.notify_to" do
-        expect(ActivityNotification::Notification).to receive(:notify_to)
-        test_instance.receive_notification_of create(:user)
-      end
-    end
-
-    describe "#receive_notification_later_of" do
-      it "is an alias of ActivityNotification::Notification.notify_later_to" do
-        expect(ActivityNotification::Notification).to receive(:notify_later_to)
-        test_instance.receive_notification_later_of create(:user)
-      end
-    end
-
-    describe "#open_all_notifications" do
-      it "is an alias of ActivityNotification::Notification.open_all_of" do
-        expect(ActivityNotification::Notification).to receive(:open_all_of)
-        test_instance.open_all_notifications
-      end
-    end
-
-    describe "#destroy_all_notifications" do
-      it "is an alias of ActivityNotification::Notification.destroy_all_of" do
-        expect(ActivityNotification::Notification).to receive(:destroy_all_of)
-        test_instance.destroy_all_notifications
-      end
-    end
-
-
-    # Methods to be overridden
-
-    describe "#notification_index_with_attributes" do
-      context "when the target has no notifications" do
-        it "returns empty records" do
-          expect(test_instance.notification_index_with_attributes).to be_empty
-        end
-      end
-
-      context "when the target has unopened notifications" do
-        before do
-          @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, created_at: @notification2.created_at + 10.second)
-          @notification3 = create(:notification, target: test_instance, notifiable: create(:article), key: @key, created_at: @notification2.created_at + 20.second)
-          @notification3.open!
-        end
-
-        it "calls unopened_notification_index_with_attributes" do
-          expect(test_instance).to receive(:unopened_notification_index_with_attributes).at_least(:once)
-          test_instance.notification_index_with_attributes
-        end
-
-        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)[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
-
-        context 'with later_than options' do
-          it "returns filtered notifications only" do
-            options = { later_than: (@notification1.created_at.in_time_zone + 0.001).iso8601(3) }
-            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
-
-        context 'with earlier_than options' do
-          it "returns filtered notifications only" do
-            options = { earlier_than: @notification1.created_at.iso8601(3) }
-            expect(test_instance.notification_index_with_attributes(options)[0]).to eq(@notification2)
-            expect(test_instance.notification_index_with_attributes(options).size).to eq(1)
-          end
-        end
-      end
-
-      context "when the target has no unopened notifications" do
-        before do
-          notification = create(:notification, target: test_instance, opened_at: Time.current)
-          create(:notification, target: test_instance, opened_at: Time.current, created_at: notification.created_at + 10.second)
-        end
-
-        it "calls unopened_notification_index_with_attributes" do
-          expect(test_instance).to receive(:opened_notification_index_with_attributes)
-          test_instance.notification_index_with_attributes
-        end
-
-        context "without limit" do
-          it "returns the same as opened_notification_index_with_attributes" do
-            expect(test_instance.notification_index_with_attributes).to eq(test_instance.opened_notification_index_with_attributes)
-            expect(test_instance.notification_index_with_attributes.size).to eq(2)
-          end
-        end
-
-        context "with limit" do
-          it "returns the same as opened_notification_index_with_attributes with limit" do
-            options = { limit: 1 }
-            expect(test_instance.notification_index_with_attributes(options)).to eq(test_instance.opened_notification_index_with_attributes(options))
-            expect(test_instance.notification_index_with_attributes(options).size).to eq(1)
-          end
-        end
-      end
-    end
-
-    describe "#unopened_notification_index_with_attributes" do
-      it "calls _unopened_notification_index" do
-        expect(test_instance).to receive(:_unopened_notification_index)
-        test_instance.unopened_notification_index_with_attributes
-      end
-
-      context "when the target has unopened notifications with no group members" do
-        context "with no group members" do
-          before do
-            create(:notification, target: test_instance)
-            create(:notification, target: test_instance)
-          end
-
-          if ActivityNotification.config.orm == :active_record
-            it "calls with_target, with_notifiable, with_notifier and does not call with_group" do
-              expect(ActivityNotification::Notification).to receive_message_chain(:with_target, :with_notifiable, :with_notifier)
-              test_instance.unopened_notification_index_with_attributes
-            end
-          end
-        end
-
-        context "with group members" do
-          before do
-            group_owner  = create(:notification, target: test_instance, group_owner: nil)
-                           create(:notification, target: test_instance, group_owner: nil)
-            group_member = create(:notification, target: test_instance, group_owner: group_owner)
-          end
-
-          if ActivityNotification.config.orm == :active_record
-            it "calls with_group" do
-              expect(ActivityNotification::Notification).to receive_message_chain(:with_target, :with_notifiable, :with_group, :with_notifier)
-              test_instance.unopened_notification_index_with_attributes
-            end
-          end
-        end
-      end
-
-      context "when the target has no unopened notifications" do
-        before do
-          create(:notification, target: test_instance, opened_at: Time.current)
-          create(:notification, target: test_instance, opened_at: Time.current)
-        end
-
-        it "returns empty records" do
-          expect(test_instance.unopened_notification_index_with_attributes).to be_empty
-        end
-      end
-    end
-
-    describe "#opened_notification_index_with_attributes" do
-      it "calls _opened_notification_index" do
-        expect(test_instance).to receive(:_opened_notification_index)
-        test_instance.opened_notification_index_with_attributes
-      end
-
-      context "when the target has opened notifications with no group members" do
-        context "with no group members" do
-          before do
-            create(:notification, target: test_instance, opened_at: Time.current)
-            create(:notification, target: test_instance, opened_at: Time.current)
-          end
-
-          if ActivityNotification.config.orm == :active_record
-            it "calls with_target, with_notifiable, with_notifier and does not call with_group" do
-              expect(ActivityNotification::Notification).to receive_message_chain(:with_target, :with_notifiable, :with_notifier)
-              test_instance.opened_notification_index_with_attributes
-            end
-          end
-        end
-
-        context "with group members" do
-          before do
-            group_owner  = create(:notification, target: test_instance, group_owner: nil, opened_at: Time.current)
-                           create(:notification, target: test_instance, group_owner: nil, opened_at: Time.current)
-            group_member = create(:notification, target: test_instance, group_owner: group_owner, opened_at: Time.current)
-          end
-
-          if ActivityNotification.config.orm == :active_record
-            it "calls with_group" do
-              expect(ActivityNotification::Notification).to receive_message_chain(:with_target, :with_notifiable, :with_group, :with_notifier)
-              test_instance.opened_notification_index_with_attributes
-            end
-          end
-        end
-      end
-
-      context "when the target has no opened notifications" do
-        before do
-          create(:notification, target: test_instance)
-          create(:notification, target: test_instance)
-        end
-
-        it "returns empty records" do
-          expect(test_instance.opened_notification_index_with_attributes).to be_empty
-        end
-      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
-
-    describe "#subscribes_to_notification?" do
-      context "when the subscription is not enabled for the target" do
-        it "returns true" do
-          described_class._notification_subscription_allowed = false
-          expect(test_instance.subscribes_to_notification?('test_key')).to be_truthy
-        end
-      end
-
-      context "when the subscription is enabled for the target" do
-        it "calls Subscriber#_subscribes_to_notification?" do
-          described_class._notification_subscription_allowed = true
-          expect(test_instance).to receive(:_subscribes_to_notification?)
-          test_instance.subscribes_to_notification?('test_key')
-        end
-      end
-    end
-
-    describe "#subscribes_to_notification_email?" do
-      context "when the subscription is not enabled for the target" do
-        it "returns true" do
-          described_class._notification_subscription_allowed = false
-          expect(test_instance.subscribes_to_notification_email?('test_key')).to be_truthy
-        end
-      end
-
-      context "when the subscription is enabled for the target" do
-        it "calls Subscriber#_subscribes_to_notification_email?" do
-          described_class._notification_subscription_allowed = true
-          expect(test_instance).to receive(:_subscribes_to_notification_email?)
-          test_instance.subscribes_to_notification_email?('test_key')
-        end
-      end
-    end
-
-    describe "#subscribes_to_optional_target?" do
-      context "when the subscription is not enabled for the target" do
-        it "returns true" do
-          described_class._notification_subscription_allowed = false
-          expect(test_instance.subscribes_to_optional_target?('test_key', :slack)).to be_truthy
-        end
-      end
-
-      context "when the subscription is enabled for the target" do
-        it "calls Subscriber#_subscribes_to_optional_target?" do
-          described_class._notification_subscription_allowed = true
-          expect(test_instance).to receive(:_subscribes_to_optional_target?)
-          test_instance.subscribes_to_optional_target?('test_key', :slack)
-        end
-      end
-    end
-  end
-
-end