mongoid-history 0.8.0 → 0.8.5

data/spec/unit/callback_options_spec.rb

@@ -1,159 +1,165 @@
-require 'spec_helper'
-
-describe Mongoid::History::Options do
-  describe ':if' do
-    let(:dummy_model) do
-      Class.new do
-        include Mongoid::Document
-        include Mongoid::History::Trackable
-        store_in collection: :model_ones
-        field :foo
-        attr_accessor :bar
-        track_history track_create: true,
-                      track_update: true,
-                      track_destroy: true,
-                      if: :bar
-        def self.name
-          'DummyModel'
-        end
-      end
-    end
-    let(:obj) { dummy_model.new(foo: 'Foo') }
-
-    context 'when condition evaluates to true' do
-      before { obj.bar = true }
-      it 'should create history tracks' do
-        expect { obj.save }.to change(Tracker, :count).by(1)
-        expect do
-          obj.update_attributes(foo: 'Foo-2')
-        end.to change(Tracker, :count).by(1)
-        expect { obj.destroy }.to change(Tracker, :count).by(1)
-      end
-    end
-
-    context 'when condition evaluates to false' do
-      before { obj.bar = false }
-      it 'should not create history tracks' do
-        expect { obj.save }.to_not change(Tracker, :count)
-        expect do
-          obj.update_attributes(foo: 'Foo-2')
-        end.to_not change(Tracker, :count)
-        expect { obj.destroy }.to_not change(Tracker, :count)
-      end
-    end
-  end
-
-  describe ':unless' do
-    let(:dummy_model) do
-      Class.new do
-        include Mongoid::Document
-        include Mongoid::History::Trackable
-        store_in collection: :model_ones
-        field :foo
-        attr_accessor :bar
-        track_history track_create: true,
-                      track_update: true,
-                      track_destroy: true,
-                      unless: ->(obj) { obj.bar }
-        def self.name
-          'DummyModel'
-        end
-      end
-    end
-    let(:obj) { dummy_model.new(foo: 'Foo') }
-
-    context 'when condition evaluates to true' do
-      before { obj.bar = true }
-      it 'should not create history tracks' do
-        expect { obj.save }.to_not change(Tracker, :count)
-        expect do
-          obj.update_attributes(foo: 'Foo-2')
-        end.to_not change(Tracker, :count)
-        expect { obj.destroy }.to_not change(Tracker, :count)
-      end
-    end
-
-    context 'when condition evaluates to false' do
-      before { obj.bar = false }
-      it 'should create history tracks' do
-        expect { obj.save }.to change(Tracker, :count).by(1)
-        expect do
-          obj.update_attributes(foo: 'Foo-2')
-        end.to change(Tracker, :count).by(1)
-        expect { obj.destroy }.to change(Tracker, :count).by(1)
-      end
-    end
-  end
-
-  describe ':if and :unless' do
-    let(:dummy_model) do
-      Class.new do
-        include Mongoid::Document
-        include Mongoid::History::Trackable
-        store_in collection: :model_ones
-        field :foo
-        attr_accessor :bar, :baz
-        track_history track_create: true,
-                      track_update: true,
-                      track_destroy: true,
-                      if: :bar, unless: ->(obj) { obj.baz }
-        def self.name
-          'DummyModel'
-        end
-      end
-    end
-    let(:obj) { dummy_model.new(foo: 'Foo') }
-
-    context 'when :if condition evaluates to true' do
-      before { obj.bar = true }
-
-      context 'and :unless condition evaluates to true' do
-        before { obj.baz = true }
-        it 'should not create history tracks' do
-          expect { obj.save }.to_not change(Tracker, :count)
-          expect do
-            obj.update_attributes(foo: 'Foo-2')
-          end.to_not change(Tracker, :count)
-          expect { obj.destroy }.to_not change(Tracker, :count)
-        end
-      end
-
-      context 'and :unless condition evaluates to false' do
-        before { obj.baz = false }
-        it 'should create history tracks' do
-          expect { obj.save }.to change(Tracker, :count).by(1)
-          expect do
-            obj.update_attributes(foo: 'Foo-2')
-          end.to change(Tracker, :count).by(1)
-          expect { obj.destroy }.to change(Tracker, :count).by(1)
-        end
-      end
-    end
-
-    context 'when :if condition evaluates to false' do
-      before { obj.bar = false }
-
-      context 'and :unless condition evaluates to true' do
-        before { obj.baz = true }
-        it 'should not create history tracks' do
-          expect { obj.save }.to_not change(Tracker, :count)
-          expect do
-            obj.update_attributes(foo: 'Foo-2')
-          end.to_not change(Tracker, :count)
-          expect { obj.destroy }.to_not change(Tracker, :count)
-        end
-      end
-
-      context 'and :unless condition evaluates to false' do
-        before { obj.baz = false }
-        it 'should not create history tracks' do
-          expect { obj.save }.to_not change(Tracker, :count)
-          expect do
-            obj.update_attributes(foo: 'Foo-2')
-          end.to_not change(Tracker, :count)
-          expect { obj.destroy }.to_not change(Tracker, :count)
-        end
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe Mongoid::History::Options do
+  describe ':if' do
+    before :each do
+      class DummyModel
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        store_in collection: :model_ones
+        field :foo
+
+        attr_accessor :bar
+
+        track_history modifier_field_optional: true, if: :bar
+      end
+    end
+
+    after :each do
+      Object.send(:remove_const, :DummyModel)
+    end
+
+    let(:obj) { DummyModel.new(foo: 'Foo') }
+
+    context 'when condition evaluates to true' do
+      before { obj.bar = true }
+      it 'should create history tracks' do
+        expect { obj.save }.to change(Tracker, :count).by(1)
+        expect do
+          obj.update_attributes(foo: 'Foo-2')
+        end.to change(Tracker, :count).by(1)
+        expect { obj.destroy }.to change(Tracker, :count).by(1)
+      end
+    end
+
+    context 'when condition evaluates to false' do
+      before { obj.bar = false }
+      it 'should not create history tracks' do
+        expect { obj.save }.to_not change(Tracker, :count)
+        expect do
+          obj.update_attributes(foo: 'Foo-2')
+        end.to_not change(Tracker, :count)
+        expect { obj.destroy }.to_not change(Tracker, :count)
+      end
+    end
+  end
+
+  describe ':unless' do
+    before :each do
+      class DummyModel
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        store_in collection: :model_ones
+        field :foo
+
+        attr_accessor :bar
+
+        track_history modifier_field_optional: true, unless: ->(obj) { obj.bar }
+      end
+    end
+
+    after :each do
+      Object.send(:remove_const, :DummyModel)
+    end
+
+    let(:obj) { DummyModel.new(foo: 'Foo') }
+
+    context 'when condition evaluates to true' do
+      before { obj.bar = true }
+      it 'should not create history tracks' do
+        expect { obj.save }.to_not change(Tracker, :count)
+        expect do
+          obj.update_attributes(foo: 'Foo-2')
+        end.to_not change(Tracker, :count)
+        expect { obj.destroy }.to_not change(Tracker, :count)
+      end
+    end
+
+    context 'when condition evaluates to false' do
+      before { obj.bar = false }
+      it 'should create history tracks' do
+        expect { obj.save }.to change(Tracker, :count).by(1)
+        expect do
+          obj.update_attributes(foo: 'Foo-2')
+        end.to change(Tracker, :count).by(1)
+        expect { obj.destroy }.to change(Tracker, :count).by(1)
+      end
+    end
+  end
+
+  describe ':if and :unless' do
+    before :each do
+      class DummyModel
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        store_in collection: :model_ones
+        field :foo
+
+        attr_accessor :bar, :baz
+
+        track_history modifier_field_optional: true, if: :bar, unless: ->(obj) { obj.baz }
+      end
+    end
+
+    after :each do
+      Object.send(:remove_const, :DummyModel)
+    end
+
+    let(:obj) { DummyModel.new(foo: 'Foo') }
+
+    context 'when :if condition evaluates to true' do
+      before { obj.bar = true }
+
+      context 'and :unless condition evaluates to true' do
+        before { obj.baz = true }
+        it 'should not create history tracks' do
+          expect { obj.save }.to_not change(Tracker, :count)
+          expect do
+            obj.update_attributes(foo: 'Foo-2')
+          end.to_not change(Tracker, :count)
+          expect { obj.destroy }.to_not change(Tracker, :count)
+        end
+      end
+
+      context 'and :unless condition evaluates to false' do
+        before { obj.baz = false }
+        it 'should create history tracks' do
+          expect { obj.save }.to change(Tracker, :count).by(1)
+          expect do
+            obj.update_attributes(foo: 'Foo-2')
+          end.to change(Tracker, :count).by(1)
+          expect { obj.destroy }.to change(Tracker, :count).by(1)
+        end
+      end
+    end
+
+    context 'when :if condition evaluates to false' do
+      before { obj.bar = false }
+
+      context 'and :unless condition evaluates to true' do
+        before { obj.baz = true }
+        it 'should not create history tracks' do
+          expect { obj.save }.to_not change(Tracker, :count)
+          expect do
+            obj.update_attributes(foo: 'Foo-2')
+          end.to_not change(Tracker, :count)
+          expect { obj.destroy }.to_not change(Tracker, :count)
+        end
+      end
+
+      context 'and :unless condition evaluates to false' do
+        before { obj.baz = false }
+        it 'should not create history tracks' do
+          expect { obj.save }.to_not change(Tracker, :count)
+          expect do
+            obj.update_attributes(foo: 'Foo-2')
+          end.to_not change(Tracker, :count)
+          expect { obj.destroy }.to_not change(Tracker, :count)
+        end
+      end
+    end
+  end
+end

