activity_notification 2.0.0 → 2.1.4

data/spec/controllers/notifications_api_controller_spec.rb

@@ -0,0 +1,19 @@
+require 'controllers/notifications_api_controller_shared_examples'
+
+describe ActivityNotification::NotificationsApiController, type: :controller do
+  let(:test_target)        { create(:user) }
+  let(:target_type)        { :users }
+  let(:typed_target_param) { :user_id }
+  let(:extra_params)       { {} }
+  let(:valid_session)      {}
+
+  it_behaves_like :notifications_api_controller
+
+  describe "/api/v#{ActivityNotification::GEM_VERSION::MAJOR}", type: :request do
+    let(:root_path)          { "/api/v#{ActivityNotification::GEM_VERSION::MAJOR}" }
+    let(:test_target)        { create(:user) }
+    let(:target_type)        { :users }
+
+    it_behaves_like :notifications_api_request
+  end
+end

data/spec/controllers/notifications_api_with_devise_controller_spec.rb

@@ -0,0 +1,60 @@
+require 'controllers/notifications_api_controller_shared_examples'
+
+context "ActivityNotification::NotificationsApiWithDeviseController" do
+  context "test admins API with associated users authentication" do
+
+    describe "/api/v#{ActivityNotification::GEM_VERSION::MAJOR}", type: :request do
+      include ActivityNotification::ControllerSpec::CommitteeUtility
+
+      let(:root_path)            { "/api/v#{ActivityNotification::GEM_VERSION::MAJOR}" }
+      let(:test_user)            { create(:confirmed_user) }
+      let(:unauthenticated_user) { create(:confirmed_user) }
+      let(:test_target)          { create(:admin, user: test_user) }
+      let(:target_type)          { :admins }
+
+      def sign_in_with_devise_token_auth(auth_user, status)
+        post_with_compatibility "#{root_path}/auth/sign_in", params: { email: auth_user.email, password: "password" }
+        expect(response).to have_http_status(status)
+        @headers = response.header.slice("access-token", "client", "uid")
+      end
+
+      context "signed in with devise as authenticated user" do
+        before do
+          sign_in_with_devise_token_auth(test_user, 200)
+        end
+      
+        it_behaves_like :notifications_api_request
+      end
+
+      context "signed in with devise as unauthenticated user" do
+        let(:target_params) { { target_type: target_type, devise_type: :users } }
+
+        describe "GET #index" do
+          before do
+            sign_in_with_devise_token_auth(unauthenticated_user, 200)
+            get_with_compatibility "#{api_path}/notifications", headers: @headers
+          end
+      
+          it "returns 403 as http status code" do
+            expect(response.status).to eq(403)
+          end
+        end
+      end
+
+      context "unsigned in with devise" do
+        let(:target_params) { { target_type: target_type, devise_type: :users } }
+
+        describe "GET #index" do
+          before do
+            get_with_compatibility "#{api_path}/notifications", headers: @headers
+          end
+      
+          it "returns 401 as http status code" do
+            expect(response.status).to eq(401)
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/controllers/notifications_controller_shared_examples.rb

@@ -1,4 +1,8 @@
-shared_examples_for :notification_controller do
+require_relative 'controller_spec_utility'
+
+shared_examples_for :notifications_controller do
+  include ActivityNotification::ControllerSpec::RequestUtility
+
   let(:target_params) { { target_type: target_type }.merge(extra_params || {}) }
 
   describe "GET #index" do
@@ -69,31 +73,6 @@ shared_examples_for :notification_controller do
       end
     end
 
-    context "with json as format parameter" do
-      before do
-        @notification = create(:notification, target: test_target)
-        get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, format: :json }), valid_session
-      end
-
-      it "returns 200 as http status code" do
-        expect(response.status).to eq(200)
-      end
-
-      it "returns json format" do
-        case ActivityNotification.config.orm
-        when :active_record
-          expect(JSON.parse(response.body).first)
-          .to include("target_id" => test_target.id, "target_type" => test_target.to_class_name)
-        when :mongoid
-          expect(JSON.parse(response.body).first)
-          .to include("target_id" => test_target.id.to_s, "target_type" => test_target.to_class_name)
-        when :dynamoid
-          expect(JSON.parse(response.body).first)
-          .to include("target_key" => "#{test_target.to_class_name}#{ActivityNotification.config.composite_key_delimiter}#{test_target.id}")
-        end
-      end
-    end
-
     context "with filter parameter" do
       context "with unopened as filter" do
         before do
