mongoid 3.1.7 → 4.0.0.alpha1

data/spec/mongoid/contextual/text_search_spec.rb

@@ -0,0 +1,207 @@
+require "spec_helper"
+
+describe Mongoid::Contextual::TextSearch do
+
+  before do
+    Word.with(database: "admin").mongo_session.command(setParameter: 1, textSearchEnabled: true)
+    Word.create_indexes
+  end
+
+  after(:all) do
+    Word.remove_indexes
+  end
+
+  describe "#each" do
+
+    let(:collection) do
+      Word.collection
+    end
+
+    let(:criteria) do
+      Word.all
+    end
+
+    before do
+      Word.create!(name: "phase", origin: "latin")
+      Word.create!(name: "phazed", origin: "latin")
+    end
+
+    context "when the search is projecting" do
+
+      let(:search) do
+        described_class.new(collection, criteria, "phase").project(name: 1)
+      end
+
+      let(:documents) do
+        search.entries
+      end
+
+      it "limits the fields to the projection" do
+        expect(documents.first.origin).to be_nil
+      end
+    end
+
+    context "when the search is not projecting" do
+
+      let(:search) do
+        described_class.new(collection, criteria, "phase")
+      end
+
+      let(:documents) do
+        search.entries
+      end
+
+      it "returns all fields" do
+        expect(documents.first.origin).to eq("latin")
+      end
+    end
+  end
+
+  describe "#execute" do
+
+    let(:collection) do
+      Word.collection
+    end
+
+    let(:criteria) do
+      Word.all
+    end
+
+    let(:search) do
+      described_class.new(collection, criteria, "phase")
+    end
+
+    before do
+      Word.create!(name: "phase", origin: "latin")
+      Word.create!(name: "phazed", origin: "latin")
+    end
+
+    let(:results) do
+      search.execute
+    end
+
+    it "returns the raw results" do
+      expect(results).to_not be_empty
+    end
+  end
+
+  describe "#initialize" do
+
+    let(:collection) do
+      Word.collection
+    end
+
+    let(:criteria) do
+      Word.limit(100)
+    end
+
+    let(:search) do
+      described_class.new(collection, criteria, "phase")
+    end
+
+    it "sets the collection" do
+      expect(search.collection).to eq(collection)
+    end
+
+    it "sets the criteria" do
+      expect(search.criteria).to eq(criteria)
+    end
+
+    it "sets the text command" do
+      expect(search.command[:text]).to eq(collection.name)
+    end
+
+    it "sets the text search parameter" do
+      expect(search.command[:search]).to eq("phase")
+    end
+
+    it "sets the criteria" do
+      expect(search.command[:filter]).to be_empty
+    end
+
+    it "sets the limit" do
+      expect(search.command[:limit]).to eq(100)
+    end
+  end
+
+  describe "#language" do
+
+    let(:collection) do
+      Word.collection
+    end
+
+    let(:criteria) do
+      Word.limit(100)
+    end
+
+    let(:search) do
+      described_class.new(collection, criteria, "phase")
+    end
+
+    let!(:text_search) do
+      search.language("deutsch")
+    end
+
+    it "sets the search language" do
+      expect(search.command[:language]).to eq("deutsch")
+    end
+
+    it "returns the text search" do
+      expect(text_search).to equal(search)
+    end
+  end
+
+  describe "#project" do
+
+    let(:collection) do
+      Word.collection
+    end
+
+    let(:criteria) do
+      Word.limit(100)
+    end
+
+    let(:search) do
+      described_class.new(collection, criteria, "phase")
+    end
+
+    let!(:text_search) do
+      search.project(name: 1, title: 1)
+    end
+
+    it "sets the search field limitations" do
+      expect(search.command[:project]).to eq(name: 1, title: 1)
+    end
+
+    it "returns the text search" do
+      expect(text_search).to equal(search)
+    end
+  end
+
+  describe "#stats" do
+
+    let(:collection) do
+      Word.collection
+    end
+
+    let(:criteria) do
+      Word.all
+    end
+
+    let(:search) do
+      described_class.new(collection, criteria, "phase")
+    end
+
+    before do
+      Word.create!(name: "phase", origin: "latin")
+    end
+
+    let(:stats) do
+      search.stats
+    end
+
+    it "returns the raw stats" do
+      expect(stats["nscanned"]).to eq(1)
+    end
+  end
+end

data/spec/mongoid/copyable_spec.rb

@@ -50,7 +50,7 @@ describe Mongoid::Copyable do
         end
 
         it "does not set the id field as the _id" do
