mongoid_archival 0.1.0

data/spec/app/models/sport.rb

@@ -0,0 +1,5 @@
+class Sport
+  include Mongoid::Document
+  include Mongoid::Archivable
+  include Mongoid::Archivable::Protected
+end

data/spec/app/models/tag.rb

@@ -0,0 +1,6 @@
+class Tag
+  include Mongoid::Document
+  field :text, type: String
+  has_and_belongs_to_many :archivable_posts
+  has_and_belongs_to_many :related, class_name: 'Tag', inverse_of: :related
+end

data/spec/app/models/title.rb

@@ -0,0 +1,4 @@
+class Title
+  include Mongoid::Document
+  belongs_to :archivable_post
+end

data/spec/mongoid/archive_spec.rb

@@ -0,0 +1,341 @@
+require 'spec_helper'
+
+RSpec.describe 'Mongoid::Archivable#archive' do
+  describe '#archive' do
+
+    context 'when the document is a root' do
+
+      let(:post) do
+        ArchivablePost.create(title: 'testing')
+      end
+
+      before do
+        post.archive
+      end
+
+      let(:raw) do
+        ArchivablePost.collection.find(_id: post.id).first
+      end
+
+      it 'archives the document' do
+        expect(raw['archived_at']).to be_within(1).of(Time.now)
+      end
+
+      it 'is still marked as persisted' do
+        expect(post.persisted?).to eq(true)
+      end
+
+      it 'does not return the document in a find' do
+        expect(ArchivablePost.find(post.id)).to eq post
+      end
+
+      it 'executes the before archive callbacks' do
+        expect(post.before_archive_called).to be_truthy
+      end
+
+      it 'executes the after archive callbacks' do
+        expect(post.after_archive_called).to be_truthy
+      end
+    end
+
+    # context 'when the document is embedded' do
+    #
+    #   let(:person) do
+    #     Person.create
+    #   end
+    #
+    #   let(:phone) do
+    #     person.archivable_phones.create(number: '911')
+    #   end
+    #
+    #   before do
+    #     phone.archive
+    #   end
+    #
+    #   let(:raw) do
+    #     Person.collection.find(_id: person.id).first
+    #   end
+    #
+    #   it 'archives the document' do
+    #     expect(raw['archivable_phones'].first['archived_at']).to be_within(1).of(Time.now)
+    #   end
+    #
+    #   it 'does not return the document in a find' do
+    #     expect {
+    #       person.archivable_phones.find(phone.id)
+    #     }.to raise_error(Mongoid::Errors::DocumentNotFound)
+    #   end
+    #
+    #   it 'does not include the document in the relation' do
+    #     expect(person.archivable_phones.scoped).to be_empty
+    #   end
+    #
+    #   it 'executes the before archive callbacks' do
+    #     expect(phone.before_archive_called).to be_truthy
+    #   end
+    #
+    #   it 'executes the after archive callbacks' do
+    #     expect(phone.after_archive_called).to be_truthy
+    #   end
+    # end
+
+    context 'when the document has a dependent: :archive relation' do
+
+      let(:post) do
+        ArchivablePost.create(title: 'test')
+      end
+
+      let!(:fish) do
+        post.fish = Fish.create
+      end
+
+      before do
+        post.archive
+      end
+
+      it 'cascades the dependent option' do
+        expect(fish.reload.archived_at).to be_a(Time)
+      end
+    end
+
+    context 'when the document has a dependent: :destroy relation' do
+
+      let(:post) do
+        ArchivablePost.create(title: 'test')
+      end
+
+      let!(:author) do
+        post.authors.create(name: 'poe')
+      end
+
+      before do
+        post.archive
+      end
+
+      it 'ignores dependent :destroy option' do
+        expect(author.reload).to be_a(Author)
+      end
+    end
+
+    context 'when the document has a dependent: :restrict relation' do
+
+      let(:post) do
+        ArchivablePost.create(title: 'test')
+      end
+
+      let!(:title) do
+        post.titles.create
+      end
+
+      before do
+        begin
+          post.archive
+        rescue Mongoid::Errors::DeleteRestriction
+        end
+      end
+
+      it 'does not archive the document' do
+        expect(post).not_to be_archived
+      end
+    end
+  end
+
+  describe '#archive_without_callbacks' do
+
+    context 'when the document is a root' do
+
+      let(:post) do
+        ArchivablePost.create(title: 'testing')
+      end
+
+      before do
+        post.archive_without_callbacks
+      end
+
+      let(:raw) do
+        ArchivablePost.collection.find(_id: post.id).first
+      end
+
+      it 'archives the document' do
+        expect(raw['archived_at']).to be_within(1).of(Time.now)
+      end
+
+      it 'does not return the document in a find' do
+        expect { ArchivablePost.current.find(post.id) }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect { ArchivablePost.find(post.id) }.to_not raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+
+    # context 'when the document is embedded' do
+    #
+    #   let(:person) do
+    #     Person.create
+    #   end
+    #
+    #   let(:phone) do
+    #     person.archivable_phones.create(number: '911')
+    #   end
+    #
+    #   before do
+    #     phone.archive_without_callbacks
+    #   end
+    #
+    #   let(:raw) do
+    #     Person.collection.find(_id: person.id).first
+    #   end
+    #
+    #   it 'archives the document' do
+    #     expect(raw['archivable_phones'].first['archived_at']).to be_within(1).of(Time.now)
+    #   end
+    #
+    #   it 'does not return the document in a find' do
+    #     expect {
+    #       person.archivable_phones.find(phone.id)
+    #     }.to raise_error(Mongoid::Errors::DocumentNotFound)
+    #   end
+    #
+    #   it 'does not include the document in the relation' do
+    #     expect(person.archivable_phones.scoped).to be_empty
+    #   end
+    # end
+
+    context 'when the document has a dependent relation' do
+
+      let(:post) do
+        ArchivablePost.create(title: 'test')
+      end
+
+      let!(:author) do
+        post.authors.create(name: 'poe')
+      end
+
+      before do
+        post.archive_without_callbacks
+      end
+
+      it 'does not cascade the dependent option' do
+        expect {
+          author.reload
+        }.to_not raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+
+    context 'when the document has a dependent: :restrict relation' do
+
+      let(:post) do
+        ArchivablePost.create(title: 'test')
+      end
+
+      let!(:title) do
+        post.titles.create
+      end
+
+      before do
+        begin
+          post.archive_without_callbacks
+        rescue Mongoid::Errors::DeleteRestriction
+        end
+      end
+
+      it 'ignores restrict and archives the document' do
+        expect(post).to be_archived
+      end
+    end
+  end
+
+  describe '#archived?' do
+
+    context 'when the document is a root' do
+
+      let(:post) do
+        ArchivablePost.create(title: 'testing')
+      end
+
+      context 'when the document is archived' do
+
+        before do
+          post.archive
+        end
+
+        it 'returns true' do
+          expect(post).to be_archived
+        end
+
+        it 'returns true for archived scope document' do
+          expect(ArchivablePost.archived.last).to be_archived
+        end
+      end
+    end
+
+    context 'when the document is embedded' do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:phone) do
+        person.archivable_phones.create(number: '911')
+      end
+
+      context 'when the document is hard deleted' do
+
+        before do
+          phone.destroy!
+        end
+
+        it 'returns true' do
+          expect(phone).to be_destroyed
+        end
+      end
+
+      context 'when the document is archived' do
+
+        before do
+          phone.archive
+        end
+
+        it 'returns true' do
+          expect(phone).to_not be_destroyed
+          expect(phone).to be_archived
+        end
+      end
+
+      context 'when the document has non-dependent relation' do
+        let(:post) do
+          ArchivablePost.create(title: 'test')
+        end
+
+        let!(:tag) do
+          post.tags.create(text: 'tagie')
+        end
+
+        before do
+          post.archive
+        end
+
+        it 'does not cascades the dependent option' do
+          expect(tag.reload).to eq(tag)
+        end
+      end
+    end
+  end
+
+  describe '#set' do
+
+    let!(:post) do
+      ArchivablePost.create
+    end
+
+    let(:time) do
+      20.days.ago
+    end
+
+    let!(:set) do
+      post.set(archived_at: time)
+    end
+
+    it 'persists the change' do
+      expect(post.reload.archived_at).to be_within(1).of(time)
+    end
+  end
+end

