mongoid-history 0.8.0 → 0.8.1

data/spec/unit/trackable_spec.rb

@@ -1,22 +1,38 @@
 require 'spec_helper'
 
-class MyModel
-  include Mongoid::Document
-  include Mongoid::History::Trackable
-  field :foo
-end
+describe Mongoid::History::Trackable do
+  before :each do
+    class MyModel
+      include Mongoid::Document
+      include Mongoid::History::Trackable
 
-class MyDynamicModel
-  include Mongoid::Document
-  include Mongoid::History::Trackable
-  include Mongoid::Attributes::Dynamic unless Mongoid::Compatibility::Version.mongoid3?
-end
+      field :foo
+    end
 
-class HistoryTracker
-  include Mongoid::History::Tracker
-end
+    class MyDynamicModel
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+      include Mongoid::Attributes::Dynamic unless Mongoid::Compatibility::Version.mongoid3?
+    end
+
+    class HistoryTracker
+      include Mongoid::History::Tracker
+    end
+
+    class User
+      include Mongoid::Document
+    end
+  end
+
+  after :each do
+    Object.send(:remove_const, :MyModel)
+    Object.send(:remove_const, :MyDynamicModel)
+    Object.send(:remove_const, :HistoryTracker)
+    Object.send(:remove_const, :User)
+  end
+
+  let(:user) { User.create! }
 
-describe Mongoid::History::Trackable do
   it 'should have #track_history' do
     expect(MyModel).to respond_to :track_history
   end
@@ -28,20 +44,27 @@ describe Mongoid::History::Trackable do
   end
 
   describe '#track_history' do
-    class MyModelWithNoModifier
-      include Mongoid::Document
-      include Mongoid::History::Trackable
-      field :foo
+    before :each do
+      class MyModelWithNoModifier
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        field :foo
+      end
+    end
+
+    after :each do
+      Object.send(:remove_const, :MyModelWithNoModifier)
     end
 
-    before :all do
+    before :each do
       MyModel.track_history
-      @persisted_history_options = Mongoid::History.trackable_class_options
       MyModelWithNoModifier.track_history modifier_field: nil
     end
-    before(:each) { Mongoid::History.trackable_class_options = @persisted_history_options }
+
     let(:expected_option) do
-      { on: %i[foo],
+      {
+        on: %i[foo],
         except: %w[created_at updated_at],
         tracker_class_name: nil,
         modifier_field: :modifier,
@@ -54,8 +77,10 @@ describe Mongoid::History::Trackable do
         fields: %w[foo],
         relations: { embeds_one: {}, embeds_many: {} },
         dynamic: [],
-        format: {} }
+        format: {}
+      }
     end
+
     let(:regular_fields) { ['foo'] }
     let(:reserved_fields) { %w[_id version modifier_id] }
 
@@ -87,15 +112,24 @@ describe Mongoid::History::Trackable do
       end
 
       context 'modifier_field_optional true' do
-        class MyModelWithOptionalModifier
-          include Mongoid::Document
-          include Mongoid::History::Trackable
-          field :foo
+        before :each do
+          class MyModelWithOptionalModifier
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+
+            field :foo
+          end
+        end
+
+        after :each do
+          Object.send(:remove_const, :MyModelWithOptionalModifier)
         end
 
         it 'marks modifier relationship optional' do
           MyModelWithOptionalModifier.track_history modifier_field_optional: true
-          if Mongoid::Compatibility::Version.mongoid6_or_newer?
+          if Mongoid::Compatibility::Version.mongoid7_or_newer?
+            expect(MyModelWithOptionalModifier.reflect_on_association(:modifier).options[:optional]).to be true
+          elsif Mongoid::Compatibility::Version.mongoid6_or_newer?
             expect(MyModelWithOptionalModifier.reflect_on_association(:modifier)[:optional]).to be true
           else
             expect(MyModelWithOptionalModifier.reflect_on_association(:modifier)).not_to be_nil
@@ -189,14 +223,19 @@ describe Mongoid::History::Trackable do
     end
 
     describe '#field_format' do
-      before :all do
-        ModelOne = Class.new do
+      before :each do
+        class ModelOne
           include Mongoid::Document
           include Mongoid::History::Trackable
+
           field :foo
         end
       end
 
