activity_notification 1.4.4 → 2.2.4

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
@@ -39,21 +56,36 @@ describe ActivityNotification::Notification, type: :model do
       notification = create(:notification, notifier: notifier)
       expect(notification.reload.notifier).to eq(notifier)
     end
+
+    context "returns as_json including associated models" do
+      it "returns as_json with include option as Symbol" do
+        notification = create(:notification)
+        expect(notification.as_json(include: :target)["target"]["id"].to_s).to eq(notification.target.id.to_s)
+      end
+
+      it "returns as_json with include option as Array" do
+        notification = create(:notification)
+        expect(notification.as_json(include: [:target])["target"]["id"].to_s).to eq(notification.target.id.to_s)
+      end
+
+      it "returns as_json with include option as Hash" do
+        notification = create(:notification)
+        expect(notification.as_json(include: { target: { methods: [:printable_target_name] } })["target"]["id"].to_s).to eq(notification.target.id.to_s)
+      end
+    end
   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 +99,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 +131,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 +166,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 +271,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 +308,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 +338,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 "returns the latest notification with latest scope" do
-        notification = ActivityNotification::Notification.latest
+      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
+      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

data/spec/models/subscription_spec.rb

@@ -1,3 +1,6 @@
+# To run as single test for debugging
+# require Rails.root.join('../../spec/concerns/apis/subscription_api_spec.rb').to_s
+
 describe ActivityNotification::Subscription, type: :model do
 
   it_behaves_like :subscription_api
@@ -8,6 +11,14 @@ describe ActivityNotification::Subscription, type: :model do
       subscription = create(:subscription, target: target)
       expect(subscription.reload.target).to eq(target)
     end
+
+    it "several targets can subscribe to the same key" do
+      target = create(:confirmed_user)
+      target2 = create(:confirmed_user)
+      subscription_1 = create(:subscription, target: target, key: 'key.1')
+      subscription_2 = create(:subscription, target: target2, key: 'key.1')
+      expect(subscription_2).to be_valid
+    end
   end
 
   describe "with validation" do
@@ -29,19 +40,6 @@ describe ActivityNotification::Subscription, type: :model do
       expect(@subscription.errors[:key].size).to eq(1)
     end
 
-    #TODO
-    # it "is invalid with non boolean value of subscribing" do
-      # @subscription.subscribing = 'hoge'
-      # expect(@subscription).to be_invalid
-      # expect(@subscription.errors[:subscribing].size).to eq(1)
-    # end
-# 
-    # it "is invalid with non boolean value of subscribing_to_email" do
-      # @subscription.subscribing_to_email = 'hoge'
-      # expect(@subscription).to be_invalid
-      # expect(@subscription.errors[:subscribing_to_email].size).to eq(1)
-    # end
-
     it "is invalid with true as subscribing_to_email and false as subscribing" do
       @subscription.subscribing = false
       @subscription.subscribing_to_email = true
@@ -92,16 +90,22 @@ describe ActivityNotification::Subscription, type: :model do
 
         context 'with custom_filter options' do
           it "works with filtered_by_options scope" do
-            if ActivityNotification.config.orm == :active_record
-              subscriptions = ActivityNotification::Subscription.filtered_by_options({ custom_filter: ["subscriptions.key = ?", @key_1] })
-              expect(subscriptions.size).to eq(1)
-              expect(subscriptions.first).to eq(@subscription_1)
-            end
-
             subscriptions = ActivityNotification::Subscription.filtered_by_options({ custom_filter: { key: @key_2 } })
             expect(subscriptions.size).to eq(1)
             expect(subscriptions.first).to eq(@subscription_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: ["subscriptions.key = ?", @key_1] }
+              when :mongoid       then { custom_filter: { key: {'$eq': @key_1} } }
+              when :dynamoid      then { custom_filter: {'key.begins_with': @key_1} }
+              end
+            subscriptions = ActivityNotification::Subscription.filtered_by_options(options)
+            expect(subscriptions.size).to eq(1)
+            expect(subscriptions.first).to eq(@subscription_1)
+          end
         end
   
         context 'with no options' do
@@ -116,21 +120,67 @@ describe ActivityNotification::Subscription, type: :model do
     context "to make order by created_at" do
       before do
         ActivityNotification::Subscription.delete_all
-        @subscription_1 = create(:subscription, key: 'key.1')
-        @subscription_2 = create(:subscription, key: 'key.2', created_at: @subscription_1.created_at + 10.second)
-        @subscription_3 = create(:subscription, key: 'key.3', created_at: @subscription_1.created_at + 20.second)
-        @subscription_4 = create(:subscription, key: 'key.4', created_at: @subscription_1.created_at + 30.second)
+        @target = create(:confirmed_user)
+        @subscription_1 = create(:subscription, target: @target, key: 'key.1')
+        @subscription_2 = create(:subscription, target: @target, key: 'key.2', created_at: @subscription_1.created_at + 10.second)
+        @subscription_3 = create(:subscription, target: @target, key: 'key.3', created_at: @subscription_1.created_at + 20.second)
+        @subscription_4 = create(:subscription, target: @target, key: 'key.4', created_at: @subscription_1.created_at + 30.second)
+      end
+
+      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
+            subscriptions = ActivityNotification::Subscription.latest_order
+            expect(subscriptions.size).to eq(4)
+            expect(subscriptions.first).to eq(@subscription_4)
+            expect(subscriptions.last).to eq(@subscription_1)
+          end
+
+          it "works with earliest_order scope" do
+            subscriptions = ActivityNotification::Subscription.earliest_order
+            expect(subscriptions.size).to eq(4)
+            expect(subscriptions.first).to eq(@subscription_1)
+            expect(subscriptions.last).to eq(@subscription_4)
+          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
+            subscriptions = ActivityNotification::Subscription.filtered_by_target(@target).latest_order
+            expect(subscriptions.size).to eq(4)
+            expect(subscriptions.first).to eq(@subscription_4)
+            expect(subscriptions.last).to eq(@subscription_1)
+          end
+
+          it "works with earliest_order scope" do
+            subscriptions = ActivityNotification::Subscription.filtered_by_target(@target).earliest_order
+            expect(subscriptions.size).to eq(4)
+            expect(subscriptions.first).to eq(@subscription_1)
+            expect(subscriptions.last).to eq(@subscription_4)
+          end
+
+        end
       end
 
