mongoid 3.1.4 → 3.1.5

data/spec/mongoid/observer_spec.rb

@@ -0,0 +1,290 @@
+require "spec_helper"
+
+describe Mongoid::Observer do
+
+  let(:recorder) do
+    CallbackRecorder.instance
+  end
+
+  after do
+    recorder.reset
+  end
+
+  it "is an instance of an active model observer" do
+    ActorObserver.instance.should be_a_kind_of(ActiveModel::Observer)
+  end
+
+  context "when the oberserver observes a different class" do
+
+    before(:all) do
+      class BandObserver < Mongoid::Observer
+        observe :record
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :BandObserver)
+    end
+
+    it "returns the proper observed classes" do
+      BandObserver.observed_classes.should eq([ Record ])
+    end
+  end
+
+  context "when the observer is for an embedded document" do
+
+    before do
+      PhoneObserver.instance
+    end
+
+    let(:person) do
+      Person.create
+    end
+
+    let!(:phone) do
+      person.phone_numbers.create(number: "0152-1111-1111")
+    end
+
+    context "when updating the embedded document" do
+
+      before do
+        phone.update_attribute(:number, "0152-2222-2222")
+      end
+
+      it "contains the updated value in the observer" do
+        phone.number_in_observer.should eq("0152-2222-2222")
+      end
+    end
+  end
+
+  context "when the observer has descendants" do
+
+    let!(:observer) do
+      ActorObserver.instance
+    end
+
+    let!(:actress) do
+      Actress.create!(name: "Tina Fey")
+    end
+
+    it "observes descendent class" do
+      observer.last_after_create_record.try(:name).should eq(actress.name)
+    end
+  end
+
+  context "when the observer is disabled" do
+
+    let!(:observer) do
+      ActorObserver.instance
+    end
+
+    let(:actor) do
+      Actor.create!(name: "Johnny Depp")
+    end
+
+    it "does not fire the observer" do
+      Actor.observers.disable(:all) do
+        actor and observer.last_after_create_record.should_not eq(actor)
+      end
+    end
+  end
+
+  context "when all observers are disabled" do
+
+    let!(:observer) do
+      ActorObserver.instance
+    end
+
+    let(:actor) do
+      Actor.create!(name: "Johnny Depp")
+    end
+
+    it "does not fire the observer" do
+      Mongoid.observers.disable(:all) do
+        actor and observer.last_after_create_record.should_not eq(actor)
+      end
+    end
+  end
+
+  context "when the document is new" do
+
+    let!(:actor) do
+      Actor.new
+    end
+
+    it "observes after initialize" do
+      recorder.last_callback.should eq(:after_initialize)
+    end
+
+    it "calls after initialize once" do
+      recorder.call_count[:after_initialize].should eq(1)
+    end
+
+    it "contains the model of the callback" do
+      recorder.last_record[:after_initialize].should eq(actor)
+    end
+  end
+
+  context "when the document is being created" do
+
+    let!(:actor) do
+      Actor.create!
+    end
+
+    [ :before_create,
+      :after_create,
+      :around_create,
+      :before_save,
+      :after_save,
+      :around_save ].each do |callback|
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when the document is being updated" do
+
+    let!(:actor) do
+      Actor.create!
+    end
+
+    [ :before_update,
+      :after_update,
+      :around_update,
+      :before_save,
+      :after_save,
+      :around_save ].each do |callback|
+
+      before do
+        recorder.reset
+        actor.update_attributes!(name: "Johnny Depp")
+      end
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when the document is being upserted" do
+
+    let!(:actor) do
+      Actor.create!
+    end
+
+    [ :before_upsert,
+      :after_upsert,
+      :around_upsert ].each do |callback|
+
+      before do
+        recorder.reset
+        actor.upsert
+      end
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when custom callbacks are being fired" do
+
+    let!(:actor) do
+      Actor.create!
+    end
+
+    [ :before_custom,
+      :after_custom,
+      :around_custom ].each do |callback|
+
+      before do
+        recorder.reset
+        actor.run_callbacks(:custom) do
+        end
+      end
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when the document is being destroyed" do
+
+    let!(:actor) do
+      Actor.create!
+    end
+
+    [ :before_destroy, :after_destroy, :around_destroy ].each do |callback|
+
+      before do
+        recorder.reset
+        actor.destroy
+      end
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when the document is being validated" do
+
+    let!(:actor) do
+      Actor.new
+    end
+
+    [:before_validation, :after_validation].each do |callback|
+
+      before do
+        recorder.reset
+        actor.valid?
+      end
+
+      it "observes #{callback}" do
+        recorder.call_count[callback].should eq(1)
+      end
+
+      it "contains the model of the callback" do
+        recorder.last_record[callback].should eq(actor)
+      end
+    end
+  end
+
+  context "when using a custom callback" do
+
+    let(:actor) do
+      Actor.new
+    end
+
+    before do
+      actor.do_something
+    end
+
+    it "notifies the observers once" do
+      actor.after_custom_count.should eq(1)
+    end
+  end
+end

