mongoid-history 0.5.0 → 0.6.0

data/spec/unit/attributes/destroy_spec.rb

@@ -0,0 +1,218 @@
+require 'spec_helper'
+
+describe Mongoid::History::Attributes::Destroy 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
+        obj_one.save!
+      end
+      let(:obj_one) { model_one.new(foo: 'Foo', bar: 'Bar') }
+      it { is_expected.to eq('_id' => [obj_one._id, nil], 'foo' => ['Foo', nil]) }
+    end
+
+    describe '#insert_embeds_one_changes' do
+      before(:all) do
+        # Need class name constant. So, defining class like this
+        class ModelTwo
+          include Mongoid::Document
+          include Mongoid::History::Trackable
+          store_in collection: :model_twos
+          embeds_one :emb_two
+          track_history on: :fields
+        end
+
+        class EmbTwo
+          include Mongoid::Document
+          field :em_foo
+          field :em_bar
+          embedded_in :model_two
+        end
+      end
+
+      before(:each) { ModelTwo.clear_trackable_memoization }
+      let(:obj_two) { ModelTwo.new(emb_two: emb_obj_two) }
+      let(:emb_obj_two) { EmbTwo.new(em_foo: 'Em-Foo', em_bar: 'Em-Bar') }
+      let(:base) { described_class.new(obj_two) }
+
+      context 'when relation tracked' do
+        before(:each) do
+          ModelTwo.track_history on: :emb_two
+          obj_two.save!
+        end
+        it { expect(subject['emb_two']).to eq [{ '_id' => emb_obj_two._id, 'em_foo' => 'Em-Foo', 'em_bar' => 'Em-Bar' }, nil] }
+      end
+
+      context 'when relation not tracked' do
+        before(:each) do
+          ModelTwo.track_history on: :fields
+          allow(ModelTwo).to receive(:dynamic_enabled?) { false }
+          obj_two.save!
+        end
+        it { expect(subject['emb_two']).to be_nil }
+      end
+
+      context 'when relation with alias' do
+        before(:all) do
+          # Need class name constant. So, defining class like this
+          class ModelThree
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            store_in collection: :model_threes
+            embeds_one :emb_three, store_as: :emtr
+          end
+
+          class EmbThree
+            include Mongoid::Document
+            field :em_foo
+            embedded_in :model_three
+          end
+        end
+
+        before(:each) do
+          ModelThree.instance_variable_set(:@history_trackable_options, nil)
+          ModelThree.track_history on: :emb_three
+          obj_three.save!
+        end
+
+        let(:obj_three) { ModelThree.new(emb_three: emb_obj_three) }
+        let(:emb_obj_three) { EmbThree.new(em_foo: 'Em-Foo') }
+        let(:base) { described_class.new(obj_three) }
+        it { expect(subject['emb_three']).to eq [{ '_id' => emb_obj_three._id, 'em_foo' => 'Em-Foo' }, nil] }
+
+        after(:all) do
+          Object.send(:remove_const, :ModelThree)
+          Object.send(:remove_const, :EmbThree)
+        end
+      end
+
+      context 'relation with permitted attributes' do
+        before(:each) do
+          ModelTwo.track_history on: [{ emb_two: :em_foo }]
+          obj_two.save!
+        end
+        it { expect(subject['emb_two']).to eq [{ '_id' => emb_obj_two._id, 'em_foo' => 'Em-Foo' }, nil] }
+      end
+
+      context 'when relation object not built' do
+        before(:each) do
+          ModelTwo.track_history on: :emb_two
+          obj_two.save!
+        end
+        let(:obj_two) { ModelTwo.new }
+        it { expect(subject['emb_two']).to be_nil }
+      end
+
+      after(:all) do
+        Object.send(:remove_const, :ModelTwo)
+        Object.send(:remove_const, :EmbTwo)
+      end
+    end
+
+    describe '#insert_embeds_many_changes' do
+      context 'Case 1:' do
+        before(:all) do
+          class ModelTwo
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            embeds_many :em_twos
+            track_history on: :fields
+          end
+
+          class EmTwo
+            include Mongoid::Document
+            field :em_foo
+            field :em_bar
+            embedded_in :model_two
+          end
+        end
+
+        let(:obj_two) { ModelTwo.new(em_twos: [em_obj_two]) }
+        let(:em_obj_two) { EmTwo.new(em_foo: 'Em-Foo', em_bar: 'Em-Bar') }
+        let(:base) { described_class.new(obj_two) }
+
+        context 'when relation tracked' do
+          before(:each) do
+            ModelTwo.clear_trackable_memoization
+            ModelTwo.track_history on: :em_twos
+          end
+          it { expect(subject['em_twos']).to eq [[{ '_id' => em_obj_two._id, 'em_foo' => 'Em-Foo', 'em_bar' => 'Em-Bar' }], nil] }
+        end
+
+        context 'when relation not tracked' do
+          before(:each) do
+            ModelTwo.clear_trackable_memoization
+            ModelTwo.track_history on: :fields
+          end
+          it { expect(subject['em_twos']).to be_nil }
+        end
+
+        context 'when relation with permitted attributes for tracking' do
+          before(:each) do
+            ModelTwo.clear_trackable_memoization
+            ModelTwo.track_history on: { em_twos: :em_foo }
+          end
+          it { expect(subject['em_twos']).to eq [[{ '_id' => em_obj_two._id, 'em_foo' => 'Em-Foo' }], nil] }
+        end
+
+        after(:all) do
+          Object.send(:remove_const, :ModelTwo)
+          Object.send(:remove_const, :EmTwo)
+        end
+      end
+
+      context 'when relation with alias' do
+        before(:all) do
+          class ModelTwo
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            embeds_many :em_twos, store_as: :emws
+            track_history on: :fields
+          end
+
+          class EmTwo
+            include Mongoid::Document
+            field :em_foo
+            embedded_in :model_two
+          end
+        end
+
+        before(:each) do
+          ModelTwo.clear_trackable_memoization
+          ModelTwo.track_history on: :em_twos
+        end
+
+        let(:obj_two) { ModelTwo.new(em_twos: [em_obj_two]) }
+        let(:em_obj_two) { EmTwo.new(em_foo: 'Em-Foo') }
+        let(:base) { described_class.new(obj_two) }
+
+        it { expect(subject['em_twos']).to eq [[{ '_id' => em_obj_two._id, 'em_foo' => 'Em-Foo' }], nil] }
+
+        after(:all) do
+          Object.send(:remove_const, :ModelTwo)
+          Object.send(:remove_const, :EmTwo)
+        end
+      end
+    end
+  end
+end