data/spec/unit/embedded_methods_spec.rb

@@ -1,69 +1,87 @@
-require 'spec_helper'
-
-describe Mongoid::History::Trackable do
-  describe 'EmbeddedMethods' do
-    describe 'embeds_one_class' do
-      before :all do
-        ModelOne = Class.new do
-          include Mongoid::Document
-          include Mongoid::History::Trackable
-          embeds_one :emb_one, inverse_class_name: 'EmbOne'
-          embeds_one :emb_two, store_as: 'emt', inverse_class_name: 'EmbTwo'
-          track_history
-        end
-
-        EmbOne = Class.new do
-          include Mongoid::Document
-          embedded_in :model_one
-        end
-
-        EmbTwo = Class.new do
-          include Mongoid::Document
-          embedded_in :model_one
-        end
-      end
-
-      it { expect(ModelOne.embeds_one_class('emb_one')).to eq EmbOne }
-      it { expect(ModelOne.embeds_one_class('emt')).to eq EmbTwo }
-      it { expect(ModelOne.embeds_one_class('invalid')).to be_nil }
-
-      after :all do
-        Object.send(:remove_const, :ModelOne)
-        Object.send(:remove_const, :EmbOne)
-        Object.send(:remove_const, :EmbTwo)
-      end
-    end
-
-    describe 'embeds_many_class' do
-      before :all do
-        ModelOne = Class.new do
-          include Mongoid::Document
-          include Mongoid::History::Trackable
-          embeds_many :emb_ones, inverse_class_name: 'EmbOne'
-          embeds_many :emb_twos, store_as: 'emts', inverse_class_name: 'EmbTwo'
-          track_history
-        end
-
-        EmbOne = Class.new do
-          include Mongoid::Document
-          embedded_in :model_one
-        end
-
-        EmbTwo = Class.new do
-          include Mongoid::Document
-          embedded_in :model_one
-        end
-      end
-
-      it { expect(ModelOne.embeds_many_class('emb_ones')).to eq EmbOne }
-      it { expect(ModelOne.embeds_many_class('emts')).to eq EmbTwo }
-      it { expect(ModelOne.embeds_many_class('invalid')).to be_nil }
-
-      after :all do
-        Object.send(:remove_const, :ModelOne)
-        Object.send(:remove_const, :EmbOne)
-        Object.send(:remove_const, :EmbTwo)
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe Mongoid::History::Trackable do
+  describe 'EmbeddedMethods' do
+    describe 'relation_class_of' do
+      before :each do
+        class ModelOne
+          include Mongoid::Document
+          include Mongoid::History::Trackable
+
+          if Mongoid::Compatibility::Version.mongoid7_or_newer?
+            embeds_one :emb_one
+            embeds_one :emb_two, store_as: 'emt'
+          else
+            embeds_one :emb_one, inverse_class_name: 'EmbOne'
+            embeds_one :emb_two, store_as: 'emt', inverse_class_name: 'EmbTwo'
+          end
+
+          track_history
+        end
+
+        class EmbOne
+          include Mongoid::Document
+
+          embedded_in :model_one
+        end
+
+        class EmbTwo
+          include Mongoid::Document
+
+          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
+
+      it { expect(ModelOne.relation_class_of('emb_one')).to eq EmbOne }
+      it { expect(ModelOne.relation_class_of('emt')).to eq EmbTwo }
+      it { expect(ModelOne.relation_class_of('invalid')).to be_nil }
+    end
+
+    describe 'relation_class_of' do
+      before :each do
+        class ModelOne
+          include Mongoid::Document
+          include Mongoid::History::Trackable
+
+          if Mongoid::Compatibility::Version.mongoid7_or_newer?
+            embeds_many :emb_ones
+            embeds_many :emb_twos, store_as: 'emts'
+          else
+            embeds_many :emb_ones, inverse_class_name: 'EmbOne'
+            embeds_many :emb_twos, store_as: 'emts', inverse_class_name: 'EmbTwo'
+          end
+
+          track_history
+        end
+
+        class EmbOne
+          include Mongoid::Document
+
+          embedded_in :model_one
+        end
+
+        class EmbTwo
+          include Mongoid::Document
+
+          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
+
+      it { expect(ModelOne.relation_class_of('emb_ones')).to eq EmbOne }
+      it { expect(ModelOne.relation_class_of('emts')).to eq EmbTwo }
+      it { expect(ModelOne.relation_class_of('invalid')).to be_nil }
+    end
+  end
+end