+      after :each do
+        Object.send(:remove_const, :ModelOne)
+      end
+
       let(:format) { '***' }
 
       before do
@@ -214,10 +253,6 @@ describe Mongoid::History::Trackable do
           expect(ModelOne.field_format(:bar)).to be_nil
         end
       end
-
-      after :all do
-        Object.send(:remove_const, :ModelOne)
-      end
     end
 
     context 'sub-model' do
@@ -226,6 +261,10 @@ describe Mongoid::History::Trackable do
         end
       end
 
+      after :each do
+        Object.send(:remove_const, :MySubModel)
+      end
+
       it 'should have default options' do
         expect(Mongoid::History.trackable_class_options[:my_model].prepared).to eq(expected_option)
       end
@@ -261,16 +300,25 @@ describe Mongoid::History::Trackable do
             expect(MyModel.new.track_history?).to eq(true)
           end
 
-          it 'should be disabled only for the class that calls disable_tracking' do
-            class MyModel2
-              include Mongoid::Document
-              include Mongoid::History::Trackable
-              track_history
+          context 'with multiple classes' do
+            before :each do
+              class MyModel2
+                include Mongoid::Document
+                include Mongoid::History::Trackable
+
+                track_history
+              end
             end
 
-            MyModel.disable_tracking do
-              expect(Mongoid::History.enabled?).to eq(true)
-              expect(MyModel2.new.track_history?).to eq(true)
+            after :each do
+              Object.send(:remove_const, :MyModel2)
+            end
+
+            it 'should be disabled only for the class that calls disable_tracking' do
+              MyModel.disable_tracking do
+                expect(Mongoid::History.enabled?).to eq(true)
+                expect(MyModel2.new.track_history?).to eq(true)
+              end
             end
           end
         end
@@ -305,17 +353,26 @@ describe Mongoid::History::Trackable do
             end
           end
 
-          it 'should be disabled only for the class that calls disable_tracking' do
-            class MyModel2
-              include Mongoid::Document
-              include Mongoid::History::Trackable
-              track_history
+          context 'with multiple classes' do
+            before :each do
+              class MyModel2
+                include Mongoid::Document
+                include Mongoid::History::Trackable
+
+                track_history
+              end
             end
 
-            Mongoid::History.disable do
-              MyModel.disable_tracking do
-                expect(Mongoid::History.enabled?).to eq(false)
-                expect(MyModel2.new.track_history?).to eq(false)
+            after :each do
+              Object.send(:remove_const, :MyModel2)
+            end
+
+            it 'should be disabled only for the class that calls disable_tracking' do
+              Mongoid::History.disable do
+                MyModel.disable_tracking do
+                  expect(Mongoid::History.enabled?).to eq(false)
+                  expect(MyModel2.new.track_history?).to eq(false)
+                end
               end
             end
           end
@@ -346,44 +403,74 @@ describe Mongoid::History::Trackable do
     end
 
     describe ':changes_method' do
-      let(:custom_tracker) do
-        CustomTracker = Class.new(MyModel) do
-          field :key
+      it 'should be set in parent class' do
+        expect(MyModel.history_trackable_options[:changes_method]).to eq :changes
+      end
+
+      context 'subclass' do
+        before :each do
+          # BUGBUG: if this is not prepared, it inherits the subclass settings
+          MyModel.history_trackable_options
 
-          track_history on: :key, changes_method: :my_changes, track_create: true
+          class CustomTracker < MyModel
+            field :key
 
-          def my_changes
-            changes.merge('key' => "Save history-#{key}")
+            track_history on: :key, changes_method: :my_changes, track_create: true
+
+            def my_changes
+              changes.merge('key' => "Save history-#{key}")
+            end
           end
         end
-      end
 
-      it 'should default to :changes' do
-        m = MyModel.create
-        expect(m).to receive(:changes).exactly(3).times.and_call_original
-        expect(m).not_to receive(:my_changes)
-        m.save
-      end
+        after :each do
+          Object.send(:remove_const, :CustomTracker)
+        end
 
-      it 'should allow an alternate method to be specified' do
-        class MyModel3 < MyModel
-          track_history changes_method: :my_changes
+        it 'should not override in parent class' do
+          expect(MyModel.history_trackable_options[:changes_method]).to eq :changes
+          expect(CustomTracker.history_trackable_options[:changes_method]).to eq :my_changes
+        end
 
