activity_notification 1.4.4 → 2.2.4

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,115 @@ 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
+
+    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
@@ -612,18 +727,39 @@ shared_examples_for :target do
           end
         end
 
-        context 'with custom_filter options' do
+        context 'with later_than 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 = { 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
 
@@ -778,10 +914,17 @@ shared_examples_for :target do
 
     # Wrapper methods of Notification class methods
 
-    describe "#notify_to" do
+    describe "#receive_notification_of" do
       it "is an alias of ActivityNotification::Notification.notify_to" do
         expect(ActivityNotification::Notification).to receive(:notify_to)
-        test_instance.notify_to create(:user)
+        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
 
@@ -793,7 +936,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
@@ -880,6 +1023,22 @@ shared_examples_for :target do
             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
@@ -924,18 +1083,8 @@ shared_examples_for :target do
           end
 
           if ActivityNotification.config.orm == :active_record
-            it "calls with_target, with_notifiable and with_notifier" do
-              expect(ActiveRecord::Base).to receive(:includes).with(:target)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifiable)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifier)
-              test_instance.unopened_notification_index_with_attributes
-            end
-
-            it "does not call with_group" do
-              expect(ActiveRecord::Base).to receive(:includes).with(:target)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifiable)
-              expect(ActiveRecord::Base).not_to receive(:includes).with(:group)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifier)
+            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
@@ -950,10 +1099,7 @@ shared_examples_for :target do
 
           if ActivityNotification.config.orm == :active_record
             it "calls with_group" do
-              expect(ActiveRecord::Base).to receive(:includes).with(:target)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifiable)
-              expect(ActiveRecord::Base).to receive(:includes).with(:group)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifier)
+              expect(ActivityNotification::Notification).to receive_message_chain(:with_target, :with_notifiable, :with_group, :with_notifier)
               test_instance.unopened_notification_index_with_attributes
             end
           end
@@ -986,18 +1132,8 @@ shared_examples_for :target do
           end
 
           if ActivityNotification.config.orm == :active_record
-            it "calls with_target, with_notifiable and with_notifier" do
-              expect(ActiveRecord::Base).to receive(:includes).with(:target)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifiable)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifier)
-              test_instance.opened_notification_index_with_attributes
-            end
-
-            it "does not call with_group" do
-              expect(ActiveRecord::Base).to receive(:includes).with(:target)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifiable)
-              expect(ActiveRecord::Base).not_to receive(:includes).with(:group)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifier)
+            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
@@ -1012,10 +1148,7 @@ shared_examples_for :target do
 
           if ActivityNotification.config.orm == :active_record
             it "calls with_group" do
-              expect(ActiveRecord::Base).to receive(:includes).with(:target)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifiable)
-              expect(ActiveRecord::Base).to receive(:includes).with(:group)
-              expect(ActiveRecord::Base).to receive(:includes).with(:notifier)
+              expect(ActivityNotification::Notification).to receive_message_chain(:with_target, :with_notifiable, :with_group, :with_notifier)
               test_instance.opened_notification_index_with_attributes
             end
           end

data/spec/concerns/renderable_spec.rb

@@ -4,17 +4,23 @@ shared_examples_for :renderable do
   let(:test_instance) { create(test_class_name, target: test_target) }
   let(:target_type_key) { 'user' }
 
