mongoid-history 0.8.0 → 0.8.1

data/spec/integration/subclasses_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Mongoid::History::Tracker do
-  before :all do
+  before :each do
     class Element
       include Mongoid::Document
       include Mongoid::Timestamps
@@ -9,20 +9,32 @@ describe Mongoid::History::Tracker do
 
       field :body
 
-      track_history on: [:body], track_create: true, track_update: true, track_destroy: true
+      track_history on: [:body]
     end
 
     class Prompt < Element
     end
+
+    class User
+      include Mongoid::Document
+    end
   end
 
+  after :each do
+    Object.send(:remove_const, :Element)
+    Object.send(:remove_const, :Prompt)
+    Object.send(:remove_const, :User)
+  end
+
+  let(:user) { User.create! }
+
   it 'tracks subclass create and update' do
-    prompt = Prompt.new
+    prompt = Prompt.new(modifier: user)
     expect { prompt.save! }.to change(Tracker, :count).by(1)
     expect { prompt.update_attributes!(body: 'one') }.to change(Tracker, :count).by(1)
-    prompt.undo!
+    prompt.undo! user
     expect(prompt.body).to be_blank
-    prompt.redo! nil, 2
+    prompt.redo! user, 2
     expect(prompt.body).to eq('one')
     expect { prompt.destroy }.to change(Tracker, :count).by(1)
   end

data/spec/integration/track_history_order_spec.rb

@@ -1,52 +1,84 @@
 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
+  context 'when track_history not called' do
+    before :each do
+      class NotModel
+        include Mongoid::Document
+        include Mongoid::History::Trackable
 
-      field :foo
+        field :foo
+      end
     end
 
-    expect(NotModel.respond_to?(:tracked?)).to be false
+    after :each do
+      Object.send(:remove_const, :NotModel)
+    end
+
+    it 'should not track fields' do
+      expect(NotModel.respond_to?(:tracked?)).to be false
+    end
   end
 
-  it 'should track fields when track_history called inside class and before fields' do
-    class InsideBeforeModel
-      include Mongoid::Document
-      include Mongoid::History::Trackable
+  context 'boefore field' do
+    before :each do
+      class InsideBeforeModel
+        include Mongoid::Document
+        include Mongoid::History::Trackable
 
-      track_history on: :fields
+        track_history on: :fields
 
-      field :foo
+        field :foo
+      end
     end
 
-    expect(InsideBeforeModel.tracked?(:foo)).to be true
+    after :each do
+      Object.send(:remove_const, :InsideBeforeModel)
+    end
+
+    it 'should track fields' do
+      expect(InsideBeforeModel.tracked?(:foo)).to be true
+    end
   end
 
-  it 'should track fields when track_history called inside class and after fields' do
-    class InsideAfterModel
-      include Mongoid::Document
-      include Mongoid::History::Trackable
+  context 'when track_history called inside class and after fields' do
+    before :each do
+      class InsideAfterModel
+        include Mongoid::Document
+        include Mongoid::History::Trackable
 
-      field :foo
+        field :foo
 
-      track_history on: :fields
+        track_history on: :fields
+      end
     end
 
-    expect(InsideAfterModel.tracked?(:foo)).to be true
+    after :each do
+      Object.send(:remove_const, :InsideAfterModel)
+    end
+
+    it 'should track fields' do
+      expect(InsideAfterModel.tracked?(:foo)).to be true
+    end
   end
 
-  it 'should track fields when track_history called outside class' do
-    class OutsideModel
-      include Mongoid::Document
-      include Mongoid::History::Trackable
+  context 'when track_history called outside class' do
+    before :each do
+      class OutsideModel
+        include Mongoid::Document
+        include Mongoid::History::Trackable
 
-      field :foo
+        field :foo
+      end
     end
 
-    OutsideModel.track_history on: :fields
-    expect(OutsideModel.tracked?(:foo)).to be true
+    after :each do
+      Object.send(:remove_const, :OutsideModel)
+    end
+
+    it 'should track fields' do
+      OutsideModel.track_history on: :fields
+      expect(OutsideModel.tracked?(:foo)).to be true
+    end
   end
 end

data/spec/integration/validation_failure_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Mongoid::History::Tracker do
-  before :all do
+  before :each do
     class Element
       include Mongoid::Document
       include Mongoid::Timestamps