-          def my_changes
-            {}
-          end
+        it 'should default to :changes' do
+          m = MyModel.create!(modifier: user)
+          expect(m).to receive(:changes).exactly(3).times.and_call_original
+          expect(m).not_to receive(:my_changes)
+          m.save!
         end
 
-        m = MyModel3.create
-        expect(m).to receive(:changes).twice.and_call_original
-        expect(m).to receive(:my_changes).once.and_call_original
-        m.save
-      end
+        context 'with another model' do
+          before :each do
+            class MyModel3 < MyModel
+              track_history changes_method: :my_changes
+
+              def my_changes
+                {}
+              end
+            end
+          end
+
+          after :each do
+            Object.send(:remove_const, :MyModel3)
+          end
 
-      it 'should allow an alternate method to be specified on object creation' do
-        m = custom_tracker.create(key: 'on object creation')
-        history_track = m.history_tracks.last
-        expect(history_track.modified['key']).to eq('Save history-on object creation')
+          it 'should allow an alternate method to be specified' do
+            m = MyModel3.create!(modifier: user)
+            expect(m).to receive(:changes).twice.and_call_original
+            expect(m).to receive(:my_changes).once.and_call_original
+            m.save
+          end
+        end
+
+        it 'should allow an alternate method to be specified on object creation' do
+          m = if Mongoid::Compatibility::Version.mongoid7_or_newer? # BUGBUG
+                CustomTracker.create!(key: 'on object creation', modifier: user)
+              else
+                CustomTracker.create!(key: 'on object creation')
+              end
+          history_track = m.history_tracks.last
+          expect(history_track.modified['key']).to eq('Save history-on object creation')
+        end
       end
     end
   end
@@ -391,51 +478,50 @@ describe Mongoid::History::Trackable do
   describe '#history_settings' do
     before(:each) { Mongoid::History.trackable_settings = nil }
 
-    let(:model_one) do
-      Class.new do
+    before :each do
+      class ModelOne
         include Mongoid::Document
         include Mongoid::History::Trackable
+
         store_in collection: :model_ones
-        embeds_one :emb_one, inverse_class_name: 'EmbOne'
-        embeds_many :emb_twos, inverse_class_name: 'EmbTwo'
 
-        def self.name
-          'ModelOne'
+        if Mongoid::Compatibility::Version.mongoid7_or_newer?
+          embeds_one :emb_one
+          embeds_many :emb_twos
+        else
+          embeds_one :emb_one, inverse_class_name: 'EmbOne'
+          embeds_many :emb_twos, inverse_class_name: 'EmbTwo'
         end
       end
-    end
 
-    let(:emb_one) do
-      Class.new do
+      class EmbOne
         include Mongoid::Document
         include Mongoid::History::Trackable
-        embedded_in :model_one
 
-        def self.name
-          'EmbOne'
-        end
+        embedded_in :model_one
       end
-    end
 
-    let(:emb_two) do
-      Class.new do
+      class EmbTwo
         include Mongoid::Document
         include Mongoid::History::Trackable
-        embedded_in :model_one
 
-        def self.name
-          'EmbTwo'
-        end
+        embedded_in :model_one
       end
     end
 
+    after :each do
+      Object.send(:remove_const, :ModelOne)
+      Object.send(:remove_const, :EmbOne)
+      Object.send(:remove_const, :EmbTwo)
+    end
+
     let(:default_options) { { paranoia_field: 'deleted_at' } }
 
     context 'when options not passed' do
       before(:each) do
-        model_one.history_settings
-        emb_one.history_settings
-        emb_two.history_settings
+        ModelOne.history_settings
+        EmbOne.history_settings
+        EmbTwo.history_settings
       end
 
       it 'should use default options' do
@@ -447,9 +533,9 @@ describe Mongoid::History::Trackable do
 
     context 'when extra invalid options passed' do
       before(:each) do
-        model_one.history_settings foo: :bar
-        emb_one.history_settings em_foo: :em_bar
-        emb_two.history_settings em_foo: :em_baz
+        ModelOne.history_settings foo: :bar
+        EmbOne.history_settings em_foo: :em_bar
+        EmbTwo.history_settings em_foo: :em_baz
       end
 
       it 'should ignore invalid options' do
