activity_notification 1.7.1 → 2.0.0

data/spec/concerns/models/target_spec.rb

@@ -10,7 +10,7 @@ shared_examples_for :target do
       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          eq(ActivityNotification::Notification.filtered_by_target(test_instance))
+      expect(test_instance.notifications.to_a).to     eq(ActivityNotification::Notification.filtered_by_target(test_instance).to_a)
     end
   end    
 
@@ -24,10 +24,15 @@ shared_examples_for :target do
     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._notification_devise_resource).to       be_a_kind_of(Proc)
-        expect(described_class._printable_notification_target_name).to eq(:printable_name)
+        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    
 
@@ -264,7 +269,8 @@ shared_examples_for :target do
           expect(test_instance.notification_email_allowed?(test_notifiable, 'dummy_key')).to eq(true)
         end
 
-        it "returns specified symbol with target and key arguments" do
+        it "returns specified symbol with notifiable
+         and key arguments" do
           module AdditionalMethods
             def custom_notification_email_allowed?(notifiable, key)
               true
@@ -391,6 +397,117 @@ shared_examples_for :target do
       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
+
+    if Rails::VERSION::MAJOR >= 5
+      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
+    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
@@ -614,16 +731,21 @@ shared_examples_for :target do
 
         context 'with custom_filter options' do
           it "returns filtered notifications only" do
-            if ActivityNotification.config.orm == :active_record
-              options = { custom_filter: ["notifications.key = ?", @key] }
-              expect(test_instance.notification_index(options)[0]).to eq(@notification3)
-              expect(test_instance.notification_index(options).size).to eq(1)
-            end
-
             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
 
@@ -800,7 +922,7 @@ shared_examples_for :target do
     end
 
 
-    # Methods to be overriden
+    # Methods to be overridden
 
     describe "#notification_index_with_attributes" do
       context "when the target has no notifications" do

data/spec/config_spec.rb

@@ -7,7 +7,7 @@ describe ActivityNotification::Config do
         expect(ActivityNotification::Mailer).to receive(:send_notification_email).and_call_original
         notification.send_notification_email send_later: false
       end
-  
+
       it "is not configured with CustomNotificationMailer" do
         expect(CustomNotificationMailer).not_to receive(:send_notification_email).and_call_original
         notification.send_notification_email send_later: false
@@ -31,4 +31,44 @@ describe ActivityNotification::Config do
       end
     end
   end
+
+  describe "config.store_with_associated_records" do
+    let(:target) { create(:confirmed_user) }
+
+    context "false as default" do
+      before do
+        @notification = create(:notification, target: target)
+      end
+
+      it "stores notification without associated records" do
+        expect(@notification.target).to eq(target)
+        expect { @notification.target_record }.to raise_error(NoMethodError)
+      end
+    end
+
+    context "when it is configured as true" do
+      if ActivityNotification.config.orm == :active_record
+        it "raises ActivityNotification::ConfigError when you use active_record ORM" do
+          expect { ActivityNotification.config.store_with_associated_records = true }.to raise_error(ActivityNotification::ConfigError)
+        end
+
+      else
+        before do
+          ActivityNotification.config.store_with_associated_records = true
+          load Rails.root.join("../../lib/activity_notification/orm/#{ActivityNotification.config.orm}/notification.rb").to_s
+          @notification = create(:notification, target: target)
+        end
+
+        after do
+          ActivityNotification.config.store_with_associated_records = false
+          load Rails.root.join("../../lib/activity_notification/orm/#{ActivityNotification.config.orm}/notification.rb").to_s
+        end
+
+        it "stores notification without associated records" do
+          expect(@notification.target).to eq(target)
+          expect(@notification.target_record).to eq(target.to_json)
+        end
+      end
+    end
+  end
 end

data/spec/controllers/notifications_controller_shared_examples.rb

@@ -80,12 +80,16 @@ shared_examples_for :notification_controller do
       end
 
       it "returns json format" do