@@ -170,12 +149,10 @@ shared_examples_for :notification_controller 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]
+        @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 "as default" do
@@ -211,8 +188,8 @@ shared_examples_for :notification_controller do
         @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)
-        @notification3 = create(:notification, target: test_target, notifiable: create(:article), key: @key)
+        @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
 
@@ -240,6 +217,22 @@ shared_examples_for :notification_controller do
           expect(assigns(:notifications).size).to eq(1)
         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
+          expect(assigns(:notifications)[0]).to eq(@notification3)
+          expect(assigns(:notifications).size).to eq(1)
+        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
+          expect(assigns(:notifications)[0]).to eq(@notification2)
+          expect(assigns(:notifications).size).to eq(1)
+        end
+      end
     end
   end
 
@@ -314,7 +307,7 @@ shared_examples_for :notification_controller 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)
+        @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
@@ -343,6 +336,22 @@ shared_examples_for :notification_controller do
         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
@@ -397,7 +406,7 @@ shared_examples_for :notification_controller do
       end
 
       it "deletes the notification" do
-        expect(assigns(test_target.notifications.where(id: @notification.id).exists?)).to be_falsey
+        expect(test_target.notifications.where(id: @notification.id).exists?).to be_falsey
       end
 
       it "redirects to :index" do
@@ -449,13 +458,13 @@ shared_examples_for :notification_controller do
     end
   end
 
-  describe "POST #open" do
+  describe "PUT #open" do
     context "without move parameter" do
-      context "http direct POST request" do
+      context "http direct PUT request" do
         before do
           @notification = create(:notification, target: test_target)
           expect(@notification.opened?).to be_falsey
-          post_with_compatibility :open, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
+          put_with_compatibility :open, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
         end
 
         it "returns 302 as http status code" do
@@ -471,12 +480,12 @@ shared_examples_for :notification_controller do
         end
       end
 
-      context "http POST request from root_path" do
+      context "http PUT request from root_path" do
         before do
           @notification = create(:notification, target: test_target)
           expect(@notification.opened?).to be_falsey
           request.env["HTTP_REFERER"] = root_path
-          post_with_compatibility :open, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
+          put_with_compatibility :open, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
         end
 
         it "returns 302 as http status code" do
@@ -492,12 +501,12 @@ shared_examples_for :notification_controller do
         end
       end
 
-      context "Ajax POST request" do
+      context "Ajax PUT request" do
         before do
           @notification = create(:notification, target: test_target)
           expect(@notification.opened?).to be_falsey
           request.env["HTTP_REFERER"] = root_path
-          xhr_with_compatibility :post, :open, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
+          xhr_with_compatibility :put, :open, target_params.merge({ id: @notification, typed_target_param => test_target }), valid_session
         end
     
         it "returns 200 as http status code" do
@@ -519,11 +528,11 @@ shared_examples_for :notification_controller do
     end
 
     context "with true as move parameter" do
-      context "http direct POST request" do
+      context "http direct PUT request" do
         before do
           @notification = create(:notification, target: test_target)
           expect(@notification.opened?).to be_falsey
-          post_with_compatibility :open, target_params.merge({ id: @notification, typed_target_param => test_target, move: true }), valid_session
+          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
@@ -581,38 +590,4 @@ shared_examples_for :notification_controller do
       end
     end
   end
-
-  private
-
-    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 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

data/spec/controllers/notifications_controller_spec.rb

@@ -7,6 +7,5 @@ describe ActivityNotification::NotificationsController, type: :controller do
   let(:extra_params)       { {} }
   let(:valid_session)      {}
 
-  it_behaves_like :notification_controller
-
+  it_behaves_like :notifications_controller
 end

data/spec/controllers/notifications_with_devise_controller_spec.rb

@@ -1,6 +1,8 @@
 require 'controllers/notifications_controller_shared_examples'
 
 describe ActivityNotification::NotificationsWithDeviseController, type: :controller do