data/spec/mongoid/configuration_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe Mongoid::Archivable::Configuration do
+  context 'configuring the archived_field setting' do
+    before do
+      Mongoid::Archivable.configure do |c|
+        c.archived_field = :my_field_name
+      end
+    end
+
+    describe '.configure' do
+      before do
+        class ArchivableConfigured
+          include Mongoid::Document
+          include Mongoid::Archivable
+        end
+      end
+
+      it 'allows custom setting of the archived_field' do
+        archivable_configured = ArchivableConfigured.new
+        expect(archivable_configured.attribute_names).to include('my_field_name')
+      end
+
+      after(:each) do
+        Mongoid::Archivable.reset
+      end
+    end
+
+    describe '.reset' do
+      before do
+        Mongoid::Archivable.reset
+
+        # the configuration gets set at include time
+        # so you need to reset before defining a new class
+        class ArchivableConfiguredReset
+          include Mongoid::Document
+          include Mongoid::Archivable
+        end
+      end
+
+      it 'restores the archived_field to the default setting' do
+        archivable_configured = ArchivableConfiguredReset.new
+        expect(archivable_configured.attribute_names).to include('archived_at')
+      end
+    end
+  end
+
+  describe '#archived_field' do
+    it 'initializes with default value set to :archived_at' do
+      expect(Mongoid::Archivable::Configuration.new.archived_field).to eq(:archived_at)
+    end
+
+    it 'can be updated' do
+      config = Mongoid::Archivable::Configuration.new
+      config.archived_field = :my_field_name
+      expect(config.archived_field).to eq(:my_field_name)
+    end
+  end
+end

