mongoid-history 0.6.1 → 0.8.0

data/lib/mongoid/history/trackable.rb

@@ -7,14 +7,16 @@ module Mongoid
         def track_history(options = {})
           extend EmbeddedMethods
 
-          options_parser = Mongoid::History::Options.new(self)
-          options = options_parser.parse(options)
+          history_options = Mongoid::History::Options.new(self, options)
 
-          field options[:version_field].to_sym, type: Integer
+          field history_options.options[:version_field].to_sym, type: Integer
 
-          belongs_to_modifier_options = { class_name: Mongoid::History.modifier_class_name }
-          belongs_to_modifier_options[:inverse_of] = options[:modifier_field_inverse_of] if options.key?(:modifier_field_inverse_of)
-          belongs_to options[:modifier_field].to_sym, belongs_to_modifier_options
+          unless history_options.options[:modifier_field].nil?
+            belongs_to_modifier_options = { class_name: Mongoid::History.modifier_class_name }
+            belongs_to_modifier_options[:inverse_of] = history_options.options[:modifier_field_inverse_of] if history_options.options.key?(:modifier_field_inverse_of)
+            belongs_to_modifier_options[:optional] = true if history_options.options[:modifier_field_optional] && Mongoid::Compatibility::Version.mongoid6_or_newer?
+            belongs_to history_options.options[:modifier_field].to_sym, belongs_to_modifier_options
+          end
 
           include MyInstanceMethods
           extend SingletonMethods
@@ -22,12 +24,13 @@ module Mongoid
           delegate :history_trackable_options, to: 'self.class'
           delegate :track_history?, to: 'self.class'
 
-          before_update :track_update if options[:track_update]
-          before_create :track_create if options[:track_create]
-          before_destroy :track_destroy if options[:track_destroy]
+          callback_options = history_options.options.slice(:if, :unless)
+          around_update :track_update, callback_options if history_options.options[:track_update]
+          around_create :track_create, callback_options if history_options.options[:track_create]
+          around_destroy :track_destroy, callback_options if history_options.options[:track_destroy]
 
           Mongoid::History.trackable_class_options ||= {}
-          Mongoid::History.trackable_class_options[options_parser.scope] = options
+          Mongoid::History.trackable_class_options[history_options.scope] = history_options
         end
 
         def history_settings(options = {})
@@ -131,7 +134,7 @@ module Mongoid
             elsif options[:last]
               versions = history_tracks.limit(options[:last])
             else
-              fail 'Invalid options, please specify (:from / :to) keys or :last key.'
+              raise 'Invalid options, please specify (:from / :to) keys or :last key.'
             end
           else
             options_or_version = options_or_version.to_a if options_or_version.is_a?(Range)
@@ -178,7 +181,7 @@ module Mongoid
                 relation.class_name == node.metadata.class_name.to_s && relation.name == node.metadata.name
               else
                 relation.class_name == node.relation_metadata.class_name.to_s &&
-                relation.name == node.relation_metadata.name
+                  relation.name == node.relation_metadata.name
               end
             end
           end
@@ -219,11 +222,12 @@ module Mongoid
         def history_tracker_attributes(action)
           return @history_tracker_attributes if @history_tracker_attributes
 
+          modifier_field = history_trackable_options[:modifier_field]
           @history_tracker_attributes = {
             association_chain: traverse_association_chain,
-            scope: related_scope,
-            modifier: send(history_trackable_options[:modifier_field])
+            scope: related_scope
           }
+          @history_tracker_attributes[:modifier] = send(modifier_field) if modifier_field
 
           original, modified = transform_changes(modified_attributes_for_action(action))
 
@@ -232,16 +236,16 @@ module Mongoid
           @history_tracker_attributes
         end
 
-        def track_create
-          track_history_for_action(:create)
+        def track_create(&block)
+          track_history_for_action(:create, &block)
         end
 
-        def track_update
-          track_history_for_action(:update)
+        def track_update(&block)
+          track_history_for_action(:update, &block)
         end
 
-        def track_destroy
-          track_history_for_action(:destroy) unless destroyed?
+        def track_destroy(&block)
+          track_history_for_action(:destroy, &block) unless destroyed?
         end
 
         def clear_trackable_memoization
