activity_notification 1.3.0 → 1.4.0

data/lib/activity_notification/apis/notification_api.rb

@@ -125,11 +125,11 @@ module ActivityNotification
       }
 
       # Orders by latest (newest) first as created_at: :desc.
-      # @return [Mongoid::Criteria<Notificaion>] Database query of notifications ordered by latest first
+      # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of notifications ordered by latest first
       scope :latest_order,                      -> { order(created_at: :desc) }
 
       # Orders by earliest (older) first as created_at: :asc.
-      # @return [Mongoid::Criteria<Notificaion>] Database query of notifications ordered by earliest first
+      # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of notifications ordered by earliest first
       scope :earliest_order,                    -> { order(created_at: :asc) }
     end
 

data/lib/activity_notification/apis/subscription_api.rb

@@ -9,7 +9,7 @@ module ActivityNotification
       #   @subscriptions = @user.subscriptions.filtered_by_key('comment.reply')
       # @scope class
       # @param [String] key Key of the subscription for filter
-      # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of filtered subscriptions
+      # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of filtered subscriptions
       scope :filtered_by_key,     ->(key) { where(key: key) }
 
       # Selects filtered subscriptions by key with filter options.
@@ -21,7 +21,7 @@ module ActivityNotification
       # @param [Hash] options Options for filter
       # @option options [String]     :filtered_by_key        (nil) Key of the subscription for filter 
       # @option options [Array|Hash] :custom_filter          (nil) Custom subscription filter (e.g. ["created_at >= ?", time.hour.ago])
-      # @return [Mongoid::Criteria<Notificaion>] Database query of filtered subscriptions
+      # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of filtered subscriptions
       scope :filtered_by_options, ->(options = {}) {
         options = ActivityNotification.cast_to_indifferent_hash(options)
         filtered_subscriptions = all
@@ -35,23 +35,23 @@ module ActivityNotification
       }
 
       # Orders by latest (newest) first as created_at: :desc.
-      # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of subscriptions ordered by latest first
+      # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of subscriptions ordered by latest first
       scope :latest_order,              -> { order(created_at: :desc) }
 
       # Orders by earliest (older) first as created_at: :asc.
-      # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of subscriptions ordered by earliest first
+      # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of subscriptions ordered by earliest first
       scope :earliest_order,            -> { order(created_at: :asc) }
 
       # Orders by latest (newest) first as subscribed_at: :desc.
-      # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of subscriptions ordered by latest subscribed_at first
+      # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of subscriptions ordered by latest subscribed_at first
       scope :latest_subscribed_order,   -> { order(subscribed_at: :desc) }
 
       # Orders by earliest (older) first as subscribed_at: :asc.
-      # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of subscriptions ordered by earliest subscribed_at first
+      # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of subscriptions ordered by earliest subscribed_at first
       scope :earliest_subscribed_order, -> { order(subscribed_at: :asc) }
 
       # Orders by key name as key: :asc.
-      # @return [ActiveRecord_AssociationRelation<Subscription>] Database query of subscriptions ordered by key name
+      # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of subscriptions ordered by key name
       scope :key_order,                 -> { order(key: :asc) }
     end
 

data/lib/activity_notification/controllers/common_controller.rb

@@ -24,8 +24,8 @@ module ActivityNotification
         if (target_type = params[:target_type]).present?
           target_class = target_type.to_model_class
           @target = params[:target_id].present? ?
-            target_class.find_by_id!(params[:target_id]) : 
-            target_class.find_by_id!(params["#{target_type.to_resource_name}_id"])
+            target_class.find_by!(id: params[:target_id]) :
+            target_class.find_by!(id: params["#{target_type.to_resource_name}_id"])
         else
           render plain: "400 Bad Request: Missing parameter", status: 400
         end

data/lib/activity_notification/helpers/view_helpers.rb

@@ -58,7 +58,7 @@ module ActivityNotification
       notification_options = options.merge( target: target.to_resources_name,
                                             partial: options[:notification_partial],
                                             layout: options[:notification_layout] )
