activity_notification 1.1.0 → 1.2.0

data/lib/activity_notification/version.rb

@@ -1,3 +1,3 @@
 module ActivityNotification
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/generators/activity_notification/views_generator.rb

@@ -14,7 +14,7 @@ module ActivityNotification
     # @example Run view generator to create only notification email views
     #   rails generate activity_notification:views -v mailer
     class ViewsGenerator < Rails::Generators::Base
-      VIEWS = [:notifications, :mailer, :subscriptions].freeze
+      VIEWS = [:notifications, :mailer, :subscriptions, :optional_targets].freeze
 
       source_root File.expand_path("../../../../app/views/activity_notification", __FILE__)
       desc "Copies default ActivityNotification views to your application."
@@ -22,7 +22,7 @@ module ActivityNotification
       argument :target, required: false, default: nil,
         desc: "The target to copy views to"
       class_option :views, aliases: "-v", type: :array,
-        desc: "Select specific view directories to generate (notifications, mailer, subscriptions)"
+        desc: "Select specific view directories to generate (notifications, mailer, subscriptions, optional_targets)"
       public_task :copy_views
 
       # Copies view files in application directory

data/lib/generators/templates/migrations/migration.rb

@@ -35,7 +35,7 @@ class <%= @migration_name %> < ActiveRecord::Migration
       t.datetime   :unsubscribed_at
       t.datetime   :subscribed_to_email_at
       t.datetime   :unsubscribed_to_email_at
-      t.text       :parameters
+      t.text       :optional_targets
 
       t.timestamps
     end
@@ -48,7 +48,7 @@ class <%= @migration_name %> < ActiveRecord::Migration
     #   t.datetime   :unsubscribed_at
     #   t.datetime   :subscribed_to_email_at
     #   t.datetime   :unsubscribed_to_email_at
-    #   t.text       :parameters
+    #   t.text       :optional_targets
     #
     #   t.timestamps
     # end

data/spec/concerns/apis/notification_api_spec.rb

@@ -2,6 +2,7 @@ shared_examples_for :notification_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) }
+  let(:notifiable_class) { test_instance.notifiable.class }
   before do
     ActiveJob::Base.queue_adapter = :test
     ActivityNotification::Mailer.deliveries.clear
@@ -513,6 +514,47 @@ shared_examples_for :notification_api do
       end
     end
 
+    describe "#publish_to_optional_targets" do
+      before do
+        require 'custom_optional_targets/console_output'
+        @optional_target = CustomOptionalTarget::ConsoleOutput.new
+        notifiable_class.acts_as_notifiable test_instance.target.to_resources_name.to_sym, optional_targets: ->{ [@optional_target] }
+        expect(test_instance.notifiable.optional_targets(test_instance.target.to_resources_name, test_instance.key)).to eq([@optional_target])
+      end
+
+      context "subscribed by target" do
+        before do
+          test_instance.target.create_subscription(key: test_instance.key, optional_targets: { subscribing_to_console_output: true })
+          expect(test_instance.optional_target_subscribed?(:console_output)).to be_truthy
+        end
+
+        it "calls OptionalTarget#notify" do
+          expect(@optional_target).to receive(:notify)
+          test_instance.publish_to_optional_targets
+        end
+
+        it "returns truthy result hash" do
+          expect(test_instance.publish_to_optional_targets).to eq({ console_output: true })
+        end
+      end
+
+      context "unsubscribed by target" do
+        before do
+          test_instance.target.create_subscription(key: test_instance.key, optional_targets: { subscribing_to_console_output: false })
+          expect(test_instance.optional_target_subscribed?(:console_output)).to be_falsey
+        end
+
+        it "does not call OptionalTarget#notify" do
+          expect(@optional_target).not_to receive(:notify)
+          test_instance.publish_to_optional_targets
+        end
+
+        it "returns truthy result hash" do
+          expect(test_instance.publish_to_optional_targets).to eq({ console_output: false })
+        end
+      end
+    end
+
     describe "#open!" do
       before do
         described_class.delete_all
@@ -1104,6 +1146,30 @@ shared_examples_for :notification_api do
       end
     end
 
+    describe "#remove_from_group" do
+      before do
+        @member1 = create(test_class_name, target: test_instance.target, group_owner: test_instance)
+        @member2 = create(test_class_name, target: test_instance.target, group_owner: test_instance)
+        expect(test_instance.group_member_count).to eq(2)
+        expect(@member1.group_owner?).to            be_falsey
+      end
+
+      it "removes from notification group" do
+        test_instance.remove_from_group
+        expect(test_instance.group_member_count).to eq(0)
+      end
+
+      it "makes a new group owner" do
+        test_instance.remove_from_group
+        expect(@member1.reload.group_owner?).to     be_truthy
+        expect(@member1.group_members).to           eq([@member2])
+      end
+
+      it "returns new group owner instance" do
+        expect(test_instance.remove_from_group).to eq(@member1)
+      end
+    end
+
     describe "#notifiable_path" do
       it "returns notifiable.notifiable_path" do
         expect(test_instance.notifiable_path)
@@ -1124,6 +1190,37 @@ shared_examples_for :notification_api do
           .to eq(test_instance.target.subscribes_to_notification_email?(test_instance.key))
       end
     end