-        if ActivityNotification.config.orm == :active_record
+        case ActivityNotification.config.orm
+        when :active_record
           expect(JSON.parse(response.body).first)
           .to include("target_id" => test_target.id, "target_type" => test_target.to_class_name)
-        else
+        when :mongoid
           expect(JSON.parse(response.body).first)
           .to include("target_id" => test_target.id.to_s, "target_type" => test_target.to_class_name)
+        when :dynamoid
+          expect(JSON.parse(response.body).first)
+          .to include("target_key" => "#{test_target.to_class_name}#{ActivityNotification.config.composite_key_delimiter}#{test_target.id}")
         end
       end
     end
@@ -221,7 +225,7 @@ shared_examples_for :notification_controller do
         end
       end
 
-      context 'with filtered_by_group_type and :filtered_by_group_id parameters' do
+      context 'with filtered_by_group_type and filtered_by_group_id parameters' do
         it "returns filtered notifications only" do
           get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, filtered_by_group_type: 'Article', filtered_by_group_id: @group.id.to_s }), valid_session
           expect(assigns(:notifications)[0]).to eq(@notification1)

data/spec/controllers/subscriptions_controller_shared_examples.rb

@@ -93,12 +93,16 @@ shared_examples_for :subscription_controller do
       end
 
       it "returns json format" do
-        if ActivityNotification.config.orm == :active_record
+        case ActivityNotification.config.orm
+        when :active_record
           expect(JSON.parse(response.body)["subscriptions"].first)
           .to include("target_id" => test_target.id, "target_type" => test_target.to_class_name)
-        else
+        when :mongoid
           expect(JSON.parse(response.body)["subscriptions"].first)
           .to include("target_id" => test_target.id.to_s, "target_type" => test_target.to_class_name)
+        when :dynamoid
+          expect(JSON.parse(response.body)["subscriptions"].first)
+          .to include("target_key" => "#{test_target.to_class_name}#{ActivityNotification.config.composite_key_delimiter}#{test_target.id}")
         end
         expect(JSON.parse(response.body)["unconfigured_notification_keys"].first)
         .to eq('test_notification_key')
@@ -227,7 +231,7 @@ shared_examples_for :subscription_controller do
 
   describe "POST #create" do
     before do
-      expect(test_target.subscriptions.size).to      eq(0)
+      expect(test_target.subscriptions.size).to       eq(0)
     end
 
     context "http direct POST request without optional targets" do

data/spec/helpers/view_helpers_spec.rb

@@ -46,12 +46,14 @@ describe ActivityNotification::ViewHelpers, type: :helper do
           )
       end
 
-      if ActivityNotification.config.orm == :active_record
-        it 'handles multiple notifications of active_record' do
-          expect(notifications.to_a.first).to receive(:render).with(self, { fallback: :default })
-          expect(notifications.to_a.last).to  receive(:render).with(self, { fallback: :default })
-          render_notification notifications, fallback: :default
-        end
+      it 'handles multiple notifications of records' do
+        rendered_template = render_notification notifications, fallback: :default
+        expect(rendered_template).to start_with(
+          render partial: 'activity_notification/notifications/default/default',
+                 locals: { notification: notifications.to_a.first, parameters: {} })
+        expect(rendered_template).to end_with(
+          render partial: 'activity_notification/notifications/default/default',
+                 locals: { notification: notifications.to_a.last , parameters: {} })
       end
 
       it 'handles multiple notifications of array' do
@@ -117,17 +119,17 @@ describe ActivityNotification::ViewHelpers, type: :helper do
       end
 
       context "with defined overriding_notification_template_key in notifiable model" do
-        it "renders overriden custom notification view" do
+        it "renders overridden custom notification view" do
           notification.key = 'custom.test'
           module AdditionalMethods
             def overriding_notification_template_key(target, key)
-              'overriden.custom.test'
+              'overridden.custom.test'
             end
           end
           notification.notifiable.extend(AdditionalMethods)
-          # render activity_notification/notifications/users/overriden/custom/test
+          # render activity_notification/notifications/users/overridden/custom/test
           expect(render_notification notification, target: :users)