-      index_options = options.slice( :limit, :reverse, :with_group_members,
+      index_options = options.slice( :limit, :reverse, :with_group_members, :as_latest_group_member,
                                      :filtered_by_group, :filtered_by_group_type, :filtered_by_group_id,
                                      :filtered_by_type, :filtered_by_key, :custom_filter )
       notification_index = load_notification_index(target, options[:index_content], index_options)

data/lib/activity_notification/models/concerns/notifiable.rb

@@ -285,11 +285,29 @@ module ActivityNotification
     # This method is able to be overriden.
     # "#{to_resource_name}.default" is defined as default key.
     #
-    # @return [String] Default Key of the notification
+    # @return [String] Default key of the notification
     def default_notification_key
       "#{to_resource_name}.default"
     end
 
+    # Returns key of the notification for tracked notifiable creation.
+    # This method is able to be overriden.
+    # "#{to_resource_name}.create" is defined as default creation key.
+    #
+    # @return [String] Key of the notification for tracked notifiable creation
+    def notification_key_for_tracked_creation
+      "#{to_resource_name}.create"
+    end
+
+    # Returns key of the notification for tracked notifiable update.
+    # This method is able to be overriden.
+    # "#{to_resource_name}.update" is defined as default update key.
+    #
+    # @return [String] Key of the notification for tracked notifiable update
+    def notification_key_for_tracked_update
+      "#{to_resource_name}.update"
+    end
+
     private
 
       # Used to transform parameter value from configured field or defined method.

data/lib/activity_notification/models/concerns/target.rb

@@ -534,6 +534,7 @@ module ActivityNotification
       # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
       # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
       # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+      # @option options [Boolean]    :as_latest_group_member (false) If grouped notification will be shown as the latest group member (default is shown as the earliest member)
       # @option options [String]     :filtered_by_type       (nil)   Notifiable type for filter
       # @option options [Object]     :filtered_by_group      (nil)   Group instance for filter
       # @option options [String]     :filtered_by_group_type (nil)   Group type for filter, valid with :filtered_by_group_id
@@ -560,6 +561,7 @@ module ActivityNotification
       # @option options [Integer]    :limit                  (nil)   Limit to query for notifications
       # @option options [Boolean]    :reverse                (false) If notification index will be ordered as earliest first
       # @option options [Boolean]    :with_group_members     (false) If notification index will include group members
+      # @option options [Boolean]    :as_latest_group_member (false) If grouped notification will be shown as the latest group member (default is shown as the earliest member)
       # @option options [String]     :filtered_by_type       (nil)   Notifiable type for filter
       # @option options [Object]     :filtered_by_group      (nil)   Group instance for filter
       # @option options [String]     :filtered_by_group_type (nil)   Group type for filter, valid with :filtered_by_group_id
@@ -571,19 +573,19 @@ module ActivityNotification
         # When the target have unopened notifications
         if has_unopened_notifications?(options)
           # Return unopened notifications first
-          target_unopened_index = loading_unopened_index_method.call(options).to_a
+          target_unopened_index = arrange_single_notification_index(loading_unopened_index_method, options)
           # Total limit if notification index
           total_limit = options[:limit] || ActivityNotification.config.opened_index_limit
           # Additionaly, return opened notifications unless unopened index size overs the limit
           if (opened_limit = total_limit - target_unopened_index.size) > 0
-            target_opened_index = loading_opened_index_method.call(options.merge(limit: opened_limit))
+            target_opened_index = arrange_single_notification_index(loading_opened_index_method, options.merge(limit: opened_limit))
             target_unopened_index.concat(target_opened_index.to_a)
           else
             target_unopened_index
           end
         else
           # Otherwise, return opened notifications
-          loading_opened_index_method.call(options).to_a
+          arrange_single_notification_index(loading_opened_index_method, options)
         end
       end
 

data/lib/activity_notification/orm/active_record/notification.rb

@@ -175,7 +175,9 @@ module ActivityNotification
         # Selects unique keys from query for notifications.
         # @return [Array<String>] Array of notification unique keys
         def self.uniq_keys
-          select(:key).distinct.pluck(:key)
+          # select method cannot be chained with order by other columns like created_at
+          # select(:key).distinct.pluck(:key)
+          pluck(:key).uniq
         end
 
         protected

data/lib/activity_notification/orm/active_record/subscription.rb

@@ -43,7 +43,9 @@ module ActivityNotification
         # Selects unique keys from query for subscriptions.
         # @return [Array<String>] Array of subscription unique keys
         def self.uniq_keys
-          select(:key).distinct.pluck(:key)
+          # select method cannot be chained with order by other columns like created_at
+          # select(:key).distinct.pluck(:key)
+          pluck(:key).uniq
         end
 
       end

data/lib/activity_notification/orm/mongoid.rb

@@ -13,7 +13,7 @@ module ActivityNotification
       def belongs_to_polymorphic_xdb_record(name, _options = {})
         association_name     = name.to_s.singularize.underscore
         id_field, type_field = "#{association_name}_id", "#{association_name}_type"
-        field id_field,   type: Integer
+        field id_field,   type: String
         field type_field, type: String
 
         self.instance_eval do
@@ -22,7 +22,7 @@ module ActivityNotification
             if self.instance_variable_get("@#{name}").blank?
               if (class_name = self.send(type_field)).present?
                 object_class = class_name.classify.constantize
-                self.instance_variable_set("@#{name}", object_class.where(object_class.primary_key => self.send(id_field)).first)
+                self.instance_variable_set("@#{name}", object_class.where(id: self.send(id_field)).first)
               end
             end
             self.instance_variable_get("@#{name}")

data/lib/activity_notification/renderable.rb

@@ -152,7 +152,7 @@ module ActivityNotification
         context.render params.merge(partial: partial, layout: layout, locals: locals)
       rescue ActionView::MissingTemplate => e
         if params[:fallback] == :text
-          context.render text: self.text(params)
+          context.render plain: self.text(params)
         elsif params[:fallback].present?
           partial = partial_path(*params.values_at(:fallback, :partial_root, :target))
           context.render params.merge(partial: partial, layout: layout, locals: locals)

data/lib/activity_notification/roles/acts_as_notifiable.rb

@@ -105,6 +105,29 @@ module ActivityNotification
       #     end
       #   end
       #
+      # * :tracked
+      #   * Adds required callbacks to generate notifications for creation and update of the notifiable model.
+      #     Default callbacks are enabled for [:create, :update].
+      #     You can use :only and :except options as hash for this option.
+      # @example Add all callbacks to generate notifications for creation and update
+      #   # app/models/comment.rb
+      #   class Comment < ActiveRecord::Base
+      #     belongs_to :article
+      #     acts_as_notifiable :users, targets: User.all, tracked: true
+      #   end
+      # @example Add callbacks to generate notifications for creation only
+      #   # app/models/comment.rb
+      #   class Comment < ActiveRecord::Base
+      #     belongs_to :article
+      #     acts_as_notifiable :users, targets: User.all, tracked: { only: [:create] }
+      #   end
+      # @example Add callbacks to generate notifications for creation (except update) only
+      #   # app/models/comment.rb
+      #   class Comment < ActiveRecord::Base
+      #     belongs_to :article
+      #     acts_as_notifiable :users, targets: User.all, tracked: { except: [:update] }
+      #   end
+      #
       # * :printable_name or :printable_notifiable_name
       #   * Printable notifiable name.
       #     This parameter is a optional since `ActivityNotification::Common.printable_name` is used as default value.
@@ -168,26 +191,16 @@ module ActivityNotification
         include Notifiable
         configured_params = {}
 
-        if [:delete_all, :destroy, :restrict_with_error, :restrict_with_exception, :update_group_and_delete_all, :update_group_and_destroy].include? options[:dependent_notifications]
-          case options[:dependent_notifications]
-          when :delete_all, :destroy, :restrict_with_error, :restrict_with_exception
-            before_destroy -> { destroy_generated_notifications_with_dependency(options[:dependent_notifications], target_type) }
-          when :update_group_and_delete_all
-            before_destroy -> { destroy_generated_notifications_with_dependency(:delete_all, target_type, true) }
-          when :update_group_and_destroy
-            before_destroy -> { destroy_generated_notifications_with_dependency(:destroy, target_type, true) }
-          end
-          configured_params = { dependent_notifications: options[:dependent_notifications] }
+        if options[:tracked].present?
+          configured_params.update(add_tracked_callbacks(target_type, options[:tracked].is_a?(Hash) ? options[:tracked] : {}))
+        end
+
+        if available_dependent_notifications_options.include? options[:dependent_notifications]
+          configured_params.update(add_destroy_dependency(target_type, options[:dependent_notifications]))
         end
 
         if options[:optional_targets].is_a?(Hash)
-          options[:optional_targets] = options[:optional_targets].map { |target_class, target_options|
-            optional_target = target_class.new(target_options)
-            unless optional_target.kind_of?(ActivityNotification::OptionalTarget::Base)
-              raise TypeError, "#{optional_target.class.name} for an optional target is not a kind of ActivityNotification::OptionalTarget::Base"
-            end
-            optional_target
-          }
+          options[:optional_targets] = arrange_optional_targets_option(options[:optional_targets])
         end
 
         options[:printable_notifiable_name] ||= options.delete(:printable_name)
@@ -212,6 +225,74 @@ module ActivityNotification
         ].freeze
       end
 