@@ -12,9 +12,13 @@ describe Mongoid::History::Tracker do
 
       validates :title, presence: true
 
-      has_many :items, dependent: :restrict
+      if Mongoid::Compatibility::Version.mongoid7_or_newer?
+        has_many :items, dependent: :restrict_with_exception
+      else
+        has_many :items, dependent: :restrict
+      end
 
-      track_history on: [:body], track_create: true, track_update: true, track_destroy: true
+      track_history on: [:body]
     end
 
     class Item
@@ -27,13 +31,22 @@ describe Mongoid::History::Tracker do
     class Prompt < Element
     end
 
-    @persisted_history_options = Mongoid::History.trackable_class_options
+    class User
+      include Mongoid::Document
+    end
+  end
+
+  after :each do
+    Object.send(:remove_const, :Element)
+    Object.send(:remove_const, :Item)
+    Object.send(:remove_const, :Prompt)
+    Object.send(:remove_const, :User)
   end
 
-  before(:each) { Mongoid::History.trackable_class_options = @persisted_history_options }
+  let(:user) { User.create! }
 
   it 'does not track delete when parent class validation fails' do
-    prompt = Prompt.new(title: 'first')
+    prompt = Prompt.new(title: 'first', modifier: user)
     expect { prompt.save! }.to change(Tracker, :count).by(1)
     expect do
       expect { prompt.update_attributes!(title: nil, body: 'one') }
@@ -42,7 +55,7 @@ describe Mongoid::History::Tracker do
   end
 
   it 'does not track delete when parent class restrict dependency fails' do
-    prompt = Prompt.new(title: 'first')
+    prompt = Prompt.new(title: 'first', modifier: user)
     prompt.items << Item.new
     expect { prompt.save! }.to change(Tracker, :count).by(1)
     expect(prompt.version).to eq(1)
@@ -52,7 +65,7 @@ describe Mongoid::History::Tracker do
   end
 
   it 'does not track delete when restrict dependency fails' do
-    elem = Element.new(title: 'first')
+    elem = Element.new(title: 'first', modifier: user)
     elem.items << Item.new
     expect { elem.save! }.to change(Tracker, :count).by(1)
     expect(elem.version).to eq(1)

data/spec/spec_helper.rb

@@ -17,9 +17,14 @@ require 'mongoid/history'
 
 RSpec.configure do |config|
   config.raise_errors_for_deprecations!
+
   config.before :all do
     Mongoid.logger.level = Logger::INFO
-    Mongo::Logger.logger.level = Logger::INFO if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+    Mongo::Logger.logger.level = Logger::INFO if Mongoid::Compatibility::Version.mongoid5_or_newer?
     Mongoid.belongs_to_required_by_default = false if Mongoid::Compatibility::Version.mongoid6?
   end
+
+  config.before :each do
+    Mongoid::History.reset!
+  end
 end

data/spec/unit/attributes/base_spec.rb

@@ -1,31 +1,29 @@
 require 'spec_helper'
 
 describe Mongoid::History::Attributes::Base do
-  let(:model_one) do
-    Class.new do
+  before :each do
+    class ModelOne
       include Mongoid::Document
       include Mongoid::History::Trackable
+
       field :foo
       field :b, as: :bar
-      def self.name
-        'ModelOne'
-      end
     end
-  end
 
-  before :all do
     class ModelTwo
       include Mongoid::Document
+
       field :foo
       field :goo
     end
   end
 
-  after :all do
+  after :each do
+    Object.send(:remove_const, :ModelOne)
     Object.send(:remove_const, :ModelTwo)
   end
 
-  let(:obj_one) { model_one.new }
+  let(:obj_one) { ModelOne.new }
   let(:base) { described_class.new(obj_one) }
   subject { base }
 
@@ -37,7 +35,7 @@ describe Mongoid::History::Attributes::Base do
 
   describe '#trackable_class' do
     subject { base.send(:trackable_class) }
-    it { is_expected.to eq model_one }
+    it { is_expected.to eq ModelOne }
   end
 
   describe '#aliased_fields' do
@@ -47,8 +45,7 @@ describe Mongoid::History::Attributes::Base do
 
   describe '#changes_method' do
     before(:each) do