data/spec/unit/attributes/update_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe Mongoid::History::Attributes::Update do
+  describe '#attributes' do
+    describe '#insert_embeds_one_changes' do
+      context 'Case: relation without alias' do
+        before(:all) do
+          class ModelOne
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            store_in collection: :model_ones
+            embeds_one :emb_one
+            track_history on: :fields
+          end
+
+          class EmbOne
+            include Mongoid::Document
+            field :em_foo
+            field :em_bar
+            embedded_in :model_one
+          end
+        end
+
+        before(:each) do
+          ModelOne.clear_trackable_memoization
+          allow(base).to receive(:changes) { changes }
+        end
+
+        let(:obj_one) { ModelOne.new }
+        let(:base) { described_class.new(obj_one) }
+        let(:changes) do
+          { 'emb_one' => [{ 'em_foo' => 'Em-Foo', 'em_bar' => 'Em-Bar' }, { 'em_foo' => 'Em-Foo-new', 'em_bar' => 'Em-Bar-new' }] }
+        end
+        subject { base.attributes }
+
+        context 'with permitted attributes' do
+          before(:each) { ModelOne.track_history on: { emb_one: :em_foo } }
+          it { expect(subject['emb_one']).to eq [{ 'em_foo' => 'Em-Foo' }, { 'em_foo' => 'Em-Foo-new' }] }
+        end
+
+        context 'without permitted attributes' do
+          before(:each) { ModelOne.track_history on: :emb_one }
+          it { expect(subject['emb_one']).to eq [{ 'em_foo' => 'Em-Foo', 'em_bar' => 'Em-Bar' }, { 'em_foo' => 'Em-Foo-new', 'em_bar' => 'Em-Bar-new' }] }
+        end
+
+        context 'when old value soft-deleted' do
+          before(:each) { ModelOne.track_history on: :emb_one }
+          let(:changes) do
+            { 'emb_one' => [{ 'em_foo' => 'Em-Foo', 'deleted_at' => Time.now }, { 'em_foo' => 'Em-Foo-new', 'em_bar' => 'Em-Bar-new' }] }
+          end
+          it { expect(subject['emb_one']).to eq [{}, { 'em_foo' => 'Em-Foo-new', 'em_bar' => 'Em-Bar-new' }] }
+        end
+
+        context 'when new value soft-deleted' do
+          before(:each) { ModelOne.track_history on: :emb_one }
+          let(:changes) do
+            { 'emb_one' => [{ 'em_foo' => 'Em-Foo' }, { 'em_foo' => 'Em-Foo-new', 'deleted_at' => Time.now }] }
+          end
+          it { expect(subject['emb_one']).to eq [{ 'em_foo' => 'Em-Foo' }, {}] }
+        end
+
+        context 'when not tracked' do
+          before(:each) do
+            ModelOne.track_history on: :fields
+            allow(ModelOne).to receive(:dynamic_enabled?) { false }
+          end
+          it { expect(subject['emb_one']).to be_nil }
+        end
+
+        after(:all) do
+          Object.send(:remove_const, :ModelOne)
+          Object.send(:remove_const, :EmbOne)
+        end
+      end
+
+      context 'Case: relation with alias' do
+        before(:all) do
+          class ModelOne
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            store_in collection: :model_ones
+            embeds_one :emb_one, store_as: :eon
+            track_history on: :fields
+          end
+
+          class EmbOne
+            include Mongoid::Document
+            field :em_foo
+            field :em_bar
+            embedded_in :model_one
+          end
+        end
+
+        before(:each) do
+          ModelOne.clear_trackable_memoization
+          ModelOne.track_history on: :emb_one
+          allow(base).to receive(:changes) { changes }
+        end
+
+        let(:obj_one) { ModelOne.new }
+        let(:base) { described_class.new(obj_one) }
+        let(:changes) do
+          { 'emb_one' => [{ 'em_foo' => 'Em-Foo' }, { 'em_foo' => 'Em-Foo-new', 'em_bar' => 'Em-Bar-new' }] }
+        end
+        subject { base.attributes }
+        it { expect(subject['eon']).to eq [{ 'em_foo' => 'Em-Foo' }, { 'em_foo' => 'Em-Foo-new', 'em_bar' => 'Em-Bar-new' }] }
+
+        after(:all) do
+          Object.send(:remove_const, :ModelOne)
+          Object.send(:remove_const, :EmbOne)
+        end
+      end
+    end
+
+    describe '#insert_embeds_many_changes' do
+      context 'Case: relation without alias' do
+        before(:all) do
+          class ModelOne
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            store_in collection: :model_ones
+            embeds_many :emb_ones
+            track_history on: :fields
+          end
+
+          class EmbOne
+            include Mongoid::Document
+            field :em_foo
+            field :em_bar
+            embedded_in :model_one
+          end
+        end
+
+        before(:each) do
+          ModelOne.clear_trackable_memoization
+          allow(base).to receive(:changes) { changes }
+        end
+
+        let(:obj_one) { ModelOne.new }
+        let(:base) { described_class.new(obj_one) }
+        subject { base.attributes }
+
+        context 'with whitelist attributes' do
+          before(:each) { ModelOne.track_history on: { emb_ones: :em_foo } }
+          let(:changes) do
+            { 'emb_ones' => [[{ 'em_foo' => 'Em-Foo', 'em_bar' => 'Em-Bar' }], [{ 'em_foo' => 'Em-Foo-new', 'em_bar' => 'Em-Bar-new' }]] }
+          end
+          it 'should track only whitelisted attributes' do
+            expect(subject['emb_ones']).to eq [[{ 'em_foo' => 'Em-Foo' }], [{ 'em_foo' => 'Em-Foo-new' }]]
+          end
+        end
+
+        context 'without whitelist attributes' do
+          before(:each) { ModelOne.track_history on: :emb_ones }
+          let(:changes) do
+            { 'emb_ones' => [[{ 'em_foo' => 'Em-Foo', 'deleted_at' => Time.now }], [{ 'em_foo' => 'Em-Foo-new', 'em_bar' => 'Em-Bar-new' }]] }
+          end
+          it 'should ignore soft-deleted objects' do
+            expect(subject['emb_ones']).to eq [[], [{ 'em_foo' => 'Em-Foo-new', 'em_bar' => 'Em-Bar-new' }]]
+          end
+        end
+
+        after(:all) do
+          Object.send(:remove_const, :ModelOne)
+          Object.send(:remove_const, :EmbOne)
+        end
+      end
+
+      context 'Case: relation with alias' do
+        before(:all) do
+          class ModelOne
+            include Mongoid::Document
+            include Mongoid::History::Trackable
+            store_in collection: :model_ones
+            embeds_many :emb_ones, store_as: :eons
+            track_history on: :fields
+          end
+
+          class EmbOne
+            include Mongoid::Document
+            field :em_foo
+            field :em_bar
+            embedded_in :model_one
+          end
+        end
+
+        before(:each) do
+          ModelOne.clear_trackable_memoization
+          ModelOne.track_history on: :emb_ones
+          allow(base).to receive(:changes) { changes }
+        end
+
+        let(:obj_one) { ModelOne.new }
+        let(:base) { described_class.new(obj_one) }
+        let(:changes) do
+          { 'emb_ones' => [[{ 'em_foo' => 'Em-Foo' }], [{ 'em_foo' => 'Em-Foo-new', 'em_bar' => 'Em-Bar-new' }]] }
+        end
+        subject { base.attributes }
+        it 'should save audit history under relation alias' do
+          expect(subject['eons']).to eq [[{ 'em_foo' => 'Em-Foo' }], [{ 'em_foo' => 'Em-Foo-new', 'em_bar' => 'Em-Bar-new' }]]
+        end
+      end
+
+      after(:all) do
+        Object.send(:remove_const, :ModelOne)
+        Object.send(:remove_const, :EmbOne)
+      end
+    end
+  end
+end

data/spec/unit/embedded_methods_spec.rb

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