mongoid-history 0.8.3 → 0.8.5

data/spec/integration/multi_relation_spec.rb

@@ -1,47 +1,47 @@
-require 'spec_helper'
-
-describe Mongoid::History::Tracker do
-  before :each do
-    class Model
-      include Mongoid::Document
-      include Mongoid::History::Trackable
-
-      field :name, type: String
-      belongs_to :user, inverse_of: :models
-      has_and_belongs_to_many :external_users, class_name: 'User', inverse_of: :external_models
-
-      track_history on: %i[name user external_user_ids], modifier_field_inverse_of: nil
-    end
-
-    class User
-      include Mongoid::Document
-
-      has_many :models, dependent: :destroy, inverse_of: :user
-      has_and_belongs_to_many :external_model, class_name: 'Model', inverse_of: :external_users
-    end
-  end
-
-  after :each do
-    Object.send(:remove_const, :Model)
-    Object.send(:remove_const, :User)
-  end
-
-  let(:user) { User.create! }
-  let(:model) { Model.create!(name: 'Foo', user: user, modifier: user) }
-
-  it 'should be possible to undo when having multiple relations to modifier class' do
-    model.update_attributes!(name: 'Bar', modifier: user)
-
-    model.undo! user
-    expect(model.name).to eq 'Foo'
-
-    model.redo! user, 2
-    expect(model.name).to eq 'Bar'
-  end
-
-  it 'should track foreign key relations' do
-    expect(Model.tracked_field?(:external_user_ids)).to be true
-    expect(Model.tracked_field?(:user)).to be true
-    expect(Model.tracked_field?(:user_id)).to be true
-  end
-end
+require 'spec_helper'
+
+describe Mongoid::History::Tracker do
+  before :each do
+    class Model
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+
+      field :name, type: String
+      belongs_to :user, inverse_of: :models
+      has_and_belongs_to_many :external_users, class_name: 'User', inverse_of: :external_models
+
+      track_history on: %i[name user external_user_ids], modifier_field_inverse_of: nil
+    end
+
+    class User
+      include Mongoid::Document
+
+      has_many :models, dependent: :destroy, inverse_of: :user
+      has_and_belongs_to_many :external_model, class_name: 'Model', inverse_of: :external_users
+    end
+  end
+
+  after :each do
+    Object.send(:remove_const, :Model)
+    Object.send(:remove_const, :User)
+  end
+
+  let(:user) { User.create! }
+  let(:model) { Model.create!(name: 'Foo', user: user, modifier: user) }
+
+  it 'should be possible to undo when having multiple relations to modifier class' do
+    model.update_attributes!(name: 'Bar', modifier: user)
+
+    model.undo! user
+    expect(model.name).to eq 'Foo'
+
+    model.redo! user, 2
+    expect(model.name).to eq 'Bar'
+  end
+
+  it 'should track foreign key relations' do
+    expect(Model.tracked_field?(:external_user_ids)).to be true
+    expect(Model.tracked_field?(:user)).to be true
+    expect(Model.tracked_field?(:user_id)).to be true
+  end
+end

data/spec/integration/multiple_trackers_spec.rb