-      model_one.instance_variable_set(:@history_trackable_options, nil)
-      model_one.track_history changes_method: :my_changes
+      ModelOne.track_history changes_method: :my_changes
     end
     subject { base.send(:changes_method) }
     it { is_expected.to eq :my_changes }
@@ -56,8 +53,7 @@ describe Mongoid::History::Attributes::Base do
 
   describe '#changes' do
     before(:each) do
-      model_one.instance_variable_set(:@history_trackable_options, nil)
-      model_one.track_history
+      ModelOne.track_history
       allow(obj_one).to receive(:changes) { { 'foo' => ['Foo', 'Foo-new'] } }
     end
     subject { base.send(:changes) }
@@ -65,15 +61,11 @@ describe Mongoid::History::Attributes::Base do
   end
 
   describe '#format_field' do
-    before(:each) do
-      model_one.instance_variable_set(:@history_trackable_options, nil)
-    end
-
     subject { base.send(:format_field, :bar, 'foo') }
 
     context 'when formatted via string' do
       before do
-        model_one.track_history format: { bar: '*%s*' }
+        ModelOne.track_history format: { bar: '*%s*' }
       end
 
       it { is_expected.to eq '*foo*' }
@@ -81,7 +73,7 @@ describe Mongoid::History::Attributes::Base do
 
     context 'when formatted via proc' do
       before do
-        model_one.track_history format: { bar: ->(v) { v * 2 } }
+        ModelOne.track_history format: { bar: ->(v) { v * 2 } }
       end
 
       it { is_expected.to eq 'foofoo' }
@@ -89,7 +81,7 @@ describe Mongoid::History::Attributes::Base do
 
     context 'when not formatted' do
       before do
-        model_one.track_history
+        ModelOne.track_history
       end
 
       it { is_expected.to eq 'foo' }
@@ -100,15 +92,14 @@ describe Mongoid::History::Attributes::Base do
     let(:model_two) { ModelTwo.new(foo: :bar, goo: :baz) }
 
     before :each do
-      model_one.instance_variable_set(:@history_trackable_options, nil)
-      model_one.send(relation_type, :model_two)
+      ModelOne.send(relation_type, :model_two)
     end
 
     subject { base.send("format_#{relation_type}_relation", :model_two, model_two.attributes) }
 
     context 'with permitted attributes' do
       before do
-        model_one.track_history on: { model_two: %i[foo] }
+        ModelOne.track_history on: { model_two: %i[foo] }
       end
 
       it 'should select only permitted attributes' do
@@ -119,7 +110,7 @@ describe Mongoid::History::Attributes::Base do
 
     context 'with attributes formatted via string' do
       before do
-        model_one.track_history on: { model_two: %i[foo] }, format: { model_two: { foo: '&%s&' } }
+        ModelOne.track_history on: { model_two: %i[foo] }, format: { model_two: { foo: '&%s&' } }
       end
 
       it 'should select obfuscate permitted attributes' do
@@ -130,7 +121,7 @@ describe Mongoid::History::Attributes::Base do
 
     context 'with attributes formatted via proc' do
       before do
-        model_one.track_history on: { model_two: %i[foo] }, format: { model_two: { foo: ->(v) { v.to_s * 2 } } }
+        ModelOne.track_history on: { model_two: %i[foo] }, format: { model_two: { foo: ->(v) { v.to_s * 2 } } }
       end
 
       it 'should select obfuscate permitted attributes' do

data/spec/unit/attributes/create_spec.rb

@@ -1,20 +1,23 @@
 require 'spec_helper'
 
 describe Mongoid::History::Attributes::Create do
-  let(:model_one) do
-    Class.new do
+  before :each do
+    class ModelOne
       include Mongoid::Document
       include Mongoid::History::Trackable
+
       store_in collection: :model_ones
       field :foo
       field :b, as: :bar
-      def self.name
-        'ModelOne'
-      end
+
+      track_history on: :foo
     end
   end
 
-  let(:obj_one) { model_one.new }
+  after :each do
+    Object.send(:remove_const, :ModelOne)
+  end
+
   let(:base) { described_class.new(obj_one) }
   subject { base }
 