@@ -273,9 +277,20 @@ module Mongoid
           if track_history_for_action?(action)
             current_version = (send(history_trackable_options[:version_field]) || 0) + 1
             send("#{history_trackable_options[:version_field]}=", current_version)
-            self.class.tracker_class.create!(history_tracker_attributes(action.to_sym).merge(version: current_version, action: action.to_s, trackable: self))
+            last_track = self.class.tracker_class.create!(history_tracker_attributes(action.to_sym).merge(version: current_version, action: action.to_s, trackable: self))
           end
+
           clear_trackable_memoization
+
+          begin
+            yield
+          rescue => e
+            if track_history_for_action?(action)
+              send("#{history_trackable_options[:version_field]}=", current_version - 1)
+              last_track.destroy
+            end
+            raise e
+          end
         end
       end
 
@@ -414,7 +429,12 @@ module Mongoid
         #
         # @return [ Array < String > ] the list of reserved database field names
         def reserved_tracked_fields
-          @reserved_tracked_fields ||= ['_id', history_trackable_options[:version_field].to_s, "#{history_trackable_options[:modifier_field]}_id"]
+          @reserved_tracked_fields ||= begin
+                                         fields = ['_id', history_trackable_options[:version_field].to_s]
+                                         modifier_field = history_trackable_options[:modifier_field]
+                                         fields << "#{modifier_field}_id" if modifier_field
+                                         fields
+                                       end
         end
 
         def field_formats
@@ -445,8 +465,8 @@ module Mongoid
         def tracked_embeds_one
           @tracked_embeds_one ||= begin
             reflect_on_all_associations(:embeds_one)
-            .map(&:key)
-            .select { |rel| history_trackable_options[:relations][:embeds_one].include? rel }
+              .map(&:key)
+              .select { |rel| history_trackable_options[:relations][:embeds_one].include? rel }
           end
         end
 
@@ -469,8 +489,8 @@ module Mongoid
         def tracked_embeds_many
           @tracked_embeds_many ||= begin
             reflect_on_all_associations(:embeds_many)
-            .map(&:key)
-            .select { |rel| history_trackable_options[:relations][:embeds_many].include? rel }
+              .map(&:key)
+              .select { |rel| history_trackable_options[:relations][:embeds_many].include? rel }
           end
         end
 
@@ -483,7 +503,7 @@ module Mongoid
         end
 
         def history_trackable_options
-          @history_trackable_options ||= Mongoid::History.trackable_class_options[trackable_scope]
+          @history_trackable_options ||= Mongoid::History.trackable_class_options[trackable_scope].prepared
         end
 
         def clear_trackable_memoization

data/lib/mongoid/history/tracker.rb

@@ -14,12 +14,16 @@ module Mongoid
         field :version,                 type: Integer
         field :action,                  type: String
         field :scope,                   type: String
-        belongs_to :modifier, class_name: Mongoid::History.modifier_class_name
+        modifier_options = {
+          class_name: Mongoid::History.modifier_class_name
+        }
+        modifier_options[:optional] = true if Mongoid::Compatibility::Version.mongoid6_or_newer?
+        belongs_to :modifier, modifier_options
 
         index(scope: 1)
         index(association_chain: 1)
 
-        Mongoid::History.tracker_class_name = name.tableize.singularize.to_sym
+        Mongoid::History.tracker_class_name ||= name.tableize.singularize.to_sym
       end
 
       def undo!(modifier = nil)
@@ -50,7 +54,7 @@ module Mongoid
         undo_hash = affected.easy_unmerge(modified)
         undo_hash.easy_merge!(original)
         modifier_field = trackable.history_trackable_options[:modifier_field]
-        undo_hash[modifier_field] = modifier
+        undo_hash[modifier_field] = modifier if modifier_field
         (modified.keys - undo_hash.keys).each do |k|
           undo_hash[k] = nil
         end
@@ -61,7 +65,7 @@ module Mongoid
         redo_hash = affected.easy_unmerge(original)
         redo_hash.easy_merge!(modified)
         modifier_field = trackable.history_trackable_options[:modifier_field]
-        redo_hash[modifier_field] = modifier
+        redo_hash[modifier_field] = modifier if modifier_field
         localize_keys(redo_hash)
       end
 