+      # Returns array of available notifiable options in acts_as_notifiable.
+      # @return [Array<Symbol>] Array of available notifiable options
+      def available_dependent_notifications_options
+        [ :delete_all,
+          :destroy,
+          :restrict_with_error,
+          :restrict_with_exception,
+          :update_group_and_delete_all,
+          :update_group_and_destroy
+        ].freeze
+      end
+
+      # Adds tracked callbacks.
+      # @param [Symbol] target_type    Type of notification target as symbol
+      # @param [Hash]   tracked_option Specified :tracked option
+      # @return [Hash<Symbol, Symbol>] Configured tracked callbacks options
+      def add_tracked_callbacks(target_type, tracked_option = {})
+        tracked_callbacks = [:create, :update]
+        if tracked_option[:except]
+          tracked_callbacks -= tracked_option.delete(:except)
+        elsif tracked_option[:only]
+          tracked_callbacks &= tracked_option.delete(:only)
+        end
+        if tracked_callbacks.include? :create
+          if tracked_option.has_key?(:key)
+            after_create -> { notify target_type, tracked_option }
+          else
+            after_create -> { notify target_type, *tracked_option, key: notification_key_for_tracked_creation }
+          end
+        end
+        if tracked_callbacks.include? :update
+          if tracked_option.has_key?(:key)
+            after_update -> { notify target_type, tracked_option }
+          else
+            after_update -> { notify target_type, *tracked_option, key: notification_key_for_tracked_update }
+          end
+        end
+        { tracked: tracked_callbacks }
+      end
+
+      # Adds destroy dependency.
+      # @param [Symbol] target_type                    Type of notification target as symbol
+      # @param [Symbol] dependent_notifications_option Specified :dependent_notifications option
+      # @return [Hash<Symbol, Symbol>] Configured dependency options
+      def add_destroy_dependency(target_type, dependent_notifications_option)
+        case dependent_notifications_option
+        when :delete_all, :destroy, :restrict_with_error, :restrict_with_exception
+          before_destroy -> { destroy_generated_notifications_with_dependency(dependent_notifications_option, target_type) }
+        when :update_group_and_delete_all
+          before_destroy -> { destroy_generated_notifications_with_dependency(:delete_all, target_type, true) }
+        when :update_group_and_destroy
+          before_destroy -> { destroy_generated_notifications_with_dependency(:destroy, target_type, true) }
+        end
+        { dependent_notifications: dependent_notifications_option }
+      end
+
+      # Arrange optional targets option.
+      # @param [Symbol] optional_targets_option Specified :optional_targets option
+      # @return [Hash<ActivityNotification::OptionalTarget::Base, Hash>] Arranged optional targets options
+      def arrange_optional_targets_option(optional_targets_option)
+        optional_targets_option.map { |target_class, target_options|
+          optional_target = target_class.new(target_options)
+          unless optional_target.kind_of?(ActivityNotification::OptionalTarget::Base)
+            raise TypeError, "#{optional_target.class.name} for an optional target is not a kind of ActivityNotification::OptionalTarget::Base"
+          end
+          optional_target
+        }
+      end
     end
   end
 end