@@ -22,294 +25,318 @@ describe Mongoid::History::Attributes::Create do
     subject { base.attributes }
 
     describe 'fields' do
-      before(:each) do
-        model_one.instance_variable_set(:@history_trackable_options, nil)
-        model_one.track_history on: :foo
-      end
-      let(:obj_one) { model_one.new(foo: 'Foo', bar: 'Bar') }
+      let(:obj_one) { ModelOne.new }
+      let(:obj_one) { ModelOne.new(foo: 'Foo', bar: 'Bar') }
       it { is_expected.to eq('foo' => [nil, 'Foo']) }
     end
 
     describe '#insert_embeds_one_changes' do
       context 'when untracked relation' do
-        before(:all) do
-          # Need class name constant
+        before :each do
           class ModelTwo
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             store_in collection: :model_twos
-            embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+
+            if Mongoid::Compatibility::Version.mongoid7_or_newer?
+              embeds_one :emb_one_one
+            else
+              embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+            end
+
+            track_history on: :fields
           end
 
           class EmbOneOne
             include Mongoid::Document
+
             field :em_bar
             embedded_in :model_one
           end
         end
 
-        before(:each) do
-          ModelTwo.instance_variable_set(:@history_trackable_options, nil)
-          ModelTwo.track_history on: :fields
+        after :each do
+          Object.send(:remove_const, :ModelTwo)
+          Object.send(:remove_const, :EmbOneOne)
         end
 
-        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj_one) }
-        let(:emb_obj_one) { EmbOneOne.new(em_bar: 'Em-Bar') }
+        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj) }
+        let(:emb_obj) { EmbOneOne.new(em_bar: 'Em-Bar') }
 
         it { is_expected.to eq({}) }
-
-        after(:all) do
-          Object.send(:remove_const, :ModelTwo)
-          Object.send(:remove_const, :EmbOneOne)
-        end
       end
 
       context 'when tracked relation' do
-        before(:all) do
-          # Need class name constant
+        before :each do
           class ModelTwo
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             store_in collection: :model_twos
-            embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+
+            if Mongoid::Compatibility::Version.mongoid7_or_newer?
+              embeds_one :emb_one_one
+            else
+              embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+            end
+
+            track_history on: :emb_one_one
           end
 
           class EmbOneOne
             include Mongoid::Document
+
             field :em_bar
             embedded_in :model_one
           end
         end
 
-        before(:each) do
-          ModelTwo.instance_variable_set(:@history_trackable_options, nil)
-          ModelTwo.track_history on: :emb_one_one
-        end
-
-        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj_one) }
-        let(:emb_obj_one) { EmbOneOne.new(em_bar: 'Em-Bar') }
-
-        it { is_expected.to eq('emb_one_one' => [nil, { '_id' => emb_obj_one._id, 'em_bar' => 'Em-Bar' }]) }
-
-        after(:all) do
+        after :each do
           Object.send(:remove_const, :ModelTwo)
           Object.send(:remove_const, :EmbOneOne)
         end
+
+        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj) }
+        let(:emb_obj) { EmbOneOne.new(em_bar: 'Em-Bar') }
+
+        it { is_expected.to eq('emb_one_one' => [nil, { '_id' => emb_obj._id, 'em_bar' => 'Em-Bar' }]) }
       end
 
       context 'when paranoia_field without alias' do
-        before(:all) do
-          # Need class name constant
+        before :each do
           class ModelTwo
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             store_in collection: :model_twos
-            embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+
+            if Mongoid::Compatibility::Version.mongoid7_or_newer?
+              embeds_one :emb_one_one
+            else
+              embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+            end
+
+            track_history on: :emb_one_one
           end
 
           class EmbOneOne
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             field :em_bar
             field :removed_at
+
             embedded_in :model_one
+
+            history_settings paranoia_field: :removed_at
           end
         end
 
-        before(:each) do
-          ModelTwo.instance_variable_set(:@history_trackable_options, nil)
-          EmbOneOne.instance_variable_set(:@rackable_settings, nil)
-          ModelTwo.track_history on: :emb_one_one
-          EmbOneOne.history_settings paranoia_field: :removed_at
+        after :each do
+          Object.send(:remove_const, :ModelTwo)
+          Object.send(:remove_const, :EmbOneOne)
         end
 
