mongoid-history 0.5.0 → 0.6.0

data/lib/mongoid/history/tracker.rb

@@ -9,8 +9,8 @@ module Mongoid
         attr_writer :trackable
 
         field :association_chain,       type: Array, default: []
-        field :modified,                type: Hash
-        field :original,                type: Hash
+        field :modified,                type: Hash, default: {}
+        field :original,                type: Hash, default: {}
         field :version,                 type: Integer
         field :action,                  type: String
         field :scope,                   type: String
@@ -91,7 +91,7 @@ module Mongoid
         @tracked_changes ||= (modified.keys | original.keys).inject(HashWithIndifferentAccess.new) do |h, k|
           h[k] = { from: original[k], to: modified[k] }.delete_if { |_, vv| vv.nil? }
           h
-        end.delete_if { |k, v| v.blank? || !trackable_parent_class.tracked_field?(k) }
+        end.delete_if { |k, v| v.blank? || !trackable_parent_class.tracked?(k) }
       end
 
       # Outputs summary of edit actions performed: :add, :modify, :remove, or :array.
@@ -104,28 +104,31 @@ module Mongoid
       #     remove: { field_3: old_val },
       #     array: { field_4: {add: ['foo', 'bar'], remove: ['baz']} } }
       def tracked_edits
-        @tracked_edits ||= tracked_changes.inject(HashWithIndifferentAccess.new) do |h, (k, v)|
-          unless v[:from].blank? && v[:to].blank?
-            if v[:from].blank?
-              h[:add] ||= {}
-              h[:add][k] = v[:to]
-            elsif v[:to].blank?
-              h[:remove] ||= {}
-              h[:remove][k] = v[:from]
-            else
-              if v[:from].is_a?(Array) && v[:to].is_a?(Array)
-                h[:array] ||= {}
-                old_values = v[:from] - v[:to]
-                new_values = v[:to] - v[:from]
-                h[:array][k] = { add: new_values, remove: old_values }.delete_if { |_, vv| vv.blank? }
-              else
-                h[:modify] ||= {}
-                h[:modify][k] = v
-              end
-            end
+        return @tracked_edits if @tracked_edits
+        @tracked_edits = HashWithIndifferentAccess.new
+
+        tracked_changes.each do |k, v|
+          next if v[:from].blank? && v[:to].blank?
+
+          if trackable_parent_class.tracked_embeds_many?(k)
+            prepare_tracked_edits_for_embeds_many(k, v)
+          elsif v[:from].blank?
+            @tracked_edits[:add] ||= {}
+            @tracked_edits[:add][k] = v[:to]
+          elsif v[:to].blank?
+            @tracked_edits[:remove] ||= {}
+            @tracked_edits[:remove][k] = v[:from]
+          elsif v[:from].is_a?(Array) && v[:to].is_a?(Array)
+            @tracked_edits[:array] ||= {}
+            old_values = v[:from] - v[:to]
+            new_values = v[:to] - v[:from]
+            @tracked_edits[:array][k] = { add: new_values, remove: old_values }.delete_if { |_, vv| vv.blank? }
+          else
+            @tracked_edits[:modify] ||= {}
+            @tracked_edits[:modify][k] = v
           end
-          h
         end
+        @tracked_edits
       end
 
       # Similar to #tracked_changes, but contains only a single value for each
@@ -217,6 +220,19 @@ module Mongoid
         end if klass.respond_to?(:localized_fields)
         hash
       end
+
+      def prepare_tracked_edits_for_embeds_many(key, value)
+        @tracked_edits[:embeds_many] ||= {}
+        value[:from] ||= []
+        value[:to] ||= []
+        modify_ids = value[:from].map { |vv| vv['_id'] }.compact & value[:to].map { |vv| vv['_id'] }.compact
+        modify_values = modify_ids.map { |id| { from: value[:from].detect { |vv| vv['_id'] == id }, to: value[:to].detect { |vv| vv['_id'] == id } } }
+        modify_values.delete_if { |vv| vv[:from] == vv[:to] }
+        ignore_values = modify_values.map { |vv| [vv[:from], vv[:to]] }.flatten
+        old_values = value[:from] - value[:to] - ignore_values
+        new_values = value[:to] - value[:from] - ignore_values
+        @tracked_edits[:embeds_many][key] = { add: new_values, remove: old_values, modify: modify_values }.delete_if { |_, vv| vv.blank? }
+      end
     end
   end
 end

data/lib/mongoid/history/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module History
-    VERSION = '0.5.0'
+    VERSION = '0.6.0'
   end
 end

data/mongoid-history.gemspec

