activity_notification 2.4.0 → 2.5.0

data/spec/concerns/renderable_spec.rb

@@ -1,129 +0,0 @@
-shared_examples_for :renderable do
-  let(:test_class_name) { described_class.to_s.underscore.split('/').last.to_sym }
-  let(:test_target) { create(:user) }
-  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_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
-      expect(I18n.t("notification.#{target_type_key}.#{simple_text_key}.text"))
-        .to eq(simple_text_original)
-    end
-
-    it "has key configured with embedded params" 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",
-        article_title: article_title))
-        .to eq(params_text_embedded)
-    end
-
-    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, 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
-    describe "#text" do
-      context "without params argument" do
-        context "with target type of test instance" do
-          it "uses text from key" do
-            test_instance.key = simple_text_key
-            expect(test_instance.text).to eq(simple_text_original)
-          end
-
-          it "uses text from key with notification namespace" do
-            test_instance.key = "notification.#{simple_text_key}"
-            expect(test_instance.text).to eq(simple_text_original)
-          end
-
-          context "when the text is missing for the target type" do
-            it "returns translation missing text" do
-              test_instance.target = create(:admin)
-              test_instance.key = "notification.#{simple_text_key}"
-              expect(test_instance.text)
-                .to eq("Translation missing: en.notification.admin.#{simple_text_key}.text")
-            end
-          end
-
-          context "when the text has embedded parameters" do
-            it "raises MissingInterpolationArgument without embedded parameters" do
-              test_instance.key = params_text_key
-              expect { test_instance.text }
-                .to raise_error(I18n::MissingInterpolationArgument)
-            end
-          end
-        end
-      end
-
-      context "with params argument" do
-        context "with target type of target parameter" do
-          it "uses text from key" do
-            test_instance.target = create(:admin)
-            test_instance.key = simple_text_key
-            expect(test_instance.text({target: :user})).to eq(simple_text_original)
-          end
-
-          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({article_title: article_title}))
-                .to eq(params_text_embedded)
-            end
-
-            it "uses text with automatically embedded group_member_count" do
-              # Create 3 group members
-              create(test_class_name, target: test_instance.target, group_owner: test_instance)
-              create(test_class_name, target: test_instance.target, group_owner: test_instance)
-              create(test_class_name, target: test_instance.target, group_owner: test_instance)
-              test_instance.key = group_text_key
-              expect(test_instance.text({notifier_name: notifier_name}))
-                .to eq(group_text_embedded)
-            end
-          end
-        end
-      end
-    end
-
-    # Test with view_helper for the following methods
-    # #render
-    # #partial_path
-    # #layout_path
-
-  end
-end

data/spec/config_spec.rb

@@ -1,85 +0,0 @@
-describe ActivityNotification::Config do
-  describe "config.mailer" do
-    let(:notification) { create(:notification) }
-
-    context "as default" do
-      it "is configured with ActivityNotification::Mailer" 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
-      end
-    end
-
-    context "when it is configured with CustomNotificationMailer" do
-      before do
-        ActivityNotification.config.mailer = 'CustomNotificationMailer'
-        ActivityNotification::Notification.set_notification_mailer
-      end
-
-      after do
-        ActivityNotification.config.mailer = 'ActivityNotification::Mailer'
-        ActivityNotification::Notification.set_notification_mailer
-      end
-
-      it "is configured with CustomMailer" do
-        expect(CustomNotificationMailer).to receive(:send_notification_email).and_call_original
-        notification.send_notification_email send_later: false
-      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/common_controller_spec.rb

@@ -1,25 +0,0 @@
-require 'controllers/dummy_common_controller'
-
-describe ActivityNotification::DummyCommonController, type: :controller do
-
-  describe "#set_index_options" do
-    it "raises NotImplementedError" do
-      expect { controller.send(:set_index_options) }
-        .to raise_error(NotImplementedError, /You have to implement .+#set_index_options/)
-    end
-  end
-
-  describe "#load_index" do
-    it "raises NotImplementedError" do
-      expect { controller.send(:load_index) }
-        .to raise_error(NotImplementedError, /You have to implement .+#load_index/)
-    end
-  end
-
-  describe "#controller_path" do
-    it "raises NotImplementedError" do
-      expect { controller.send(:controller_path) }
-        .to raise_error(NotImplementedError, /You have to implement .+#controller_path/)
-    end
-  end
-end

data/spec/controllers/controller_spec_utility.rb

@@ -1,100 +0,0 @@
-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(status)
-        end
-      end
-    end
-  end
-end

data/spec/controllers/dummy_common_controller.rb

@@ -1,5 +0,0 @@
-module ActivityNotification
-  class DummyCommonController < ActivityNotification.config.parent_controller.constantize
-    include CommonController
-  end
-end