-            .to eq("Overriden custom template root for user target: #{notification.id}")
+            .to eq("Overridden custom template root for user target: #{notification.id}")
         end
       end
     end

data/spec/models/dummy/dummy_group_spec.rb

@@ -1,3 +1,7 @@
+# To run as single test for debugging
+# require Rails.root.join('../../spec/concerns/models/group_spec.rb').to_s
+# require Rails.root.join('../../spec/concerns/common_spec.rb').to_s
+
 describe Dummy::DummyGroup, type: :model do
 
   it_behaves_like :group

data/spec/models/dummy/dummy_notifiable_spec.rb

@@ -1,3 +1,7 @@
+# To run as single test for debugging
+# require Rails.root.join('../../spec/concerns/models/notifiable_spec.rb').to_s
+# require Rails.root.join('../../spec/concerns/common_spec.rb').to_s
+
 describe Dummy::DummyNotifiable, type: :model do
 
   it_behaves_like :notifiable

data/spec/models/dummy/dummy_notifier_spec.rb

@@ -1,3 +1,7 @@
+# To run as single test for debugging
+# require Rails.root.join('../../spec/concerns/models/notifier_spec.rb').to_s
+# require Rails.root.join('../../spec/concerns/common_spec.rb').to_s
+
 describe Dummy::DummyNotifier, type: :model do
 
   it_behaves_like :notifier

data/spec/models/dummy/dummy_subscriber_spec.rb

@@ -1,3 +1,6 @@
+# To run as single test for debugging
+# require Rails.root.join('../../spec/concerns/models/subscriber_spec.rb').to_s
+
 describe Dummy::DummySubscriber, type: :model do
 
   it_behaves_like :subscriber

data/spec/models/dummy/dummy_target_spec.rb

@@ -1,3 +1,7 @@
+# To run as single test for debugging
+# require Rails.root.join('../../spec/concerns/models/target_spec.rb').to_s
+# require Rails.root.join('../../spec/concerns/common_spec.rb').to_s
+
 describe Dummy::DummyTarget, type: :model do
 
   it_behaves_like :target

data/spec/models/notification_spec.rb

@@ -1,13 +1,30 @@
+# To run as single test for debugging
+# require Rails.root.join('../../spec/concerns/apis/notification_api_spec.rb').to_s
+# require Rails.root.join('../../spec/concerns/renderable_spec.rb').to_s
+
 describe ActivityNotification::Notification, type: :model do
 
   it_behaves_like :notification_api
   it_behaves_like :renderable
 
   describe "with association" do
-    it "belongs to target" do
-      target = create(:confirmed_user)
-      notification = create(:notification, target: target)
-      expect(notification.reload.target).to eq(target)
+    context "belongs to target" do
+      before do
+        @target = create(:confirmed_user)
+        @notification = create(:notification, target: @target)
+      end
+
+      it "responds to target" do
+        expect(@notification.reload.target).to eq(@target)
+      end
+
+      it "responds to target_id" do
+        expect(@notification.reload.target_id.to_s).to eq(@target.id.to_s)
+      end
+
+      it "responds to target_type" do
+        expect(@notification.reload.target_type).to eq("User")
+      end
     end
 
     it "belongs to notifiable" do
@@ -42,18 +59,16 @@ describe ActivityNotification::Notification, type: :model do
   end
 
   describe "with serializable column" do
-    if ActivityNotification.config.orm == :active_record
-      it "has parameters for hash with symbol" do
-        parameters = {a: 1, b: 2, c: 3}
-        notification = create(:notification, parameters: parameters)
-        expect(notification.reload.parameters).to eq(parameters)
-      end
+    it "has parameters for hash with symbol" do
+      parameters = {a: 1, b: 2, c: 3}
+      notification = create(:notification, parameters: parameters)
+      expect(notification.reload.parameters.symbolize_keys).to eq(parameters)
     end
 
     it "has parameters for hash with string" do
       parameters = {'a' => 1, 'b' => 2, 'c' => 3}
       notification = create(:notification, parameters: parameters)