@@ -180,7 +184,7 @@ module Mongoid
         elsif trackable_parent.class.embeds_many?(name)
           trackable_parent.get_embedded(name).create!(localize_keys(original))
         else
-          fail 'This should never happen. Please report bug!'
+          raise 'This should never happen. Please report bug!'
         end
       end
 
@@ -205,7 +209,7 @@ module Mongoid
                 elsif doc.class.embeds_many?(name)
                   doc.get_embedded(name).unscoped.where(_id: node['id']).first
                 else
-                  fail 'This should never happen. Please report bug.'
+                  raise 'This should never happen. Please report bug.'
                 end
           documents << doc
           break if chain.empty?
@@ -215,9 +219,11 @@ module Mongoid
 
       def localize_keys(hash)
         klass = association_chain.first['name'].constantize
-        klass.localized_fields.keys.each do |name|
-          hash["#{name}_translations"] = hash.delete(name) if hash[name].present?
-        end if klass.respond_to?(:localized_fields)
+        if klass.respond_to?(:localized_fields)
+          klass.localized_fields.keys.each do |name|
+            hash["#{name}_translations"] = hash.delete(name) if hash[name].present?
+          end
+        end
         hash
       end
 

data/lib/mongoid/history/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module History
-    VERSION = '0.6.1'
+    VERSION = '0.8.0'.freeze
   end
 end

data/lib/mongoid/history.rb

@@ -11,7 +11,7 @@ require 'mongoid/history/trackable'
 
 module Mongoid
   module History
-    GLOBAL_TRACK_HISTORY_FLAG = 'mongoid_history_trackable_enabled'
+    GLOBAL_TRACK_HISTORY_FLAG = 'mongoid_history_trackable_enabled'.freeze
 
     class << self
       attr_accessor :tracker_class_name

data/mongoid-history.gemspec

@@ -20,6 +20,6 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency 'easy_diff'
   s.add_runtime_dependency 'mongoid', '>= 3.0'
-  s.add_runtime_dependency 'mongoid-compatibility'
+  s.add_runtime_dependency 'mongoid-compatibility', '>= 0.5.1'
   s.add_runtime_dependency 'activesupport'
 end

data/spec/integration/embedded_in_polymorphic_spec.rb

@@ -68,7 +68,7 @@ describe Mongoid::History::Tracker do
                     track_create: true, # track document creation, default is false
                     track_update: true, # track document updates, default is true
                     track_destroy: false, # track document destruction, default is false
-                    scope: [:real_state, :company]
+                    scope: %i[real_state company]
     end
 
     class User

data/spec/integration/integration_spec.rb

@@ -18,7 +18,7 @@ describe Mongoid::History do
 
       accepts_nested_attributes_for :tags, allow_destroy: true
 
-      track_history on: [:title, :body], track_destroy: true
+      track_history on: %i[title body], track_destroy: true
     end
 
     class Comment
@@ -29,7 +29,7 @@ describe Mongoid::History do
       field :t, as: :title
       field :body
       embedded_in :commentable, polymorphic: true
-      track_history on: [:title, :body], scope: :post, track_create: true, track_destroy: true
+      track_history on: %i[title body], scope: :post, track_create: true, track_destroy: true
     end
 
     class Section
@@ -54,7 +54,7 @@ describe Mongoid::History do
       field :city
       field :country
       field :aliases, type: Array
-      track_history except: [:email, :updated_at]
+      track_history except: %i[email updated_at]
     end
 
     class Tag
@@ -122,6 +122,7 @@ describe Mongoid::History do
 
     describe 'on destruction' do
       it 'should have two history track records in post' do
+        post # This will create history track records for creation
         expect do
           post.destroy
         end.to change(Tracker, :count).by(1)
@@ -147,12 +148,14 @@ describe Mongoid::History do
 
     describe 'on update non-embedded' do
       it 'should create a history track if changed attributes match tracked attributes' do
+        post # This will create history track records for creation
         expect do
           post.update_attributes(title: 'Another Test')
         end.to change(Tracker, :count).by(1)
       end
 
       it 'should not create a history track if changed attributes do not match tracked attributes' do
+        post # This will create history track records for creation
         expect do
           post.update_attributes(rating: 'untracked')
         end.to change(Tracker, :count).by(0)