-          cloned.id.should_not eq(1234)
+          expect(cloned.id).to_not eq(1234)
         end
       end
 
@@ -76,17 +76,17 @@ describe Mongoid::Copyable do
 
         it "sets the pt_BR version" do
           I18n.locale = 'pt_BR'
-          copy.desc.should eq("descrição")
+          expect(copy.desc).to eq("descrição")
         end
 
         it "sets the english version" do
           I18n.locale = :en
-          copy.desc.should eq("description")
+          expect(copy.desc).to eq("description")
         end
 
         it "sets to nil an nonexistent lang" do
           I18n.locale = :fr
-          copy.desc.should be_nil
+          expect(copy.desc).to be_nil
         end
       end
 
@@ -105,21 +105,21 @@ describe Mongoid::Copyable do
         end
 
         it "marks the fields as dirty" do
-          copy.changes["age"].should eq([ nil, 100 ])
+          expect(copy.changes["age"]).to eq([ nil, 100 ])
         end
 
         it "flags the document as changed" do
-          copy.should be_changed
+          expect(copy).to be_changed
         end
 
         it "copies protected fields" do
-          copy.owner_id.should eq(5)
+          expect(copy.owner_id).to eq(5)
         end
       end
 
       context "when the document is new" do
 
-        context "when versions exist" do
+        context "when there are changes" do
 
           let(:copy) do
             person.send(method)
@@ -130,71 +130,63 @@ describe Mongoid::Copyable do
           end
 
           it "returns a new document" do
-            copy.should_not be_persisted
+            expect(copy).to_not be_persisted
           end
 
           it "has an id" do
-            copy.id.should_not be_nil
+            expect(copy.id).to_not be_nil
           end
 
           it "flags the document as changed" do
-            copy.should be_changed
+            expect(copy).to be_changed
           end
 
           it "marks fields as dirty" do
-            copy.changes["age"].should eq([ nil, 100 ])
+            expect(copy.changes["age"]).to eq([ nil, 100 ])
           end
 
           it "has a different id from the original" do
-            copy.id.should_not eq(person.id)
-          end
-
-          it "does not copy the versions" do
-            copy[:versions].should be_nil
-          end
-
-          it "resets the document version" do
-            copy.version.should eq(1)
+            expect(copy.id).to_not eq(person.id)
           end
 
           it "returns a new instance" do
-            copy.should_not be_eql(person)
+            expect(copy).to_not be_eql(person)
           end
 
           it "copys embeds many documents" do
-            copy.addresses.should eq(person.addresses)
+            expect(copy.addresses).to eq(person.addresses)
           end
 
           it "sets the embedded many documents as new" do
-            copy.addresses.first.should be_new_record
+            expect(copy.addresses.first).to be_new_record
           end
 
           it "creates new embeds many instances" do
-            copy.addresses.should_not equal(person.addresses)
+            expect(copy.addresses).to_not equal(person.addresses)
           end
 
           it "copys embeds one documents" do
-            copy.name.should eq(person.name)
+            expect(copy.name).to eq(person.name)
           end
 
           it "flags the embeds one documents as new" do
-            copy.name.should be_new_record
+            expect(copy.name).to be_new_record
           end
 
           it "creates a new embeds one instance" do
-            copy.name.should_not equal(person.name)
+            expect(copy.name).to_not equal(person.name)
           end
 
           it "does not copy referenced many documents" do
-            copy.posts.should be_empty
+            expect(copy.posts).to be_empty
           end
 
           it "does not copy references one documents" do
-            copy.game.should be_nil
+            expect(copy.game).to be_nil
           end
 
           it "copies localized fields" do
-            copy.desc.should eq("description")
+            expect(copy.desc).to eq("description")
           end
 
           context "when saving the copy" do
@@ -208,15 +200,15 @@ describe Mongoid::Copyable do
             end
 
             it "persists the attributes" do
-              reloaded.title.should eq("Sir")
+              expect(reloaded.title).to eq("Sir")
             end
 
             it "persists the embeds many relation" do
-              reloaded.addresses.should eq(person.addresses)
+              expect(reloaded.addresses).to eq(person.addresses)
             end
 
             it "persists the embeds one relation" do
-              reloaded.name.should eq(person.name)
+              expect(reloaded.name).to eq(person.name)
             end
           end
         end
@@ -228,7 +220,7 @@ describe Mongoid::Copyable do
           person.new_record = false
         end
 
-        context "when versions exist" do
+        context "when there are changes" do
 
           let(:copy) do
             person.send(method)