data/spec/mongoid/paranoia_spec.rb

@@ -0,0 +1,759 @@
+require "spec_helper"
+
+describe Mongoid::Paranoia do
+
+  describe ".scoped" do
+
+    it "returns a scoped criteria" do
+      ParanoidPost.scoped.selector.should eq({ "deleted_at" => nil })
+    end
+  end
+
+  describe ".deleted" do
+
+    context "when called on a root document" do
+
+      let(:post) do
+        ParanoidPost.create(title: "testing")
+      end
+
+      before do
+        post.destroy
+      end
+
+      let(:deleted) do
+        ParanoidPost.deleted
+      end
+
+      it "returns the deleted documents" do
+        deleted.should eq([ post ])
+      end
+    end
+
+    context "when called on an embedded document" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:phone) do
+        person.paranoid_phones.create
+      end
+
+      before do
+        phone.destroy
+        person.reload
+      end
+
+      it "returns the deleted documents" do
+        person.paranoid_phones.deleted.should eq([ phone ])
+      end
+
+      it "returns the correct count" do
+        person.paranoid_phones.deleted.count.should eq(1)
+      end
+    end
+  end
+
+  describe "#destroy!" do
+
+    context "when the document is a root" do
+
+      let(:post) do
+        ParanoidPost.create(title: "testing")
+      end
+
+      before do
+        post.destroy!
+      end
+
+      let(:raw) do
+        ParanoidPost.collection.find(_id: post.id).first
+      end
+
+      it "hard deletes the document" do
+        raw.should be_nil
+      end
+
+      it "executes the before destroy callbacks" do
+        post.before_destroy_called.should be_true
+      end
+
+      it "executes the after destroy callbacks" do
+        post.after_destroy_called.should be_true
+      end
+    end
+
+    context "when the document is embedded" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:phone) do
+        person.paranoid_phones.create(number: "911")
+      end
+
+      before do
+        phone.destroy!
+      end
+
+      let(:raw) do
+        Person.collection.find(_id: person.id).first
+      end
+
+      it "hard deletes the document" do
+        raw["paranoid_phones"].should be_empty
+      end
+
+      it "executes the before destroy callbacks" do
+        phone.before_destroy_called.should be_true
+      end
+
+      it "executes the after destroy callbacks" do
+        phone.after_destroy_called.should be_true
+      end
+    end
+
+    context "when the document has a dependent relation" do
+
+      let(:post) do
+        ParanoidPost.create(title: "test")
+      end
+
+      let!(:author) do
+        post.authors.create(name: "poe")
+      end
+
+      before do
+        post.destroy!
+      end
+
+      it "cascades the dependent option" do
+        expect {
+          author.reload
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+  end
+
+  describe "#destroy" do
+
+    context "when the document is a root" do
+
+      let(:post) do
+        ParanoidPost.create(title: "testing")
+      end
+
+      before do
+        post.destroy
+      end
+
+      let(:raw) do
+        ParanoidPost.collection.find(_id: post.id).first
+      end
+
+      it "soft deletes the document" do
+        raw["deleted_at"].should be_within(1).of(Time.now)
+      end
+
+      it "does not return the document in a find" do
+        expect {
+          ParanoidPost.find(post.id)
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+
+      it "executes the before destroy callbacks" do
+        post.before_destroy_called.should be_true
+      end
+
+      it "executes the after destroy callbacks" do
+        post.after_destroy_called.should be_true
+      end
+    end
+
+    context "when the document is embedded" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:phone) do
+        person.paranoid_phones.create(number: "911")
+      end
+
+      before do
+        phone.destroy
+      end
+
+      let(:raw) do
+        Person.collection.find(_id: person.id).first
+      end
+
+      it "soft deletes the document" do
+        raw["paranoid_phones"].first["deleted_at"].should be_within(1).of(Time.now)
+      end
+
+      it "does not return the document in a find" do
+        expect {
+          person.paranoid_phones.find(phone.id)
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+
+      it "does not include the document in the relation" do
+        person.paranoid_phones.scoped.should be_empty
+      end
+
+      it "executes the before destroy callbacks" do
+        phone.before_destroy_called.should be_true
+      end
+
+      it "executes the after destroy callbacks" do
+        phone.after_destroy_called.should be_true
+      end
+    end
+
+    context "when the document has a dependent: :delete relation" do
+
+      let(:post) do
+        ParanoidPost.create(title: "test")
+      end
+
+      let!(:author) do
+        post.authors.create(name: "poe")
+      end
+
+      before do
+        post.destroy
+      end
+
+      it "cascades the dependent option" do
+        expect {
+          author.reload
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+
+    context "when the document has a dependent: :restrict relation" do
+
+      let(:post) do
+        ParanoidPost.create(title: "test")
+      end
+
+      let!(:title) do
+        post.titles.create
+      end
+
+      before do
+        begin
+          post.destroy
+        rescue Mongoid::Errors::DeleteRestriction
+        end
+      end
+
+      it "does not destroy the document" do
+        post.should_not be_destroyed
+      end
+    end
+  end
+
+  describe "#destroyed?" do
+
+    context "when the document is a root" do
+
+      let(:post) do
+        ParanoidPost.create(title: "testing")
+      end
+
+      context "when the document is hard deleted" do
+
+        before do
+          post.destroy!
+        end
+
+        it "returns true" do
+          post.should be_destroyed
+        end
+      end
+
+      context "when the document is soft deleted" do
+
+        before do
+          post.destroy
+        end
+
+        it "returns true" do
+          post.should be_destroyed
+        end
+      end
+    end
+
+    context "when the document is embedded" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:phone) do
+        person.paranoid_phones.create(number: "911")
+      end
+
+      context "when the document is hard deleted" do
+
+        before do
+          phone.destroy!
+        end
+
+        it "returns true" do
+          phone.should be_destroyed
+        end
+      end
+
+      context "when the document is soft deleted" do
+
+        before do
+          phone.destroy
+        end
+
+        it "returns true" do
+          phone.should be_destroyed
+        end
+      end
+    end
+  end
+
+  describe "#deleted?" do
+
+    context "when the document is a root" do
+
+      let(:post) do
+        ParanoidPost.create(title: "testing")
+      end
+
+      context "when the document is hard deleted" do
+
+        before do
+          post.destroy!
+        end
+
+        it "returns true" do
+          post.should be_deleted
+        end
+      end
+
+      context "when the document is soft deleted" do
+
+        before do
+          post.destroy
+        end
+
+        it "returns true" do
+          post.should be_deleted
+        end
+      end
+    end
+
+    context "when the document is embedded" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:phone) do
+        person.paranoid_phones.create(number: "911")
+      end
+
+      context "when the document is hard deleted" do
+
+        before do
+          phone.destroy!
+        end
+
+        it "returns true" do
+          phone.should be_deleted
+        end
+      end
+
+      context "when the document is soft deleted" do
+
+        before do
+          phone.destroy
+        end
+
+        it "returns true" do
+          phone.should be_deleted
+        end
+      end
+    end
+  end
+
+  describe "#destroyed?" do
+
+    context "when the document is a root" do
+
+      let(:post) do
+        ParanoidPost.create(title: "testing")
+      end
+
+      context "when the document is hard deleted" do
+
+        before do
+          post.destroy!
+        end
+
+        it "returns false" do
+          post.should_not be_persisted
+        end
+      end
+
+      context "when the document is soft deleted" do
+
+        before do
+          post.destroy
+        end
+
+        it "returns false" do
+          post.should_not be_persisted
+        end
+      end
+
+      context "when the document is reloaded" do
+
+        before do
+          post.destroy
+          post.reload
+        end
+
+        it "returns false" do
+          post.should_not be_persisted
+        end
+      end
+    end
+  end
+
+  describe "#delete!" do
+
+    context "when the document is a root" do
+
+      let(:post) do
+        ParanoidPost.create(title: "testing")
+      end
+
+      before do
+        post.delete!
+      end
+
+      let(:raw) do
+        ParanoidPost.collection.find(_id: post.id).first
+      end
+
+      it "hard deletes the document" do
+        raw.should be_nil
+      end
+    end
+
+    context "when the document is embedded" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:phone) do
+        person.paranoid_phones.create(number: "911")
+      end
+
+      before do
+        phone.delete!
+      end
+
+      let(:raw) do
+        Person.collection.find(_id: person.id).first
+      end
+
+      it "hard deletes the document" do
+        raw["paranoid_phones"].should be_empty
+      end
+    end
+
+    context "when the document has a dependent relation" do
+
+      let(:post) do
+        ParanoidPost.create(title: "test")
+      end
+
+      let!(:author) do
+        post.authors.create(name: "poe")
+      end
+
+      before do
+        post.delete!
+      end
+
+      it "cascades the dependent option" do
+        expect {
+          author.reload
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+  end
+
+  describe "#delete" do
+
+    context "when the document is a root" do
+
+      let(:post) do
+        ParanoidPost.create(title: "testing")
+      end
+
+      before do
+        post.delete
+      end
+
+      let(:raw) do
+        ParanoidPost.collection.find(_id: post.id).first
+      end
+
+      it "soft deletes the document" do
+        raw["deleted_at"].should be_within(1).of(Time.now)
+      end
+
+      it "does not return the document in a find" do
+        expect {
+          ParanoidPost.find(post.id)
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+
+      it "clears out the persistence options" do
+        Mongoid::Threaded.persistence_options(ParanoidPost).should be_nil
+      end
+
+      it "clears out the identity map" do
+        Mongoid::IdentityMap.should be_empty
+      end
+    end
+
+    context "when the document is embedded" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:phone) do
+        person.paranoid_phones.create(number: "911")
+      end
+
+      before do
+        phone.delete
+      end
+
+      let(:raw) do
+        Person.collection.find(_id: person.id).first
+      end
+
+      it "soft deletes the document" do
+        raw["paranoid_phones"].first["deleted_at"].should be_within(1).of(Time.now)
+      end
+
+      it "does not return the document in a find" do
+        expect {
+          person.paranoid_phones.find(phone.id)
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+
+      it "does not include the document in the relation" do
+        person.paranoid_phones.scoped.should be_empty
+      end
+    end
+
+    context "when the document has a dependent relation" do
+
+      let(:post) do
+        ParanoidPost.create(title: "test")
+      end
+
+      let!(:author) do
+        post.authors.create(name: "poe")
+      end
+
+      before do
+        post.delete
+      end
+
+      it "cascades the dependent option" do
+        expect {
+          author.reload
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+
+    context "when the document has a dependent: :restrict relation" do
+
+      let(:post) do
+        ParanoidPost.create(title: "test")
+      end
+
+      let!(:title) do
+        post.titles.create
+      end
+
+      before do
+        begin
+          post.delete
+        rescue Mongoid::Errors::DeleteRestriction
+        end
+      end
+
+      it "does not destroy the document" do
+        post.should_not be_destroyed
+      end
+    end
+  end
+
+  describe "#remove" do
+
+    let(:post) do
+      ParanoidPost.new
+    end
+
+    let!(:time) do
+      Time.now
+    end
+
+    before do
+      post.remove
+    end
+
+    it "sets the deleted flag" do
+      post.should be_destroyed
+    end
+  end
+
+  describe "#restore" do
+
+    context "when the document is a root" do
+
+      let(:post) do
+        ParanoidPost.create(title: "testing")
+      end
+
+      before do
+        post.delete
+        post.restore
+      end
+
+      it "removes the deleted at time" do
+        post.deleted_at.should be_nil
+      end
+
+      it "persists the change" do
+        post.reload.deleted_at.should be_nil
+      end
+
+      it "marks document again as persisted" do
+        post.persisted?.should be_true
+      end
+    end
+
+    context "when the document is embedded" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:phone) do
+        person.paranoid_phones.create(number: "911")
+      end
+
+      before do
+        phone.delete
+        phone.restore
+      end
+
+      it "removes the deleted at time" do
+        phone.deleted_at.should be_nil
+      end
+
+      it "persists the change" do
+        person.reload.paranoid_phones.first.deleted_at.should be_nil
+      end
+    end
+  end
+
+  describe ".scoped" do
+
+    let(:scoped) do
+      ParanoidPost.scoped
+    end
+
+    it "returns a scoped criteria" do
+      scoped.selector.should eq({ "deleted_at" => nil })
+    end
+  end
+
+  describe "#set" do
+
+    let!(:post) do
+      ParanoidPost.create
+    end
+
+    let(:time) do
+      20.days.ago
+    end
+
+    before do
+      post.set(:deleted_at, time)
+    end
+
+    it "persists the change" do
+      post.reload.deleted_at.should be_within(1).of(time)
+    end
+  end
+
+  describe ".unscoped" do
+
+    let(:unscoped) do
+      ParanoidPost.unscoped
+    end
+
+    it "returns an unscoped criteria" do
+      unscoped.selector.should eq({})
+    end
+  end
+
+  describe "#to_param" do
+
+    let(:post) do
+      ParanoidPost.new(title: "testing")
+    end
+
+    context "when the document is new" do
+
+      it "still returns nil" do
+        post.to_param.should be_nil
+      end
+    end
+
+    context "when the document is not deleted" do
+
+      before do
+        post.save
+      end
+
+      it "returns the id as a string" do
+        post.to_param.should eq(post.id.to_s)
+      end
+    end
+
+    context "when the document is deleted" do
+
+      before do
+        post.save
+        post.delete
+      end
+
+      it "returns the id as a string" do
+        post.to_param.should eq(post.id.to_s)
+      end
+    end
+  end
+end