data/lib/activity_notification/version.rb

@@ -1,3 +1,3 @@
 module ActivityNotification
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

data/spec/concerns/apis/notification_api_spec.rb

@@ -313,10 +313,11 @@ shared_examples_for :notification_api do
 
           context "out of the group expiry period" do
             it "does not belong to single group" do
-              owner_notification    = described_class.notify_to(@user_1, @comment_1, group: @article, group_expiry_delay: 1.second)
-              member_notification_1 = described_class.notify_to(@user_1, @comment_2, group: @article, group_expiry_delay: 1.second)
-              sleep(1)
-              member_notification_2 = described_class.notify_to(@user_1, @comment_2, group: @article, group_expiry_delay: 1.second)
+              Timecop.travel(90.seconds.ago)
+              owner_notification    = described_class.notify_to(@user_1, @comment_1, group: @article, group_expiry_delay: 1.minute)
+              member_notification_1 = described_class.notify_to(@user_1, @comment_2, group: @article, group_expiry_delay: 1.minute)
+              Timecop.return
+              member_notification_2 = described_class.notify_to(@user_1, @comment_2, group: @article, group_expiry_delay: 1.minute)
               expect(member_notification_1.group_owner).to eq(owner_notification)
               expect(member_notification_2.group_owner).to be_nil
             end
