activity_notification 2.0.0 → 2.1.4

data/spec/concerns/models/subscriber_spec.rb

@@ -74,10 +74,9 @@ shared_examples_for :subscriber do
       end
 
       context "without params" do
-        it "does not create a new subscription since it is invalid" do
-          new_subscription = test_instance.create_subscription
-          expect(new_subscription).to                        be_nil
-          expect(test_instance.subscriptions.reload.to_a).to be_empty
+        it "raises ActivityNotification::RecordInvalidError it is invalid" do
+          expect { test_instance.create_subscription }
+          .to raise_error(ActivityNotification::RecordInvalidError)
         end
       end
 
@@ -122,16 +121,14 @@ shared_examples_for :subscriber do
       end
 
       context "with false as subscribing and true as subscribing_to_email params" do
-        it "does not create a new subscription since it is invalid" do
-          params = { key: 'key_1', subscribing: false, subscribing_to_email: true }
-          new_subscription = test_instance.create_subscription(params)
-          expect(new_subscription).to                        be_nil
-          expect(test_instance.subscriptions.reload.to_a).to be_empty
+        it "raises ActivityNotification::RecordInvalidError it is invalid" do
+          expect {
+            params = { key: 'key_1', subscribing: false, subscribing_to_email: true }
+            test_instance.create_subscription(params)
+          }.to raise_error(ActivityNotification::RecordInvalidError)
         end
       end
 
-
-
       context "with true as optional_targets params" do
         it "creates a new subscription" do
           params = { key: 'key_1', optional_targets: { subscribing_to_console_output: true } }
@@ -163,11 +160,11 @@ shared_examples_for :subscriber do
       end
 
       context "with false as subscribing and true as optional_targets params" do
-        it "does not create a new subscription since it is invalid" do
-          params = { key: 'key_1', subscribing: false, optional_targets: { subscribing_to_console_output: true } }
-          new_subscription = test_instance.create_subscription(params)
-          expect(new_subscription).to                        be_nil
-          expect(test_instance.subscriptions.reload.to_a).to be_empty
+        it "raises ActivityNotification::RecordInvalidError it is invalid" do
+          expect {
+            params = { key: 'key_1', subscribing: false, optional_targets: { subscribing_to_console_output: true } }
+            test_instance.create_subscription(params)
+          }.to raise_error(ActivityNotification::RecordInvalidError)
         end
       end
     end

data/spec/concerns/models/target_spec.rb

@@ -729,6 +729,22 @@ shared_examples_for :target do
           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(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 } }
@@ -1009,6 +1025,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

data/spec/concerns/renderable_spec.rb