data/spec/unit/history_spec.rb

@@ -1,35 +1,58 @@
-require 'spec_helper'
-
-describe Mongoid::History do
-  it { is_expected.to respond_to(:trackable_settings) }
-  it { is_expected.to respond_to(:trackable_settings=) }
-
-  describe '#default_settings' do
-    let(:default_settings) { { paranoia_field: 'deleted_at' } }
-    it { expect(described_class.default_settings).to eq(default_settings) }
-  end
-
-  describe '#trackable_class_settings' do
-    before(:each) { Mongoid::History.trackable_settings = {} }
-    let(:model_one) do
-      Class.new do
-        include Mongoid::Document
-        include Mongoid::History::Trackable
-        store_in collection: :model_ones
-
-        def self.name
-          'ModelOne'
-        end
-      end
-    end
-
-    context 'when present' do
-      before(:each) { model_one.history_settings paranoia_field: :annuled_at }
-      it { expect(described_class.trackable_class_settings(model_one)).to eq(paranoia_field: 'annuled_at') }
-    end
-
-    context 'when not present' do
-      it { expect(described_class.trackable_class_settings(model_one)).to eq(paranoia_field: 'deleted_at') }
-    end
-  end
-end
+require 'spec_helper'
+
+describe Mongoid::History do
+  it { is_expected.to respond_to(:trackable_settings) }
+  it { is_expected.to respond_to(:trackable_settings=) }
+
+  describe '#default_settings' do
+    let(:default_settings) { { paranoia_field: 'deleted_at' } }
+    it { expect(described_class.default_settings).to eq(default_settings) }
+  end
+
+  describe '#trackable_class_settings' do
+    before :each do
+      class ModelOne
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        store_in collection: :model_ones
+      end
+    end
+
+    after :each do
+      Object.send(:remove_const, :ModelOne)
+    end
+
+    context 'when present' do
+      before :each do
+        ModelOne.history_settings paranoia_field: :annuled_at
+      end
+      it { expect(described_class.trackable_class_settings(ModelOne)).to eq(paranoia_field: 'annuled_at') }
+    end
+
+    context 'when not present' do
+      it { expect(described_class.trackable_class_settings(ModelOne)).to eq(paranoia_field: 'deleted_at') }
+    end
+  end
+
+  describe '#reset!' do
+    before :each do
+      class ModelTwo
+        include Mongoid::Document
+        include Mongoid::History::Trackable
+
+        track_history
+      end
+    end
+
+    after :each do
+      Object.send(:remove_const, :ModelTwo)
+    end
+
+    it 'should remove all configurations' do
+      expect(ModelTwo).to have_attributes mongoid_history_options: be_a(Mongoid::History::Options)
+      Mongoid::History.reset!
+      expect(ModelTwo).to_not respond_to :mongoid_history_options
+    end
+  end
+end