activity_notification 1.2.1 → 1.3.0

data/spec/controllers/subscriptions_controller_shared_examples.rb

@@ -216,7 +216,6 @@ shared_examples_for :subscription_controller do
 
   describe "POST #create" do
     before do
-      test_target.subscriptions.delete_all
       expect(test_target.subscriptions.size).to      eq(0)
     end
 

data/spec/helpers/view_helpers_spec.rb

@@ -45,13 +45,15 @@ describe ActivityNotification::ViewHelpers, type: :helper do
                    locals: { notification: notification }
           )
       end
-  
-      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
+
+      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
       end
-  
+
       it 'handles multiple notifications of array' do
         expect(notification).to receive(:render).with(self, { fallback: :default })
         expect(notification_2).to receive(:render).with(self, { fallback: :default })
@@ -74,7 +76,7 @@ describe ActivityNotification::ViewHelpers, type: :helper do
         expect(render_notification notification)
           .to eq("Custom template root for default target: #{notification.id}")
       end
-  
+
       it "renders custom notification view for specified target" do
         notification.key = 'custom.test'
         # render activity_notification/notifications/users/custom/test
@@ -98,6 +100,21 @@ describe ActivityNotification::ViewHelpers, type: :helper do
         })
         render_notification notification, layout: 'test'
       end
+
+      context "with defined overriding_notification_template_key in notifiable model" do
+        it "renders overriden custom notification view" do
+          notification.key = 'custom.test'
+          module AdditionalMethods
+            def overriding_notification_template_key(target, key)
+              'overriden.custom.test'
+            end
+          end
+          notification.notifiable.extend(AdditionalMethods)
+          # render activity_notification/notifications/users/overriden/custom/test
+          expect(render_notification notification, target: :users)
+            .to eq("Overriden custom template root for user target: #{notification.id}")
+        end
+      end
     end
   end
 

data/spec/models/notification_spec.rb

@@ -25,13 +25,13 @@ describe ActivityNotification::Notification, type: :model do
     it "belongs to notification as group_owner" do
       group_owner  = create(:notification, group_owner: nil)
       group_member = create(:notification, group_owner: group_owner)
-      expect(group_member.reload.group_owner).to eq(group_owner)
+      expect(group_member.reload.group_owner.becomes(ActivityNotification::Notification)).to eq(group_owner)
     end
 
     it "has many notifications as group_members" do
       group_owner  = create(:notification, group_owner: nil)
       group_member = create(:notification, group_owner: group_owner)
-      expect(group_owner.reload.group_members.first).to eq(group_member)
+      expect(group_owner.reload.group_members.first.becomes(ActivityNotification::Notification)).to eq(group_member)
     end
 
     it "belongs to notifier" do
@@ -42,8 +42,16 @@ describe ActivityNotification::Notification, type: :model do
   end
 
   describe "with serializable column" do
-    it "has parameters for hash" do
-      parameters = {a: 1, b: 2, c: 3}
+    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
+    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)
     end
@@ -87,81 +95,81 @@ describe ActivityNotification::Notification, type: :model do
 
       it "works with group_owners_only scope" do
         notifications = ActivityNotification::Notification.group_owners_only
-        expect(notifications.size).to eq(2)
-        expect(notifications.where(opened_at: nil).first).to eq(@unopened_group_owner)
-        expect(notifications.where.not(opened_at: nil).first).to eq(@opened_group_owner)
+        expect(notifications.to_a.size).to eq(2)
+        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.size).to eq(2)
-        expect(notifications.where(opened_at: nil).first).to eq(@unopened_group_member)
-        expect(notifications.where.not(opened_at: nil).first).to eq(@opened_group_member)
+        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.size).to eq(2)
-        expect(notifications.where(group_owner: nil).first).to eq(@unopened_group_owner)
-        expect(notifications.where.not(group_owner: nil).first).to eq(@unopened_group_member)
+        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.size).to eq(1)
+        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.size).to eq(2)
-        expect(notifications.where(group_owner: nil).first).to eq(@opened_group_owner)
-        expect(notifications.where.not(group_owner: nil).first).to eq(@opened_group_member)
+        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)
-          expect(notifications.size).to eq(2)
-          expect(notifications.where(group_owner: nil).first).to eq(@opened_group_owner)
-          expect(notifications.where.not(group_owner: nil).first).to eq(@opened_group_member)
+          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
   
         it "works with limit" do
           notifications = ActivityNotification::Notification.opened_only(1)
-          expect(notifications.size).to eq(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.size).to eq(1)
+          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.size).to eq(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.size).to eq(1)
+        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.size).to eq(1)
+          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.size).to eq(0)
+          expect(notifications.to_a.size).to eq(0)
         end
       end
     end
@@ -177,46 +185,46 @@ describe ActivityNotification::Notification, type: :model do
 
       it "works with filtered_by_target scope" do
         notifications = ActivityNotification::Notification.filtered_by_target(@target_1)
-        expect(notifications.size).to eq(1)
+        expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@notification_1)
         notifications = ActivityNotification::Notification.filtered_by_target(@target_2)