@@ -239,55 +231,51 @@ describe Mongoid::Copyable do
           end
 
           it "flags the document as changed" do
-            copy.should be_changed
+            expect(copy).to be_changed
           end
 
           it "marks fields as dirty" do
-            copy.changes["age"].should eq([ nil, 100 ])
+            expect(copy.changes["age"]).to eq([ nil, 100 ])
           end
 
           it "returns a new document" do
-            copy.should_not be_persisted
+            expect(copy).to_not be_persisted
           end
 
           it "has an id" do
-            copy.id.should_not be_nil
+            expect(copy.id).to_not be_nil
           end
 
           it "has a different id from the original" do
-            copy.id.should_not eq(person.id)
-          end
-
-          it "does not copy the versions" do
-            copy[:versions].should be_nil
+            expect(copy.id).to_not eq(person.id)
           end
 
           it "returns a new instance" do
-            copy.should_not be_eql(person)
+            expect(copy).to_not be_eql(person)
           end
 
           it "copys embeds many documents" do
-            copy.addresses.should eq(person.addresses)
+            expect(copy.addresses).to eq(person.addresses)
           end
 
           it "creates new embeds many instances" do
-            copy.addresses.should_not equal(person.addresses)
+            expect(copy.addresses).to_not equal(person.addresses)
           end
 
           it "copys embeds one documents" do
-            copy.name.should eq(person.name)
+            expect(copy.name).to eq(person.name)
           end
 
           it "creates a new embeds one instance" do
-            copy.name.should_not equal(person.name)
+            expect(copy.name).to_not equal(person.name)
           end
 
           it "does not copy referenced many documents" do
-            copy.posts.should be_empty
+            expect(copy.posts).to be_empty
           end
 
           it "does not copy references one documents" do
-            copy.game.should be_nil
+            expect(copy.game).to be_nil
           end
 
           context "when saving the copy" do
@@ -301,15 +289,15 @@ describe Mongoid::Copyable do
             end
 
             it "persists the attributes" do
-              reloaded.title.should eq("Sir")
+              expect(reloaded.title).to eq("Sir")
             end
 
             it "persists the embeds many relation" do
-              reloaded.addresses.should eq(person.addresses)
+              expect(reloaded.addresses).to eq(person.addresses)
             end
 
             it "persists the embeds one relation" do
-              reloaded.name.should eq(person.name)
+              expect(reloaded.name).to eq(person.name)
             end
           end
         end
@@ -322,47 +310,47 @@ describe Mongoid::Copyable do
         end
 
         it "returns a new document" do
-          copy.should_not be_persisted
+          expect(copy).to_not be_persisted
         end
 
         it "has an id" do
-          copy.id.should_not be_nil
+          expect(copy.id).to_not be_nil
         end
 
         it "has a different id from the original" do
-          copy.id.should_not eq(person.id)
+          expect(copy.id).to_not eq(person.id)
         end
 
         it "returns a new instance" do
-          copy.should_not be_eql(person)
+          expect(copy).to_not be_eql(person)
         end
 
         it "copys embeds many documents" do
-          copy.addresses.should eq(person.addresses)
+          expect(copy.addresses).to eq(person.addresses)
         end
 
         it "creates new embeds many instances" do
-          copy.addresses.should_not equal(person.addresses)
+          expect(copy.addresses).to_not equal(person.addresses)
         end
 
         it "copys embeds one documents" do
-          copy.name.should eq(person.name)
+          expect(copy.name).to eq(person.name)
         end
 
         it "creates a new embeds one instance" do
-          copy.name.should_not equal(person.name)
+          expect(copy.name).to_not equal(person.name)
         end
 
         it "does not copy referenced many documents" do
-          copy.posts.should be_empty
+          expect(copy.posts).to be_empty
         end
 
         it "does not copy references one documents" do
-          copy.game.should be_nil
+          expect(copy.game).to be_nil
         end
 
         it "keeps the original attributes frozen" do
-          person.attributes.should be_frozen
+          expect(person.attributes).to be_frozen
         end
 
         context "when saving the copy" do
@@ -376,15 +364,15 @@ describe Mongoid::Copyable do
           end
 
           it "persists the attributes" do
-            reloaded.title.should eq("Sir")
+            expect(reloaded.title).to eq("Sir")
           end
 
           it "persists the embeds many relation" do
-            reloaded.addresses.should eq(person.addresses)
+            expect(reloaded.addresses).to eq(person.addresses)
           end
 
           it "persists the embeds one relation" do
-            reloaded.name.should eq(person.name)
+            expect(reloaded.name).to eq(person.name)
           end
         end
       end