+
+    describe "#optional_target_subscribed?" do
+      it "returns target.subscribes_to_optional_target?" do
+        test_instance.target.create_subscription(key: test_instance.key, optional_targets: { subscribing_to_console_output: false })
+        expect(test_instance.optional_target_subscribed?(:console_output)).to be_falsey
+        expect(test_instance.optional_target_subscribed?(:console_output))
+          .to eq(test_instance.target.subscribes_to_optional_target?(test_instance.key, :console_output))
+      end
+    end
+
+    describe "#optional_targets" do
+      it "returns notifiable.optional_targets" do
+        require 'custom_optional_targets/console_output'
+        @optional_target = CustomOptionalTarget::ConsoleOutput.new
+        notifiable_class.acts_as_notifiable test_instance.target.to_resources_name.to_sym, optional_targets: ->{ [@optional_target] }
+        expect(test_instance.optional_targets).to eq([@optional_target])
+        expect(test_instance.optional_targets)
+          .to eq(test_instance.notifiable.optional_targets(test_instance.target.to_resources_name, test_instance.key))
+      end
+    end
+
+    describe "#optional_target_names" do
+      it "returns notifiable.optional_target_names" do
+        require 'custom_optional_targets/console_output'
+        @optional_target = CustomOptionalTarget::ConsoleOutput.new
+        notifiable_class.acts_as_notifiable test_instance.target.to_resources_name.to_sym, optional_targets: ->{ [@optional_target] }
+        expect(test_instance.optional_target_names).to eq([:console_output])
+        expect(test_instance.optional_target_names)
+          .to eq(test_instance.notifiable.optional_target_names(test_instance.target.to_resources_name, test_instance.key))
+      end
+    end
   end
 
   describe "as protected instance methods" do

data/spec/concerns/apis/subscription_api_spec.rb

@@ -3,6 +3,26 @@ shared_examples_for :subscription_api do
   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
@@ -15,12 +35,12 @@ shared_examples_for :subscription_api do
 
       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)
+          expect(test_instance.subscribing?).to                   eq(false)
+          expect(test_instance.subscribing_to_email?).to          eq(false)
           Timecop.freeze(Time.current)
           test_instance.subscribe
-          expect(test_instance.subscribing).to                   eq(true)
-          expect(test_instance.subscribing_to_email).to          eq(true)
+          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
@@ -29,12 +49,12 @@ shared_examples_for :subscription_api do
 
       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)
+          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.subscribing?).to                   eq(true)
+          expect(test_instance.subscribing_to_email?).to          eq(true)
           expect(test_instance.subscribed_at).to                 eq(subscribed_at)
           expect(test_instance.subscribed_to_email_at).to        eq(subscribed_at)
         end
@@ -42,11 +62,33 @@ shared_examples_for :subscription_api do
 
       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)
+          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)
+          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
+      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
@@ -58,12 +100,12 @@ shared_examples_for :subscription_api do
 
       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)
+          expect(test_instance.subscribing?).to                     eq(true)
+          expect(test_instance.subscribing_to_email?).to            eq(true)
           Timecop.freeze(Time.current)
           test_instance.unsubscribe
-          expect(test_instance.subscribing).to                     eq(false)
-          expect(test_instance.subscribing_to_email).to            eq(false)
+          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
@@ -72,12 +114,12 @@ shared_examples_for :subscription_api do
 
       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)
+          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.subscribing?).to                     eq(false)
+          expect(test_instance.subscribing_to_email?).to            eq(false)
           expect(test_instance.unsubscribed_at).to                 eq(unsubscribed_at)
           expect(test_instance.unsubscribed_to_email_at).to        eq(unsubscribed_at)
         end
@@ -91,29 +133,29 @@ shared_examples_for :subscription_api do
 
       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.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 successfully updated subscription 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.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)
+          expect(test_instance.subscribing?).to                   eq(true)
+          expect(test_instance.subscribing_to_email?).to          eq(false)
           Timecop.freeze(Time.current)
           test_instance.subscribe_to_email
-          expect(test_instance.subscribing).to                   eq(true)
-          expect(test_instance.subscribing_to_email).to          eq(true)
+          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
@@ -121,12 +163,12 @@ shared_examples_for :subscription_api do
 
       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)
+          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.subscribing?).to                   eq(true)
+          expect(test_instance.subscribing_to_email?).to          eq(true)
           expect(test_instance.subscribed_to_email_at).to        eq(subscribed_to_email_at)
         end
       end
@@ -139,12 +181,12 @@ shared_examples_for :subscription_api do
 
       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)
+          expect(test_instance.subscribing?).to                     eq(true)
+          expect(test_instance.subscribing_to_email?).to            eq(true)
           Timecop.freeze(Time.current)
           test_instance.unsubscribe_to_email
-          expect(test_instance.subscribing).to                     eq(true)
-          expect(test_instance.subscribing_to_email).to            eq(false)
+          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
@@ -152,16 +194,139 @@ shared_examples_for :subscription_api do
 
       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)
+          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.subscribing?).to                     eq(true)
+          expect(test_instance.subscribing_to_email?).to            eq(false)
           expect(test_instance.unsubscribed_to_email_at).to        eq(unsubscribed_to_email_at)
         end
       end
     end
 
+    describe "#subscribing_to_optional_target?" do
+      before do
+        test_instance.update(optional_targets: {})
+      end
+
+      context "without configured optional target subscpriotion" 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
+          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
+          end
+        end
+      end
+
+      context "with configured subscpriotion" 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.current)
+          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(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   eq(subscribed_at)
+        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.current)
+          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(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 eq(unsubscribed_at)
+        end
+      end
+    end
+
   end
 end