-  let(:notifier_name)        { 'foo' }
-  let(:article_title)        { 'bar' }
-  let(:group_member_count)   { 3 }
-  let(:simple_text_key)      { 'article.create' }
-  let(:params_text_key)      { 'comment.post' }
-  let(:group_text_key)       { 'comment.reply' }
-  let(:simple_text_original) { 'Article has been created' }
-  let(:params_text_original) { "<p>%{notifier_name} posted comments to your article %{article_title}</p>" }
-  let(:group_text_original)  { "<p>%{notifier_name} and %{group_member_count} people replied for your comments</p>" }
-  let(:params_text_embedded) { "<p>foo posted comments to your article bar</p>" }
-  let(:group_text_embedded)  { "<p>foo and 3 people replied for your comments</p>" }
+  let(:notifier_name)              { 'foo' }
+  let(:article_title)              { 'bar' }
+  let(:group_notification_count)   { 4 }
+  let(:group_member_count)         { 3 }
+  let(:simple_text_key)            { 'article.create' }
+  let(:params_text_key)            { 'article.update' }
+  let(:group_text_key)             { 'comment.reply' }
+  let(:plural_text_key)            { 'comment.post' }
+  let(:simple_text_original)       { 'Article has been created' }
+  let(:params_text_original)       { 'Article "%{article_title}" has been updated' }
+  let(:plural_text_original_one)   { "<p>%{notifier_name} posted a comment on your article %{article_title}</p>" }
+  let(:plural_text_original_other) { "<p>%{notifier_name} posted %{count} comments on your article %{article_title}</p>" }
+  let(:group_text_original)        { "<p>%{notifier_name} and %{group_member_count} other people replied %{group_notification_count} times to your comment</p>" }
+  let(:params_text_embedded)       { 'Article "bar" has been updated' }
+  let(:group_text_embedded)        { "<p>foo and 3 other people replied 4 times to your comment</p>" }
+  let(:plural_text_embedded_one)   { "<p>foo posted a comment on your article bar</p>" }
+  let(:plural_text_embedded_other) { "<p>foo posted 4 comments on your article bar</p>" }
 
   describe "i18n configuration" do
     it "has key configured for simple text" do
@@ -26,17 +32,30 @@ shared_examples_for :renderable do
       expect(I18n.t("notification.#{target_type_key}.#{params_text_key}.text"))
         .to eq(params_text_original)
       expect(I18n.t("notification.#{target_type_key}.#{params_text_key}.text",
-        {notifier_name: notifier_name, article_title: article_title}))
+        article_title: article_title))
         .to eq(params_text_embedded)
     end
 
-    it "has key configured with embedded params including group_member_count" do
+    it "has key configured with embedded params including group_member_count and group_notification_count" do
       expect(I18n.t("notification.#{target_type_key}.#{group_text_key}.text"))
         .to eq(group_text_original)
       expect(I18n.t("notification.#{target_type_key}.#{group_text_key}.text",
-        {notifier_name: notifier_name, group_member_count: group_member_count}))
+        **{ notifier_name: notifier_name, group_member_count: group_member_count, group_notification_count: group_notification_count }))
         .to eq(group_text_embedded)
     end
+
+    it "has key configured with plurals" do
+      expect(I18n.t("notification.#{target_type_key}.#{plural_text_key}.text")[:one])
+        .to eq(plural_text_original_one)
+      expect(I18n.t("notification.#{target_type_key}.#{plural_text_key}.text")[:other])
+        .to eq(plural_text_original_other)
+      expect(I18n.t("notification.#{target_type_key}.#{plural_text_key}.text",
+        **{ article_title: article_title, notifier_name: notifier_name, count: 1 }))
+        .to eq(plural_text_embedded_one)
+      expect(I18n.t("notification.#{target_type_key}.#{plural_text_key}.text",
+        **{ article_title: article_title, notifier_name: notifier_name, count: group_notification_count }))
+        .to eq(plural_text_embedded_other)
+    end
   end
 
   describe "as public instance methods" do
@@ -83,7 +102,7 @@ shared_examples_for :renderable do
           context "when the text has embedded parameters" do
             it "uses text with embedded parameters" do
               test_instance.key = params_text_key
-              expect(test_instance.text({notifier_name: notifier_name, article_title: article_title}))
+              expect(test_instance.text({article_title: article_title}))
                 .to eq(params_text_embedded)
             end
 
@@ -107,4 +126,4 @@ shared_examples_for :renderable do
     # #layout_path
 
   end