data/spec/mongoid/document_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe 'Mongoid::Archivable.archivable?' do
+
+  describe '.archivable?' do
+
+    context 'when Mongoid::Archivable is included' do
+      subject { ArchivablePost }
+      it 'returns true' do
+        expect(subject.archivable?).to eq true
+      end
+    end
+
+    context 'when Mongoid::Archivable not included' do
+      subject { Author }
+      it 'returns true' do
+        expect(subject.respond_to?(:archivable?)).to eq false
+      end
+    end
+  end
+end

data/spec/mongoid/nested_attributes_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+RSpec.describe Mongoid::Attributes::Nested do
+  describe '##{name}_attributes=' do
+    context 'when the parent document is new' do
+      context 'when the relation is an embeds many' do
+        context 'when ids are passed' do
+
+          let(:person) do
+            Person.create
+          end
+
+          let(:address_one) do
+            Address.new(street: 'Unter den Linden')
+          end
+
+          let(:address_two) do
+            Address.new(street: 'Kurfeurstendamm')
+          end
+
+          let(:phone_one) do
+            ArchivablePhone.new(number: '1')
+          end
+
+          let(:phone_two) do
+            ArchivablePhone.new(number: '2')
+          end
+
+          before do
+            person.addresses << [ address_one, address_two ]
+          end
+
+          # context 'when archive attributes are passed' do
+          #   context 'when the ids match' do
+          #     context 'when allow_archive is true' do
+          #       context 'when the child is archivable' do
+          #
+          #         before(:all) do
+          #           Person.send(:undef_method, :archivable_phones_attributes=)
+          #           Person.accepts_nested_attributes_for :archivable_phones,
+          #             allow_archive: true
+          #         end
+          #
+          #         after(:all) do
+          #           Person.send(:undef_method, :archivable_phones_attributes=)
+          #           Person.accepts_nested_attributes_for :archivable_phones
+          #         end
+          #
+          #         [ 1, '1', true, 'true' ].each do |truth|
+          #
+          #           context 'when passed a #{truth} with archive' do
+          #             context 'when the parent is persisted' do
+          #
+          #               let!(:persisted) do
+          #                 Person.create do |p|
+          #                   p.archivable_phones << [ phone_one, phone_two ]
+          #                 end
+          #               end
+          #
+          #               context 'when setting, pulling, and pushing in one op' do
+          #
+          #                 before do
+          #                   persisted.archivable_phones_attributes =
+          #                     {
+          #                     'bar' => { 'id' => phone_one.id, '_archive' => truth },
+          #                     'foo' => { 'id' => phone_two.id, 'number' => '3' },
+          #                     'baz' => { 'number' => '4' }
+          #                   }
+          #                 end
+          #
+          #                 it 'removes the first document from the relation' do
+          #                   expect(persisted.archivable_phones.size).to eq(2)
+          #                 end
+          #
+          #                 it 'does not delete the unmarked document' do
+          #                   expect(persisted.archivable_phones.first.number).to eq('3')
+          #                 end
+          #
+          #                 it 'adds the new document to the relation' do
+          #                   expect(persisted.archivable_phones.last.number).to eq('4')
+          #                 end
+          #
+          #                 it 'has the proper persisted count' do
+          #                   expect(persisted.archivable_phones.count).to eq(1)
+          #                 end
+          #
+          #                 it 'archives the removed document' do
+          #                   expect(phone_one).to be_archiveed
+          #                 end
+          #
+          #                 context 'when saving the parent' do
+          #
+          #                   before do
+          #                     persisted.save
+          #                   end
+          #
+          #                   it 'deletes the marked document from the relation' do
+          #                     expect(persisted.reload.archivable_phones.count).to eq(2)
+          #                   end
+          #
+          #                   it 'does not delete the unmarked document' do
+          #                     expect(persisted.reload.archivable_phones.first.number).to eq('3')
+          #                   end
+          #
+          #                   it 'persists the new document to the relation' do
+          #                     expect(persisted.reload.archivable_phones.last.number).to eq('4')
+          #                   end
+          #                 end
+          #               end
+          #             end
+          #           end
+          #         end
+          #       end
+          #
+          #       context 'when the child has defaults' do
+          #
+          #         before(:all) do
+          #           Person.accepts_nested_attributes_for :appointments, allow_archive: true
+          #         end
+          #
+          #         after(:all) do
+          #           Person.send(:undef_method, :appointments_attributes=)
+          #         end
+          #         context 'when the parent is persisted' do
+          #           context 'when the child returns false in a before callback' do
+          #             context 'when the child is archivable' do
+          #
+          #               before(:all) do
+          #                 Person.accepts_nested_attributes_for :archivable_phones, allow_archive: true
+          #               end
+          #
+          #               after(:all) do
+          #                 Person.send(:undef_method, :archivable_phones=)
+          #                 Person.accepts_nested_attributes_for :archivable_phones
+          #               end
+          #
+          #               let!(:persisted) do
+          #                 Person.create(age: 42)
+          #               end
+          #
+          #               let!(:phone) do
+          #                 persisted.archivable_phones.create
+          #               end
+          #
+          #               before do
+          #                 persisted.archivable_phones_attributes =
+          #                   { 'foo' => { 'id' => phone.id, 'number' => 42, '_archive' => true }}
+          #               end
+          #
+          #               it 'does not archive the child' do
+          #                 expect(persisted.reload.archivable_phones).not_to be_empty
+          #               end
+          #             end
+          #           end
+          #         end
+          #       end
+          #     end
+          #   end
+          # end
+        end
+      end
+    end
+  end
+end