activity_notification 2.4.1 → 2.5.0

data/spec/concerns/apis/subscription_api_spec.rb

@@ -1,474 +0,0 @@
-shared_examples_for :subscription_api do
-  include ActiveJob::TestHelper
-  let(:test_class_name) { described_class.to_s.underscore.split('/').last.to_sym }
-  let(:test_instance) { create(test_class_name) }
-
-  describe "as public class methods" do
-    describe ".to_optional_target_key" do
-      it "returns optional target key" do
-        expect(described_class.to_optional_target_key(:console_output)).to eq(:subscribing_to_console_output)
-      end
-    end
-
-    describe ".to_optional_target_subscribed_at_key" do
-      it "returns optional target subscribed_at key" do
-        expect(described_class.to_optional_target_subscribed_at_key(:console_output)).to eq(:subscribed_to_console_output_at)
-      end
-    end
-
-    describe ".to_optional_target_unsubscribed_at_key" do
-      it "returns optional target unsubscribed_at key" do
-        expect(described_class.to_optional_target_unsubscribed_at_key(:console_output)).to eq(:unsubscribed_to_console_output_at)
-      end
-    end
-  end
-
-  describe "as public instance methods" do
-    describe "#subscribe" do
-      before do
-        test_instance.unsubscribe
-      end
-
-      it "returns if successfully updated subscription instance" do
-        expect(test_instance.subscribe).to be_truthy
-      end
-
-      context "as default" do
-        it "subscribe with current time" do
-          expect(test_instance.subscribing?).to                   eq(false)
-          expect(test_instance.subscribing_to_email?).to          eq(false)
-          Timecop.freeze(Time.at(Time.now.to_i))
-          test_instance.subscribe
-          expect(test_instance.subscribing?).to                   eq(true)
-          expect(test_instance.subscribing_to_email?).to          eq(true)
-          expect(test_instance.subscribed_at).to                  eq(Time.current)
-          expect(test_instance.subscribed_to_email_at).to         eq(Time.current)
-          Timecop.return
-        end
-
-        context "with true as ActivityNotification.config.subscribe_to_email_as_default" do
-          it "subscribe with current time" do
-            ActivityNotification.config.subscribe_to_email_as_default = true
-
-            expect(test_instance.subscribing?).to                   eq(false)
-            expect(test_instance.subscribing_to_email?).to          eq(false)
-            Timecop.freeze(Time.at(Time.now.to_i))
-            test_instance.subscribe
-            expect(test_instance.subscribing?).to                   eq(true)
-            expect(test_instance.subscribing_to_email?).to          eq(true)
-            expect(test_instance.subscribed_at).to                  eq(Time.current)
-            expect(test_instance.subscribed_to_email_at).to         eq(Time.current)
-            Timecop.return
-
-            ActivityNotification.config.subscribe_to_email_as_default = nil
-          end
-        end
-
-        context "with false as ActivityNotification.config.subscribe_to_email_as_default" do
-          it "subscribe with current time" do
-            ActivityNotification.config.subscribe_to_email_as_default = false
-
-            expect(test_instance.subscribing?).to                   eq(false)
-            expect(test_instance.subscribing_to_email?).to          eq(false)
-            Timecop.freeze(Time.at(Time.now.to_i))
-            test_instance.subscribe
-            expect(test_instance.subscribing?).to                   eq(true)
-            expect(test_instance.subscribing_to_email?).to          eq(false)
-            expect(test_instance.subscribed_at).to                  eq(Time.current)
-            Timecop.return
-
-            ActivityNotification.config.subscribe_to_email_as_default = nil
-          end
-        end
-      end
-
-      context "with subscribed_at option" do
-        it "subscribe with specified time" do
-          expect(test_instance.subscribing?).to                   eq(false)
-          expect(test_instance.subscribing_to_email?).to          eq(false)
-          subscribed_at = Time.current - 1.months
-          test_instance.subscribe(subscribed_at: subscribed_at)
-          expect(test_instance.subscribing?).to                   eq(true)
-          expect(test_instance.subscribing_to_email?).to          eq(true)
-          expect(test_instance.subscribed_at.to_i).to             eq(subscribed_at.to_i)
-          expect(test_instance.subscribed_to_email_at.to_i).to    eq(subscribed_at.to_i)
-        end
-
-        context "with true as ActivityNotification.config.subscribe_to_email_as_default" do
-          it "subscribe with current time" do
-            ActivityNotification.config.subscribe_to_email_as_default = true
-
-            expect(test_instance.subscribing?).to                   eq(false)
-            expect(test_instance.subscribing_to_email?).to          eq(false)
-            subscribed_at = Time.current - 1.months
-            test_instance.subscribe(subscribed_at: subscribed_at)
-            expect(test_instance.subscribing?).to                   eq(true)
-            expect(test_instance.subscribing_to_email?).to          eq(true)
-            expect(test_instance.subscribed_at.to_i).to             eq(subscribed_at.to_i)
-            expect(test_instance.subscribed_to_email_at.to_i).to    eq(subscribed_at.to_i)
-
-            ActivityNotification.config.subscribe_to_email_as_default = nil
-          end
-        end
-
-        context "with false as ActivityNotification.config.subscribe_to_email_as_default" do
-          it "subscribe with current time" do
-            ActivityNotification.config.subscribe_to_email_as_default = false
-
-            expect(test_instance.subscribing?).to                   eq(false)
-            expect(test_instance.subscribing_to_email?).to          eq(false)
-            subscribed_at = Time.current - 1.months
-            test_instance.subscribe(subscribed_at: subscribed_at)
-            expect(test_instance.subscribing?).to                   eq(true)
-            expect(test_instance.subscribing_to_email?).to          eq(false)
-            expect(test_instance.subscribed_at.to_i).to             eq(subscribed_at.to_i)
-
-            ActivityNotification.config.subscribe_to_email_as_default = nil
-          end
-        end
-      end
-
-      context "with false as with_email_subscription" do
-        it "does not subscribe to email" do
-          expect(test_instance.subscribing?).to                   eq(false)
-          expect(test_instance.subscribing_to_email?).to          eq(false)
-          test_instance.subscribe(with_email_subscription: false)
-          expect(test_instance.subscribing?).to                   eq(true)
-          expect(test_instance.subscribing_to_email?).to          eq(false)
-        end
-      end
-
-      context "with optional targets" do
-        it "also subscribes to optional targets" do
-          test_instance.unsubscribe_to_optional_target(:console_output)
-          expect(test_instance.subscribing?).to                                     eq(false)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to eq(false)
-          test_instance.subscribe
-          expect(test_instance.subscribing?).to                                     eq(true)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to eq(true)
-        end
-
-        context "with true as ActivityNotification.config.subscribe_to_optional_targets_as_default" do
-          it "also subscribes to optional targets" do
-            ActivityNotification.config.subscribe_to_optional_targets_as_default = true
-
-            test_instance.unsubscribe_to_optional_target(:console_output)
-            expect(test_instance.subscribing?).to                                     eq(false)
-            expect(test_instance.subscribing_to_optional_target?(:console_output)).to eq(false)
-            test_instance.subscribe
-            expect(test_instance.subscribing?).to                                     eq(true)
-            expect(test_instance.subscribing_to_optional_target?(:console_output)).to eq(true)
-
-            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 "does not subscribe to optional targets" do
-            ActivityNotification.config.subscribe_to_optional_targets_as_default = false
-
-            test_instance.unsubscribe_to_optional_target(:console_output)
-            expect(test_instance.subscribing?).to                                     eq(false)
-            expect(test_instance.subscribing_to_optional_target?(:console_output)).to eq(false)
-            test_instance.subscribe
-            expect(test_instance.subscribing?).to                                     eq(true)
-            expect(test_instance.subscribing_to_optional_target?(:console_output)).to eq(false)
-
-            ActivityNotification.config.subscribe_to_optional_targets_as_default = nil
-          end
-        end
-      end
-
-      context "with false as with_optional_targets" do
-        it "does not subscribe to optional targets" do
-          test_instance.unsubscribe_to_optional_target(:console_output)
-          expect(test_instance.subscribing?).to                                     eq(false)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to eq(false)
-          test_instance.subscribe(with_optional_targets: false)
-          expect(test_instance.subscribing?).to                                     eq(true)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to eq(false)
-        end
-      end
-    end
-
-    describe "#unsubscribe" do
-      it "returns if successfully updated subscription instance" do
-        expect(test_instance.subscribe).to be_truthy
-      end
-
-      context "as default" do
-        it "unsubscribe with current time" do
-          expect(test_instance.subscribing?).to                     eq(true)
-          expect(test_instance.subscribing_to_email?).to            eq(true)
-          Timecop.freeze(Time.at(Time.now.to_i))
-          test_instance.unsubscribe
-          expect(test_instance.subscribing?).to                     eq(false)
-          expect(test_instance.subscribing_to_email?).to            eq(false)
-          expect(test_instance.unsubscribed_at).to                  eq(Time.current)
-          expect(test_instance.unsubscribed_to_email_at).to         eq(Time.current)
-          Timecop.return
-        end
-      end
-
-      context "with unsubscribed_at option" do
-        it "unsubscribe with specified time" do
-          expect(test_instance.subscribing?).to                     eq(true)
-          expect(test_instance.subscribing_to_email?).to            eq(true)
-          unsubscribed_at = Time.current - 1.months
-          test_instance.unsubscribe(unsubscribed_at: unsubscribed_at)
-          expect(test_instance.subscribing?).to                     eq(false)
-          expect(test_instance.subscribing_to_email?).to            eq(false)
-          expect(test_instance.unsubscribed_at.to_i).to             eq(unsubscribed_at.to_i)
-          expect(test_instance.unsubscribed_to_email_at.to_i).to    eq(unsubscribed_at.to_i)
-        end
-      end
-    end
-
-    describe "#subscribe_to_email" do
-      before do
-        test_instance.unsubscribe_to_email
-      end
-
-      context "for subscribing instance" do
-        it "returns true as successfully updated subscription instance" do
-          expect(test_instance.subscribing?).to                   eq(true)
-          expect(test_instance.subscribing_to_email?).to          eq(false)
-          expect(test_instance.subscribe_to_email).to be_truthy
-        end
-      end
-
-      context "for not subscribing instance" do
-        it "returns false as failure to update subscription instance" do
-          test_instance.unsubscribe
-          expect(test_instance.subscribing?).to                   eq(false)
-          expect(test_instance.subscribing_to_email?).to          eq(false)
-          expect(test_instance.subscribe_to_email).to be_falsey
-        end
-      end
-
-      context "as default" do
-        it "subscribe_to_email with current time" do
-          expect(test_instance.subscribing?).to                   eq(true)
-          expect(test_instance.subscribing_to_email?).to          eq(false)
-          Timecop.freeze(Time.at(Time.now.to_i))
-          test_instance.subscribe_to_email
-          expect(test_instance.subscribing?).to                   eq(true)
-          expect(test_instance.subscribing_to_email?).to          eq(true)
-          expect(test_instance.subscribed_to_email_at).to         eq(Time.current)
-          Timecop.return
-        end
-      end
-
-      context "with subscribed_to_email_at option" do
-        it "subscribe with specified time" do
-          expect(test_instance.subscribing?).to                   eq(true)
-          expect(test_instance.subscribing_to_email?).to          eq(false)
-          subscribed_to_email_at = Time.current - 1.months
-          test_instance.subscribe_to_email(subscribed_to_email_at: subscribed_to_email_at)
-          expect(test_instance.subscribing?).to                   eq(true)
-          expect(test_instance.subscribing_to_email?).to          eq(true)
-          expect(test_instance.subscribed_to_email_at.to_i).to    eq(subscribed_to_email_at.to_i)
-        end
-      end
-    end
-
-    describe "#unsubscribe_to_email" do
-      it "returns if successfully updated subscription instance" do
-        expect(test_instance.unsubscribe_to_email).to be_truthy
-      end
-
-      context "as default" do
-        it "unsubscribe_to_email with current time" do
-          expect(test_instance.subscribing?).to                     eq(true)
-          expect(test_instance.subscribing_to_email?).to            eq(true)
-          Timecop.freeze(Time.at(Time.now.to_i))
-          test_instance.unsubscribe_to_email
-          expect(test_instance.subscribing?).to                     eq(true)
-          expect(test_instance.subscribing_to_email?).to            eq(false)
-          expect(test_instance.unsubscribed_to_email_at).to         eq(Time.current)
-          Timecop.return
-        end
-      end
-
-      context "with unsubscribed_to_email_at option" do
-        it "unsubscribe with specified time" do
-          expect(test_instance.subscribing?).to                     eq(true)
-          expect(test_instance.subscribing_to_email?).to            eq(true)
-          unsubscribed_to_email_at = Time.current - 1.months
-          test_instance.unsubscribe_to_email(unsubscribed_to_email_at: unsubscribed_to_email_at)
-          expect(test_instance.subscribing?).to                     eq(true)
-          expect(test_instance.subscribing_to_email?).to            eq(false)
-          expect(test_instance.unsubscribed_to_email_at.to_i).to    eq(unsubscribed_to_email_at.to_i)
-        end
-      end
-    end
-
-    describe "#subscribing_to_optional_target?" do
-      before do
-        test_instance.update(optional_targets: {})
-      end
-
-      context "without configured optional target 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.subscribing_to_optional_target?(:console_output)).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.subscribing_to_optional_target?(:console_output)).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.subscribing_to_optional_target?(:console_output)).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.subscribing_to_optional_target?(:console_output)).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.subscribing_to_optional_target?(:console_output)).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.subscribing_to_optional_target?(:console_output)).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 optional target" do
-          it "returns true" do
-            test_instance.subscribe_to_optional_target(:console_output)
-            expect(test_instance.subscribing_to_optional_target?(:console_output)).to be_truthy
-          end
-        end
-
-        context "unsubscribed to optional target" do
-          it "returns false" do
-            test_instance.unsubscribe_to_optional_target(:console_output)
-            expect(test_instance.subscribing_to_optional_target?(:console_output)).to be_falsey
-          end
-        end
-      end
-    end
-
-    describe "#subscribe_to_optional_target" do
-      before do
-        test_instance.unsubscribe_to_optional_target(:console_output)
-      end
-
-      context "for subscribing instance" do
-        it "returns true as successfully updated subscription instance" do
-          expect(test_instance.subscribing?).to                                         eq(true)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to     eq(false)
-          expect(test_instance.subscribe_to_optional_target(:console_output)).to        be_truthy
-        end
-      end
-
-      context "for not subscribing instance" do
-        it "returns false as failure to update subscription instance" do
-          test_instance.unsubscribe
-          expect(test_instance.subscribing?).to                                         eq(false)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to     eq(false)
-          expect(test_instance.subscribe_to_optional_target(:console_output)).to        be_falsey
-        end
-      end
-
-      context "as default" do
-        it "subscribe_to_optional_target with current time" do
-          expect(test_instance.subscribing?).to                                         eq(true)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to     eq(false)
-          Timecop.freeze(Time.at(Time.now.to_i))
-          test_instance.subscribe_to_optional_target(:console_output)
-          expect(test_instance.subscribing?).to                                         eq(true)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to     eq(true)
-          expect(test_instance.optional_targets[:subscribed_to_console_output_at]).to   eq(ActivityNotification::Subscription.convert_time_as_hash(Time.current))
-          Timecop.return
-        end
-      end
-
-      context "with subscribed_at option" do
-        it "subscribe with specified time" do
-          expect(test_instance.subscribing?).to                                            eq(true)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to        eq(false)
-          subscribed_at = Time.current - 1.months
-          test_instance.subscribe_to_optional_target(:console_output, subscribed_at: subscribed_at)
-          expect(test_instance.subscribing?).to                                            eq(true)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to        eq(true)
-          expect(test_instance.optional_targets[:subscribed_to_console_output_at].to_i).to eq(subscribed_at.to_i)
-        end
-      end
-    end
-
-    describe "#unsubscribe_to_optional_target" do
-      it "returns if successfully updated subscription instance" do
-        expect(test_instance.unsubscribe_to_optional_target(:console_output)).to be_truthy
-      end
-
-      context "as default" do
-        it "unsubscribe_to_optional_target with current time" do
-          expect(test_instance.subscribing?).to                                         eq(true)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to     eq(true)
-          Timecop.freeze(Time.at(Time.now.to_i))
-          test_instance.unsubscribe_to_optional_target(:console_output)
-          expect(test_instance.subscribing?).to                                         eq(true)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to     eq(false)
-          expect(test_instance.optional_targets[:unsubscribed_to_console_output_at]).to eq(ActivityNotification::Subscription.convert_time_as_hash(Time.current))
-          Timecop.return
-        end
-      end
-
-      context "with unsubscribed_at option" do
-        it "unsubscribe with specified time" do
-          expect(test_instance.subscribing?).to                                              eq(true)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to          eq(true)
-          unsubscribed_at = Time.current - 1.months
-          test_instance.unsubscribe_to_optional_target(:console_output, unsubscribed_at: unsubscribed_at)
-          expect(test_instance.subscribing?).to                                              eq(true)
-          expect(test_instance.subscribing_to_optional_target?(:console_output)).to          eq(false)
-          expect(test_instance.optional_targets[:unsubscribed_to_console_output_at].to_i).to eq(unsubscribed_at.to_i)
-        end
-      end
-    end
-
-  end
-end