@@ -22,12 +22,4 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'mongoid', '>= 3.0'
   s.add_runtime_dependency 'mongoid-compatibility'
   s.add_runtime_dependency 'activesupport'
-
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec', '~> 3.1'
-  s.add_development_dependency 'bundler'
-  s.add_development_dependency 'rubocop', '0.34.1'
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'gem-release'
-  s.add_development_dependency 'coveralls'
 end

data/spec/integration/embedded_in_polymorphic_spec.rb

@@ -124,4 +124,12 @@ describe Mongoid::History::Tracker do
     expect(company.embone.history_tracks.last.action).to eq('create')
     expect(company.embone.history_tracks.last.association_chain.last['name']).to eq('embone')
   end
+
+  after :all do
+    Object.send(:remove_const, :RealState)
+    Object.send(:remove_const, :Company)
+    Object.send(:remove_const, :Embone)
+    Object.send(:remove_const, :Contact)
+    Object.send(:remove_const, :User)
+  end
 end

data/spec/integration/integration_spec.rb

@@ -327,6 +327,10 @@ describe Mongoid::History do
         end
       end
       context 'with empty values' do
+        before do
+          allow(subject).to receive(:trackable_parent_class) { Tracker }
+          allow(Tracker).to receive(:tracked_embeds_many?) { false }
+        end
         subject { Tracker.new }
         it 'should skip empty values' do
           allow(subject).to receive(:tracked_changes) { { name: { to: '', from: [] }, city: { to: 'Toronto', from: '' } } }

data/spec/integration/nested_embedded_documents_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe Mongoid::History::Tracker do
   before :all do
-    class Model
+    class Modelone
       include Mongoid::Document
       include Mongoid::History::Trackable
 
       field :name, type: String
-      belongs_to :user, inverse_of: :models
+      belongs_to :user, inverse_of: :modelones
       embeds_many :embones
 
       track_history on: :all, # track title and body fields only, default is :all
@@ -24,7 +24,7 @@ describe Mongoid::History::Tracker do
 
       field :name
       embeds_many :embtwos, store_as: :ems
-      embedded_in :model
+      embedded_in :modelone
 
       track_history on: :all, # 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
@@ -48,12 +48,12 @@ describe Mongoid::History::Tracker do
                     track_create: false,    # 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: :model
+                    scope: :modelone
     end
 
     class User
       include Mongoid::Document
-      has_many :models, dependent: :destroy, inverse_of: :user
+      has_many :modelones, dependent: :destroy, inverse_of: :user
     end
   end
 
@@ -61,7 +61,7 @@ describe Mongoid::History::Tracker do
     user = User.new
     user.save!
 
-    model = Model.new(name: 'm1name')
+    model = Modelone.new(name: 'm1name')
     model.user = user
     model.save!
     embedded1 = model.embones.create(name: 'e1name')
@@ -74,4 +74,11 @@ describe Mongoid::History::Tracker do
     expect(embedded1.reload.name).to eq('e1name')
     expect(embedded2.reload.name).to eq('e2name')
   end
+
+  after :all do
+    Object.send(:remove_const, :Modelone)
+    Object.send(:remove_const, :Embone)
+    Object.send(:remove_const, :Embtwo)
+    Object.send(:remove_const, :User)
+  end
 end

data/spec/integration/nested_embedded_polymorphic_documents_spec.rb

@@ -8,7 +8,7 @@ describe Mongoid::History::Tracker do
 
       field :name, type: String
       belongs_to :user
-      embeds_one :embedded_one, as: :embedable
+      embeds_one :one_embedded, as: :embedable
 
       track_history on: :all,
                     modifier_field: :modifier,
@@ -24,7 +24,7 @@ describe Mongoid::History::Tracker do
 
       field :name, type: String
       belongs_to :user
-      embeds_one :embedded_one, as: :embedable
+      embeds_one :one_embedded, as: :embedable
 
       track_history on: :all,
                     modifier_field: :modifier,
@@ -34,7 +34,7 @@ describe Mongoid::History::Tracker do
                     track_destroy: true
     end
 
-    class EmbeddedOne
+    class OneEmbedded
       include Mongoid::Document
       include Mongoid::History::Trackable
 
@@ -56,7 +56,7 @@ describe Mongoid::History::Tracker do
       include Mongoid::History::Trackable
 
       field :name
-      embedded_in :embedded_one
+      embedded_in :one_embedded
 
       track_history on: :all,
                     modifier_field: :modifier,
@@ -80,48 +80,48 @@ describe Mongoid::History::Tracker do
 
     modelone = user.modelones.build(name: 'modelone')
     modelone.save!