-      it "works with latest_order scope" do
-        subscriptions = ActivityNotification::Subscription.latest_order
+      it "works with latest_order! scope" do
+        subscriptions = ActivityNotification::Subscription.latest_order!
         expect(subscriptions.size).to eq(4)
         expect(subscriptions.first).to eq(@subscription_4)
         expect(subscriptions.last).to eq(@subscription_1)
       end
 
-      it "works with earliest_order scope" do
-        subscriptions = ActivityNotification::Subscription.earliest_order
+      it "works with latest_order!(reverse=true) scope" do
+        subscriptions = ActivityNotification::Subscription.latest_order!(true)
+        expect(subscriptions.size).to eq(4)
+        expect(subscriptions.first).to eq(@subscription_1)
+        expect(subscriptions.last).to eq(@subscription_4)
+      end
+
+      it "works with earliest_order! scope" do
+        subscriptions = ActivityNotification::Subscription.earliest_order!
         expect(subscriptions.size).to eq(4)
         expect(subscriptions.first).to eq(@subscription_1)
         expect(subscriptions.last).to eq(@subscription_4)

data/spec/optional_targets/action_cable_api_channel_spec.rb

@@ -0,0 +1,34 @@
+require 'activity_notification/optional_targets/action_cable_api_channel'
+describe ActivityNotification::OptionalTarget::ActionCableApiChannel do
+  let(:test_instance) { ActivityNotification::OptionalTarget::ActionCableApiChannel.new(skip_initializing_target: true) }
+
+  describe "as public instance methods" do
+    describe "#to_optional_target_name" do
+      it "is return demodulized symbol class name" do
+        expect(test_instance.to_optional_target_name).to eq(:action_cable_api_channel)
+      end
+    end
+
+    describe "#initialize_target" do
+      it "does not raise NotImplementedError" do
+        test_instance.initialize_target
+      end
+    end
+
+    describe "#notify" do
+      it "does not raise NotImplementedError" do
+        test_instance.notify(create(:notification))
+      end
+    end
+  end
+
+  describe "as protected instance methods" do
+    describe "#render_notification_message" do
+      context "as default" do
+        it "renders notification message as formatted JSON" do
+          expect(test_instance.send(:render_notification_message, create(:notification)).with_indifferent_access[:notification].has_key?(:id)).to be_truthy
+        end
+      end
+    end
+  end
+end

data/spec/optional_targets/action_cable_channel_spec.rb

@@ -0,0 +1,41 @@
+require 'activity_notification/optional_targets/action_cable_channel'
+describe ActivityNotification::OptionalTarget::ActionCableChannel do
+  let(:test_instance) { ActivityNotification::OptionalTarget::ActionCableChannel.new(skip_initializing_target: true) }
+
+  describe "as public instance methods" do
+    describe "#to_optional_target_name" do
+      it "is return demodulized symbol class name" do
+        expect(test_instance.to_optional_target_name).to eq(:action_cable_channel)
+      end
+    end
+
+    describe "#initialize_target" do
+      it "does not raise NotImplementedError" do
+        test_instance.initialize_target
+      end
+    end
+
+    describe "#notify" do
+      it "does not raise NotImplementedError" do
+        test_instance.notify(create(:notification))
+      end
+    end
+  end
+
+  describe "as protected instance methods" do
+    describe "#render_notification_message" do
+      context "as default" do
+        it "renders notification message with default template" do
+          expect(test_instance.send(:render_notification_message, create(:notification))).to be_include("<div class='notification_list") 
+        end
+      end
+
+      context "with unexisting template as fallback option" do
+        it "raise ActionView::MissingTemplate" do
+          expect { expect(test_instance.send(:render_notification_message, create(:notification), fallback: :hoge)) }
+            .to raise_error(ActionView::MissingTemplate)
+        end
+      end
+    end
+  end
+end

data/spec/optional_targets/amazon_sns_spec.rb

@@ -10,7 +10,6 @@ describe ActivityNotification::OptionalTarget::AmazonSNS do
     end
 
     describe "#initialize_target" do
-      #TODO
       it "does not raise NotImplementedError" do
         begin
           test_instance.initialize_target
@@ -21,7 +20,6 @@ describe ActivityNotification::OptionalTarget::AmazonSNS do
     end
 
     describe "#notify" do
-      #TODO
       it "does not raise NotImplementedError but NoMethodError" do
         expect { test_instance.notify(create(:notification)) }
           .to raise_error(NoMethodError)

data/spec/optional_targets/slack_spec.rb

@@ -10,7 +10,6 @@ describe ActivityNotification::OptionalTarget::Slack do
     end
 
     describe "#initialize_target" do
-      #TODO
       it "does not raise NotImplementedError but URI::InvalidURIError" do
         expect { test_instance.initialize_target }
           .to raise_error(URI::InvalidURIError)
@@ -18,7 +17,6 @@ describe ActivityNotification::OptionalTarget::Slack do
     end
 
     describe "#notify" do
-      #TODO
       it "does not raise NotImplementedError but NoMethodError" do
         expect { test_instance.notify(create(:notification)) }
           .to raise_error(NoMethodError)