activity_notification 2.4.1 → 2.5.0

data/spec/concerns/models/subscriber_spec.rb

@@ -1,800 +0,0 @@
-shared_examples_for :subscriber do
-  include ActiveJob::TestHelper
-  let(:test_class_name) { described_class.to_s.underscore.split('/').last.to_sym }
-  let(:test_instance) { create(test_class_name) }
-  before do
-    ActiveJob::Base.queue_adapter = :test
-    ActivityNotification::Mailer.deliveries.clear
-    expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
-  end
-
-  describe "with association" do
-    it "has many subscriptions" do
-      subscription_1 = create(:subscription, target: test_instance, key: 'subscription_key_1')
-      subscription_2 = create(:subscription, target: test_instance, key: 'subscription_key_2', created_at: subscription_1.created_at + 10.second)
-      expect(test_instance.subscriptions.count).to                eq(2)
-      expect(test_instance.subscriptions.earliest_order.first).to eq(subscription_1)
-      expect(test_instance.subscriptions.latest_order.first).to   eq(subscription_2)
-      expect(test_instance.subscriptions.latest_order.to_a).to    eq(ActivityNotification::Subscription.filtered_by_target(test_instance).latest_order.to_a)
-    end
-  end    
-
-  describe "as public class methods" do
-    describe ".available_as_subscriber?" do
-      it "returns true" do
-        expect(described_class.available_as_subscriber?).to be_truthy
-      end
-    end
-  end
-
-  describe "as public instance methods" do
-    describe "#find_subscription" do
-      before do
-        expect(test_instance.subscriptions.to_a).to be_empty
-      end
-
-      context "when the cofigured subscription exists" do
-        it "returns subscription record" do
-          subscription = test_instance.create_subscription(key: 'test_key')
-          expect(test_instance.subscriptions.reload.to_a).not_to be_empty
-          expect(test_instance.find_subscription('test_key')).to eq(subscription)
-        end
-      end
-
-      context "when the cofigured subscription does not exist" do
-        it "returns nil" do
-          expect(test_instance.find_subscription('test_key')).to be_nil
-        end
-      end
-    end
-
-    describe "#find_or_create_subscription" do
-      before do
-        expect(test_instance.subscriptions.to_a).to be_empty
-      end
-
-      context "when the cofigured subscription exists" do
-        it "returns subscription record" do
-          subscription = test_instance.create_subscription(key: 'test_key')
-          expect(test_instance.subscriptions.reload.to_a).not_to be_empty
-          expect(test_instance.find_or_create_subscription('test_key')).to eq(subscription)
-        end
-      end
-
-      context "when the cofigured subscription does not exist" do
-        it "returns created subscription record" do
-          expect(test_instance.find_or_create_subscription('test_key').target).to eq(test_instance)
-        end
-      end
-    end
-
-    describe "#create_subscription" do
-      before do
-        expect(test_instance.subscriptions.to_a).to be_empty
-      end
-
-      context "without params" do
-        it "raises ActivityNotification::RecordInvalidError it is invalid" do
-          expect { test_instance.create_subscription }
-          .to raise_error(ActivityNotification::RecordInvalidError)
-        end
-      end
-
-      context "with only key params" do
-        it "creates a new subscription" do
-          params = { key: 'key_1' }
-          new_subscription = test_instance.create_subscription(params)
-          expect(new_subscription.subscribing?).to           be_truthy
-          expect(new_subscription.subscribing_to_email?).to  be_truthy
-          expect(new_subscription.subscribing_to_optional_target?(:console_output)).to be_truthy
-          expect(test_instance.subscriptions.reload.size).to eq(1)
-        end
-
-        context "with true as ActivityNotification.config.subscribe_to_email_as_default" do
-          it "creates a new subscription" do
-            ActivityNotification.config.subscribe_to_email_as_default = true
-
-            params = { key: 'key_1' }
-            new_subscription = test_instance.create_subscription(params)
-            expect(new_subscription.subscribing?).to           be_truthy
-            expect(new_subscription.subscribing_to_email?).to  be_truthy
-            expect(test_instance.subscriptions.reload.size).to eq(1)
-
-            ActivityNotification.config.subscribe_to_email_as_default = nil
-          end
-        end
-
-        context "with false as ActivityNotification.config.subscribe_to_email_as_default" do
-          it "creates a new subscription" do
-            ActivityNotification.config.subscribe_to_email_as_default = false
-
-            params = { key: 'key_1' }
-            new_subscription = test_instance.create_subscription(params)
-            expect(new_subscription.subscribing?).to           be_truthy
-            expect(new_subscription.subscribing_to_email?).to  be_falsey
-            expect(test_instance.subscriptions.reload.size).to eq(1)
-
-            ActivityNotification.config.subscribe_to_email_as_default = nil
-          end
-        end
-
-        context "with true as ActivityNotification.config.subscribe_to_optional_targets_as_default" do
-          it "creates a new subscription" do
-            ActivityNotification.config.subscribe_to_optional_targets_as_default = true
-
-            params = { key: 'key_1' }
-            new_subscription = test_instance.create_subscription(params)
-            expect(new_subscription.subscribing?).to           be_truthy
-            expect(new_subscription.subscribing_to_optional_target?(:console_output)).to be_truthy
-            expect(test_instance.subscriptions.reload.size).to eq(1)
-
-            ActivityNotification.config.subscribe_to_optional_targets_as_default = nil
-          end
-        end
-
-        context "with false as ActivityNotification.config.subscribe_to_optional_targets_as_default" do
-          it "creates a new subscription" do
-            ActivityNotification.config.subscribe_to_optional_targets_as_default = false
-
-            params = { key: 'key_1' }
-            new_subscription = test_instance.create_subscription(params)
-            expect(new_subscription.subscribing?).to           be_truthy
-            expect(new_subscription.subscribing_to_optional_target?(:console_output)).to be_falsey
-            expect(test_instance.subscriptions.reload.size).to eq(1)
-
-            ActivityNotification.config.subscribe_to_optional_targets_as_default = nil
-          end
-        end
-      end
-
-      context "with false as subscribing params" do
-        it "creates a new subscription" do
-          params = { key: 'key_1', subscribing: false }
-          new_subscription = test_instance.create_subscription(params)
-          expect(new_subscription.subscribing?).to           be_falsey
-          expect(new_subscription.subscribing_to_email?).to  be_falsey
-          expect(test_instance.subscriptions.reload.size).to eq(1)
-        end
-
-        context "with true as ActivityNotification.config.subscribe_to_email_as_default" do
-          it "creates a new subscription" do
-            ActivityNotification.config.subscribe_to_email_as_default = true
-
-            params = { key: 'key_1', subscribing: false }
-            new_subscription = test_instance.create_subscription(params)
-            expect(new_subscription.subscribing?).to           be_falsey
-            expect(new_subscription.subscribing_to_email?).to  be_falsey
-            expect(test_instance.subscriptions.reload.size).to eq(1)
-
-            ActivityNotification.config.subscribe_to_email_as_default = nil
-          end
-        end
-
-        context "with false as ActivityNotification.config.subscribe_to_email_as_default" do
-          it "creates a new subscription" do
-            ActivityNotification.config.subscribe_to_email_as_default = false
-
-            params = { key: 'key_1', subscribing: false }
-            new_subscription = test_instance.create_subscription(params)
-            expect(new_subscription.subscribing?).to           be_falsey
-            expect(new_subscription.subscribing_to_email?).to  be_falsey
-            expect(test_instance.subscriptions.reload.size).to eq(1)
-
-            ActivityNotification.config.subscribe_to_email_as_default = nil
-          end
-        end
-      end
-
-      context "with false as subscribing_to_email params" do
-        it "creates a new subscription" do
-          params = { key: 'key_1', subscribing_to_email: false }
-          new_subscription = test_instance.create_subscription(params)
-          expect(new_subscription.subscribing?).to           be_truthy
-          expect(new_subscription.subscribing_to_email?).to  be_falsey
-          expect(test_instance.subscriptions.reload.size).to eq(1)
-        end
-      end
-
-      context "with true as subscribing and false as subscribing_to_email params" do
-        it "creates a new subscription" do
-          params = { key: 'key_1', subscribing: true, subscribing_to_email: false }
-          new_subscription = test_instance.create_subscription(params)
-          expect(new_subscription.subscribing?).to           be_truthy
-          expect(new_subscription.subscribing_to_email?).to  be_falsey
-          expect(test_instance.subscriptions.reload.size).to eq(1)
-        end
-      end
-
-      context "with false as subscribing and true as subscribing_to_email params" do
-        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 } }
-          new_subscription = test_instance.create_subscription(params)
-          expect(new_subscription.subscribing?).to                                     be_truthy
-          expect(new_subscription.subscribing_to_optional_target?(:console_output)).to be_truthy
-          expect(test_instance.subscriptions.reload.size).to eq(1)
-        end
-      end
-
-      context "with false as optional_targets params" do
-        it "creates a new subscription" do
-          params = { key: 'key_1', optional_targets: { subscribing_to_console_output: false } }
-          new_subscription = test_instance.create_subscription(params)
-          expect(new_subscription.subscribing?).to                                     be_truthy
-          expect(new_subscription.subscribing_to_optional_target?(:console_output)).to be_falsey
-          expect(test_instance.subscriptions.reload.size).to eq(1)
-        end
-      end
-
-      context "with true as subscribing and false as optional_targets params" do
-        it "creates a new subscription" do
-          params = { key: 'key_1', subscribing: true, optional_targets: { subscribing_to_console_output: false } }
-          new_subscription = test_instance.create_subscription(params)
-          expect(new_subscription.subscribing?).to                                     be_truthy
-          expect(new_subscription.subscribing_to_optional_target?(:console_output)).to be_falsey
-          expect(test_instance.subscriptions.reload.size).to eq(1)
-        end
-      end
-
-      context "with false as subscribing and true as optional_targets params" do
-        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
-
-    describe "#subscription_index" do
-      context "when the target has no subscriptions" do
-        it "returns empty records" do
-          expect(test_instance.subscription_index).to be_empty
-        end
-      end
-
-      context "when the target has subscriptions" do
-        before do
-          @subscription2 = create(:subscription, target: test_instance, key: 'subscription_key_2')
-          @subscription1 = create(:subscription, target: test_instance, key: 'subscription_key_1', created_at: @subscription2.created_at + 10.second)
-        end
-
-        context "without any options" do
-          it "returns the array of subscriptions" do
-            expect(test_instance.subscription_index[0]).to   eq(@subscription1)
-            expect(test_instance.subscription_index[1]).to   eq(@subscription2)
-            expect(test_instance.subscription_index.size).to eq(2)
-          end
-        end
-
-        context "with limit" do
-          it "returns the same as subscriptions with limit" do
-            options = { limit: 1 }
-            expect(test_instance.subscription_index(options)[0]).to   eq(@subscription1)
-            expect(test_instance.subscription_index(options).size).to eq(1)
-          end
-        end
-
-        context "with reverse" do
-          it "returns the earliest order" do
-            options = { reverse: true }
-            expect(test_instance.subscription_index(options)[0]).to   eq(@subscription2)
-            expect(test_instance.subscription_index(options)[1]).to   eq(@subscription1)
-            expect(test_instance.subscription_index(options).size).to eq(2)
-          end
-        end
-
-        context 'with filtered_by_key options' do
-          it "returns filtered notifications only" do
-            options = { filtered_by_key: 'subscription_key_2' }
-            expect(test_instance.subscription_index(options)[0]).to   eq(@subscription2)
-            expect(test_instance.subscription_index(options).size).to eq(1)
-          end
-        end
-
-        context 'with custom_filter options' do
-          it "returns filtered subscriptions only" do
-            options = { custom_filter: { key: 'subscription_key_1' } }
-            expect(test_instance.subscription_index(options)[0]).to   eq(@subscription1)
-            expect(test_instance.subscription_index(options).size).to eq(1)
-          end
-
-          it "returns filtered subscriptions only with filter depending on ORM" do
-            options =
-              case ActivityNotification.config.orm
-              when :active_record then { custom_filter: ["subscriptions.key = ?", 'subscription_key_2'] }
-              when :mongoid       then { custom_filter: { key: {'$eq': 'subscription_key_2'} } }
-              when :dynamoid      then { custom_filter: {'key.begins_with': 'subscription_key_2'} }
-              end
-            expect(test_instance.subscription_index(options)[0]).to   eq(@subscription2)
-            expect(test_instance.subscription_index(options).size).to eq(1)
-          end
-        end
-
-        if ActivityNotification.config.orm == :active_record
-          context 'with with_target options' do
-            it "calls with_target" do
-              expect(ActivityNotification::Subscription).to receive_message_chain(:with_target)
-              test_instance.subscription_index(with_target: true)
-            end
-          end
-        end
-      end
-    end
-
-    describe "#notification_keys" do
-      context "when the target has no notifications" do
-        it "returns empty records" do
-          expect(test_instance.notification_keys).to be_empty
-        end
-      end
-
-      context "when the target has notifications" do
-        before do
-          notification = create(:notification, target: test_instance, key: 'notification_key_2')
-          create(:notification, target: test_instance, key: 'notification_key_1', created_at: notification.created_at + 10.second)
-          create(:subscription, target: test_instance, key: 'notification_key_1')
-        end
-
-        context "without any options" do
-          it "returns the array of notification keys" do
-            expect(test_instance.notification_keys[0]).to eq('notification_key_1')
-            expect(test_instance.notification_keys[1]).to eq('notification_key_2')
-            expect(test_instance.notification_keys.size).to eq(2)
-          end
-        end
-
-        context "with limit" do
-          it "returns the same as subscriptions with limit" do
-            options = { limit: 1 }
-            expect(test_instance.notification_keys(options)[0]).to eq('notification_key_1')
-            expect(test_instance.notification_keys(options).size).to eq(1)
-          end
-        end
-
-        context "with reverse" do
-          it "returns the earliest order" do
-            options = { reverse: true }
-            expect(test_instance.notification_keys(options)[0]).to eq('notification_key_2')
-            expect(test_instance.notification_keys(options)[1]).to eq('notification_key_1')
-            expect(test_instance.notification_keys(options).size).to eq(2)
-          end
-        end
-
-        context 'with filter' do
-          context 'as :configured' do
-            it "returns notification keys of configured subscriptions only" do
-              options = { filter: :configured }
-              expect(test_instance.notification_keys(options)[0]).to eq('notification_key_1')
-              expect(test_instance.notification_keys(options).size).to eq(1)
-              options = { filter: 'configured' }
-              expect(test_instance.notification_keys(options)[0]).to eq('notification_key_1')
-              expect(test_instance.notification_keys(options).size).to eq(1)
-            end
-          end
-
-          context 'as :unconfigured' do
-            it "returns unconfigured notification keys only" do
-              options = { filter: :unconfigured }
-              expect(test_instance.notification_keys(options)[0]).to eq('notification_key_2')
-              expect(test_instance.notification_keys(options).size).to eq(1)
-              options = { filter: 'unconfigured' }
-              expect(test_instance.notification_keys(options)[0]).to eq('notification_key_2')
-              expect(test_instance.notification_keys(options).size).to eq(1)
-            end
-          end
-        end
-
-        context 'with filtered_by_key options' do
-          it "returns filtered notifications only" do
-            options = { filtered_by_key: 'notification_key_2' }
-            expect(test_instance.notification_keys(options)[0]).to eq('notification_key_2')
-            expect(test_instance.notification_keys(options).size).to eq(1)
-          end
-        end
-
-        context 'with custom_filter options' do
-          it "returns filtered notifications only" do
-            options = { custom_filter: { key: 'notification_key_1' } }
-            expect(test_instance.notification_keys(options)[0]).to eq('notification_key_1')
-            expect(test_instance.notification_keys(options).size).to eq(1)
-          end
-
-          it "returns filtered notifications only with filter depending on ORM" do
-            options =
-              case ActivityNotification.config.orm
-              when :active_record then { custom_filter: ["notifications.key = ?", 'notification_key_2'] }
-              when :mongoid       then { custom_filter: { key: {'$eq': 'notification_key_2'} } }
-              when :dynamoid      then { custom_filter: {'key.begins_with': 'notification_key_2'} }
-              end
-            expect(test_instance.notification_keys(options)[0]).to eq('notification_key_2')
-            expect(test_instance.notification_keys(options).size).to eq(1)
-          end
-        end
-      end
-    end
-
-    # Function test for subscriptions
-
-    describe "#receive_notification_of" do
-      before do
-        @test_key = 'test_key'
-        Comment.acts_as_notifiable described_class.to_s.underscore.pluralize.to_sym, targets: [], email_allowed: true
-        @notifiable = create(:comment)
-        expect(@notifiable.notification_email_allowed?(test_instance, @test_key)).to be_truthy
-      end
-
-      context "subscribing to notification" do
-        before do
-          test_instance.create_subscription(key: @test_key)
-          expect(test_instance.subscribes_to_notification?(@test_key)).to be_truthy
-        end
-
-        it "returns created notification" do
-          notification = test_instance.receive_notification_of(@notifiable, key: @test_key)
-          expect(notification).not_to be_nil
-          expect(notification.target).to eq(test_instance)
-        end
-  
-        it "creates notification records" do
-          test_instance.receive_notification_of(@notifiable, key: @test_key)
-          expect(test_instance.notifications.unopened_only.count).to eq(1)
-        end
-      end
-
-      context "subscribing to notification email" do
-        before do
-          test_instance.create_subscription(key: @test_key)
-          expect(test_instance.subscribes_to_notification_email?(@test_key)).to be_truthy
-        end
-
-        context "as default" do
-          it "sends notification email later" do
-            expect {
-              perform_enqueued_jobs do
-                test_instance.receive_notification_of(@notifiable, key: @test_key)
-              end
-            }.to change { ActivityNotification::Mailer.deliveries.size }.by(1)
-            expect(ActivityNotification::Mailer.deliveries.size).to eq(1)
-          end
-  
-          it "sends notification email with active job queue" do
-            expect {
-              test_instance.receive_notification_of(@notifiable, key: @test_key)
-            }.to change(ActiveJob::Base.queue_adapter.enqueued_jobs, :size).by(1)
-          end
-        end
-
-        context "with send_later false" do
-          it "sends notification email now" do
-            test_instance.receive_notification_of(@notifiable, key: @test_key, send_later: false)
-            expect(ActivityNotification::Mailer.deliveries.size).to eq(1)
-          end
-        end
-      end
-
-      context "unsubscribed to notification" do
-        before do
-          test_instance.create_subscription(key: @test_key, subscribing: false)
-          expect(test_instance.subscribes_to_notification?(@test_key)).to be_falsey
-        end
-
-        it "returns nil" do
-          notification = test_instance.receive_notification_of(@notifiable, key: @test_key)
-          expect(notification).to be_nil
-        end
-  
-        it "does not create notification records" do
-          test_instance.receive_notification_of(@notifiable, key: @test_key)
-          expect(test_instance.notifications.unopened_only.count).to eq(0)
-        end
-      end
-
-      context "unsubscribed to notification email" do
-        before do
-          test_instance.create_subscription(key: @test_key, subscribing: true, subscribing_to_email: false)
-          expect(test_instance.subscribes_to_notification_email?(@test_key)).to be_falsey
-        end
-
-        context "as default" do
-          it "does not send notification email later" do
-            expect {
-              perform_enqueued_jobs do
-                test_instance.receive_notification_of(@notifiable, key: @test_key)
-              end
-            }.to change { ActivityNotification::Mailer.deliveries.size }.by(0)
-            expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
-          end
-  
-          it "does not send notification email with active job queue" do
-            expect {
-              test_instance.receive_notification_of(@notifiable, key: @test_key)
-            }.to change(ActiveJob::Base.queue_adapter.enqueued_jobs, :size).by(0)
-          end
-        end
-
-        context "with send_later false" do
-          it "does not send notification email now" do
-            test_instance.receive_notification_of(@notifiable, key: @test_key, send_later: false)
-            expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
-          end
-        end
-      end
-    end
-
-    describe "#subscribes_to_notification?" do
-      before do
-        @test_key = 'test_key'
-      end
-
-      context "when the subscription is not enabled for the target" do
-        it "returns true" do
-          described_class._notification_subscription_allowed = false
-          expect(test_instance.subscribes_to_notification?(@test_key)).to be_truthy
-        end
-      end
-
-      context "when the subscription is enabled for the target" do
-        before do
-          described_class._notification_subscription_allowed = true
-        end
-
-        context "without configured subscription" do
-          context "without subscribe_as_default argument" do
-            context "with true as ActivityNotification.config.subscribe_as_default" do
-              it "returns true" do
-                subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                ActivityNotification.config.subscribe_as_default = true
-                expect(test_instance.subscribes_to_notification?(@test_key)).to be_truthy
-                ActivityNotification.config.subscribe_as_default = subscribe_as_default
-              end
-            end
-
-            context "with false as ActivityNotification.config.subscribe_as_default" do
-              it "returns false" do
-                subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                ActivityNotification.config.subscribe_as_default = false
-                expect(test_instance.subscribes_to_notification?(@test_key)).to be_falsey
-                ActivityNotification.config.subscribe_as_default = subscribe_as_default
-              end
-            end
-          end
-        end
-
-        context "with configured subscription" do
-          context "subscribing to notification" do
-            it "returns true" do
-              subscription = test_instance.create_subscription(key: @test_key)
-              expect(subscription.subscribing?).to be_truthy
-              expect(test_instance.subscribes_to_notification?(@test_key)).to be_truthy
-            end
-          end
-
-          context "unsubscribed to notification" do
-            it "returns false" do
-              subscription = test_instance.create_subscription(key: @test_key, subscribing: false)
-              expect(subscription.subscribing?).to be_falsey
-              expect(test_instance.subscribes_to_notification?(@test_key)).to be_falsey
-            end
-          end
-        end
-      end
-    end
-
-    describe "#subscribes_to_notification_email?" do
-      before do
-        @test_key = 'test_key'
-      end
-
-      context "when the subscription is not enabled for the target" do
-        it "returns true" do
-          described_class._notification_subscription_allowed = false
-          expect(test_instance.subscribes_to_notification_email?(@test_key)).to be_truthy
-        end
-      end
-
-      context "when the subscription is enabled for the target" do
-        before do
-          described_class._notification_subscription_allowed = true
-        end
-
-        context "without configured subscription" do
-          context "without subscribe_as_default argument" do
-            context "with true as ActivityNotification.config.subscribe_as_default" do
-              it "returns true" do
-                subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                ActivityNotification.config.subscribe_as_default = true
-                expect(test_instance.subscribes_to_notification_email?(@test_key)).to be_truthy
-                ActivityNotification.config.subscribe_as_default = subscribe_as_default
-              end
-
-              context "with true as ActivityNotification.config.subscribe_to_email_as_default" do
-                it "returns true" do
-                  subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                  ActivityNotification.config.subscribe_as_default = true
-                  ActivityNotification.config.subscribe_to_email_as_default = true
-                  expect(test_instance.subscribes_to_notification_email?(@test_key)).to be_truthy
-                  ActivityNotification.config.subscribe_as_default = subscribe_as_default
-                  ActivityNotification.config.subscribe_to_email_as_default = nil
-                end
-              end
-
-              context "with false as ActivityNotification.config.subscribe_to_email_as_default" do
-                it "returns false" do
-                  subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                  ActivityNotification.config.subscribe_as_default = true
-                  ActivityNotification.config.subscribe_to_email_as_default = false
-                  expect(test_instance.subscribes_to_notification_email?(@test_key)).to be_falsey
-                  ActivityNotification.config.subscribe_as_default = subscribe_as_default
-                  ActivityNotification.config.subscribe_to_email_as_default = nil
-                end
-              end
-            end
-
-            context "with false as ActivityNotification.config.subscribe_as_default" do
-              it "returns false" do
-                subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                ActivityNotification.config.subscribe_as_default = false
-                expect(test_instance.subscribes_to_notification_email?(@test_key)).to be_falsey
-                ActivityNotification.config.subscribe_as_default = subscribe_as_default
-              end
-
-              context "with true as ActivityNotification.config.subscribe_to_email_as_default" do
-                it "returns false" do
-                  subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                  ActivityNotification.config.subscribe_as_default = false
-                  ActivityNotification.config.subscribe_to_email_as_default = true
-                  expect(test_instance.subscribes_to_notification_email?(@test_key)).to be_falsey
-                  ActivityNotification.config.subscribe_as_default = subscribe_as_default
-                  ActivityNotification.config.subscribe_to_email_as_default = nil
-                end
-              end
-
-              context "with false as ActivityNotification.config.subscribe_to_email_as_default" do
-                it "returns false" do
-                  subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                  ActivityNotification.config.subscribe_as_default = false
-                  ActivityNotification.config.subscribe_to_email_as_default = false
-                  expect(test_instance.subscribes_to_notification_email?(@test_key)).to be_falsey
-                  ActivityNotification.config.subscribe_as_default = subscribe_as_default
-                  ActivityNotification.config.subscribe_to_email_as_default = nil
-                end
-              end
-            end
-          end
-        end
-
-        context "with configured subscription" do
-          context "subscribing to notification email" do
-            it "returns true" do
-              subscription = test_instance.create_subscription(key: @test_key)
-              expect(subscription.subscribing_to_email?).to be_truthy
-              expect(test_instance.subscribes_to_notification_email?(@test_key)).to be_truthy
-            end
-          end
-
-          context "unsubscribed to notification email" do
-            it "returns false" do
-              subscription = test_instance.create_subscription(key: @test_key, subscribing: true, subscribing_to_email: false)
-              expect(subscription.subscribing_to_email?).to be_falsey
-              expect(test_instance.subscribes_to_notification_email?(@test_key)).to be_falsey
-            end
-          end
-        end
-      end
-    end
-
-    describe "#subscribes_to_optional_target?" do
-      before do
-        @test_key             = 'test_key'
-        @optional_target_name = :console_output
-      end
-
-      context "when the subscription is not enabled for the target" do
-        it "returns true" do
-          described_class._notification_subscription_allowed = false
-          expect(test_instance.subscribes_to_optional_target?(@test_key, @optional_target_name)).to be_truthy
-        end
-      end
-
-      context "when the subscription is enabled for the target" do
-        before do
-          described_class._notification_subscription_allowed = true
-        end
-
-        context "without configured subscription" do
-          context "without subscribe_as_default argument" do
-            context "with true as ActivityNotification.config.subscribe_as_default" do
-              it "returns true" do
-                subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                ActivityNotification.config.subscribe_as_default = true
-                expect(test_instance.subscribes_to_optional_target?(@test_key, @optional_target_name)).to be_truthy
-                ActivityNotification.config.subscribe_as_default = subscribe_as_default
-              end
-
-              context "with true as ActivityNotification.config.subscribe_to_optional_targets_as_default" do
-                it "returns true" do
-                  subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                  ActivityNotification.config.subscribe_as_default = true
-                  ActivityNotification.config.subscribe_to_optional_targets_as_default = true
-                  expect(test_instance.subscribes_to_optional_target?(@test_key, @optional_target_name)).to be_truthy
-                  ActivityNotification.config.subscribe_as_default = subscribe_as_default
-                  ActivityNotification.config.subscribe_to_optional_targets_as_default = nil
-                end
-              end
-
-              context "with false as ActivityNotification.config.subscribe_to_optional_targets_as_default" do
-                it "returns false" do
-                  subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                  ActivityNotification.config.subscribe_as_default = true
-                  ActivityNotification.config.subscribe_to_optional_targets_as_default = false
-                  expect(test_instance.subscribes_to_optional_target?(@test_key, @optional_target_name)).to be_falsey
-                  ActivityNotification.config.subscribe_as_default = subscribe_as_default
-                  ActivityNotification.config.subscribe_to_optional_targets_as_default = nil
-                end
-              end
-            end
-
-            context "with false as ActivityNotification.config.subscribe_as_default" do
-              it "returns false" do
-                subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                ActivityNotification.config.subscribe_as_default = false
-                expect(test_instance.subscribes_to_optional_target?(@test_key, @optional_target_name)).to be_falsey
-                ActivityNotification.config.subscribe_as_default = subscribe_as_default
-              end
-
-              context "with true as ActivityNotification.config.subscribe_to_optional_targets_as_default" do
-                it "returns false" do
-                  subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                  ActivityNotification.config.subscribe_as_default = false
-                  ActivityNotification.config.subscribe_to_optional_targets_as_default = true
-                  expect(test_instance.subscribes_to_optional_target?(@test_key, @optional_target_name)).to be_falsey
-                  ActivityNotification.config.subscribe_as_default = subscribe_as_default
-                  ActivityNotification.config.subscribe_to_optional_targets_as_default = nil
-                end
-              end
-
-              context "with false as ActivityNotification.config.subscribe_to_optional_targets_as_default" do
-                it "returns false" do
-                  subscribe_as_default = ActivityNotification.config.subscribe_as_default
-                  ActivityNotification.config.subscribe_as_default = false
-                  ActivityNotification.config.subscribe_to_optional_targets_as_default = false
-                  expect(test_instance.subscribes_to_optional_target?(@test_key, @optional_target_name)).to be_falsey
-                  ActivityNotification.config.subscribe_as_default = subscribe_as_default
-                  ActivityNotification.config.subscribe_to_optional_targets_as_default = nil
-                end
-              end
-            end
-          end
-        end
-
-        context "with configured subscription" do
-          context "subscribing to the specified optional target" do
-            it "returns true" do
-              subscription = test_instance.create_subscription(key: @test_key, optional_targets: { ActivityNotification::Subscription.to_optional_target_key(@optional_target_name) => true })
-              expect(subscription.subscribing_to_optional_target?(@optional_target_name)).to be_truthy
-              expect(test_instance.subscribes_to_optional_target?(@test_key, @optional_target_name)).to be_truthy
-            end
-          end
-
-          context "unsubscribed to the specified optional target" do
-            it "returns false" do
-              subscription = test_instance.create_subscription(key: @test_key, subscribing: true, optional_targets: { ActivityNotification::Subscription.to_optional_target_key(@optional_target_name) => false })
-              expect(subscription.subscribing_to_optional_target?(@optional_target_name)).to be_falsey
-              expect(test_instance.subscribes_to_optional_target?(@test_key, @optional_target_name)).to be_falsey
-            end
-          end
-        end
-      end
-    end
-
-  end
-end