-      expect(notification.reload.parameters).to eq(parameters)
+      expect(notification.reload.parameters.stringify_keys).to eq(parameters)
     end
   end
 
@@ -67,19 +82,19 @@ describe ActivityNotification::Notification, type: :model do
     it "is invalid with blank target" do
       @notification.target = nil
       expect(@notification).to be_invalid
-      expect(@notification.errors[:target].size).to eq(1)
+      expect(@notification.errors[:target]).not_to be_empty
     end
 
     it "is invalid with blank notifiable" do
       @notification.notifiable = nil
       expect(@notification).to be_invalid
-      expect(@notification.errors[:notifiable].size).to eq(1)
+      expect(@notification.errors[:notifiable]).not_to be_empty
     end
 
     it "is invalid with blank key" do
       @notification.key = nil
       expect(@notification).to be_invalid
-      expect(@notification.errors[:key].size).to eq(1)
+      expect(@notification.errors[:key]).not_to be_empty
     end
   end
 
@@ -99,34 +114,34 @@ describe ActivityNotification::Notification, type: :model do
         expect(notifications.unopened_only.first).to eq(@unopened_group_owner)
         expect(notifications.opened_only!.first).to eq(@opened_group_owner)
       end
-  
+
       it "works with group_members_only scope" do
         notifications = ActivityNotification::Notification.group_members_only
         expect(notifications.to_a.size).to eq(2)
         expect(notifications.unopened_only.first).to eq(@unopened_group_member)
         expect(notifications.opened_only!.first).to eq(@opened_group_member)
       end
-  
+
       it "works with unopened_only scope" do
         notifications = ActivityNotification::Notification.unopened_only
         expect(notifications.to_a.size).to eq(2)
         expect(notifications.group_owners_only.first).to eq(@unopened_group_owner)
         expect(notifications.group_members_only.first).to eq(@unopened_group_member)
       end
-  
+
       it "works with unopened_index scope" do
         notifications = ActivityNotification::Notification.unopened_index
         expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@unopened_group_owner)
       end
-  
+
       it "works with opened_only! scope" do
         notifications = ActivityNotification::Notification.opened_only!
         expect(notifications.to_a.size).to eq(2)
         expect(notifications.group_owners_only.first).to eq(@opened_group_owner)
         expect(notifications.group_members_only.first).to eq(@opened_group_member)
       end
-  
+
       context "with opened_only scope" do
         it "works" do
           notifications = ActivityNotification::Notification.opened_only(4)
@@ -134,39 +149,39 @@ describe ActivityNotification::Notification, type: :model do
           expect(notifications.group_owners_only.first).to eq(@opened_group_owner)
           expect(notifications.group_members_only.first).to eq(@opened_group_member)
         end
-  
+
         it "works with limit" do
           notifications = ActivityNotification::Notification.opened_only(1)
           expect(notifications.to_a.size).to eq(1)
         end
       end
-  
+
       context "with opened_index scope" do
         it "works" do
           notifications = ActivityNotification::Notification.opened_index(4)
           expect(notifications.to_a.size).to eq(1)
           expect(notifications.first).to eq(@opened_group_owner)
         end
-    
+
         it "works with limit" do
           notifications = ActivityNotification::Notification.opened_index(0)
           expect(notifications.to_a.size).to eq(0)
         end
       end
-  
+
       it "works with unopened_index_group_members_only scope" do
         notifications = ActivityNotification::Notification.unopened_index_group_members_only
         expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@unopened_group_member)
       end
-  
+
       context "with opened_index_group_members_only scope" do
         it "works" do
           notifications = ActivityNotification::Notification.opened_index_group_members_only(4)
           expect(notifications.to_a.size).to eq(1)
           expect(notifications.first).to eq(@opened_group_member)
         end
-    
+
         it "works with limit" do
           notifications = ActivityNotification::Notification.opened_index_group_members_only(0)
           expect(notifications.to_a.size).to eq(0)