@@ -461,9 +547,9 @@ describe Mongoid::History::Trackable do
 
     context 'when valid options passed' do
       before(:each) do
-        model_one.history_settings paranoia_field: :disabled_at
-        emb_one.history_settings paranoia_field: :deactivated_at
-        emb_two.history_settings paranoia_field: :omitted_at
+        ModelOne.history_settings paranoia_field: :disabled_at
+        EmbOne.history_settings paranoia_field: :deactivated_at
+        EmbTwo.history_settings paranoia_field: :omitted_at
       end
 
       it 'should override default options' do
@@ -474,7 +560,7 @@ describe Mongoid::History::Trackable do
     end
 
     context 'when string keys' do
-      before(:each) { model_one.history_settings 'paranoia_field' => 'erased_at' }
+      before(:each) { ModelOne.history_settings 'paranoia_field' => 'erased_at' }
 
       it 'should convert option keys to symbols' do
         expect(Mongoid::History.trackable_settings[:ModelOne]).to eq(paranoia_field: 'erased_at')
@@ -482,33 +568,36 @@ describe Mongoid::History::Trackable do
     end
 
     context 'when paranoia field has alias' do
-      before(:each) do
-        Mongoid::History.trackable_settings = nil
-        model_two.history_settings paranoia_field: :neglected_at
-      end
-
-      let(:model_two) do
-        Class.new do
+      before :each do
+        class ModelTwo
           include Mongoid::Document
           include Mongoid::History::Trackable
-          field :nglt, as: :neglected_at
 
-          def self.name
-            'ModelTwo'
-          end
+          field :nglt, as: :neglected_at
         end
       end
 
+      after :each do
+        Object.send(:remove_const, :ModelTwo)
+      end
+
+      before :each do
+        ModelTwo.history_settings paranoia_field: :neglected_at
+      end
+
       it { expect(Mongoid::History.trackable_settings[:ModelTwo]).to eq(paranoia_field: 'nglt') }
     end
   end
 
   describe '#tracker_class' do
-    before :all do
-      MyTrackerClass = Class.new
+    before :each do
+      class MyTrackerClass
+      end
     end
 
-    before { MyModel.instance_variable_set(:@history_trackable_options, nil) }
+    after :each do
+      Object.send(:remove_const, :MyTrackerClass)
+    end
 
     context 'when options contain tracker_class_name' do
       context 'when underscored' do
@@ -528,28 +617,37 @@ describe Mongoid::History::Trackable do
     end
 
     describe '#modified_attributes_for_update' do
-      before(:all) do
-        ModelOne = Class.new do
+      before :each do
+        class ModelOne
           include Mongoid::Document
           include Mongoid::History::Trackable
+
           store_in collection: :model_ones
           field :foo
-          embeds_many :emb_ones, inverse_class_name: 'EmbOne'
+
+          if Mongoid::Compatibility::Version.mongoid7_or_newer?
+            embeds_many :emb_ones
+          else
+            embeds_many :emb_ones, inverse_class_name: 'EmbOne'
+          end
         end
 
-        EmbOne = Class.new do
+        class EmbOne
           include Mongoid::Document
           include Mongoid::History::Trackable
+
           field :em_foo
           embedded_in :model_one
         end
       end
 
-      before(:each) do
+      after :each do
+        Object.send(:remove_const, :ModelOne)
+        Object.send(:remove_const, :EmbOne)
+      end
+
+      before :each do
         model_one.save!
-        ModelOne.instance_variable_set(:@history_trackable_options, nil)
-        ModelOne.instance_variable_set(:@trackable_settings, nil)
-        EmbOne.instance_variable_set(:@trackable_settings, nil)
       end
 
       let(:model_one) { ModelOne.new(foo: 'Foo') }
@@ -560,14 +658,14 @@ describe Mongoid::History::Trackable do
         before(:each) { allow(model_one).to receive(:changes) { changes } }
 
         context 'when not paranoia' do
-          before(:each) { ModelOne.track_history(on: :emb_ones) }
+          before(:each) { ModelOne.track_history(on: :emb_ones, modifier_field_optional: true) }
           let(:changes) { { 'emb_ones' => [[{ 'em_foo' => 'Foo' }], [{ 'em_foo' => 'Foo-new' }]] } }
           it { expect(subject['emb_ones'][0]).to eq [{ 'em_foo' => 'Foo' }] }
           it { expect(subject['emb_ones'][1]).to eq [{ 'em_foo' => 'Foo-new' }] }
         end
 
         context 'when default field for paranoia' do