-        expect(notifications.size).to eq(1)
+        expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@notification_2)
       end
 
       it "works with filtered_by_instance scope" do
         notifications = ActivityNotification::Notification.filtered_by_instance(@notifiable_1)
-        expect(notifications.size).to eq(1)
+        expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@notification_1)
         notifications = ActivityNotification::Notification.filtered_by_instance(@notifiable_2)
-        expect(notifications.size).to eq(1)
+        expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@notification_2)
       end
 
       it "works with filtered_by_type scope" do
         notifications = ActivityNotification::Notification.filtered_by_type(@notifiable_1.to_class_name)
-        expect(notifications.size).to eq(1)
+        expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@notification_1)
         notifications = ActivityNotification::Notification.filtered_by_type(@notifiable_2.to_class_name)
-        expect(notifications.size).to eq(1)
+        expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@notification_2)
       end
 
       it "works with filtered_by_group scope" do
         notifications = ActivityNotification::Notification.filtered_by_group(@group_1)
-        expect(notifications.size).to eq(1)
+        expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@notification_1)
         notifications = ActivityNotification::Notification.filtered_by_group(@group_2)
-        expect(notifications.size).to eq(1)
+        expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@notification_2)
       end
 
       it "works with filtered_by_key scope" do
         notifications = ActivityNotification::Notification.filtered_by_key(@key_1)
-        expect(notifications.size).to eq(1)
+        expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@notification_1)
         notifications = ActivityNotification::Notification.filtered_by_key(@key_2)
-        expect(notifications.size).to eq(1)
+        expect(notifications.to_a.size).to eq(1)
         expect(notifications.first).to eq(@notification_2)
       end
 
@@ -224,10 +232,10 @@ describe ActivityNotification::Notification, type: :model do
         context 'with filtered_by_type options' do
           it "works with filtered_by_options scope" do
             notifications = ActivityNotification::Notification.filtered_by_options({ filtered_by_type: @notifiable_1.to_class_name })
-            expect(notifications.size).to eq(1)
+            expect(notifications.to_a.size).to eq(1)
             expect(notifications.first).to eq(@notification_1)
             notifications = ActivityNotification::Notification.filtered_by_options({ filtered_by_type: @notifiable_2.to_class_name })
-            expect(notifications.size).to eq(1)
+            expect(notifications.to_a.size).to eq(1)
             expect(notifications.first).to eq(@notification_2)
           end
         end
@@ -235,10 +243,10 @@ describe ActivityNotification::Notification, type: :model do
         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 })
-            expect(notifications.size).to eq(1)
+            expect(notifications.to_a.size).to eq(1)
             expect(notifications.first).to eq(@notification_1)
             notifications = ActivityNotification::Notification.filtered_by_options({ filtered_by_group: @group_2 })
-            expect(notifications.size).to eq(1)
+            expect(notifications.to_a.size).to eq(1)
             expect(notifications.first).to eq(@notification_2)
           end
         end
@@ -246,33 +254,36 @@ describe ActivityNotification::Notification, type: :model do
         context 'with filtered_by_group_type and :filtered_by_group_id options' do
           it "works with filtered_by_options scope" do
             notifications = ActivityNotification::Notification.filtered_by_options({ filtered_by_group_type: 'Article', filtered_by_group_id: @group_2.id.to_s })
-            expect(notifications.size).to eq(1)
+            expect(notifications.to_a.size).to eq(1)
             expect(notifications.first).to eq(@notification_2)
             notifications = ActivityNotification::Notification.filtered_by_options({ filtered_by_group_type: 'Article' })
-            expect(notifications.size).to eq(2)
+            expect(notifications.to_a.size).to eq(2)
             notifications = ActivityNotification::Notification.filtered_by_options({ filtered_by_group_id: @group_2.id.to_s })
-            expect(notifications.size).to eq(2)
+            expect(notifications.to_a.size).to eq(2)
           end
         end
 
         context 'with filtered_by_key options' do
           it "works with filtered_by_options scope" do
             notifications = ActivityNotification::Notification.filtered_by_options({ filtered_by_key: @key_1 })
-            expect(notifications.size).to eq(1)
+            expect(notifications.to_a.size).to eq(1)
             expect(notifications.first).to eq(@notification_1)
             notifications = ActivityNotification::Notification.filtered_by_options({ filtered_by_key: @key_2 })
-            expect(notifications.size).to eq(1)
+            expect(notifications.to_a.size).to eq(1)
             expect(notifications.first).to eq(@notification_2)
           end
         end
 
         context 'with custom_filter options' do
           it "works with filtered_by_options scope" do