@@ -1,68 +1,68 @@
-require 'spec_helper'
-
-describe Mongoid::History do
-  before :each do
-    class First
-      include Mongoid::Document
-      include Mongoid::History::Trackable
-
-      field :text, type: String
-      track_history on: [:text], tracker_class_name: :first_history_tracker
-    end
-
-    class Second
-      include Mongoid::Document
-      include Mongoid::History::Trackable
-
-      field :text, type: String
-      track_history on: [:text], tracker_class_name: :second_history_tracker
-    end
-
-    class User
-      include Mongoid::Document
-    end
-
-    class FirstHistoryTracker
-      include Mongoid::History::Tracker
-    end
-
-    class SecondHistoryTracker
-      include Mongoid::History::Tracker
-    end
-  end
-
-  after :each do
-    Object.send(:remove_const, :First)
-    Object.send(:remove_const, :Second)
-    Object.send(:remove_const, :User)
-    Object.send(:remove_const, :FirstHistoryTracker)
-    Object.send(:remove_const, :SecondHistoryTracker)
-  end
-
-  let(:user) { User.create! }
-
-  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(First.tracker_class).to be FirstHistoryTracker
-    expect(Second.tracker_class).to be SecondHistoryTracker
-
-    foo = First.create!(modifier: user)
-    bar = Second.create!(modifier: user)
-
-    expect(FirstHistoryTracker.count).to eq 1
-    expect(SecondHistoryTracker.count).to eq 1
-
-    foo.update_attributes!(text: "I'm foo")
-    bar.update_attributes!(text: "I'm bar")
-
-    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
+require 'spec_helper'
+
+describe Mongoid::History do
+  before :each do
+    class First
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+
+      field :text, type: String
+      track_history on: [:text], tracker_class_name: :first_history_tracker
+    end
+
+    class Second
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+
+      field :text, type: String
+      track_history on: [:text], tracker_class_name: :second_history_tracker
+    end
+
+    class User
+      include Mongoid::Document
+    end
+
+    class FirstHistoryTracker
+      include Mongoid::History::Tracker
+    end
+
+    class SecondHistoryTracker
+      include Mongoid::History::Tracker
+    end
+  end
+
+  after :each do
+    Object.send(:remove_const, :First)
+    Object.send(:remove_const, :Second)
+    Object.send(:remove_const, :User)
+    Object.send(:remove_const, :FirstHistoryTracker)
+    Object.send(:remove_const, :SecondHistoryTracker)
+  end
+
+  let(:user) { User.create! }
+
+  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(First.tracker_class).to be FirstHistoryTracker
+    expect(Second.tracker_class).to be SecondHistoryTracker
+
+    foo = First.create!(modifier: user)
+    bar = Second.create!(modifier: user)
+
+    expect(FirstHistoryTracker.count).to eq 1
+    expect(SecondHistoryTracker.count).to eq 1
+
+    foo.update_attributes!(text: "I'm foo")
+    bar.update_attributes!(text: "I'm bar")
+
+    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_documents_spec.rb

@@ -1,64 +1,64 @@
-require 'spec_helper'
-
-describe Mongoid::History::Tracker do
-  before :each do
-    class ModelOne
-      include Mongoid::Document
-      include Mongoid::History::Trackable
-
-      field :name, type: String
-      belongs_to :user, inverse_of: :model_ones
-      embeds_many :emb_ones
-
-      track_history
-    end
-
-    class EmbOne
-      include Mongoid::Document
-      include Mongoid::History::Trackable
-
-      field :name
-      embeds_many :emb_twos, store_as: :ems
-      embedded_in :model_one
-
-      track_history
-    end
-
-    class EmbTwo
-      include Mongoid::Document
-      include Mongoid::History::Trackable
-
-      field :name
-      embedded_in :emb_one
-
-      track_history scope: :model_one
-    end
-
-    class User
-      include Mongoid::Document
-
-      has_many :model_ones, dependent: :destroy, inverse_of: :user
-    end
-  end
-
-  after :each do
-    Object.send(:remove_const, :ModelOne)
-    Object.send(:remove_const, :EmbOne)
-    Object.send(:remove_const, :EmbTwo)
-    Object.send(:remove_const, :User)
-  end
-
-  let(:user) { User.create! }
-
-  it 'should be able to track history for nested embedded documents' do
-    model = ModelOne.create!(name: 'm1name', user: user, modifier: user)
-    embedded1 = model.emb_ones.create!(name: 'e1name', modifier: user)
-    embedded2 = embedded1.emb_twos.create!(name: 'e2name', modifier: user)
-
-    embedded2.update_attributes!(name: 'a new name')
-
-    model.history_tracks[-1].undo! user
-    expect(embedded1.reload.name).to eq('e1name')
-    expect(embedded2.reload.name).to eq('e2name')
-  end
-end
+require 'spec_helper'
+
+describe Mongoid::History::Tracker do
+  before :each do
+    class ModelOne
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+
+      field :name, type: String
+      belongs_to :user, inverse_of: :model_ones
+      embeds_many :emb_ones
+
+      track_history
+    end
+
+    class EmbOne
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+
+      field :name
+      embeds_many :emb_twos, store_as: :ems
+      embedded_in :model_one
+
+      track_history
+    end
+
+    class EmbTwo
+      include Mongoid::Document
+      include Mongoid::History::Trackable
+
+      field :name
+      embedded_in :emb_one
+
+      track_history scope: :model_one
+    end
+
+    class User
+      include Mongoid::Document
+
+      has_many :model_ones, dependent: :destroy, inverse_of: :user
+    end
+  end
+
+  after :each do
+    Object.send(:remove_const, :ModelOne)
+    Object.send(:remove_const, :EmbOne)
+    Object.send(:remove_const, :EmbTwo)
+    Object.send(:remove_const, :User)
+  end
+
+  let(:user) { User.create! }
+
+  it 'should be able to track history for nested embedded documents' do
+    model = ModelOne.create!(name: 'm1name', user: user, modifier: user)
+    embedded1 = model.emb_ones.create!(name: 'e1name', modifier: user)
+    embedded2 = embedded1.emb_twos.create!(name: 'e2name', modifier: user)
+
+    embedded2.update_attributes!(name: 'a new name')
+
+    model.history_tracks[-1].undo! user
+    expect(embedded1.reload.name).to eq('e1name')
+    expect(embedded2.reload.name).to eq('e2name')
+  end
+end