-        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj_one) }
-        let(:emb_obj_one) { EmbOneOne.new(em_bar: 'Em-Bar', removed_at: Time.now) }
+        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj) }
+        let(:emb_obj) { EmbOneOne.new(em_bar: 'Em-Bar', removed_at: Time.now) }
 
         it { is_expected.to eq({}) }
-
-        after(:all) do
-          Object.send(:remove_const, :ModelTwo)
-          Object.send(:remove_const, :EmbOneOne)
-        end
       end
 
       context 'when paranoia_field with alias' do
-        before(:all) do
-          # Need class name constant
+        before :each do
           class ModelTwo
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             store_in collection: :model_twos
-            embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+
+            if Mongoid::Compatibility::Version.mongoid7_or_newer?
+              embeds_one :emb_one_one
+            else
+              embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+            end
+
+            track_history on: :emb_one_one
           end
 
           class EmbOneOne
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             field :em_bar
             field :rmvt, as: :removed_at
+
             embedded_in :model_one
+
+            history_settings paranoia_field: :removed_at
           end
         end
 
-        before(:each) do
-          ModelTwo.instance_variable_set(:@history_trackable_options, nil)
-          EmbOneOne.instance_variable_set(:@rackable_settings, nil)
-          ModelTwo.track_history on: :emb_one_one
-          EmbOneOne.history_settings paranoia_field: :removed_at
+        after :each do
+          Object.send(:remove_const, :ModelTwo)
+          Object.send(:remove_const, :EmbOneOne)
         end
 
-        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj_one) }
-        let(:emb_obj_one) { EmbOneOne.new(em_bar: 'Em-Bar', removed_at: Time.now) }
+        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj) }
+        let(:emb_obj) { EmbOneOne.new(em_bar: 'Em-Bar', removed_at: Time.now) }
 
         it { is_expected.to eq({}) }
-
-        after(:all) do
-          Object.send(:remove_const, :ModelTwo)
-          Object.send(:remove_const, :EmbOneOne)
-        end
       end
 
       context 'with permitted attributes' do
-        before(:all) do
-          # Need class name constant
+        before :each do
           class ModelTwo
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             store_in collection: :model_twos
-            embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+
+            if Mongoid::Compatibility::Version.mongoid7_or_newer?
+              embeds_one :emb_one_one
+            else
+              embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+            end
+
+            track_history on: [{ emb_one_one: :em_bar }]
           end
 
           class EmbOneOne
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             field :em_foo
             field :em_bar
+
             embedded_in :model_one
           end
         end
 
-        before(:each) do
-          ModelTwo.instance_variable_set(:@history_trackable_options, nil)
-          ModelTwo.track_history on: [{ emb_one_one: :em_bar }]
-        end
-
-        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj_one) }
-        let(:emb_obj_one) { EmbOneOne.new(em_foo: 'Em-Foo', em_bar: 'Em-Bar') }
-
-        it { is_expected.to eq('emb_one_one' => [nil, { '_id' => emb_obj_one._id, 'em_bar' => 'Em-Bar' }]) }
-
-        after(:all) do
+        after :each do
           Object.send(:remove_const, :ModelTwo)
           Object.send(:remove_const, :EmbOneOne)
         end
+
+        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj) }
+        let(:emb_obj) { EmbOneOne.new(em_foo: 'Em-Foo', em_bar: 'Em-Bar') }
+
+        it { is_expected.to eq('emb_one_one' => [nil, { '_id' => emb_obj._id, 'em_bar' => 'Em-Bar' }]) }
       end
 
       context 'when relation with alias' do
-        before(:all) do
-          # Need class name constant
+        before :each do
           class ModelTwo
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             store_in collection: :model_twos
-            embeds_one :emb_one_one, store_as: :eoo, inverse_class_name: 'EmbOneOne'
+
+            if Mongoid::Compatibility::Version.mongoid7_or_newer?
+              embeds_one :emb_one_one, store_as: :eoo
+            else
+              embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne', store_as: :eoo
+            end
+
+            track_history on: :emb_one_one
           end
 
           class EmbOneOne
             include Mongoid::Document
+
             field :em_bar
             embedded_in :model_one
           end
         end
 