data/spec/concerns/common_spec.rb

@@ -1,213 +0,0 @@
-shared_examples_for :common do
-  let(:test_class_name) { described_class.to_s.underscore.split('/').last.to_sym }
-  let(:test_instance) { create(test_class_name) }
-
-  describe "as public ActivityNotification methods with described class" do
-    describe ".resolve_value" do
-      before do
-        allow(ActivityNotification).to receive(:get_controller).and_return('StubController')
-      end
-
-      context "with value" do
-        it "returns specified value" do
-          expect(ActivityNotification.resolve_value(test_instance, 1)).to eq(1)
-        end
-      end
-
-      context "with Symbol" do
-        it "returns specified symbol without arguments" do
-          module AdditionalMethods
-            def custom_method
-              1
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          expect(ActivityNotification.resolve_value(test_instance, :custom_method)).to eq(1)
-        end
-
-        it "returns specified symbol with controller arguments" do
-          module AdditionalMethods
-            def custom_method(controller)
-              controller == 'StubController' ? 1 : 0
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          expect(ActivityNotification.resolve_value(test_instance, :custom_method)).to eq(1)
-        end
-
-        it "returns specified symbol with controller and additional arguments" do
-          module AdditionalMethods
-            def custom_method(controller, key)
-              controller == 'StubController' and key == 'test1.key' ? 1 : 0
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          expect(ActivityNotification.resolve_value(test_instance, :custom_method, 'test1.key')).to eq(1)
-          expect(ActivityNotification.resolve_value(test_instance, :custom_method, 'test2.key')).to eq(0)
-        end
-
-        it "returns specified symbol with controller and additional arguments including hash as last argument" do
-           module AdditionalMethods
-             def custom_method(controller, key, options:)
-               controller == 'StubController' and key == 'test1.key' ? 1 : 0
-             end
-           end
-           test_instance.extend(AdditionalMethods)
-           expect(ActivityNotification.resolve_value(test_instance, :custom_method, 'test1.key', options: 1)).to eq(1)
-           expect(ActivityNotification.resolve_value(test_instance, :custom_method, 'test2.key', options: 1)).to eq(0)
-         end
-      end
-
-      context "with Proc" do
-        it "returns specified lambda without argument" do
-          test_proc = ->{ 1 }
-          expect(ActivityNotification.resolve_value(test_instance, test_proc)).to eq(1)
-        end
-
-        it "returns specified lambda with context(model) arguments" do
-          test_proc = ->(model){ model == test_instance ? 1 : 0 }
-          expect(ActivityNotification.resolve_value(test_instance, test_proc)).to eq(1)
-        end
-
-        it "returns specified lambda with controller and context(model) arguments" do
-          test_proc = ->(controller, model){ controller == 'StubController' and model == test_instance ? 1 : 0 }
-          expect(ActivityNotification.resolve_value(test_instance, test_proc)).to eq(1)
-        end
-
-        it "returns specified lambda with controller, context(model) and additional arguments" do
-          test_proc = ->(controller, model, key){ controller == 'StubController' and model == test_instance and key == 'test1.key' ? 1 : 0 }
-          expect(ActivityNotification.resolve_value(test_instance, test_proc, 'test1.key')).to eq(1)
-          expect(ActivityNotification.resolve_value(test_instance, test_proc, 'test2.key')).to eq(0)
-        end
-      end
-
-      context "with Hash" do
-        it "returns resolve_value for each entry of hash" do
-          module AdditionalMethods
-            def custom_method(controller)
-              controller == 'StubController' ? 2 : 0
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          test_hash = {
-            key1: 1,
-            key2: :custom_method,
-            key3: ->(controller, model){ 3 }
-          }
-          expect(ActivityNotification.resolve_value(test_instance, test_hash)).to eq({ key1: 1, key2: 2, key3: 3 })
-        end
-      end
-    end
-  end
-
-  describe "as public instance methods" do
-    describe "#resolve_value" do
-      context "with value" do
-        it "returns specified value" do
-          expect(test_instance.resolve_value(1)).to eq(1)
-        end
-      end
-
-      context "with Symbol" do
-        it "returns specified symbol without arguments" do
-          module AdditionalMethods
-            def custom_method
-              1
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          expect(test_instance.resolve_value(:custom_method)).to eq(1)
-        end
-
-        it "returns specified symbol with additional arguments" do
-          module AdditionalMethods
-            def custom_method(key)
-              key == 'test1.key' ? 1 : 0
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          expect(test_instance.resolve_value(:custom_method, 'test1.key')).to eq(1)
-          expect(test_instance.resolve_value(:custom_method, 'test2.key')).to eq(0)
-        end
-
-        it "returns specified symbol with additional arguments including hash as last argument" do
-          module AdditionalMethods
-            def custom_method(key, options:)
-              key == 'test1.key' ? 1 : 0
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          expect(test_instance.resolve_value(:custom_method, 'test1.key', options: 1)).to eq(1)
-          expect(test_instance.resolve_value(:custom_method, 'test2.key', options: 1)).to eq(0)
-        end
-      end
-
-      context "with Proc" do
-        it "returns specified lambda with context(model) argument" do
-          test_proc = ->(model){ model == test_instance ? 1 : 0 }
-          expect(test_instance.resolve_value(test_proc)).to eq(1)
-        end
-
-        it "returns specified lambda with context(model) and additional arguments" do
-          test_proc = ->(model, key){ model == test_instance and key == 'test1.key' ? 1 : 0 }
-          expect(test_instance.resolve_value(test_proc, 'test1.key')).to eq(1)
-          expect(test_instance.resolve_value(test_proc, 'test2.key')).to eq(0)
-        end
-      end
-
-      context "with Hash" do
-        it "returns resolve_value for each entry of hash" do
-          module AdditionalMethods
-            def custom_method
-              2
-            end
-          end
-          test_instance.extend(AdditionalMethods)
-          test_hash = {
-            key1: 1,
-            key2: :custom_method,
-            key3: ->(model){ model == test_instance ? 3 : 0 }
-          }
-          expect(test_instance.resolve_value(test_hash)).to eq({ key1: 1, key2: 2, key3: 3 })
-        end
-      end
-    end
-
-    describe "#to_class_name" do
-      it "returns resource name" do
-        expect(create(:user).to_class_name).to eq 'User'
-        expect(test_instance.to_class_name).to eq test_instance.class.name
-      end
-    end
-
-    describe "#to_resource_name" do
-      it "returns singularized model name (resource name)" do
-        expect(create(:user).to_resource_name).to eq 'user'
-        expect(test_instance.to_resource_name).to eq test_instance.class.name.demodulize.singularize.underscore
-      end
-    end
-
-    describe "#to_resources_name" do
-      it "returns pluralized model name (resources name)" do
-        expect(create(:user).to_resources_name).to eq 'users'
-        expect(test_instance.to_resources_name).to eq test_instance.class.name.demodulize.pluralize.underscore
-      end
-    end
-
-    describe "#printable_type" do
-      it "returns printable model type name to be humanized" do
-        expect(create(:user).printable_type).to eq 'User'
-        expect(test_instance.printable_type).to eq test_instance.class.name.demodulize.humanize
-      end
-    end
-
-    describe "#printable_name" do
-      it "returns printable model name to show in view or email" do
-        user = create(:user)
-        expect(user.printable_name).to eq "User (#{user.id})"
-        expect(test_instance.printable_name).to eq "#{test_instance.printable_type} (#{test_instance.id})"
-      end
-    end
-  end
-
-end