-            notifications = ActivityNotification::Notification.filtered_by_options({ custom_filter: ["key = ?", @key_1] })
-            expect(notifications.size).to eq(1)
-            expect(notifications.first).to eq(@notification_1)
+            if ActivityNotification.config.orm == :active_record
+              notifications = ActivityNotification::Notification.filtered_by_options({ custom_filter: ["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.size).to eq(1)
+            expect(notifications.to_a.size).to eq(1)
             expect(notifications.first).to eq(@notification_2)
           end
         end
@@ -280,7 +291,7 @@ describe ActivityNotification::Notification, type: :model do
         context 'with no options' do
           it "works with filtered_by_options scope" do
             notifications = ActivityNotification::Notification.filtered_by_options
-            expect(notifications.size).to eq(2)
+            expect(notifications.to_a.size).to eq(2)
           end
         end
       end
@@ -299,14 +310,14 @@ describe ActivityNotification::Notification, type: :model do
 
       it "works with latest_order scope" do
         notifications = ActivityNotification::Notification.latest_order
-        expect(notifications.size).to eq(4)
+        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.size).to eq(4)
+        expect(notifications.to_a.size).to eq(4)
         expect(notifications.first).to eq(@earliest_notification)
         expect(notifications.last).to eq(@latest_notification)
       end

data/spec/models/subscription_spec.rb

@@ -92,9 +92,12 @@ describe ActivityNotification::Subscription, type: :model do
 
         context 'with custom_filter options' do
           it "works with filtered_by_options scope" do
-            subscriptions = ActivityNotification::Subscription.filtered_by_options({ custom_filter: ["key = ?", @key_1] })
-            expect(subscriptions.size).to eq(1)
-            expect(subscriptions.first).to eq(@subscription_1)
+            if ActivityNotification.config.orm == :active_record
+              subscriptions = ActivityNotification::Subscription.filtered_by_options({ custom_filter: ["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)

data/spec/optional_targets/amazon_sns_spec.rb

@@ -1,6 +1,6 @@
 require 'activity_notification/optional_targets/amazon_sns'
 describe ActivityNotification::OptionalTarget::AmazonSNS do
-  let(:test_instance) { ActivityNotification::OptionalTarget::AmazonSNS.new }
+  let(:test_instance) { ActivityNotification::OptionalTarget::AmazonSNS.new(skip_initializing_target: true) }
 
   describe "as public instance methods" do
     describe "#to_optional_target_name" do
@@ -12,16 +12,19 @@ describe ActivityNotification::OptionalTarget::AmazonSNS do
     describe "#initialize_target" do
       #TODO
       it "does not raise NotImplementedError" do
-        expect { test_instance.initialize_target }
-          .not_to raise_error(NotImplementedError)
+        begin
+          test_instance.initialize_target
+        rescue Aws::Errors::MissingRegionError
+          # Rescue for CI without AWS client configuration
+        end
       end
     end
 
     describe "#notify" do
       #TODO
-      it "raises NotImplementedError" do
+      it "does not raise NotImplementedError but NoMethodError" do
         expect { test_instance.notify(create(:notification)) }
-          .not_to raise_error(NotImplementedError)
+          .to raise_error(NoMethodError)
       end
     end
   end

data/spec/optional_targets/base_spec.rb

@@ -1,5 +1,7 @@
 describe ActivityNotification::OptionalTarget::Base do
-  let(:test_instance) { ActivityNotification::OptionalTarget::Base.new }
+  let(:test_instance) {
+    ActivityNotification::OptionalTarget::Base.new(skip_initializing_target: true)
+  }
 
   describe "as public instance methods" do
     describe "#to_optional_target_name" do

data/spec/optional_targets/slack_spec.rb

@@ -1,6 +1,6 @@
 require 'activity_notification/optional_targets/slack'
 describe ActivityNotification::OptionalTarget::Slack do
-  let(:test_instance) { ActivityNotification::OptionalTarget::Slack.new }
+  let(:test_instance) { ActivityNotification::OptionalTarget::Slack.new(skip_initializing_target: true) }
 
   describe "as public instance methods" do
     describe "#to_optional_target_name" do
@@ -11,17 +11,17 @@ describe ActivityNotification::OptionalTarget::Slack do
 
     describe "#initialize_target" do
       #TODO
-      it "does not raise NotImplementedError" do
+      it "does not raise NotImplementedError but URI::InvalidURIError" do
         expect { test_instance.initialize_target }
-          .not_to raise_error(NotImplementedError)
+          .to raise_error(URI::InvalidURIError)
       end
     end
 
     describe "#notify" do
       #TODO
-      it "raises NotImplementedError" do
+      it "does not raise NotImplementedError but NoMethodError" do
         expect { test_instance.notify(create(:notification)) }
-          .not_to raise_error(NotImplementedError)
+          .to raise_error(NoMethodError)
       end
     end
   end

data/spec/rails_app/app/models/comment.rb

@@ -7,7 +7,7 @@ class Comment < ActiveRecord::Base
   acts_as_notifiable :users,
     targets: ->(comment, key) { ([comment.article.user] + comment.article.commented_users.to_a - [comment.user]).uniq },
     group: :article, notifier: :user, email_allowed: true,
-    parameters: { test_default_param: '1' },
+    parameters: { 'test_default_param' => '1' },
     notifiable_path: :article_notifiable_path,
     printable_name: ->(comment) { "comment \"#{comment.body}\"" },
     dependent_notifications: :update_group_and_delete_all