@@ -568,7 +569,7 @@ shared_examples_for :notification_api do
       context "as default" do
         it "open notification with current time" do
           expect(test_instance.opened_at.blank?).to be_truthy
-          Timecop.freeze(Time.current)
+          Timecop.freeze(Time.at(Time.now.to_i))
           test_instance.open!
           expect(test_instance.opened_at.blank?).to be_falsey
           expect(test_instance.opened_at).to        eq(Time.current)
@@ -578,7 +579,7 @@ shared_examples_for :notification_api do
         it "open group member notifications with current time" do
           group_member = create(test_class_name, group_owner: test_instance)
           expect(group_member.opened_at.blank?).to be_truthy
-          Timecop.freeze(Time.current)
+          Timecop.freeze(Time.at(Time.now.to_i))
           test_instance.open!
           group_member = group_member.reload
           expect(group_member.opened_at.blank?).to be_falsey
@@ -593,7 +594,7 @@ shared_examples_for :notification_api do
           opened_at = Time.current - 1.months
           test_instance.open!(opened_at: opened_at)
           expect(test_instance.opened_at.blank?).to be_falsey
-          expect(test_instance.opened_at).to        eq(opened_at)
+          expect(test_instance.opened_at.to_i).to        eq(opened_at.to_i)
         end
 
         it "open group member notifications with specified time" do
@@ -1146,7 +1147,7 @@ shared_examples_for :notification_api do
       context "with group member" do
         it "returns latest group member" 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)
+          member2 = create(test_class_name, target: test_instance.target, group_owner: test_instance, created_at: member1.created_at + 10.second)
           expect(test_instance.latest_group_member.becomes(ActivityNotification::Notification)).to eq(member2)
         end
       end

data/spec/concerns/apis/subscription_api_spec.rb

@@ -37,12 +37,12 @@ shared_examples_for :subscription_api 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.current)
+          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)
+          expect(test_instance.subscribed_at).to                  eq(Time.current)
+          expect(test_instance.subscribed_to_email_at).to         eq(Time.current)
           Timecop.return
         end
       end
@@ -55,8 +55,8 @@ shared_examples_for :subscription_api do
           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                 eq(subscribed_at)
-          expect(test_instance.subscribed_to_email_at).to        eq(subscribed_at)
+          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
       end
 
@@ -102,12 +102,12 @@ shared_examples_for :subscription_api 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.current)
+          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)
+          expect(test_instance.unsubscribed_at).to                  eq(Time.current)
+          expect(test_instance.unsubscribed_to_email_at).to         eq(Time.current)
           Timecop.return
         end
       end
@@ -120,8 +120,8 @@ shared_examples_for :subscription_api do
           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                 eq(unsubscribed_at)
-          expect(test_instance.unsubscribed_to_email_at).to        eq(unsubscribed_at)
+          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
@@ -152,11 +152,11 @@ shared_examples_for :subscription_api 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.current)
+          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)
+          expect(test_instance.subscribed_to_email_at).to         eq(Time.current)
           Timecop.return
         end
       end
@@ -169,7 +169,7 @@ shared_examples_for :subscription_api do
           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        eq(subscribed_to_email_at)
+          expect(test_instance.subscribed_to_email_at.to_i).to    eq(subscribed_to_email_at.to_i)
         end
       end
     end
@@ -183,11 +183,11 @@ shared_examples_for :subscription_api 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.current)
+          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)
+          expect(test_instance.unsubscribed_to_email_at).to         eq(Time.current)
           Timecop.return
         end
       end
@@ -200,7 +200,7 @@ shared_examples_for :subscription_api do
           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        eq(unsubscribed_to_email_at)
+          expect(test_instance.unsubscribed_to_email_at.to_i).to    eq(unsubscribed_to_email_at.to_i)
         end
       end
     end
@@ -275,7 +275,7 @@ shared_examples_for :subscription_api 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)
+          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)
@@ -286,13 +286,13 @@ shared_examples_for :subscription_api do
 
       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)
+          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)
+          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
@@ -306,7 +306,7 @@ shared_examples_for :subscription_api 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)
+          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)
@@ -317,13 +317,13 @@ 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_optional_target?(:console_output)).to     eq(true)
+          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)
+          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