-    modelone.build_embedded_one(name: 'modelone_embedded_one').save!
+    modelone.build_one_embedded(name: 'modelone_one_embedded').save!
     expect(modelone.history_tracks.count).to eq(2)
-    expect(modelone.embedded_one.history_tracks.count).to eq(1)
+    expect(modelone.one_embedded.history_tracks.count).to eq(1)
 
     modelone.reload
-    modelone.embedded_one.update_attribute(:name, 'modelone_embedded_one!')
+    modelone.one_embedded.update_attribute(:name, 'modelone_embedded_one!')
     expect(modelone.history_tracks.count).to eq(3)
-    expect(modelone.embedded_one.history_tracks.count).to eq(2)
+    expect(modelone.one_embedded.history_tracks.count).to eq(2)
     expect(modelone.history_tracks.last.action).to eq('update')
 
-    modelone.build_embedded_one(name: 'Lorem ipsum').save!
+    modelone.build_one_embedded(name: 'Lorem ipsum').save!
     expect(modelone.history_tracks.count).to eq(4)
-    expect(modelone.embedded_one.history_tracks.count).to eq(1)
-    expect(modelone.embedded_one.history_tracks.last.action).to eq('create')
-    expect(modelone.embedded_one.history_tracks.last.association_chain.last['name']).to eq('embedded_one')
+    expect(modelone.one_embedded.history_tracks.count).to eq(1)
+    expect(modelone.one_embedded.history_tracks.last.action).to eq('create')
+    expect(modelone.one_embedded.history_tracks.last.association_chain.last['name']).to eq('one_embedded')
 
-    embedded_one1 = modelone.embedded_one.embedded_twos.create(name: 'modelone_embedded_one_1')
+    embedded_one1 = modelone.one_embedded.embedded_twos.create(name: 'modelone_one_embedded_1')
     expect(modelone.history_tracks.count).to eq(5)
-    expect(modelone.embedded_one.history_tracks.count).to eq(2)
+    expect(modelone.one_embedded.history_tracks.count).to eq(2)
     expect(embedded_one1.history_tracks.count).to eq(1)
 
     modeltwo = user.modeltwos.build(name: 'modeltwo')
     modeltwo.save!
-    modeltwo.build_embedded_one(name: 'modeltwo_embedded_one').save!
+    modeltwo.build_one_embedded(name: 'modeltwo_one_embedded').save!
     expect(modeltwo.history_tracks.count).to eq(2)
-    expect(modeltwo.embedded_one.history_tracks.count).to eq(1)
+    expect(modeltwo.one_embedded.history_tracks.count).to eq(1)
 
     modeltwo.reload
-    modeltwo.embedded_one.update_attribute(:name, 'modeltwo_embedded_one!')
+    modeltwo.one_embedded.update_attribute(:name, 'modeltwo_one_embedded!')
     expect(modeltwo.history_tracks.count).to eq(3)
-    expect(modeltwo.embedded_one.history_tracks.count).to eq(2)
+    expect(modeltwo.one_embedded.history_tracks.count).to eq(2)
     expect(modeltwo.history_tracks.last.action).to eq('update')
 
-    modeltwo.build_embedded_one(name: 'Lorem ipsum').save!
+    modeltwo.build_one_embedded(name: 'Lorem ipsum').save!
     expect(modeltwo.history_tracks.count).to eq(4)
-    expect(modeltwo.embedded_one.history_tracks.count).to eq(1)
-    expect(modeltwo.embedded_one.history_tracks.last.action).to eq('create')
-    expect(modeltwo.embedded_one.history_tracks.last.association_chain.last['name']).to eq('embedded_one')
+    expect(modeltwo.one_embedded.history_tracks.count).to eq(1)
+    expect(modeltwo.one_embedded.history_tracks.last.action).to eq('create')
+    expect(modeltwo.one_embedded.history_tracks.last.association_chain.last['name']).to eq('one_embedded')
 
-    embedded_one2 = modeltwo.embedded_one.embedded_twos.create(name: 'modeltwo_embedded_one_1')
+    embedded_one2 = modeltwo.one_embedded.embedded_twos.create(name: 'modeltwo_one_embedded_1')
     expect(modeltwo.history_tracks.count).to eq(5)
-    expect(modeltwo.embedded_one.history_tracks.count).to eq(2)
+    expect(modeltwo.one_embedded.history_tracks.count).to eq(2)
     expect(embedded_one2.history_tracks.count).to eq(1)
   end
 end

data/spec/spec_helper.rb

@@ -5,6 +5,11 @@ $LOAD_PATH.push File.expand_path('../../lib', __FILE__)
 
 require 'active_support/all'
 require 'mongoid'