@@ -239,7 +254,7 @@ describe ActivityNotification::Notification, type: :model do
             expect(notifications.first).to eq(@notification_2)
           end
         end
-  
+
         context 'with filtered_by_group options' do
           it "works with filtered_by_options scope" do
             notifications = ActivityNotification::Notification.filtered_by_options({ filtered_by_group: @group_1 })
@@ -276,18 +291,24 @@ describe ActivityNotification::Notification, type: :model do
 
         context 'with custom_filter options' do
           it "works with filtered_by_options scope" do
-            if ActivityNotification.config.orm == :active_record
-              notifications = ActivityNotification::Notification.filtered_by_options({ custom_filter: ["notifications.key = ?", @key_1] })
-              expect(notifications.to_a.size).to eq(1)
-              expect(notifications.first).to eq(@notification_1)
-            end
-
             notifications = ActivityNotification::Notification.filtered_by_options({ custom_filter: { key: @key_2 } })
             expect(notifications.to_a.size).to eq(1)
             expect(notifications.first).to eq(@notification_2)
           end
+
+          it "works with filtered_by_options scope with filter depending on ORM" do
+            options =
+              case ActivityNotification.config.orm
+              when :active_record then { custom_filter: ["notifications.key = ?", @key_1] }
+              when :mongoid       then { custom_filter: { key: {'$eq': @key_1} } }
+              when :dynamoid      then { custom_filter: {'key.begins_with': @key_1} }
+              end
+            notifications = ActivityNotification::Notification.filtered_by_options(options)
+            expect(notifications.to_a.size).to eq(1)
+            expect(notifications.first).to eq(@notification_1)
+          end
         end
-  
+
         context 'with no options' do
           it "works with filtered_by_options scope" do
             notifications = ActivityNotification::Notification.filtered_by_options
@@ -300,37 +321,135 @@ describe ActivityNotification::Notification, type: :model do
     context "to make order by created_at" do
       before do
         ActivityNotification::Notification.delete_all
-        unopened_group_owner   = create(:notification, group_owner: nil)
-        unopened_group_member  = create(:notification, group_owner: unopened_group_owner, created_at: unopened_group_owner.created_at + 10.second)
-        opened_group_owner     = create(:notification, group_owner: nil, opened_at: Time.current, created_at: unopened_group_owner.created_at + 20.second)
-        opened_group_member    = create(:notification, group_owner: opened_group_owner, opened_at: Time.current, created_at: unopened_group_owner.created_at + 30.second)
+        @target = create(:confirmed_user)
+        unopened_group_owner   = create(:notification, target: @target, group_owner: nil)
+        unopened_group_member  = create(:notification, target: @target, group_owner: unopened_group_owner, created_at: unopened_group_owner.created_at + 10.second)
+        opened_group_owner     = create(:notification, target: @target, group_owner: nil, opened_at: Time.current, created_at: unopened_group_owner.created_at + 20.second)
+        opened_group_member    = create(:notification, target: @target, group_owner: opened_group_owner, opened_at: Time.current, created_at: unopened_group_owner.created_at + 30.second)
         @earliest_notification = unopened_group_owner
         @latest_notification   = opened_group_member
       end
 