-          before(:each) { ModelOne.track_history(on: :emb_ones) }
+          before(:each) { ModelOne.track_history(on: :emb_ones, modifier_field_optional: true) }
           let(:changes) do
             { 'emb_ones' => [[{ 'em_foo' => 'Foo' }, { 'em_foo' => 'Foo-2', 'deleted_at' => Time.now }],
                              [{ 'em_foo' => 'Foo-new' }, { 'em_foo' => 'Foo-2-new', 'deleted_at' => Time.now }]] }
@@ -578,7 +676,7 @@ describe Mongoid::History::Trackable do
 
         context 'when custom field for paranoia' do
           before(:each) do
-            ModelOne.track_history on: :emb_ones
+            ModelOne.track_history on: :emb_ones, modifier_field_optional: true
             EmbOne.history_settings paranoia_field: :my_paranoia_field
           end
           let(:changes) do
@@ -595,39 +693,29 @@ describe Mongoid::History::Trackable do
       describe 'fields' do
         context 'when custom method for changes' do
           before(:each) do
-            ModelOne.clear_trackable_memoization
             ModelOne.track_history(on: :foo, changes_method: :my_changes_method)
             allow(ModelOne).to receive(:dynamic_enabled?) { false }
             allow(model_one).to receive(:my_changes_method) { changes }
           end
+
           let(:changes) { { 'foo' => ['Foo', 'Foo-new'], 'bar' => ['Bar', 'Bar-new'] } }
           it { is_expected.to eq('foo' => ['Foo', 'Foo-new']) }
         end
       end
-
-      after(:all) do
-        Object.send(:remove_const, :ModelOne)
-        Object.send(:remove_const, :EmbOne)
-      end
     end
 
     context 'when options not contain tracker_class_name' do
       before { MyModel.track_history }
       it { expect(MyModel.tracker_class).to eq Tracker }
     end
-
-    after :all do
-      Object.send(:remove_const, :MyTrackerClass)
-    end
   end
 
   describe '#track_update' do
-    before :all do
+    before :each do
       MyModel.track_history(on: :foo, track_update: true)
-      @persisted_history_options = Mongoid::History.trackable_class_options
     end
-    before(:each) { Mongoid::History.trackable_class_options = @persisted_history_options }
-    let!(:m) { MyModel.create!(foo: 'bar') }
+
+    let!(:m) { MyModel.create!(foo: 'bar', modifier: user) }
 
     it 'should create history' do
       expect { m.update_attributes!(foo: 'bar2') }.to change(Tracker, :count).by(1)
@@ -642,12 +730,11 @@ describe Mongoid::History::Trackable do
   end
 
   describe '#track_destroy' do
-    before :all do
+    before :each do
       MyModel.track_history(on: :foo, track_destroy: true)
-      @persisted_history_options = Mongoid::History.trackable_class_options
     end
-    before(:each) { Mongoid::History.trackable_class_options = @persisted_history_options }
-    let!(:m) { MyModel.create!(foo: 'bar') }
+
+    let!(:m) { MyModel.create!(foo: 'bar', modifier: user) }
 
     it 'should create history' do
       expect { m.destroy }.to change(Tracker, :count).by(1)
@@ -662,15 +749,26 @@ describe Mongoid::History::Trackable do
   end
 
   describe '#track_create' do
-    before :all do
+    before :each do
+      class MyModelWithNoModifier
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        field :foo
+      end
+    end
+
+    after :each do
+      Object.send(:remove_const, :MyModelWithNoModifier)
+    end
+
+    before :each do
       MyModel.track_history(on: :foo, track_create: true)
-      @persisted_history_options = Mongoid::History.trackable_class_options
       MyModelWithNoModifier.track_history modifier_field: nil
     end
-    before(:each) { Mongoid::History.trackable_class_options = @persisted_history_options }
 
     it 'should create history' do
-      expect { MyModel.create!(foo: 'bar') }.to change(Tracker, :count).by(1)
+      expect { MyModel.create!(foo: 'bar', modifier: user) }.to change(Tracker, :count).by(1)
     end
 
     context 'no modifier_field' do