+  include ActivityNotification::ControllerSpec::RequestUtility
+
   let(:test_user)            { create(:confirmed_user) }
   let(:unauthenticated_user) { create(:confirmed_user) }
   let(:test_target)          { create(:admin, user: test_user) }
@@ -14,7 +16,7 @@ describe ActivityNotification::NotificationsWithDeviseController, type: :control
       sign_in test_user
     end
   
-    it_behaves_like :notification_controller
+    it_behaves_like :notifications_controller
   end
 
   context "signed in with devise as unauthenticated user" do
@@ -92,15 +94,4 @@ describe ActivityNotification::NotificationsWithDeviseController, type: :control
       end
     end
   end
-
-  private
-
-    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
-
 end

data/spec/controllers/subscriptions_api_controller_shared_examples.rb

@@ -0,0 +1,750 @@
+require_relative 'controller_spec_utility'
+
+shared_examples_for :subscriptions_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
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        @notification = create(:notification, target: test_target, key: 'test_notification_key')
+        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 configured subscription index as JSON" do
+        expect(response_json["configured_count"]).to eq(1)
+        assert_json_with_object_array(response_json["subscriptions"], [@subscription])
+      end
+
+      it "returns unconfigured notification keys as JSON" do
+        expect(response_json["unconfigured_count"]).to eq(1)
+        expect(response_json['unconfigured_notification_keys']).to eq([@notification.key])
+      end
+    end
+
+    context "with target_type and (typed_target)_id parameters" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        @notification = create(:notification, target: test_target, key: 'test_notification_key')
+        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
+
+      it "returns subscription index as JSON" do
+        expect(response_json["configured_count"]).to eq(1)
+        assert_json_with_object_array(response_json["subscriptions"], [@subscription])
+      end
+
+      it "returns unconfigured notification keys as JSON" do
+        expect(response_json["unconfigured_count"]).to eq(1)
+        expect(response_json['unconfigured_notification_keys']).to eq([@notification.key])
+      end
+    end
+
+    context "without target_type parameters" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        @notification = create(:notification, target: test_target, key: 'test_notification_key')
+        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
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        @notification = create(:notification, target: test_target, key: 'test_notification_key')
+        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 configured as filter" do
+        before do
+          @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+          @notification = create(:notification, target: test_target, key: 'test_notification_key')
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, filter: 'configured' }), valid_session
+        end
+
+        it "returns configured subscription index as JSON" do
+          expect(response_json["configured_count"]).to eq(1)
+          assert_json_with_object_array(response_json["subscriptions"], [@subscription])
+        end
+
+        it "does not return unconfigured notification keys as JSON" do
+          expect(response_json['unconfigured_count']).to be_nil
+          expect(response_json['unconfigured_notification_keys']).to be_nil
+        end
+      end
+
+      context "with unconfigured as filter" do
+        before do
+          @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+          @notification = create(:notification, target: test_target, key: 'test_notification_key')
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, filter: 'unconfigured' }), valid_session
+        end
+
+        it "does not return configured subscription index as JSON" do
+          expect(response_json['configured_count']).to be_nil
+          expect(response_json['subscriptions']).to be_nil
+        end
+
+        it "returns unconfigured notification keys as JSON" do
+          expect(response_json["unconfigured_count"]).to eq(1)
+          expect(response_json['unconfigured_notification_keys']).to eq([@notification.key])
+        end
+      end
+    end
+
+    context "with limit parameter" do
+      before do
+        create(:subscription, target: test_target, key: 'test_subscription_key_1')
+        create(:subscription, target: test_target, key: 'test_subscription_key_2')
+        create(:notification, target: test_target, key: 'test_notification_key_1')
+        create(:notification, target: test_target, key: 'test_notification_key_2')
+      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 subscription index of size 2 as JSON" do
+          assert_json_with_array_size(response_json["subscriptions"], 2)
+        end
+
+        it "returns notification key index of size 2 as JSON" do
+          assert_json_with_array_size(response_json["unconfigured_notification_keys"], 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 subscription index of size 1 as JSON" do
+          assert_json_with_array_size(response_json["subscriptions"], 1)
+        end
+
+        it "returns notification key index of size 1 as JSON" do
+          assert_json_with_array_size(response_json["unconfigured_notification_keys"], 1)
+        end
+      end
+    end
+
+    context "with options filter parameters" do
+      before do
+        @subscription1 = create(:subscription, target: test_target, key: 'test_subscription_key_1')
+        @subscription2 = create(:subscription, target: test_target, key: 'test_subscription_key_2')
+        @notification1 = create(:notification, target: test_target, key: 'test_notification_key_1')
+        @notification2 = create(:notification, target: test_target, key: 'test_notification_key_2')
+      end
+
+      context 'with filtered_by_key parameter' do
+        it "returns filtered subscriptions only" do
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, filtered_by_key: 'test_subscription_key_2' }), valid_session
+          assert_json_with_object_array(response_json["subscriptions"], [@subscription2])
+        end
+
+        it "returns filtered notification keys only" do
+          get_with_compatibility :index, target_params.merge({ typed_target_param => test_target, filtered_by_key: 'test_notification_key_2' }), valid_session
+          expect(response_json['unconfigured_notification_keys']).to eq([@notification2.key])
+        end
+      end
+    end
+  end
+
+  describe "POST #create" do
+    before do
+      expect(test_target.subscriptions.size).to eq(0)
+    end
+
+    context "http POST request without optional targets" do
+      before do
+        post_with_compatibility :create, target_params.merge({
+            typed_target_param => test_target,
+            "subscription"     => { "key"        => "new_subscription_key",
+                                    "subscribing"=> "true",
+                                    "subscribing_to_email"=>"true"
+                                  }
+          }), valid_session
+      end
+
+      it "returns 201 as http status code" do
+        expect(response.status).to eq(201)
+      end
+
+      it "creates new subscription of the target" do
+        expect(test_target.subscriptions.reload.size).to      eq(1)
+        expect(test_target.subscriptions.reload.first.key).to eq("new_subscription_key")
+      end
+
+      it "returns created subscription" do
+        created_subscription = test_target.subscriptions.reload.first
+        assert_json_with_object(response_json, created_subscription)
+      end
+    end
+
+    context "http POST request with optional targets" do
+      before do
+        post_with_compatibility :create, target_params.merge({
+            typed_target_param => test_target,
+            "subscription"     => { "key"        => "new_subscription_key",
+                                    "subscribing"=> "true",
+                                    "subscribing_to_email"=>"true",
+                                    "optional_targets" => { "subscribing_to_base1" => "true", "subscribing_to_base2" => "false" }
+                                  }
+          }), valid_session
+      end
+
+      it "returns 201 as http status code" do
+        expect(response.status).to eq(201)
+      end
+
+      it "creates new subscription of the target" do
+        expect(test_target.subscriptions.reload.size).to eq(1)
+        created_subscription = test_target.subscriptions.reload.first
+        expect(created_subscription.key).to eq("new_subscription_key")
+        expect(created_subscription.subscribing_to_optional_target?("base1")).to be_truthy
+        expect(created_subscription.subscribing_to_optional_target?("base2")).to be_falsey
+      end
+
+      it "returns created subscription" do
+        created_subscription = test_target.subscriptions.reload.first
+        assert_json_with_object(response_json, created_subscription)
+      end
+    end
+
+    context "without subscription parameter" do
+      before do
+        put_with_compatibility :create, target_params.merge({
+            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 "unprocessable entity because of duplicate key" do
+      before do
+        @duplicate_subscription = create(:subscription, target: test_target, key: 'duplicate_subscription_key')
+        put_with_compatibility :create, target_params.merge({
+            typed_target_param => test_target,
+            "subscription"     => { "key"        => "duplicate_subscription_key",
+                                    "subscribing"=> "true",
+                                    "subscribing_to_email"=>"true"
+                                  }
+          }), valid_session
+      end
+
+      it "returns 422 as http status code" do
+        expect(response.status).to eq(422)
+      end
+
+      it "returns error JSON response" do
+        assert_error_response(422)
+      end
+    end
+  end
+
+  describe "GET #find" do
+    context "with key, target_type and (typed_target)_id parameters" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        get_with_compatibility :find, target_params.merge({ key: 'test_subscription_key', 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 subscription as JSON" do
+        assert_json_with_object(response_json, @subscription)
+      end
+    end
+
+    context "with wrong id and (typed_target)_id parameters" do
+      before do
+        @subscription = create(:subscription, target: create(:user))
+        get_with_compatibility :find, target_params.merge({ key: 'test_subscription_key', typed_target_param => test_target }), 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
+  end
+
+  describe "GET #optional_target_names" do
+    context "with key, target_type and (typed_target)_id parameters" do
+      before do
+        @notification = create(:notification, target: test_target, key: 'test_subscription_key')
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        get_with_compatibility :optional_target_names, target_params.merge({ key: 'test_subscription_key', 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 blank array since configurured optional targets are not configured" do
+        expect(JSON.parse(response.body)["optional_target_names"].is_a?(Array)).to be_truthy
+      end
+    end
+
+    context "with wrong id and (typed_target)_id parameters" do
+      before do
+        @subscription = create(:subscription, target: create(:user))
+        get_with_compatibility :find, target_params.merge({ key: 'test_subscription_key', typed_target_param => test_target }), 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
+  end
+
+  describe "GET #show" do
+    context "with id, target_type and (typed_target)_id parameters" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        get_with_compatibility :show, target_params.merge({ id: @subscription, 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 subscription as JSON" do
+        assert_json_with_object(response_json, @subscription)
+      end
+    end
+
+    context "with wrong id and (typed_target)_id parameters" do
+      before do
+        @subscription = create(:subscription, target: create(:user))
+        get_with_compatibility :show, target_params.merge({ id: @subscription, 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
+  end
+
+  describe "DELETE #destroy" do
+    context "http DELETE request" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        delete_with_compatibility :destroy, target_params.merge({ id: @subscription, 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 subscription" do
+        expect(test_target.subscriptions.where(id: @subscription.id).exists?).to be_falsey
+      end
+    end
+  end
+
+  describe "PUT #subscribe" do
+    context "http PUT request" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        @subscription.unsubscribe
+        expect(@subscription.subscribing?).to be_falsey
+        put_with_compatibility :subscribe, target_params.merge({ id: @subscription, typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 200 as http status code" do
+        expect(response.status).to eq(200)
+      end
+
+      it "updates subscribing to true" do
+        expect(@subscription.reload.subscribing?).to be_truthy
+      end
+
+      it "returns JSON response" do
+        assert_json_with_object(response_json, @subscription)
+      end
+    end
+  end
+
+  describe "PUT #unsubscribe" do
+    context "http PUT request" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        expect(@subscription.subscribing?).to be_truthy
+        put_with_compatibility :unsubscribe, target_params.merge({ id: @subscription, typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 200 as http status code" do
+        expect(response.status).to eq(200)
+      end
+
+      it "updates subscribing to false" do
+        expect(@subscription.reload.subscribing?).to be_falsey
+      end
+
+      it "returns JSON response" do
+        assert_json_with_object(response_json, @subscription)
+      end
+    end
+  end
+
+  describe "PUT #subscribe_to_email" do
+    context "http PUT request" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        @subscription.unsubscribe_to_email
+        expect(@subscription.subscribing_to_email?).to be_falsey
+        put_with_compatibility :subscribe_to_email, target_params.merge({ id: @subscription, typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 200 as http status code" do
+        expect(response.status).to eq(200)
+      end
+
+      it "updates subscribing_to_email to true" do
+        expect(@subscription.reload.subscribing_to_email?).to be_truthy
+      end
+
+      it "returns JSON response" do
+        assert_json_with_object(response_json, @subscription)
+      end
+    end
+
+    context "with unsubscribed target" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        @subscription.unsubscribe
+        expect(@subscription.subscribing?).to be_falsey
+        expect(@subscription.subscribing_to_email?).to be_falsey
+        put_with_compatibility :subscribe_to_email, target_params.merge({ id: @subscription, typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 422 as http status code" do
+        expect(response.status).to eq(422)
+      end
+
+      it "cannot update subscribing_to_email to true" do
+        expect(@subscription.reload.subscribing_to_email?).to be_falsey
+      end
+
+      it "returns error JSON response" do
+        assert_error_response(422)
+      end
+    end
+  end
+
+  describe "PUT #unsubscribe_to_email" do
+    context "http PUT request" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        expect(@subscription.subscribing_to_email?).to be_truthy
+        put_with_compatibility :unsubscribe_to_email, target_params.merge({ id: @subscription, typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 200 as http status code" do
+        expect(response.status).to eq(200)
+      end
+
+      it "updates subscribing_to_email to false" do
+        expect(@subscription.reload.subscribing_to_email?).to be_falsey
+      end
+
+      it "returns JSON response" do
+        assert_json_with_object(response_json, @subscription)
+      end
+    end
+  end
+
+  describe "PUT #subscribe_to_optional_target" do
+    context "without optional_target_name param" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        @subscription.unsubscribe_to_optional_target(:base)
+        expect(@subscription.subscribing_to_optional_target?(:base)).to be_falsey
+        put_with_compatibility :subscribe_to_optional_target, target_params.merge({ id: @subscription, typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 400 as http status code" do
+        expect(response.status).to eq(400)
+      end
+
+      it "does not update subscribing_to_optional_target?" do
+        expect(@subscription.subscribing_to_optional_target?(:base)).to be_falsey
+      end
+
+      it "returns error JSON response" do
+        assert_error_response(400)
+      end
+    end
+
+    context "http PUT request" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        @subscription.unsubscribe_to_optional_target(:base)
+        expect(@subscription.subscribing_to_optional_target?(:base)).to be_falsey
+        put_with_compatibility :subscribe_to_optional_target, target_params.merge({ id: @subscription, optional_target_name: 'base', typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 200 as http status code" do
+        expect(response.status).to eq(200)
+      end
+
+      it "updates subscribing_to_optional_target to true" do
+        expect(@subscription.reload.subscribing_to_optional_target?(:base)).to be_truthy
+      end
+
+      it "returns JSON response" do
+        assert_json_with_object(response_json, @subscription)
+      end
+    end
+
+    context "with unsubscribed target" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        @subscription.unsubscribe_to_optional_target(:base)
+        @subscription.unsubscribe
+        expect(@subscription.subscribing?).to be_falsey
+        expect(@subscription.subscribing_to_optional_target?(:base)).to be_falsey
+        put_with_compatibility :subscribe_to_optional_target, target_params.merge({ id: @subscription, optional_target_name: 'base', typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 422 as http status code" do
+        expect(response.status).to eq(422)
+      end
+
+      it "cannot update subscribing_to_optional_target to true" do
+        expect(@subscription.reload.subscribing_to_optional_target?(:base)).to be_falsey
+      end
+
+      it "returns error JSON response" do
+        assert_error_response(422)
+      end
+    end
+  end
+
+  describe "PUT #unsubscribe_to_optional_target" do
+    context "without optional_target_name param" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        expect(@subscription.subscribing_to_optional_target?(:base)).to be_truthy
+        put_with_compatibility :unsubscribe_to_optional_target, target_params.merge({ id: @subscription, typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 400 as http status code" do
+        expect(response.status).to eq(400)
+      end
+
+      it "does not update subscribing_to_optional_target?" do
+        expect(@subscription.subscribing_to_optional_target?(:base)).to be_truthy
+      end
+
+      it "returns error JSON response" do
+        assert_error_response(400)
+      end
+    end
+
+    context "http PUT request" do
+      before do
+        @subscription = create(:subscription, target: test_target, key: 'test_subscription_key')
+        expect(@subscription.subscribing_to_optional_target?(:base)).to be_truthy
+        put_with_compatibility :unsubscribe_to_optional_target, target_params.merge({ id: @subscription, optional_target_name: 'base', typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 200 as http status code" do
+        expect(response.status).to eq(200)
+      end
+
+      it "updates subscribing_to_optional_target to false" do
+        expect(@subscription.reload.subscribing_to_optional_target?(:base)).to be_falsey
+      end
+
+      it "returns JSON response" do
+        assert_json_with_object(response_json, @subscription)
+      end
+    end
+  end
+end
+
+shared_examples_for :subscriptions_api_request do
+  include ActivityNotification::ControllerSpec::CommitteeUtility
+
+  before do
+    @notification = create(:notification, target: test_target, key: "unconfigured_key")
+    @subscription = create(:subscription, target: test_target, key: "configured_key")
+  end
+
+  describe "GET /apidocs to test" 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}/subscriptions", type: :request do
+    it "returns response as API references" do
+      get_with_compatibility "#{api_path}/subscriptions", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+  end
+
+  describe "POST /{target_type}/{target_id}/subscriptions", type: :request do
+    it "returns response as API references" do
+      post_with_compatibility "#{api_path}/subscriptions", params: {
+        "subscription"  => { "key"        => "new_subscription_key",
+                             "subscribing"=> "true",
+                             "subscribing_to_email"=>"true",
+                             "optional_targets"=>{
+                               "action_cable_channel"=>{
+                                 "subscribing"=>"true",
+                               },
+                               "slack"=>{
+                                 "subscribing"=>"false"
+                               }
+                             }
+                           }
+      }, headers: @headers
+      assert_all_schema_confirm(response, 201)
+    end
+
+    it "returns response as API references when the key is duplicate" do
+      post_with_compatibility "#{api_path}/subscriptions", params: {
+        "subscription"  => { "key"        => "configured_key",
+                             "subscribing"=> "true",
+                             "subscribing_to_email"=>"true"
+                           }
+      }, headers: @headers
+      assert_all_schema_confirm(response, 422)
+    end
+  end
+
+  describe "GET /{target_type}/{target_id}/subscriptions/find", type: :request do
+    it "returns response as API references" do
+      get_with_compatibility "#{api_path}/subscriptions/find?key=#{@subscription.key}", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+  end
+
+  describe "GET /{target_type}/{target_id}/subscriptions/optional_target_names", type: :request do
+    it "returns response as API references" do
+      create(:notification, target: test_target, key: @subscription.key)
+      get_with_compatibility "#{api_path}/subscriptions/optional_target_names?key=#{@subscription.key}", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+
+    it "returns response as API references when any notification with the key is not found" do
+      get_with_compatibility "#{api_path}/subscriptions/optional_target_names?key=#{@subscription.key}", headers: @headers
+      assert_all_schema_confirm(response, 404)
+    end
+  end
+
+  describe "GET /{target_type}/{target_id}/subscriptions/{id}", type: :request do
+    it "returns response as API references" do
+      get_with_compatibility "#{api_path}/subscriptions/#{@subscription.id}", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+
+    it "returns error response as API references" do
+      get_with_compatibility "#{api_path}/subscriptions/0", headers: @headers
+      assert_all_schema_confirm(response, 404)
+    end
+  end
+
+  describe "DELETE /{target_type}/{target_id}/subscriptions/{id}", type: :request do
+    it "returns response as API references" do
+      delete_with_compatibility "#{api_path}/subscriptions/#{@subscription.id}", headers: @headers
+      assert_all_schema_confirm(response, 204)
+    end
+  end
+
+  describe "PUT /{target_type}/{target_id}/subscriptions/{id}/subscribe", type: :request do
+    it "returns response as API references" do
+      put_with_compatibility "#{api_path}/subscriptions/#{@subscription.id}/subscribe", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+  end
+
+  describe "PUT /{target_type}/{target_id}/subscriptions/{id}/unsubscribe", type: :request do
+    it "returns response as API references" do
+      put_with_compatibility "#{api_path}/subscriptions/#{@subscription.id}/unsubscribe", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+  end
+
+  describe "PUT /{target_type}/{target_id}/subscriptions/{id}/subscribe_to_email", type: :request do
+    it "returns response as API references" do
+      put_with_compatibility "#{api_path}/subscriptions/#{@subscription.id}/subscribe_to_email", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+  end
+
+  describe "PUT /{target_type}/{target_id}/subscriptions/{id}/unsubscribe_to_email", type: :request do
+    it "returns response as API references" do
+      put_with_compatibility "#{api_path}/subscriptions/#{@subscription.id}/unsubscribe_to_email", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+  end
+
+  describe "PUT /{target_type}/{target_id}/subscriptions/{id}/subscribe_to_optional_target", type: :request do
+    it "returns response as API references" do
+      put_with_compatibility "#{api_path}/subscriptions/#{@subscription.id}/subscribe_to_optional_target?optional_target_name=slack", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+  end
+
+  describe "PUT /{target_type}/{target_id}/subscriptions/{id}/unsubscribe_to_optional_target", type: :request do
+    it "returns response as API references" do
+      put_with_compatibility "#{api_path}/subscriptions/#{@subscription.id}/unsubscribe_to_optional_target?optional_target_name=slack", headers: @headers
+      assert_all_schema_confirm(response, 200)
+    end
+  end
+end