+require 'request_store'
+
+# Undefine RequestStore so that it may be stubbed in specific tests
+RequestStoreTemp = RequestStore
+Object.send(:remove_const, :RequestStore)
 
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
@@ -15,5 +20,6 @@ RSpec.configure do |config|
   config.before :all do
     Mongoid.logger.level = Logger::INFO
     Mongo::Logger.logger.level = Logger::INFO if Mongoid::Compatibility::Version.mongoid5?
+    Mongoid.belongs_to_required_by_default = false if Mongoid::Compatibility::Version.mongoid6?
   end
 end

data/spec/unit/attributes/base_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Mongoid::History::Attributes::Base do
+  let(:model_one) do
+    Class.new do
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+      field :foo
+      field :b, as: :bar
+      def self.name
+        'ModelOne'
+      end
+    end
+  end
+
+  let(:obj_one) { model_one.new }
+  let(:base) { described_class.new(obj_one) }
+  subject { base }
+
+  it { is_expected.to respond_to(:trackable) }
+
+  describe '#initialize' do
+    it { expect(base.instance_variable_get(:@trackable)).to eq obj_one }
+  end
+
+  describe '#trackable_class' do
+    subject { base.send(:trackable_class) }
+    it { is_expected.to eq model_one }
+  end
+
+  describe '#aliased_fields' do
+    subject { base.send(:aliased_fields) }
+    it { is_expected.to eq('id' => '_id', 'bar' => 'b') }
+  end
+
+  describe '#changes_method' do
+    before(:each) do
+      model_one.instance_variable_set(:@history_trackable_options, nil)
+      model_one.track_history changes_method: :my_changes
+    end
+    subject { base.send(:changes_method) }
+    it { is_expected.to eq :my_changes }
+  end
+
+  describe '#changes' do
+    before(:each) do
+      model_one.instance_variable_set(:@history_trackable_options, nil)
+      model_one.track_history
+      allow(obj_one).to receive(:changes) { { 'foo' => ['Foo', 'Foo-new'] } }
+    end
+    subject { base.send(:changes) }
+    it { is_expected.to eq('foo' => ['Foo', 'Foo-new']) }
+  end
+end

data/spec/unit/attributes/create_spec.rb

@@ -0,0 +1,315 @@
+require 'spec_helper'
+
+describe Mongoid::History::Attributes::Create do
+  let(:model_one) do
+    Class.new do
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+      store_in collection: :model_ones
+      field :foo
+      field :b, as: :bar
+      def self.name
+        'ModelOne'
+      end
+    end
+  end
+
+  let(:obj_one) { model_one.new }
+  let(:base) { described_class.new(obj_one) }
+  subject { base }
+
+  describe '#attributes' 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') }
+      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
+          class ModelTwo
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            store_in collection: :model_twos
+            embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+          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
+        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({}) }
+
+        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
+          class ModelTwo
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            store_in collection: :model_twos
+            embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+          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
+          Object.send(:remove_const, :ModelTwo)
+          Object.send(:remove_const, :EmbOneOne)
+        end
+      end
+
+      context 'when paranoia_field without alias' do
+        before(:all) do
+          # Need class name constant
+          class ModelTwo
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            store_in collection: :model_twos
+            embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+          end
+
+          class EmbOneOne
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            field :em_bar
+            field :removed_at
+            embedded_in :model_one
+          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
+        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) }
+
+        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
+          class ModelTwo
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            store_in collection: :model_twos
+            embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+          end
+
+          class EmbOneOne
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            field :em_bar
+            field :rmvt, as: :removed_at
+            embedded_in :model_one
+          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
+        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) }
+
+        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
+          class ModelTwo
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            store_in collection: :model_twos
+            embeds_one :emb_one_one, inverse_class_name: 'EmbOneOne'
+          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
+          Object.send(:remove_const, :ModelTwo)
+          Object.send(:remove_const, :EmbOneOne)
+        end
+      end
+
+      context 'when relation with alias' do
+        before(:all) do
+          # Need class name constant
+          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'
+          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
+          Object.send(:remove_const, :ModelTwo)
+          Object.send(:remove_const, :EmbOneOne)
+        end
+      end
+
+      context 'when no object' do
+        before(:all) do
+          # Need class name constant
+          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'
+          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 }
+
+        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
+          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'
+          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
+        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
+          Object.send(:remove_const, :ModelTwo)
+          Object.send(:remove_const, :EmbOneOne)
+        end
+      end
+    end
+
+    describe '#insert_embeds_many_changes' do
+    end
+  end
+end