mongoid 3.1.7 → 4.0.0.alpha1

data/spec/mongoid/{finders_spec.rb → findable_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Mongoid::Finders do
+describe Mongoid::Findable do
 
   describe ".distinct" do
 
@@ -10,7 +10,7 @@ describe Mongoid::Finders do
     end
 
     it "returns the distinct values for the field" do
-      Band.distinct(:name).should eq([ "Tool", "Photek" ])
+      expect(Band.distinct(:name)).to eq([ "Tool", "Photek" ])
     end
   end
 
@@ -22,7 +22,7 @@ describe Mongoid::Finders do
 
     it "iterates through all documents" do
       Band.each do |band|
-        band.should be_a(Band)
+        expect(band).to be_a(Band)
       end
     end
   end
@@ -35,7 +35,7 @@ describe Mongoid::Finders do
 
     it "iterates through all documents" do
       Band.each_with_index do |band, index|
-        index.should eq(0)
+        expect(index).to eq(0)
       end
     end
   end
@@ -47,7 +47,7 @@ describe Mongoid::Finders do
     end
 
     it "returns the document" do
-      Person.find_and_modify(title: "Junior").should eq(person)
+      expect(Person.find_and_modify(title: "Junior")).to eq(person)
     end
   end
 
@@ -62,7 +62,7 @@ describe Mongoid::Finders do
       context "when no block is provided" do
 
         it "returns the document" do
-          Person.find_by(title: "sir").should eq(person)
+          expect(Person.find_by(title: "sir")).to eq(person)
         end
       end
 
@@ -75,7 +75,7 @@ describe Mongoid::Finders do
         end
 
         it "yields the returned document" do
-          result.age.should eq(50)
+          expect(result.age).to eq(50)
         end
       end
     end
@@ -108,7 +108,7 @@ describe Mongoid::Finders do
         context "when no block is provided" do
 
           it "returns nil" do
-            Person.find_by(ssn: "333-22-1111").should be_nil
+            expect(Person.find_by(ssn: "333-22-1111")).to be_nil
           end
         end
 
@@ -121,13 +121,27 @@ describe Mongoid::Finders do
           end
 
           it "returns nil" do
-            result.should be_nil
+            expect(result).to be_nil
           end
         end
       end
     end
   end
 
+  [ :first, :one ].each do |method|
+
+    describe "##{method}" do
+
+      let!(:person) do
+        Person.create
+      end
+
+      it "returns the first matching document" do
+        expect(Person.send(method)).to eq(person)
+      end
+    end
+  end
+
   describe ".first_or_create" do
 
     context "when the document is found" do
@@ -137,7 +151,7 @@ describe Mongoid::Finders do
       end
 
       it "returns the document" do
-        Person.first_or_create.should eq(person)
+        expect(Person.first_or_create).to eq(person)
       end
     end
 
@@ -154,7 +168,7 @@ describe Mongoid::Finders do
         end
 
         it "returns the new document" do
-          from_db.person.should eq(person)
+          expect(from_db.person).to eq(person)
         end
       end
 
@@ -165,11 +179,11 @@ describe Mongoid::Finders do
         end
 
         it "creates a persisted document" do
-          person.should be_persisted
+          expect(person).to be_persisted
         end
 
         it "sets the attributes" do
-          person.title.should eq("Senorita")
+          expect(person.title).to eq("Senorita")
         end
       end
 
@@ -182,15 +196,15 @@ describe Mongoid::Finders do
         end
 
         it "creates a persisted document" do
-          person.should be_persisted
+          expect(person).to be_persisted
         end
 
         it "sets the attributes" do
-          person.title.should eq("Senorita")
+          expect(person.title).to eq("Senorita")
         end
 
         it "calls the block" do
-          person.pets.should be_true
+          expect(person.pets).to be true
         end
       end
     end
@@ -205,7 +219,7 @@ describe Mongoid::Finders do
       end
 
       it "returns the document" do
-        Person.first_or_create.should eq(person)
+        expect(Person.first_or_create).to eq(person)
       end
     end
 
@@ -222,11 +236,11 @@ describe Mongoid::Finders do
         end
 
         it "returns the new document" do
-          found.person.should eq(person)
+          expect(found.person).to eq(person)
         end
 
         it "does not save the document" do
-          found.should_not be_persisted
+          expect(found).to_not be_persisted
         end
       end
 
@@ -241,11 +255,11 @@ describe Mongoid::Finders do
         end
 
         it "creates a non persisted document" do
-          person.should_not be_persisted
+          expect(person).to_not be_persisted
         end
 
         it "sets the attributes" do
-          person.title.should eq("esquire")
+          expect(person.title).to eq("esquire")
         end
       end
 
@@ -258,15 +272,15 @@ describe Mongoid::Finders do
         end
 
         it "creates a new document" do
-          person.should_not be_persisted
+          expect(person).to_not be_persisted
         end
 
         it "sets the attributes" do
-          person.title.should eq("Senorita")
+          expect(person.title).to eq("Senorita")
         end
 
         it "calls the block" do
-          person.pets.should be_true
+          expect(person.pets).to be true
         end
       end
     end
@@ -293,7 +307,7 @@ describe Mongoid::Finders do
       end
 
       it "returns the field values" do
-        plucked.should eq([ "Depeche Mode", "Tool", "Photek" ])
+        expect(plucked).to eq([ "Depeche Mode", "Tool", "Photek" ])
       end
     end
 
@@ -304,7 +318,7 @@ describe Mongoid::Finders do
       end
 
       it "returns an empty array" do
-        plucked.should be_empty
+        expect(plucked).to be_empty
       end
     end
   end
@@ -314,8 +328,29 @@ describe Mongoid::Finders do
     describe "##{method}" do
 
       it "forwards the #{method} to the criteria" do
-        Band.should respond_to(method)
+        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.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/indexable/specification_spec.rb

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+describe Mongoid::Indexable::Specification do
+
+  describe "#==" do
+
+    context "when the keys are different" do
+
+      let(:spec_one) do
+        described_class.new(Band, { name: 1 })
+      end
+
+      let(:spec_two) do
+        described_class.new(Band, { title: 1 })
+      end
+
+      it "returns false" do
+        expect(spec_one).to_not eq(spec_two)
+      end
+    end
+
+    context "when the keys are the same" do
+
+      let(:spec_one) do
+        described_class.new(Band, { name: 1 })
+      end
+
+      let(:spec_two) do
+        described_class.new(Band, { name: 1 })
+      end
+
+      it "returns true" do
+        expect(spec_one).to eq(spec_two)
+      end
+    end
+
+    context "when the keys are in different order" do
+
+      let(:spec_one) do
+        described_class.new(Band, { name: 1, title: -1 })
+      end
+
+      let(:spec_two) do
+        described_class.new(Band, { title: -1, name: 1 })
+      end
+
+      it "returns false" do
+        expect(spec_one).to_not eq(spec_two)
+      end
+    end
+
+    context "when the keys are the same with different value" do
+
+      let(:spec_one) do
+        described_class.new(Band, { name: 1, title: 1 })
+      end
+
+      let(:spec_two) do
+        described_class.new(Band, { name: 1, title: -1 })
+      end
+
+      it "returns false" do
+        expect(spec_one).to_not eq(spec_two)
+      end
+    end
+  end
+
+  describe "#fields" do
+
+    let(:spec) do
+      described_class.new(Band, { name: 1, title: 1 })
+    end
+
+    it "returns the key fields in order" do
+      expect(spec.fields).to eq([ :name, :title ])
+    end
+  end
+
+  describe "#initialize" do
+
+    let(:spec) do
+      described_class.new(
+        Band,
+        { name: 1, title: 1, years: -1 },
+        background: true,
+        drop_dups: true
+      )
+    end
+
+    it "sets the class" do
+      expect(spec.klass).to eq(Band)
+    end
+
+    it "normalizes the key" do
+      expect(spec.key).to eq(name: 1, title: 1, y: -1)
+    end
+
+    it "normalizes the options" do
+      expect(spec.options).to eq(background: true, dropDups: true)
+    end
+  end
+end

data/spec/mongoid/{indexes_spec.rb → indexable_spec.rb}

@@ -1,21 +1,21 @@
 require "spec_helper"
 
-describe Mongoid::Indexes do
+describe Mongoid::Indexable do
 
   describe ".included" do
 
     let(:klass) do
       Class.new do
-        include Mongoid::Indexes
+        include Mongoid::Indexable
       end
     end
 
-    it "adds an index_options accessor" do
-      klass.should respond_to(:index_options)
+    it "adds an index_specifications accessor" do
+      expect(klass).to respond_to(:index_specifications)
     end
 
-    it "defaults index_options to empty hash" do
-      klass.index_options.should eq({})
+    it "defaults index_specifications to empty array" do
+      expect(klass.index_specifications).to be_empty
     end
   end
 
@@ -37,7 +37,7 @@ describe Mongoid::Indexes do
       end
 
       it "removes the indexes" do
-        collection.indexes.reject{ |doc| doc["name"] == "_id_" }.should be_empty
+        expect(collection.indexes.reject{ |doc| doc["name"] == "_id_" }).to be_empty
       end
     end
 
@@ -62,7 +62,7 @@ describe Mongoid::Indexes do
       end
 
       it "creates the indexes" do
-        indexes.reject{ |doc| doc["name"] == "_id_" }.should be_empty
+        expect(indexes.reject{ |doc| doc["name"] == "_id_" }).to be_empty
       end
     end
   end
@@ -75,7 +75,7 @@ describe Mongoid::Indexes do
         Class.new do
           include Mongoid::Document
           store_in collection: "test_class"
-          index({ _type: 1 }, { unique: false, background: true })
+          index({ _type: 1 }, unique: false, background: true)
         end
       end
 
@@ -84,7 +84,7 @@ describe Mongoid::Indexes do
       end
 
       it "creates the indexes" do
-        klass.collection.indexes[_type: 1].should_not be_nil
+        expect(klass.collection.indexes[_type: 1]).to_not be_nil
       end
     end
 
@@ -107,7 +107,7 @@ describe Mongoid::Indexes do
       end
 
       it "creates the indexes" do
-        indexes[_type: 1].should_not be_nil
+        expect(indexes[_type: 1]).to_not be_nil
       end
     end
   end
@@ -129,10 +129,12 @@ describe Mongoid::Indexes do
         klass.add_indexes
       end
 
+      let(:spec) do
+        klass.index_specification(_type: 1)
+      end
+
       it "adds the _type index" do
-        klass.index_options[_type: 1].should eq(
-          { unique: false, background: true }
-        )
+        expect(spec.options).to eq(unique: false, background: true)
       end
     end
   end
@@ -149,105 +151,105 @@ describe Mongoid::Indexes do
     context "when indexing a field that is aliased" do
 
       before do
-        klass.index({ authentication_token: 1 }, { unique: true })
+        klass.index({ authentication_token: 1 }, unique: true)
       end
 
       let(:options) do
-        klass.index_options[a: 1]
+        klass.index_specification(a: 1).options
       end
 
       it "sets the index with unique options" do
-        options.should eq(unique: true)
+        expect(options).to eq(unique: true)
       end
     end
 
     context "when providing unique options" do
 
       before do
-        klass.index({ name: 1 }, { unique: true })
+        klass.index({ name: 1 }, unique: true)
       end
 
       let(:options) do
-        klass.index_options[name: 1]
+        klass.index_specification(name: 1).options
       end
 
       it "sets the index with unique options" do
-        options.should eq(unique: true)
+        expect(options).to eq(unique: true)
       end
     end
 
     context "when providing a drop_dups option" do
 
       before do
-        klass.index({ name: 1 }, { drop_dups: true })
+        klass.index({ name: 1 }, drop_dups: true)
       end
 
       let(:options) do
-        klass.index_options[name: 1]
+        klass.index_specification(name: 1).options
       end
 
       it "sets the index with dropDups options" do
-        options.should eq(dropDups: true)
+        expect(options).to eq(dropDups: true)
       end
     end
 
     context "when providing a sparse option" do
 
       before do
-        klass.index({ name: 1 }, { sparse: true })
+        klass.index({ name: 1 }, sparse: true)
       end
 
       let(:options) do
-        klass.index_options[name: 1]
+        klass.index_specification(name: 1).options
       end
 
       it "sets the index with sparse options" do
-        options.should eq(sparse: true)
+        expect(options).to eq(sparse: true)
       end
     end
 
     context "when providing a name option" do
 
       before do
-        klass.index({ name: 1 }, { name: "index_name" })
+        klass.index({ name: 1 }, name: "index_name")
       end
 
       let(:options) do
-        klass.index_options[name: 1]
+        klass.index_specification(name: 1).options
       end
 
       it "sets the index with name options" do
-        options.should eq(name: "index_name")
+        expect(options).to eq(name: "index_name")
       end
     end
 
     context "when providing database options" do
 
       before do
-        klass.index({ name: 1 }, { database: "mongoid_index_alt" })
+        klass.index({ name: 1 }, database: "mongoid_index_alt")
       end
 
       let(:options) do
-        klass.index_options[name: 1]
+        klass.index_specification(name: 1).options
       end
 
       it "sets the index with background options" do
-        options.should eq(database: "mongoid_index_alt")
+        expect(options).to eq(database: "mongoid_index_alt")
       end
     end
 
     context "when providing a background option" do
 
       before do
-        klass.index({ name: 1 }, { background: true })
+        klass.index({ name: 1 }, background: true)
       end
 
       let(:options) do
-        klass.index_options[name: 1]
+        klass.index_specification(name: 1).options
       end
 
       it "sets the index with background options" do
-        options.should eq(background: true)
+        expect(options).to eq(background: true)
       end
     end
 
@@ -258,11 +260,51 @@ describe Mongoid::Indexes do
       end
 
       let(:options) do
-        klass.index_options[name: 1, title: -1]
+        klass.index_specification(name: 1, title: -1).options
       end
 
       it "sets the compound key index" do
-        options.should be_empty
+        expect(options).to be_empty
+      end
+    end
+
+    context "when providing multiple inverse compound indexes" do
+
+      before do
+        klass.index({ name: 1, title: -1 })
+        klass.index({ title: -1, name: 1 })
+      end
+
+      let(:first_spec) do
+        klass.index_specification(name: 1, title: -1)
+      end
+
+      let(:second_spec) do
+        klass.index_specification(title: -1, name: 1)
+      end
+
+      it "does not overwrite the index options" do
+        expect(first_spec).to_not eq(second_spec)
+      end
+    end
+
+    context "when providing multiple compound indexes with different order" do
+
+      before do
+        klass.index({ name: 1, title: -1 })
+        klass.index({ name: 1, title: 1 })
+      end
+
+      let(:first_spec) do
+        klass.index_specification(name: 1, title: -1)
+      end
+
+      let(:second_spec) do
+        klass.index_specification(name: 1, title: 1)
+      end
+
+      it "does not overwrite the index options" do
+        expect(first_spec).to_not eq(second_spec)
       end
     end
 
@@ -273,11 +315,11 @@ describe Mongoid::Indexes do
       end
 
       let(:options) do
-        klass.index_options[location: "2d"]
+        klass.index_specification(location: "2d").options
       end
 
       it "sets the geospacial index" do
-        options.should eq({ min: -200, max: 200, bits: 32 })
+        expect(options).to eq({ min: -200, max: 200, bits: 32 })
       end
     end
 
@@ -288,11 +330,11 @@ describe Mongoid::Indexes do
       end
 
       let(:options) do
-        klass.index_options[location: "geoHaystack"]
+        klass.index_specification(location: "geoHaystack").options
       end
 
       it "sets the geo haystack index" do
-        options.should eq({ min: -200, max: 200, bucketSize: 0.5 })
+        expect(options).to eq({ min: -200, max: 200, bucketSize: 0.5 })
       end
     end
 
@@ -303,11 +345,89 @@ describe Mongoid::Indexes do
       end
 
       let(:options) do
-        klass.index_options[location: "2dsphere"]
+        klass.index_specification(location: "2dsphere").options
       end
 
       it "sets the spherical geospatial index" do
-        options.should be_empty
+        expect(options).to be_empty
+      end
+    end
+
+    context "when providing a text index" do
+
+      context "when the index is a single field" do
+
+        before do
+          klass.index({ description: "text" })
+        end
+
+        let(:options) do
+          klass.index_specification(description: "text").options
+        end
+
+        it "allows the set of the text index" do
+          expect(options).to be_empty
+        end
+      end
+
+      context "when the index is multiple fields" do
+
+        before do
+          klass.index({ description: "text", name: "text" })
+        end
+
+        let(:options) do
+          klass.index_specification(description: "text", name: "text").options
+        end
+
+        it "allows the set of the text index" do
+          expect(options).to be_empty
+        end
+      end
+
+      context "when the index is all string fields" do
+
+        before do
+          klass.index({ "$**" => "text" })
+        end
+
+        let(:options) do
+          klass.index_specification(:"$**" => "text").options
+        end
+
+        it "allows the set of the text index" do
+          expect(options).to be_empty
+        end
+      end
+
+      context "when providing a default language" do
+
+        before do
+          klass.index({ description: "text" }, default_language: "english")
+        end
+
+        let(:options) do
+          klass.index_specification(description: "text").options
+        end
+
+        it "allows the set of the text index" do
+          expect(options).to eq(default_language: "english")
+        end
+      end
+
+      context "when providing a name" do
+
+        before do
+          klass.index({ description: "text" }, name: "text_index")
+        end
+
+        let(:options) do
+          klass.index_specification(description: "text").options
+        end
+
+        it "allows the set of the text index" do
+          expect(options).to eq(name: "text_index")
+        end
       end
     end
 
@@ -318,11 +438,11 @@ describe Mongoid::Indexes do
       end
 
       let(:options) do
-        klass.index_options[a: "hashed"]
+        klass.index_specification(a: "hashed").options
       end
 
       it "sets the hashed index" do
-        options.should be_empty
+        expect(options).to be_empty
       end
     end
 
@@ -333,11 +453,11 @@ describe Mongoid::Indexes do
       end
 
       let(:options) do
-        klass.index_options[content: "text"]
+        klass.index_specification(content: "text").options
       end
 
       it "sets the text index" do
-        options.should be_empty
+        expect(options).to be_empty
       end
     end
 
@@ -348,11 +468,11 @@ describe Mongoid::Indexes do
       end
 
       let(:options) do
-        klass.index_options[content: "text", title: "text"]
+        klass.index_specification(content: "text", title: "text").options
       end
 
       it "sets the compound text index" do
-        options.should eq(weights: { content: 1, title: 2 })
+        expect(options).to eq(weights: { content: 1, title: 2 })
       end
     end
 
@@ -363,11 +483,11 @@ describe Mongoid::Indexes do
       end
 
       let(:options) do
-        klass.index_options[name: 1]
+        klass.index_specification(name: 1).options
       end
 
       it "sets the index with sparse options" do
-        options.should eq(expireAfterSeconds: 3600)
+        expect(options).to eq(expireAfterSeconds: 3600)
       end
     end