-      it "works with latest_order scope" do
-        notifications = ActivityNotification::Notification.latest_order
+      unless ActivityNotification.config.orm == :dynamoid
+        context "using ORM other than dynamoid, you can directly call latest/earliest order method from class objects" do
+
+          it "works with latest_order scope" do
+            notifications = ActivityNotification::Notification.latest_order
+            expect(notifications.to_a.size).to eq(4)
+            expect(notifications.first).to eq(@latest_notification)
+            expect(notifications.last).to eq(@earliest_notification)
+          end
+
+          it "works with earliest_order scope" do
+            notifications = ActivityNotification::Notification.earliest_order
+            expect(notifications.to_a.size).to eq(4)
+            expect(notifications.first).to eq(@earliest_notification)
+            expect(notifications.last).to eq(@latest_notification)
+          end
+
+          it "returns the latest notification with latest scope" do
+            notification = ActivityNotification::Notification.latest
+            expect(notification).to eq(@latest_notification)
+          end
+
+          it "returns the earliest notification with earliest scope" do
+            notification = ActivityNotification::Notification.earliest
+            expect(notification).to eq(@earliest_notification)
+          end
+
+        end
+      else
+        context "using dynamoid, you can call latest/earliest order method only with query using partition key of Global Secondary Index" do
+
+          it "works with latest_order scope" do
+            notifications = ActivityNotification::Notification.filtered_by_target(@target).latest_order
+            expect(notifications.to_a.size).to eq(4)
+            expect(notifications.first).to eq(@latest_notification)
+            expect(notifications.last).to eq(@earliest_notification)
+          end
+
+          it "works with earliest_order scope" do
+            notifications = ActivityNotification::Notification.filtered_by_target(@target).earliest_order
+            expect(notifications.to_a.size).to eq(4)
+            expect(notifications.first).to eq(@earliest_notification)
+            expect(notifications.last).to eq(@latest_notification)
+          end
+
+          it "returns the latest notification with latest scope" do
+            notification = ActivityNotification::Notification.filtered_by_target(@target).latest
+            expect(notification).to eq(@latest_notification)
+          end
+
+          it "returns the earliest notification with earliest scope" do
+            notification = ActivityNotification::Notification.filtered_by_target(@target).earliest
+            expect(notification).to eq(@earliest_notification)
+          end
+
+        end
+      end
+
+      it "works with latest_order! scope" do
+        notifications = ActivityNotification::Notification.latest_order!
         expect(notifications.to_a.size).to eq(4)
         expect(notifications.first).to eq(@latest_notification)
         expect(notifications.last).to eq(@earliest_notification)
       end
 
-      it "works with earliest_order scope" do
-        notifications = ActivityNotification::Notification.earliest_order
+      it "works with latest_order!(reverse=true) scope" do
+        notifications = ActivityNotification::Notification.latest_order!(true)
+        expect(notifications.to_a.size).to eq(4)
+        expect(notifications.first).to eq(@earliest_notification)
+        expect(notifications.last).to eq(@latest_notification)
+      end
+
+      it "works with earliest_order! scope" do
+        notifications = ActivityNotification::Notification.earliest_order!
         expect(notifications.to_a.size).to eq(4)
         expect(notifications.first).to eq(@earliest_notification)
         expect(notifications.last).to eq(@latest_notification)
       end
 
-      it "returns the latest notification with latest scope" do
-        notification = ActivityNotification::Notification.latest
+      it "returns the latest notification with latest! scope" do
+        notification = ActivityNotification::Notification.latest!
         expect(notification).to eq(@latest_notification)
       end
 
-      it "returns the earliest notification with earliest scope" do
-        notification = ActivityNotification::Notification.earliest
+      it "returns the earliest notification with earliest! scope" do
+        notification = ActivityNotification::Notification.earliest!
         expect(notification).to eq(@earliest_notification)
       end
     end
+
+    context "to include with associated records" do
+      before do
+        ActivityNotification::Notification.delete_all
+        create(:notification)
+        @notifications = ActivityNotification::Notification.filtered_by_key("default.default")
+      end
+
+      it "works with_target" do
+        expect(@notifications.with_target.count).to        eq(1)
+      end
+
+      it "works with_notifiable" do
+        expect(@notifications.with_notifiable.count).to    eq(1)
+      end
+
+      it "works with_group" do
+        expect(@notifications.with_group.count).to         eq(1)
+      end
+
+      it "works with_group_owner" do
+        expect(@notifications.with_group_owner.count).to   eq(1)
+      end
+
+      it "works with_group_members" do
+        expect(@notifications.with_group_members.count).to eq(1)
+      end
+
+      it "works with_notifier" do
+        expect(@notifications.with_notifier.count).to      eq(1)
+      end
+    end
   end
 end