mongoid-history 0.6.1 → 0.8.5

data/spec/integration/multi_relation_spec.rb

@@ -1,53 +1,47 @@
-require 'spec_helper'
-
-describe Mongoid::History::Tracker do
-  before :all 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: [: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
-                    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
-    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
-
-  it 'should be possible to undo when having multiple relations to modifier class' do
-    user = User.new
-    user.save
-
-    model = Model.new
-    model.name = 'Foo'
-    model.user = user
-    model.save!
-
-    model.name = 'Bar'
-    model.save!
-
-    model.undo! user
-    expect(model.name).to eq('Foo')
-
-    model.redo! user, 1
-    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

@@ -0,0 +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

data/spec/integration/nested_embedded_documents_spec.rb

@@ -1,84 +1,64 @@
-require 'spec_helper'
-
-describe Mongoid::History::Tracker do
-  before :all do
-    class Modelone
-      include Mongoid::Document
-      include Mongoid::History::Trackable
-
-      field :name, type: String
-      belongs_to :user, inverse_of: :modelones
-      embeds_many :embones
-
-      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
-                    version_field: :version,   # adds "field :version, :type => Integer" to track current version, default is :version
-                    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
-    end
-
-    class Embone
-      include Mongoid::Document
-      include Mongoid::History::Trackable
-
-      field :name
-      embeds_many :embtwos, store_as: :ems
-      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
-                    version_field: :version,   # adds "field :version, :type => Integer" to track current version, default is :version
-                    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
-    end
-
-    class Embtwo
-      include Mongoid::Document
-      include Mongoid::History::Trackable
-
-      field :name
-      embedded_in :embone
-
-      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
-                    version_field: :version,   # adds "field :version, :type => Integer" to track current version, default is :version
-                    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: :modelone
-    end
-
-    class User
-      include Mongoid::Document
-      has_many :modelones, dependent: :destroy, inverse_of: :user
-    end
-  end
-
-  it 'should be able to track history for nested embedded documents' do
-    user = User.new
-    user.save!
-
-    model = Modelone.new(name: 'm1name')
-    model.user = user
-    model.save!
-    embedded1 = model.embones.create(name: 'e1name')
-    embedded2 = embedded1.embtwos.create(name: 'e2name')
-
-    embedded2.name = 'a new name'
-    embedded2.save!
-
-    model.history_tracks.first.undo! user
-    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
+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

@@ -0,0 +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