mongoid_rails4 4.0.0

data/spec/mongoid/findable_spec.rb

@@ -0,0 +1,342 @@
+require "spec_helper"
+
+describe Mongoid::Findable do
+
+  describe ".distinct" do
+
+    before do
+      Band.create(name: "Tool")
+      Band.create(name: "Photek")
+    end
+
+    it "returns the distinct values for the field" do
+      expect(Band.distinct(:name)).to eq([ "Tool", "Photek" ])
+    end
+  end
+
+  describe ".each" do
+
+    let!(:band) do
+      Band.create
+    end
+
+    it "iterates through all documents" do
+      Band.each do |band|
+        expect(band).to be_a(Band)
+      end
+    end
+  end
+
+  describe ".each_with_index" do
+
+    let!(:band) do
+      Band.create
+    end
+
+    it "iterates through all documents" do
+      Band.each_with_index do |band, index|
+        expect(index).to eq(0)
+      end
+    end
+  end
+
+  describe ".find_and_modify" do
+
+    let!(:person) do
+      Person.create(title: "Senior")
+    end
+
+    it "returns the document" do
+      expect(Person.find_and_modify(title: "Junior")).to eq(person)
+    end
+  end
+
+  describe ".find_by" do
+
+    context "when the document is found" do
+
+      let!(:person) do
+        Person.create(title: "sir")
+      end
+
+      context "when no block is provided" do
+
+        it "returns the document" do
+          expect(Person.find_by(title: "sir")).to eq(person)
+        end
+      end
+
+      context "when a block is provided" do
+
+        let(:result) do
+          Person.find_by(title: "sir") do |peep|
+            peep.age = 50
+          end
+        end
+
+        it "yields the returned document" do
+          expect(result.age).to eq(50)
+        end
+      end
+    end
+
+    context "when the document is not found" do
+
+      context "when raising a not found error" do
+
+        before do
+          Mongoid.raise_not_found_error = true
+        end
+
+        it "raises an error" do
+          expect {
+            Person.find_by(ssn: "333-22-1111")
+          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+      end
+
+      context "when raising no error" do
+
+        before do
+          Mongoid.raise_not_found_error = false
+        end
+
+        after do
+          Mongoid.raise_not_found_error = true
+        end
+
+        context "when no block is provided" do
+
+          it "returns nil" do
+            expect(Person.find_by(ssn: "333-22-1111")).to be_nil
+          end
+        end
+
+        context "when a block is provided" do
+
+          let(:result) do
+            Person.find_by(ssn: "333-22-1111") do |peep|
+              peep.age = 50
+            end
+          end
+
+          it "returns nil" do
+            expect(result).to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  describe ".first_or_create" do
+
+    context "when the document is found" do
+
+      let!(:person) do
+        Person.create
+      end
+
+      it "returns the document" do
+        expect(Person.first_or_create).to eq(person)
+      end
+    end
+
+    context "when the document is not found" do
+
+      context "when providing a document" do
+
+        let!(:person) do
+          Person.create
+        end
+
+        let(:from_db) do
+          Game.first_or_create(person: person)
+        end
+
+        it "returns the new document" do
+          expect(from_db.person).to eq(person)
+        end
+      end
+
+      context "when not providing a block" do
+
+        let!(:person) do
+          Person.first_or_create(title: "Senorita")
+        end
+
+        it "creates a persisted document" do
+          expect(person).to be_persisted
+        end
+
+        it "sets the attributes" do
+          expect(person.title).to eq("Senorita")
+        end
+      end
+
+      context "when providing a block" do
+
+        let!(:person) do
+          Person.first_or_create(title: "Senorita") do |person|
+            person.pets = true
+          end
+        end
+
+        it "creates a persisted document" do
+          expect(person).to be_persisted
+        end
+
+        it "sets the attributes" do
+          expect(person.title).to eq("Senorita")
+        end
+
+        it "calls the block" do
+          expect(person.pets).to be_true
+        end
+      end
+    end
+  end
+
+  describe ".first_or_initialize" do
+
+    context "when the document is found" do
+
+      let!(:person) do
+        Person.create
+      end
+
+      it "returns the document" do
+        expect(Person.first_or_create).to eq(person)
+      end
+    end
+
+    context "when the document is not found" do
+
+      context "when providing a document" do
+
+        let!(:person) do
+          Person.create
+        end
+
+        let(:found) do
+          Game.first_or_initialize(person: person)
+        end
+
+        it "returns the new document" do
+          expect(found.person).to eq(person)
+        end
+
+        it "does not save the document" do
+          expect(found).to_not be_persisted
+        end
+      end
+
+      context "when not providing a block" do
+
+        before do
+          Person.delete_all
+        end
+
+        let!(:person) do
+          Person.first_or_initialize(title: "esquire")
+        end
+
+        it "creates a non persisted document" do
+          expect(person).to_not be_persisted
+        end
+
+        it "sets the attributes" do
+          expect(person.title).to eq("esquire")
+        end
+      end
+
+      context "when providing a block" do
+
+        let!(:person) do
+          Person.first_or_initialize(title: "Senorita") do |person|
+            person.pets = true
+          end
+        end
+
+        it "creates a new document" do
+          expect(person).to_not be_persisted
+        end
+
+        it "sets the attributes" do
+          expect(person.title).to eq("Senorita")
+        end
+
+        it "calls the block" do
+          expect(person.pets).to be_true
+        end
+      end
+    end
+  end
+
+  describe ".pluck" do
+
+    let!(:depeche) do
+      Band.create(name: "Depeche Mode", likes: 3)
+    end
+
+    let!(:tool) do
+      Band.create(name: "Tool", likes: 3)
+    end
+
+    let!(:photek) do
+      Band.create(name: "Photek", likes: 1)
+    end
+
+    context "when field values exist" do
+
+      let(:plucked) do
+        Band.pluck(:name)
+      end
+
+      it "returns the field values" do
+        expect(plucked).to eq([ "Depeche Mode", "Tool", "Photek" ])
+      end
+    end
+
+    context "when field values do not exist" do
+
+      let(:plucked) do
+        Band.pluck(:follows)
+      end
+
+      it "returns an empty array" do
+        expect(plucked).to be_empty
+      end
+    end
+  end
+
+  Origin::Selectable.forwardables.each do |method|
+
+    describe "##{method}" do
+
+      it "forwards the #{method} to the criteria" do
+        expect(Band).to respond_to(method)
+      end
+    end
+  end
+
+  describe "#text_search" do
+
+    before do
+      Word.with(database: "admin").mongo_session.command(setParameter: 1, textSearchEnabled: true)
+      Word.create_indexes
+      Word.with(safe: true).create!(name: "phase", origin: "latin")
+    end
+
+    after(:all) do
+      Word.remove_indexes
+    end
+
+    let(:search) do
+      Word.text_search("phase")
+    end
+
+    it "returns all fields" do
+      expect(search.first.origin).to eq("latin")
+    end
+  end
+end

data/spec/mongoid/identity_map_spec.rb

@@ -0,0 +1,564 @@
+require "spec_helper"
+
+describe Mongoid::IdentityMap do
+
+  before(:all) do
+    Mongoid.identity_map_enabled = true
+  end
+
+  after(:all) do
+    Mongoid.identity_map_enabled = false
+  end
+
+  let(:identity_map) do
+    described_class.new
+  end
+
+  describe "#clear" do
+
+    before do
+      identity_map.set(Person.new)
+    end
+
+    let!(:clear) do
+      identity_map.clear
+    end
+
+    it "empties the identity map" do
+      expect(identity_map).to be_empty
+    end
+
+    it "returns an empty hash" do
+      expect(clear).to eq({})
+    end
+  end
+
+  describe ".clear" do
+
+    before do
+      described_class.set(Person.new)
+    end
+
+    let!(:clear) do
+      described_class.clear
+    end
+
+    it "returns an empty hash" do
+      expect(clear).to eq({})
+    end
+  end
+
+  describe "#get" do
+
+    context "normal model" do
+      let!(:person) do
+        Person.new
+      end
+
+      context "when getting by id" do
+
+        context "when the document exists in the identity map" do
+
+          before do
+            identity_map.set(person)
+          end
+
+          let(:get) do
+            identity_map.get(Person, person.id)
+          end
+
+          it "returns the matching person" do
+            expect(get).to eq(person)
+          end
+        end
+
+        context "when the person does not exist in the map" do
+
+          let(:get) do
+            identity_map.get(Person, person.id)
+          end
+
+          it "returns nil" do
+            expect(get).to be_nil
+          end
+        end
+      end
+
+      context "when getting by an array of ids" do
+
+        context "when the document exists in the identity map" do
+
+          before do
+            identity_map.set(person)
+          end
+
+          let(:get) do
+            identity_map.get(Person, [ person.id ])
+          end
+
+          it "returns the matching documents" do
+            expect(get).to eq([ person ])
+          end
+        end
+
+        context "when any id is not found in the map" do
+
+          before do
+            identity_map.set(person)
+          end
+
+          let(:get) do
+            identity_map.get(Person, [ person.id, Moped::BSON::ObjectId.new ])
+          end
+
+          it "returns nil" do
+            expect(get).to be_nil
+          end
+        end
+      end
+    end
+
+    context "inherited class" do
+
+      let!(:document) do
+        Firefox.new
+      end
+
+      context "when getting by id" do
+
+        context "when the document exists in the identity map" do
+
+          before do
+            identity_map.set(document)
+          end
+
+          it "returns the matching document by class" do
+            get = identity_map.get(Firefox, document.id)
+            expect(get).to eq(document)
+          end
+
+          it "returns the matching document by superclass" do
+            get = identity_map.get(Browser, document.id)
+            expect(get).to eq(document)
+          end
+
+          it "returns the matching document by class" do
+            get = identity_map.get(Canvas, document.id)
+            expect(get).to eq(document)
+          end
+        end
+
+        context "when the document does not exist in the map" do
+
+          let(:get) do
+            identity_map.get(Firefox, document.id)
+          end
+
+          it "returns nil" do
+            expect(get).to be_nil
+          end
+        end
+      end
+    end
+
+    context "embedded class" do
+
+      let!(:animal) do
+        circus = Circus.new(animals: [ Animal.new(name: "Lion") ])
+        circus.animals.first
+      end
+
+      context "when getting by id" do
+
+        context "when the document exists in the identity map" do
+
+          before do
+            identity_map.set(animal)
+          end
+
+          let(:get) do
+            identity_map.get(Animal, animal.id)
+          end
+
+          it "returns the matching document" do
+            expect(get).to eq(animal)
+          end
+        end
+
+        context "when the document does not exist in the map" do
+
+          let(:get) do
+            identity_map.get(Animal, animal.id)
+          end
+
+          it "returns nil" do
+            expect(get).to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  describe ".get" do
+
+    let(:document) do
+      Person.new
+    end
+
+    context "when the document exists in the identity map" do
+
+      before do
+        described_class.set(document)
+      end
+
+      let(:get) do
+        described_class.get(Person, document.id)
+      end
+
+      it "returns the matching document" do
+        expect(get).to eq(document)
+      end
+    end
+
+    context "when the document does not exist in the map" do
+
+      let(:get) do
+        described_class.get(Person, document.id)
+      end
+
+      it "returns nil" do
+        expect(get).to be_nil
+      end
+    end
+
+    context "when the mongoid identity map is disabled" do
+
+      before do
+        Mongoid.identity_map_enabled = false
+      end
+
+      after do
+        Mongoid.identity_map_enabled = true
+      end
+
+      let(:get) do
+        described_class.get(Person, document.id)
+      end
+
+      it "returns nil" do
+        expect(get).to be_nil
+      end
+    end
+  end
+
+  describe "#get_many" do
+
+    let!(:person) do
+      Person.new
+    end
+
+    context "when getting by selector" do
+
+      let!(:post_one) do
+        Post.new(person: person)
+      end
+
+      let!(:post_two) do
+        Post.new(person: person)
+      end
+
+      context "when there are documents in the map" do
+
+        before do
+          identity_map.set_many(post_one, person_id: person.id)
+          identity_map.set_many(post_two, person_id: person.id)
+        end
+
+        let(:documents) do
+          identity_map.get_many(Post, person_id: person.id)
+        end
+
+        it "returns the matching documents" do
+          expect(documents).to eq([ post_one, post_two ])
+        end
+      end
+
+      context "when there are no documents in the map" do
+
+        let(:documents) do
+          identity_map.get_many(Post, person_id: person.id)
+        end
+
+        it "returns nil" do
+          expect(documents).to be_nil
+        end
+      end
+    end
+  end
+
+  describe "#remove" do
+
+    let(:document) do
+      Person.new
+    end
+
+    let!(:set) do
+      identity_map.set(document)
+    end
+
+    context "when provided a document" do
+
+      context "when the document has an id" do
+
+        let!(:removed) do
+          identity_map.remove(document)
+        end
+
+        it "deletes the document from the map" do
+          expect(identity_map.get(Person, document.id)).to be_nil
+        end
+
+        it "returns the document" do
+          expect(removed).to eq(document)
+        end
+      end
+
+      context "when the document has no id" do
+
+        before do
+          document.id = nil
+        end
+
+        let!(:removed) do
+          identity_map.remove(document)
+        end
+
+        it "returns nil" do
+          expect(removed).to be_nil
+        end
+      end
+    end
+
+    context "when provided nil" do
+
+      let!(:removed) do
+        identity_map.remove(nil)
+      end
+
+      it "returns nil" do
+        expect(removed).to be_nil
+      end
+    end
+  end
+
+  describe "#set" do
+
+    context "when setting a document" do
+
+      context "when the identity map is enabled" do
+
+        let(:document) do
+          Person.new
+        end
+
+        let!(:set) do
+          identity_map.set(document)
+        end
+
+        it "puts the object in the identity map" do
+          expect(identity_map.get(Person, document.id)).to eq(document)
+        end
+
+        it "returns the document" do
+          expect(set).to eq(document)
+        end
+      end
+
+      context "when the identity map is disabled" do
+
+        before do
+          Mongoid.identity_map_enabled = false
+        end
+
+        after do
+          Mongoid.identity_map_enabled = true
+        end
+
+        let(:document) do
+          Person.new
+        end
+
+        let!(:set) do
+          identity_map.set(document)
+        end
+
+        it "does not put the object in the identity map" do
+          expect(identity_map).to be_empty
+        end
+
+        it "returns nil" do
+          expect(set).to be_nil
+        end
+      end
+    end
+
+    context "when setting a document with a nil id" do
+
+      let(:document) do
+        Person.new.tap do |person|
+          person.id = nil
+        end
+      end
+
+      let!(:set) do
+        identity_map.set(document)
+      end
+
+      it "does not put the object in the identity map" do
+        expect(identity_map.get(nil, nil)).to be_nil
+      end
+
+      it "returns nil" do
+        expect(set).to be_nil
+      end
+    end
+
+    context "when setting nil" do
+
+      let!(:set) do
+        identity_map.set(nil)
+      end
+
+      it "places nothing in the map" do
+        expect(identity_map).to be_empty
+      end
+
+      it "returns nil" do
+        expect(set).to be_nil
+      end
+    end
+  end
+
+  describe "#set_many" do
+
+    let!(:person) do
+      Person.new
+    end
+
+    let!(:post_one) do
+      Post.new(person: person)
+    end
+
+    let!(:post_two) do
+      Post.new(person: person)
+    end
+
+    context "when no documents exist for the selector" do
+
+      let!(:set) do
+        identity_map.set_many(post_one, { person_id: person.id })
+        identity_map.set_many(post_two, { person_id: person.id })
+      end
+
+      let(:documents) do
+        identity_map[Post.collection_name][{ person_id: person.id }]
+      end
+
+      it "puts the documents in the map" do
+        expect(documents).to eq({
+          post_one.id => post_one, post_two.id => post_two
+        })
+      end
+    end
+  end
+
+  describe "#set_one" do
+
+    let!(:person) do
+      Person.new
+    end
+
+    let!(:post_one) do
+      Post.new(person: person)
+    end
+
+    context "when no documents exist for the selector" do
+
+      let!(:set) do
+        identity_map.set_one(post_one, { person_id: person.id })
+      end
+
+      let(:document) do
+        identity_map[Post.collection_name][{ person_id: person.id }]
+      end
+
+      it "puts the documents in the map" do
+        expect(document).to eq(post_one)
+      end
+    end
+  end
+
+  describe ".set" do
+
+    context "when setting a document" do
+
+      let(:document) do
+        Person.new
+      end
+
+      let!(:set) do
+        described_class.set(document)
+      end
+
+      it "puts the object in the identity map" do
+        expect(described_class.get(Person, document.id)).to eq(document)
+      end
+
+      it "returns the document" do
+        expect(set).to eq(document)
+      end
+    end
+
+    context "when setting nil" do
+
+      let!(:set) do
+        described_class.set(nil)
+      end
+
+      it "returns nil" do
+        expect(set).to be_nil
+      end
+    end
+  end
+
+  context "when accessing hash methods directly" do
+
+    Hash.public_instance_methods(false).each do |method|
+
+      it "can access #{method} at the class level" do
+        expect(described_class).to respond_to(method)
+      end
+    end
+  end
+
+  context "when executing in a fiber" do
+
+    describe "#.get" do
+
+      let(:document) do
+        Person.new
+      end
+
+      let(:fiber) do
+        Fiber.new do
+          described_class.set(document)
+          expect(described_class.get(Person, document.id)).to eq(document)
+        end
+      end
+
+      it "gets the object from the identity map" do
+        fiber.resume
+      end
+    end
+  end
+end