@@ -188,8 +191,9 @@ describe Mongoid::History do
       end
 
       it 'should assign version on post' do
+        expect(post.version).to eq(1) # Created
         post.update_attributes(title: 'Another Test')
-        expect(post.version).to eq(1)
+        expect(post.version).to eq(2) # Updated
       end
 
       it 'should assign scope' do
@@ -205,16 +209,16 @@ describe Mongoid::History do
       it 'should exclude defined options' do
         name = user.name
         user.update_attributes(name: 'Aaron2', email: 'aaronsnewemail@randomemail.com')
-        expect(user.history_tracks.first.original.keys).to eq(['n'])
-        expect(user.history_tracks.first.original['n']).to eq(name)
-        expect(user.history_tracks.first.modified.keys).to eq(['n'])
-        expect(user.history_tracks.first.modified['n']).to eq(user.name)
+        expect(user.history_tracks.last.original.keys).to eq(['n'])
+        expect(user.history_tracks.last.original['n']).to eq(name)
+        expect(user.history_tracks.last.modified.keys).to eq(['n'])
+        expect(user.history_tracks.last.modified['n']).to eq(user.name)
       end
 
       it 'should undo field changes' do
         name = user.name
         user.update_attributes(name: 'Aaron2', email: 'aaronsnewemail@randomemail.com')
-        user.history_tracks.first.undo! nil
+        user.history_tracks.last.undo! nil
         expect(user.reload.name).to eq(name)
       end
 
@@ -223,21 +227,21 @@ describe Mongoid::History do
         expect(post.reload.title).to be_nil
         post.update_attributes(title: 'Aaron2')
         expect(post.reload.title).to eq('Aaron2')
-        post.history_tracks.first.undo! nil
+        post.history_tracks.last.undo! nil
         expect(post.reload.title).to be_nil
       end
 
       it 'should track array changes' do
         aliases = user.aliases
-        user.update_attributes(aliases: %w(bob joe))
-        expect(user.history_tracks.first.original['aliases']).to eq(aliases)
-        expect(user.history_tracks.first.modified['aliases']).to eq(user.aliases)
+        user.update_attributes(aliases: %w[bob joe])
+        expect(user.history_tracks.last.original['aliases']).to eq(aliases)
+        expect(user.history_tracks.last.modified['aliases']).to eq(user.aliases)
       end
 
       it 'should undo array changes' do
         aliases = user.aliases
-        user.update_attributes(aliases: %w(bob joe))
-        user.history_tracks.first.undo! nil
+        user.update_attributes(aliases: %w[bob joe])
+        user.history_tracks.last.undo! nil
         expect(user.reload.aliases).to eq(aliases)
       end
     end
@@ -259,7 +263,7 @@ describe Mongoid::History do
         end
       end
       context 'update action' do
-        subject { user.history_tracks.first.tracked_changes }
+        subject { user.history_tracks.last.tracked_changes }
         before do
           user.update_attributes(name: 'Aaron2', email: nil, country: '',  city: nil, phone: '867-5309', aliases: ['', 'bill', 'james'])
         end
@@ -305,7 +309,7 @@ describe Mongoid::History do
         end
       end
       context 'update action' do
-        subject { user.history_tracks.first.tracked_edits }
+        subject { user.history_tracks.last.tracked_edits }
         before do
           user.update_attributes(name: 'Aaron2', email: nil, country: '', city: nil, phone: '867-5309', aliases: ['', 'bill', 'james'])
         end
@@ -323,12 +327,12 @@ describe Mongoid::History do
           expect(subject[:array]).to eq({ aliases: { remove: ['bob'], add: ['', 'bill', 'james'] } }.with_indifferent_access)
         end
         it 'should not track unmodified field' do
-          %w(add modify remove array).each do |edit|
+          %w[add modify remove array].each do |edit|
             expect(subject[edit][:address]).to be_nil
           end
         end
         it 'should not track untracked fields' do
-          %w(add modify remove array).each do |edit|
+          %w[add modify remove array].each do |edit|
             expect(subject[edit][:email]).to be_nil
           end
         end