-end
+end

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,55 @@ describe ActivityNotification::Config do
       end
     end
   end
+
+  describe "config.store_with_associated_records" do
+    let(:target) { create(:confirmed_user) }
+
+    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
+          @original = ActivityNotification.config.store_with_associated_records
+          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 = @original
+          load Rails.root.join("../../lib/activity_notification/orm/#{ActivityNotification.config.orm}/notification.rb").to_s
+        end
+
+        it "stores notification with associated records" do
+          expect(@notification.target).to eq(target)
+          expect(@notification.stored_target["id"].to_s).to eq(target.id.to_s)
+        end
+      end
+    end
+
+    context "when it is configured as false" do
+      before do
+        @original = ActivityNotification.config.store_with_associated_records
+        ActivityNotification.config.store_with_associated_records = false
+        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 = @original
+        load Rails.root.join("../../lib/activity_notification/orm/#{ActivityNotification.config.orm}/notification.rb").to_s
+      end
+
+      it "does not store notification with associated records" do
+        expect(@notification.target).to eq(target)
+        begin
+          expect(@notification.stored_target).to be_nil
+        rescue NoMethodError
+        end
+      end
+    end
+  end
 end

data/spec/controllers/controller_spec_utility.rb

@@ -0,0 +1,100 @@
+module ActivityNotification
+  module ControllerSpec
+    module RequestUtility
+      def get_with_compatibility action, params, session
+        get action, params: params, session: session
+      end
+
+      def post_with_compatibility action, params, session
+        post action, params: params, session: session
+      end
+
+      def put_with_compatibility action, params, session
+        put action, params: params, session: session
+      end
+
+      def delete_with_compatibility action, params, session
+        delete action, params: params, session: session
+      end
+
+      def xhr_with_compatibility method, action, params, session
+        send method.to_s, action, xhr: true, params: params, session: session
+      end
+    end
+
+    module ApiResponseUtility
+      def response_json
+        JSON.parse(response.body)
+      end
+
+      def assert_json_with_array_size(json_array, size)
+        expect(json_array.size).to eq(size)
+      end
+
+      def assert_json_with_object(json_object, object)
+        expect(json_object['id'].to_s).to eq(object.id.to_s)
+      end
+
+      def assert_json_with_object_array(json_array, expected_object_array)
+        assert_json_with_array_size(json_array, expected_object_array.size)
+        expected_object_array.each_with_index do |json_object, index|
+          assert_json_with_object(json_object, expected_object_array[index])
+        end
+      end
+
+      def assert_error_response(code)
+        expect(response_json['gem']).to eq('activity_notification')
+        expect(response_json['error']['code']).to eq(code)
+      end
+    end
+
+    module CommitteeUtility
+      extend ActiveSupport::Concern
+      included do
+        include Committee::Rails::Test::Methods
+
+        def api_path
+          "/#{root_path}/#{target_type}/#{test_target.id}"
+        end
+
+        def schema_path
+          Rails.root.join('..', 'openapi.json')
+        end
+
+        def write_schema_file(schema_json)
+          File.open(schema_path, "w") { |file| file.write(schema_json) }
+        end
+
+        def read_schema_file
+          JSON.parse(File.read(schema_path))
+        end
+
+        def committee_options
+          @committee_options ||= { schema: Committee::Drivers::load_from_file(schema_path), prefix: root_path, validate_success_only: true, parse_response_by_content_type: false }
+        end
+
+        def get_with_compatibility path, options = {}
+          get path, **options
+        end
+
+        def post_with_compatibility path, options = {}
+          post path, **options
+        end
+
+        def put_with_compatibility path, options = {}
+          put path, **options
+        end
+
+        def delete_with_compatibility path, options = {}
+          delete path, **options
+        end
+
+        def assert_all_schema_confirm(response, status)
+          expect(response).to have_http_status(status)
+          assert_request_schema_confirm
+          assert_response_schema_confirm
+        end
+      end
+    end
+  end
+end