data/spec/integration/nested_embedded_documents_tracked_in_parent_spec.rb

@@ -1,124 +1,124 @@
-require 'spec_helper'
-
-describe Mongoid::History::Tracker do
-  describe 'Tracking of changes from embedded documents' do
-    before :each do
-      # Child model (will be embedded in Parent)
-      class Child
-        include Mongoid::Document
-        include Mongoid::History::Trackable
-
-        field :name
-        embedded_in :parent, inverse_of: :child
-        embeds_one :child, inverse_of: :parent, class_name: 'NestedChild'
-      end
-
-      # NestedChild model (will be embedded in Child)
-      class NestedChild
-        include Mongoid::Document
-        include Mongoid::History::Trackable
-
-        field :name
-        embedded_in :parent, inverse_of: :child, class_name: 'Child'
-      end
-
-      # Parent model (embeds one Child)
-      class Parent
-        include Mongoid::Document
-        include Mongoid::History::Trackable
-
-        field :name, type: String
-        embeds_one :child
-
-        store_in collection: :parent
-
-        track_history(
-          on: %i[fields embedded_relations],
-          version_field: :version,
-          track_create: true,
-          track_update: true,
-          track_destroy: false,
-          modifier_field: nil
-        )
-      end
-    end
-
-    after :each do
-      Object.send(:remove_const, :Parent)
-      Object.send(:remove_const, :Child)
-      Object.send(:remove_const, :NestedChild)
-    end
-
-    context 'with a parent-child hierarchy' do
-      let(:parent) do
-        Parent.create!(name: 'bowser', child: Child.new(name: 'todd'))
-      end
-
-      it 'tracks history for the nested embedded documents in the parent' do
-        expect(parent.history_tracks.length).to eq(1)
-
-        aggregate_failures do
-          track = parent.history_tracks.last
-          expect(track.modified['name']).to eq('bowser')
-          expect(track.modified.dig('child', 'name')).to eq('todd')
-        end
-
-        parent.update_attributes(name: 'brow')
-        expect(parent.history_tracks.length).to eq(2)
-
-        parent.child.name = 'mario'
-        parent.save!
-        expect(parent.history_tracks.length).to eq(3)
-
-        aggregate_failures do
-          track = parent.history_tracks.last
-          expect(track.original.dig('child', 'name')).to eq('todd')
-          expect(track.modified.dig('child', 'name')).to eq('mario')
-        end
-      end
-    end
-
-    context 'with a deeply nested hierarchy' do
-      let(:parent) do
-        Parent.create!(
-          name: 'bowser',
-          child: Child.new(
-            name: 'todd',
-            child: NestedChild.new(name: 'peach')
-          )
-        )
-      end
-
-      it 'tracks history for deeply nested embedded documents in parent' do
-        pending('Figure out a way to track deeply nested relation changes')
-
-        expect(parent.history_tracks.length).to eq(1)
-
-        aggregate_failures do
-          track = parent.history_tracks.last
-          expect(track.modified['name']).to eq('bowser')
-          expect(track.modified.dig('child', 'name')).to eq('todd')
-          expect(track.modified.dig('child', 'child', 'name')).to eq('peach')
-        end
-
-        parent.name = 'brow'
-        parent.child.name = 'mario'
-        parent.child.child.name = 'luigi'
-        parent.save!
-        expect(parent.history_tracks.length).to eq(2)
-
-        aggregate_failures do
-          track = parent.history_tracks.last
-          expect(track.original['name']).to eq('bowser')
-          expect(track.modified['name']).to eq('brow')
-
-          expect(track.original['child']['name']).to eq('todd')
-          expect(track.modified['child']['name']).to eq('mario')
-
-          expect(track.original['child']['child']['name']).to eq('peach')
-          expect(track.modified['child']['child']['name']).to eq('luigi')
-        end
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe Mongoid::History::Tracker do
+  describe 'Tracking of changes from embedded documents' do
+    before :each do
+      # Child model (will be embedded in Parent)
+      class Child
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        field :name
+        embedded_in :parent, inverse_of: :child
+        embeds_one :child, inverse_of: :parent, class_name: 'NestedChild'
+      end
+
+      # NestedChild model (will be embedded in Child)
+      class NestedChild
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        field :name
+        embedded_in :parent, inverse_of: :child, class_name: 'Child'
+      end
+
+      # Parent model (embeds one Child)
+      class Parent
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        field :name, type: String
+        embeds_one :child
+
+        store_in collection: :parent
+
+        track_history(
+          on: %i[fields embedded_relations],
+          version_field: :version,
+          track_create: true,
+          track_update: true,
+          track_destroy: false,
+          modifier_field: nil
+        )
+      end
+    end
+
+    after :each do
+      Object.send(:remove_const, :Parent)
+      Object.send(:remove_const, :Child)
+      Object.send(:remove_const, :NestedChild)
+    end
+
+    context 'with a parent-child hierarchy' do
+      let(:parent) do
+        Parent.create!(name: 'bowser', child: Child.new(name: 'todd'))
+      end
+
+      it 'tracks history for the nested embedded documents in the parent' do
+        expect(parent.history_tracks.length).to eq(1)
+
+        aggregate_failures do
+          track = parent.history_tracks.last
+          expect(track.modified['name']).to eq('bowser')
+          expect(track.modified.dig('child', 'name')).to eq('todd')
+        end
+
+        parent.update_attributes(name: 'brow')
+        expect(parent.history_tracks.length).to eq(2)
+
+        parent.child.name = 'mario'
+        parent.save!
+        expect(parent.history_tracks.length).to eq(3)
+
+        aggregate_failures do
+          track = parent.history_tracks.last
+          expect(track.original.dig('child', 'name')).to eq('todd')
+          expect(track.modified.dig('child', 'name')).to eq('mario')
+        end
+      end
+    end
+
+    context 'with a deeply nested hierarchy' do
+      let(:parent) do
+        Parent.create!(
+          name: 'bowser',
+          child: Child.new(
+            name: 'todd',
+            child: NestedChild.new(name: 'peach')
+          )
+        )
+      end
+
+      it 'tracks history for deeply nested embedded documents in parent' do
+        pending('Figure out a way to track deeply nested relation changes')
+
+        expect(parent.history_tracks.length).to eq(1)
+
+        aggregate_failures do
+          track = parent.history_tracks.last
+          expect(track.modified['name']).to eq('bowser')
+          expect(track.modified.dig('child', 'name')).to eq('todd')
+          expect(track.modified.dig('child', 'child', 'name')).to eq('peach')
+        end
+
+        parent.name = 'brow'
+        parent.child.name = 'mario'
+        parent.child.child.name = 'luigi'
+        parent.save!
+        expect(parent.history_tracks.length).to eq(2)
+
+        aggregate_failures do
+          track = parent.history_tracks.last
+          expect(track.original['name']).to eq('bowser')
+          expect(track.modified['name']).to eq('brow')
+
+          expect(track.original['child']['name']).to eq('todd')
+          expect(track.modified['child']['name']).to eq('mario')
+
+          expect(track.original['child']['child']['name']).to eq('peach')
+          expect(track.modified['child']['child']['name']).to eq('luigi')
+        end
+      end
+    end
+  end
+end