@@ -348,12 +352,14 @@ describe Mongoid::History do
 
     describe 'on update non-embedded twice' do
       it 'should assign version on post' do
+        expect(post.version).to eq(1)
         post.update_attributes(title: 'Test2')
         post.update_attributes(title: 'Test3')
-        expect(post.version).to eq(2)
+        expect(post.version).to eq(3)
       end
 
       it 'should create a history track if changed attributes match tracked attributes' do
+        post # Created
         expect do
           post.update_attributes(title: 'Test2')
           post.update_attributes(title: 'Test3')
@@ -369,7 +375,7 @@ describe Mongoid::History do
       it 'should assign modified fields' do
         post.update_attributes(title: 'Test2')
         post.update_attributes(title: 'Test3')
-        expect(post.history_tracks.where(version: 2).first.modified).to eq(
+        expect(post.history_tracks.where(version: 3).first.modified).to eq(
           'title' => 'Test3'
         )
       end
@@ -377,7 +383,7 @@ describe Mongoid::History do
       it 'should assign original fields' do
         post.update_attributes(title: 'Test2')
         post.update_attributes(title: 'Test3')
-        expect(post.history_tracks.where(version: 2).first.original).to eq(
+        expect(post.history_tracks.where(version: 3).first.original).to eq(
           'title' => 'Test2'
         )
       end
@@ -504,7 +510,7 @@ describe Mongoid::History do
       it 'should be possible to create with redo after undo create embedded from parent' do
         comment # initialize
         post.comments.create!(title: 'The second one')
-        track = post.history_tracks.last
+        track = post.history_tracks[2]
         track.undo!(user)
         track.redo!(user)
         post.reload
@@ -552,14 +558,14 @@ describe Mongoid::History do
     describe 'non-embedded' do
       it 'should undo changes' do
         post.update_attributes(title: 'Test2')
-        post.history_tracks.where(version: 1).last.undo!(user)
+        post.history_tracks.where(version: 2).last.undo!(user)
         post.reload
         expect(post.title).to eq('Test')
       end
 
       it 'should undo destruction' do
         post.destroy
-        post.history_tracks.where(version: 1).last.undo!(user)
+        post.history_tracks.where(version: 2).last.undo!(user)
         expect(Post.find(post.id).title).to eq('Test')
       end
 
@@ -568,12 +574,12 @@ describe Mongoid::History do
         post.update_attributes(title: 'Test2')
         post.history_tracks.last.undo!(user)
         post.reload
-        expect(post.history_tracks.count).to eq(3)
+        expect(post.history_tracks.count).to eq(4)
       end
 
       it 'should assign user as the modifier of the newly created history track' do
         post.update_attributes(title: 'Test2')
-        post.history_tracks.where(version: 1).last.undo!(user)
+        post.history_tracks.where(version: 2).last.undo!(user)
         post.reload
         expect(post.history_tracks.where(version: 2).last.modifier).to eq(user)
       end
@@ -590,7 +596,7 @@ describe Mongoid::History do
 
       it 'should be destroyed after undo and redo' do
         post.destroy
-        track = post.history_tracks.where(version: 1).last
+        track = post.history_tracks.where(version: 2).last
         track.undo!(user)
         track.redo!(user)
         expect(Post.where(_id: post.id).first).to be_nil
@@ -639,7 +645,7 @@ describe Mongoid::History do
       describe 'undo' do
         { 'undo' => [nil], 'undo!' => [nil, :reload] }.each do |test_method, methods|
           methods.each do |method|
-            context "#{method || 'instance'}" do
+            context (method || 'instance').to_s do
               it 'recognizes :from, :to options' do
                 comment.send test_method, user, from: 4, to: 2
                 comment.send(method) if method
@@ -694,7 +700,7 @@ describe Mongoid::History do
 
       describe 'redo' do
         [nil, :reload].each do |method|
-          context "#{method || 'instance'}" do
+          context (method || 'instance').to_s do
             before :each do
               comment.update_attributes(title: 'Test5')
             end
@@ -919,7 +925,7 @@ describe Mongoid::History do
           track_history on: [:foo], changes_method: :my_changes
 
           def my_changes
-            { foo: %w(bar baz) }
+            { foo: %w[bar baz] }
           end
         end
       end

data/spec/integration/multi_relation_spec.rb

@@ -10,7 +10,7 @@ describe Mongoid::History::Tracker do
       belongs_to :user, inverse_of: :models
       has_and_belongs_to_many :external_users, class_name: 'User', inverse_of: :external_models
 
-      track_history on: [:name, :user, :external_user_ids], # track title and body fields only, default is :all
+      track_history on: %i[name user external_user_ids], # track title and body fields only, default is :all
                     modifier_field: :modifier, # adds "referenced_in :modifier" to track who made the change, default is :modifier
                     modifier_field_inverse_of: nil, # no inverse modifier relationship
                     version_field: :version, # adds "field :version, :type => Integer" to track current version, default is :version

data/spec/integration/multiple_trackers_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Mongoid::History do
+  before :all do
+    Mongoid::History.tracker_class_name = nil
+
+    module MultipleTrackersSpec
+      class First
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        field :text, type: String
+        track_history on: [:text],
+                      track_create: true,
+                      track_update: true,
+                      track_destroy: true,
+                      tracker_class_name: :first_history_tracker
+      end
+
+      class Second
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        field :text, type: String
+        track_history on: [:text],
+                      track_create: true,
+                      track_update: true,
+                      track_destroy: true,
+                      tracker_class_name: :second_history_tracker
+      end
+    end
+
+    class FirstHistoryTracker
+      include Mongoid::History::Tracker
+    end
+
+    class SecondHistoryTracker
+      include Mongoid::History::Tracker
+    end
+  end
+
+  it 'should be possible to have different trackers for each class' do
+    expect(FirstHistoryTracker.count).to eq(0)
+    expect(SecondHistoryTracker.count).to eq(0)
+    expect(MultipleTrackersSpec::First.tracker_class).to be FirstHistoryTracker
+    expect(MultipleTrackersSpec::Second.tracker_class).to be SecondHistoryTracker
+
+    foo = MultipleTrackersSpec::First.new
+    foo.save
+
+    bar = MultipleTrackersSpec::Second.new
+    bar.save
+
+    expect(FirstHistoryTracker.count).to eq 1
+    expect(SecondHistoryTracker.count).to eq 1
+
+    foo.text = "I'm foo"
+    foo.save
+    bar.text = "I'm bar"
+    bar.save
+
+    expect(FirstHistoryTracker.count).to eq 2
+    expect(SecondHistoryTracker.count).to eq 2
+
+    foo.destroy
+    bar.destroy
+
+    expect(FirstHistoryTracker.count).to eq 3
+    expect(SecondHistoryTracker.count).to eq 3
+  end
+end

data/spec/integration/nested_embedded_polymorphic_documents_spec.rb

@@ -48,7 +48,7 @@ describe Mongoid::History::Tracker do
                     track_create: true,
                     track_update: true,
                     track_destroy: true,
-                    scope: [:modelone, :modeltwo]
+                    scope: %i[modelone modeltwo]
     end
 
     class EmbeddedTwo
@@ -64,7 +64,7 @@ describe Mongoid::History::Tracker do
                     track_create: true,
                     track_update: true,
                     track_destroy: true,
-                    scope: [:modelone, :modeltwo]
+                    scope: %i[modelone modeltwo]
     end
 
     class User

data/spec/integration/track_history_order_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Mongoid::History::Tracker do
+  it 'should not track fields when track_history not called' do
+    class NotModel
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+
+      field :foo
+    end
+
+    expect(NotModel.respond_to?(:tracked?)).to be false
+  end
+
+  it 'should track fields when track_history called inside class and before fields' do
+    class InsideBeforeModel
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+
+      track_history on: :fields
+
+      field :foo
+    end
+
+    expect(InsideBeforeModel.tracked?(:foo)).to be true
+  end
+
+  it 'should track fields when track_history called inside class and after fields' do
+    class InsideAfterModel
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+
+      field :foo
+
+      track_history on: :fields
+    end
+
+    expect(InsideAfterModel.tracked?(:foo)).to be true
+  end
+
+  it 'should track fields when track_history called outside class' do
+    class OutsideModel
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+
+      field :foo
+    end
+
+    OutsideModel.track_history on: :fields
+    expect(OutsideModel.tracked?(:foo)).to be true
+  end
+end