@@ -13,11 +13,11 @@ shared_examples_for :renderable do
   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(: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(: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>" }

data/spec/config_spec.rb

@@ -35,38 +35,49 @@ describe ActivityNotification::Config do
   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
+          @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 = false
+          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 without associated records" do
+        it "stores notification with associated records" do
           expect(@notification.target).to eq(target)
-          expect(@notification.target_record).to eq(target.to_json)
+          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

data/spec/controllers/controller_spec_utility.rb

@@ -0,0 +1,136 @@
+module ActivityNotification
+  module ControllerSpec
+    module RequestUtility
+      def get_with_compatibility action, params, session
+        if Rails::VERSION::MAJOR <= 4
+          get action, params, session
+        else
+          get action, params: params, session: session
+        end
+      end
+
+      def post_with_compatibility action, params, session
+        if Rails::VERSION::MAJOR <= 4
+          post action, params, session
+        else
+          post action, params: params, session: session
+        end
+      end
+
+      def put_with_compatibility action, params, session
+        if Rails::VERSION::MAJOR <= 4
+          put action, params, session
+        else
+          put action, params: params, session: session
+        end
+      end
+
+      def delete_with_compatibility action, params, session
+        if Rails::VERSION::MAJOR <= 4
+          delete action, params, session
+        else
+          delete action, params: params, session: session
+        end
+      end
+
+      def xhr_with_compatibility method, action, params, session
+        if Rails::VERSION::MAJOR <= 4
+          xhr method, action, params, session
+        else
+          send method.to_s, action, xhr: true, params: params, session: session
+        end
+      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 }
+        end
+
+        def get_with_compatibility path, options = {}
+          if Rails::VERSION::MAJOR <= 4
+            get path, options[:params], options[:headers]
+          else
+            get path, options
+          end
+        end
+
+        def post_with_compatibility path, options = {}
+          if Rails::VERSION::MAJOR <= 4
+            post path, options[:params], options[:headers]
+          else
+            post path, options
+          end
+        end
+
+        def put_with_compatibility path, options = {}
+          if Rails::VERSION::MAJOR <= 4
+            put path, options[:params], options[:headers]
+          else
+            put path, options
+          end
+        end
+
+        def delete_with_compatibility path, options = {}
+          if Rails::VERSION::MAJOR <= 4
+            delete path, options[:params], options[:headers]
+          else
+            delete path, options
+          end
+        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

data/spec/controllers/notifications_api_controller_shared_examples.rb

@@ -0,0 +1,506 @@
+require_relative 'controller_spec_utility'
+
+shared_examples_for :notifications_api_controller do
+  include ActivityNotification::ControllerSpec::RequestUtility
+  include ActivityNotification::ControllerSpec::ApiResponseUtility
+
+  let(:target_params) { { target_type: target_type }.merge(extra_params || {}) }
+
+  describe "GET #index" do
+    context "with target_type and target_id parameters" do
+      before do
+        @notification = create(:notification, target: test_target)
+        get_with_compatibility :index, target_params.merge({ target_id: test_target, typed_target_param => 'dummy' }), valid_session
+      end
+
+      it "returns 200 as http status code" do
+        expect(response.status).to eq(200)
+      end
+
+      it "returns JSON response" do
+        expect(response_json["count"]).to eq(1)
+        assert_json_with_object_array(response_json["notifications"], [@notification])
+      end
+    end
+
+    context "with target_type and (typed_target)_id parameters" do
+      before do
+        @notification = create(:notification, target: test_target)
+        get_with_compatibility :index, target_params.merge({ typed_target_param => test_target }), valid_session
+      end
+  
+      it "returns 200 as http status code" do
+        expect(response.status).to eq(200)
+      end
+    end
+
+    context "without target_type parameters" do
+      before do
+        @notification = create(:notification, target: test_target)
+        get_with_compatibility :index, { typed_target_param => test_target }, valid_session
+      end
+
+      it "returns 400 as http status code" do
+        expect(response.status).to eq(400)
+      end
+
+      it "returns error JSON response" do
+        assert_error_response(400)
+      end
+    end
+
+    context "with not found (typed_target)_id parameter" do
+      before do
+        @notification = create(:notification, target: test_target)
+        get_with_compatibility :index, target_params.merge({ typed_target_param => 0 }), valid_session
+      end
+
+      it "returns 404 as http status code" do
+        expect(response.status).to eq(404)
+      end
+
+      it "returns error JSON response" do
+        assert_error_response(404)
+      end
+    end
+
+    context "with filter parameter" do
+      context "with unopened as filter" do
+        before do
+          @notification = create(:notification, target: test_target)
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, filter: 'unopened' }), valid_session
+        end
+
+        it "returns unopened notification index as JSON" do
+          assert_json_with_object_array(response_json["notifications"], [@notification])
+        end
+      end
+
+      context "with opened as filter" do
+        before do
+          @notification = create(:notification, target: test_target)
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, filter: 'opened' }), valid_session
+        end
+
+        it "returns unopened notification index as JSON" do
+          assert_json_with_object_array(response_json["notifications"], [])
+        end
+      end
+    end
+
+    context "with limit parameter" do
+      before do
+        create(:notification, target: test_target)
+        create(:notification, target: test_target)
+      end
+      context "with 2 as limit" do
+        before do
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, limit: 2 }), valid_session
+        end
+
+        it "returns notification index of size 2 as JSON" do
+          assert_json_with_array_size(response_json["notifications"], 2)
+        end
+      end
+
+      context "with 1 as limit" do
+        before do
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, limit: 1 }), valid_session
+        end
+
+        it "returns notification index of size 1 as JSON" do
+          assert_json_with_array_size(response_json["notifications"], 1)
+        end
+      end
+    end
+
+    context "with reverse parameter" do
+      before do
+        @notifiable    = create(:article)
+        @group         = create(:article)
+        @key           = 'test.key.1'
+        notification   = create(:notification, target: test_target, notifiable: @notifiable)
+        create(:notification, target: test_target, notifiable: create(:comment), group: @group, created_at: notification.created_at + 10.second)
+        create(:notification, target: test_target, notifiable: create(:article), key: @key, created_at: notification.created_at + 20.second).open!
+        @notification1 = test_target.notification_index[0]
+        @notification2 = test_target.notification_index[1]
+        @notification3 = test_target.notification_index[2]
+      end
+
+      context "as default" do
+        before do
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target }), valid_session
+        end
+
+        it "returns the latest order" do
+          assert_json_with_object_array(response_json["notifications"], [@notification1, @notification2, @notification3])
+        end
+      end
+
+      context "with true as reverse" do
+        before do
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, reverse: true }), valid_session
+        end
+
+        it "returns the earliest order" do
+          assert_json_with_object_array(response_json["notifications"], [@notification2, @notification1, @notification3])
+        end
+      end
+    end
+
+    context "with options filter parameters" do
+      before do
+        @notifiable    = create(:article)
+        @group         = create(:article)
+        @key           = 'test.key.1'
+        @notification2 = create(:notification, target: test_target, notifiable: @notifiable)
+        @notification1 = create(:notification, target: test_target, notifiable: create(:comment), group: @group, created_at: @notification2.created_at + 10.second)
+        @notification3 = create(:notification, target: test_target, notifiable: create(:article), key: @key, created_at: @notification2.created_at + 20.second)
+        @notification3.open!
+      end
+
+      context 'with filtered_by_type parameter' do
+        it "returns filtered notifications only" do
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, filtered_by_type: 'Article' }), valid_session
+          assert_json_with_object_array(response_json["notifications"], [@notification2, @notification3])
+        end
+      end
+
+      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
+          assert_json_with_object_array(response_json["notifications"], [@notification1])
+        end
+      end
+
+      context 'with filtered_by_key parameter' do
+        it "returns filtered notifications only" do
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, filtered_by_key: @key }), valid_session
+          assert_json_with_object_array(response_json["notifications"], [@notification3])
+        end
+      end
+
+      context 'with later_than parameter' do
+        it "returns filtered notifications only" do
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, later_than: (@notification1.created_at.in_time_zone + 0.001).iso8601(3) }), valid_session
+          assert_json_with_object_array(response_json["notifications"], [@notification3])
+        end
+      end
+
+      context 'with earlier_than parameter' do
+        it "returns filtered notifications only" do
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, earlier_than: @notification1.created_at.iso8601(3) }), valid_session
+          assert_json_with_object_array(response_json["notifications"], [@notification2])
+        end
+      end
+    end
+  end
+
+  describe "POST #open_all" do
+    context "http POST request" do
+      before do
+        @notification = create(:notification, target: test_target)
+        expect(@notification.opened?).to be_falsey
+        post_with_compatibility :open_all, target_params.merge({ typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 200 as http status code" do
+        expect(response.status).to eq(200)
+      end
+
+      it "opens all notifications of the target" do
+        expect(@notification.reload.opened?).to be_truthy
+      end
+
+      it "returns JSON response" do
+        expect(response_json["count"]).to eq(1)
+        assert_json_with_object_array(response_json["notifications"], [@notification])
+      end
+    end
+
+    context "with filter request parameters" do
+      before do
+        @target_1, @notifiable_1, @group_1, @key_1 = create(:confirmed_user), create(:article), nil,           "key.1"
+        @target_2, @notifiable_2, @group_2, @key_2 = create(:confirmed_user), create(:comment), @notifiable_1, "key.2"
+        @notification_1 = create(:notification, target: test_target, notifiable: @notifiable_1, group: @group_1, key: @key_1)
+        @notification_2 = create(:notification, target: test_target, notifiable: @notifiable_2, group: @group_2, key: @key_2, created_at: @notification_1.created_at + 10.second)
+        expect(@notification_1.opened?).to be_falsey
+        expect(@notification_2.opened?).to be_falsey
+      end
+
+      context "with filtered_by_type request parameters" do
+        it "opens filtered notifications only" do
+          post_with_compatibility :open_all, target_params.merge({ typed_target_param => test_target, 'filtered_by_type' => @notifiable_2.to_class_name }), valid_session
+          expect(@notification_1.reload.opened?).to be_falsey
+          expect(@notification_2.reload.opened?).to be_truthy
+        end
+      end
+  
+      context 'with filtered_by_group_type and :filtered_by_group_id request parameters' do
+        it "opens filtered notifications only" do
+          post_with_compatibility :open_all, target_params.merge({ typed_target_param => test_target, 'filtered_by_group_type' => 'Article', 'filtered_by_group_id' => @group_2.id.to_s }), valid_session
+          expect(@notification_1.reload.opened?).to be_falsey
+          expect(@notification_2.reload.opened?).to be_truthy
+        end
+      end
+
+      context 'with filtered_by_key request parameters' do
+        it "opens filtered notifications only" do
+          post_with_compatibility :open_all, target_params.merge({ typed_target_param => test_target, 'filtered_by_key' => 'key.2' }), valid_session
+          expect(@notification_1.reload.opened?).to be_falsey
+          expect(@notification_2.reload.opened?).to be_truthy
+        end
+      end
+
+      context 'with later_than parameter' do
+        it "opens filtered notifications only" do
+          post_with_compatibility :open_all, target_params.merge({ typed_target_param => test_target, later_than: (@notification_1.created_at.in_time_zone + 0.001).iso8601(3) }), valid_session
+          expect(@notification_1.reload.opened?).to be_falsey
+          expect(@notification_2.reload.opened?).to be_truthy
+        end
+      end
+
+      context 'with earlier_than parameter' do
+        it "opens filtered notifications only" do
+          post_with_compatibility :open_all, target_params.merge({ typed_target_param => test_target, earlier_than: @notification_2.created_at.iso8601(3) }), valid_session
+          expect(@notification_1.reload.opened?).to be_truthy
+          expect(@notification_2.reload.opened?).to be_falsey
+        end
+      end
+
+      context "with no filter request parameters" do
+        it "opens all notifications of the target" do
+          post_with_compatibility :open_all, target_params.merge({ typed_target_param => test_target}), valid_session
+          expect(@notification_1.reload.opened?).to be_truthy
+          expect(@notification_2.reload.opened?).to be_truthy
+        end
+      end
+    end
+  end
+
+  describe "GET #show" do
+    context "with id, target_type and (typed_target)_id parameters" do
+      before do
+        @notification = create(:notification, target: test_target)
+        get_with_compatibility :show, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 200 as http status code" do
+        expect(response.status).to eq(200)
+      end
+
+      it "returns the requested notification as JSON" do
+        assert_json_with_object(response_json, @notification)
+      end
+    end
+
+    context "with wrong id and (typed_target)_id parameters" do
+      before do
+        @notification = create(:notification, target: create(:user))
+        get_with_compatibility :show, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 403 as http status code" do
+        expect(response.status).to eq(403)
+      end
+
+      it "returns error JSON response" do
+        assert_error_response(403)
+      end
+    end
+
+    context "when associated notifiable record was not found" do
+      before do
+        @notification = create(:notification, target: test_target)
+        @notification.notifiable.delete
+        get_with_compatibility :show, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 500 as http status code" do
+        expect(response.status).to eq(500)
+      end
+
+      it "returns error JSON response" do
+        assert_error_response(500)
+      end
+    end
+  end
+
+  describe "DELETE #destroy" do
+    context "http DELETE request" do
+      before do
+        @notification = create(:notification, target: test_target)
+        delete_with_compatibility :destroy, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 204 as http status code" do
+        expect(response.status).to eq(204)
+      end
+
+      it "deletes the notification" do
+        expect(test_target.notifications.where(id: @notification.id).exists?).to be_falsey
+      end
+    end
+  end
+
+  describe "PUT #open" do
+    context "without move parameter" do
+      context "http PUT request" do
+        before do
+          @notification = create(:notification, target: test_target)
+          expect(@notification.opened?).to be_falsey
+          put_with_compatibility :open, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
+        end
+
+        it "returns 200 as http status code" do
+          expect(response.status).to eq(200)
+        end
+
+        it "opens the notification" do
+          expect(@notification.reload.opened?).to be_truthy
+        end
+
+        it "returns JSON response" do
+          expect(response_json["count"]).to eq(1)
+          assert_json_with_object(response_json["notification"], @notification)
+        end
+      end
+    end
+
+    context "with true as move parameter" do
+      context "http PUT request" do
+        before do
+          @notification = create(:notification, target: test_target)
+          expect(@notification.opened?).to be_falsey
+          put_with_compatibility :open, target_params.merge({ id: @notification, typed_target_param => test_target, move: true }), valid_session
+        end
+
+        it "returns 302 as http status code" do
+          expect(response.status).to eq(302)
+        end
+
+        it "opens the notification" do
+          expect(@notification.reload.opened?).to be_truthy
+        end
+
+        it "redirects to notifiable_path" do
+          expect(response).to redirect_to @notification.notifiable_path
+        end
+      end
+    end
+  end
+
+  describe "GET #move" do
+    context "without open parameter" do
+      context "http GET request" do
+        before do
+          @notification = create(:notification, target: test_target)
+          get_with_compatibility :move, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
+        end
+
+        it "returns 302 as http status code" do
+          expect(response.status).to eq(302)
+        end
+
+        it "redirects to notifiable_path" do
+          expect(response).to redirect_to @notification.notifiable_path
+        end
+      end
+    end
+
+    context "with true as open parameter" do
+      context "http GET request" do
+        before do
+          @notification = create(:notification, target: test_target)
+          expect(@notification.opened?).to be_falsey
+          get_with_compatibility :move, target_params.merge({ id: @notification, typed_target_param => test_target, open: true }), valid_session
+        end
+
+        it "returns 302 as http status code" do
+          expect(response.status).to eq(302)
+        end
+
+        it "opens the notification" do
+          expect(@notification.reload.opened?).to be_truthy
+        end
+
+        it "redirects to notifiable_path" do
+          expect(response).to redirect_to @notification.notifiable_path
+        end
+      end
+    end
+  end
+end
+
+shared_examples_for :notifications_api_request do
+  include ActivityNotification::ControllerSpec::CommitteeUtility
+
+  before do
+    group = create(:article)
+    notifier = create(:user)
+    create(:notification, target: test_target)
+    group_owner = create(:notification, target: test_target, group: group, notifier: notifier, parameters: { "test_default_param": "1" })
+    @notification = create(:notification, target: test_target, group: group, group_owner: group_owner, notifier: notifier, parameters: { "test_default_param": "1" })
+    group_owner.open!
+  end
+
+  describe "GET /apidocs" do
+    it "returns API references as OpenAPI Specification JSON schema" do
+      get "#{root_path}/apidocs"
+      write_schema_file(response.body)
+      expect(read_schema_file["openapi"]).to eq("3.0.0")
+    end
+  end
+
+  describe "GET /{target_type}/{target_id}/notifications", type: :request do
+    it "returns response as API references" do
+      get_with_compatibility "#{api_path}/notifications", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+  end
+
+  describe "POST /{target_type}/{target_id}/notifications/open_all", type: :request do
+    it "returns response as API references" do
+      post_with_compatibility "#{api_path}/notifications/open_all", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+  end
+
+  describe "GET /{target_type}/{target_id}/notifications/{id}", type: :request do
+    it "returns response as API references" do
+      get_with_compatibility "#{api_path}/notifications/#{@notification.id}", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+
+    it "returns error response as API references" do
+      get_with_compatibility "#{api_path}/notifications/0", headers: @headers
+      assert_all_schema_confirm(response, 404)
+    end
+  end
+
+  describe "DELETE /{target_type}/{target_id}/notifications/{id}", type: :request do
+    it "returns response as API references" do
+      delete_with_compatibility "#{api_path}/notifications/#{@notification.id}", headers: @headers
+      assert_all_schema_confirm(response, 204)
+    end
+  end
+
+  describe "PUT /{target_type}/{target_id}/notifications/{id}/open", type: :request do
+    it "returns response as API references" do
+      put_with_compatibility "#{api_path}/notifications/#{@notification.id}/open", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+
+    it "returns response as API references when request parameters have move=true" do
+      put_with_compatibility "#{api_path}/notifications/#{@notification.id}/open?move=true", headers: @headers
+      assert_all_schema_confirm(response, 302)
+    end
+  end
+
+  describe "GET /{target_type}/{target_id}/notifications/{id}/move", type: :request do
+    it "returns response as API references" do
+      get_with_compatibility "#{api_path}/notifications/#{@notification.id}/move", headers: @headers
+      assert_all_schema_confirm(response, 302)
+    end
+  end
+end