-        before(:each) do
-          ModelTwo.instance_variable_set(:@history_trackable_options, nil)
-          ModelTwo.track_history on: :emb_one_one
-        end
-
-        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj_one) }
-        let(:emb_obj_one) { EmbOneOne.new(em_bar: 'Em-Bar') }
-
-        it { is_expected.to eq('emb_one_one' => [nil, { '_id' => emb_obj_one._id, 'em_bar' => 'Em-Bar' }]) }
-
-        after(:all) do
+        after :each do
           Object.send(:remove_const, :ModelTwo)
           Object.send(:remove_const, :EmbOneOne)
         end
+
+        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj) }
+        let(:emb_obj) { EmbOneOne.new(em_bar: 'Em-Bar') }
+
+        it { is_expected.to eq('emb_one_one' => [nil, { '_id' => emb_obj._id, 'em_bar' => 'Em-Bar' }]) }
       end
 
       context 'when no object' do
-        before(:all) do
-          # Need class name constant
+        before :each do
           class ModelTwo
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             store_in collection: :model_twos
-            embeds_one :emb_one_one, store_as: :eoo, inverse_class_name: 'EmbOneOne'
+
+            if Mongoid::Compatibility::Version.mongoid7_or_newer?
+              embeds_one :emb_one_one, store_as: :eoo
+            else
+              embeds_one :emb_one_one, store_as: :eoo, inverse_class_name: 'EmbOneOne'
+            end
+
+            track_history on: :emb_one_one
           end
 
           class EmbOneOne
             include Mongoid::Document
+
             field :em_bar
             embedded_in :model_one
           end
         end
 
-        before(:each) do
-          ModelTwo.instance_variable_set(:@history_trackable_options, nil)
-          ModelTwo.track_history on: :emb_one_one
+        after :each do
+          Object.send(:remove_const, :ModelTwo)
+          Object.send(:remove_const, :EmbOneOne)
         end
 
         let(:obj_one) { ModelTwo.new }
 
         it { is_expected.to eq({}) }
-
-        after(:all) do
-          Object.send(:remove_const, :ModelTwo)
-          Object.send(:remove_const, :EmbOneOne)
-        end
       end
 
       context 'when object not paranoid' do
-        before(:all) do
-          # Need class name constant
+        before :each do
           class ModelTwo
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             store_in collection: :model_twos
-            embeds_one :emb_one_one, store_as: :eoo, inverse_class_name: 'EmbOneOne'
+
+            if Mongoid::Compatibility::Version.mongoid7_or_newer?
+              embeds_one :emb_one_one, store_as: :eoo
+            else
+              embeds_one :emb_one_one, store_as: :eoo, inverse_class_name: 'EmbOneOne'
+            end
+
+            track_history on: :emb_one_one
           end
 
           class EmbOneOne
             include Mongoid::Document
             include Mongoid::History::Trackable
+
             field :em_bar
             field :cancelled_at
+
             embedded_in :model_one
-          end
-        end
 
-        before(:each) do
-          ModelTwo.instance_variable_set(:@history_trackable_options, nil)
-          EmbOneOne.instance_variable_set(:@trackable_settings, nil)
-          ModelTwo.track_history on: :emb_one_one
-          EmbOneOne.history_settings paranoia_field: :cancelled_at
+            history_settings paranoia_field: :cancelled_at
+          end
         end
 
-        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj_one) }
-        let(:emb_obj_one) { EmbOneOne.new(em_bar: 'Em-Bar') }
-
-        it { is_expected.to eq('emb_one_one' => [nil, { '_id' => emb_obj_one._id, 'em_bar' => 'Em-Bar' }]) }
-
-        after(:all) do
+        after :each do
           Object.send(:remove_const, :ModelTwo)
           Object.send(:remove_const, :EmbOneOne)
         end
+
+        let(:obj_one) { ModelTwo.new(emb_one_one: emb_obj) }
+        let(:emb_obj) { EmbOneOne.new(em_bar: 'Em-Bar') }
+
+        it { is_expected.to eq('emb_one_one' => [nil, { '_id' => emb_obj._id, 'em_bar' => 'Em-Bar' }]) }
       end
     end
 
-    describe '#insert_embeds_many_changes' do
-    end
+    pending '#insert_embeds_many_changes'
   end
 end