mongoid 8.0.13 → 8.1.0

data/spec/mongoid/contextual/memory_spec.rb

@@ -4,6 +4,36 @@ require "spec_helper"
 
 describe Mongoid::Contextual::Memory do
 
+  shared_examples "raises an error when no documents" do
+    context "when there are no matching documents" do
+      let(:criteria) do
+        Address.all.tap do |crit|
+          crit.documents = []
+        end
+      end
+
+      it "returns nil" do
+        expect do
+          context.send(method)
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Address./)
+      end
+    end
+  end
+
+  shared_examples "returns nil when no documents" do
+    context "when there are no matching documents" do
+      let(:criteria) do
+        Address.all.tap do |crit|
+          crit.documents = []
+        end
+      end
+
+      it "returns nil" do
+        expect(context.send(method)).to be_nil
+      end
+    end
+  end
+
   [ :blank?, :empty? ].each do |method|
 
     describe "##{method}" do
@@ -492,6 +522,8 @@ describe Mongoid::Contextual::Memory do
       end
 
       context "when getting a localized field" do
+        with_default_i18n_configs
+
         before do
           I18n.locale = :en
           d = Dictionary.create!(description: 'english-text')
@@ -500,10 +532,6 @@ describe Mongoid::Contextual::Memory do
           d.save!
         end
 
-        after do
-          I18n.locale = :en
-        end
-
         let(:criteria) do
           Dictionary.all.tap do |crit|
             crit.documents = [ Dictionary.first ]
@@ -546,17 +574,11 @@ describe Mongoid::Contextual::Memory do
         end
 
         context 'when fallbacks are enabled with a locale list' do
-          with_i18n_fallbacks
+          require_fallbacks
+          with_default_i18n_configs
 
-          around(:all) do |example|
-            prev_fallbacks = I18n.fallbacks.dup
+          before do
             I18n.fallbacks[:he] = [ :en ]
-            example.run
-            I18n.fallbacks = prev_fallbacks
-          end
-
-          after do
-            I18n.locale = :en
           end
 
           let(:distinct) do
@@ -572,6 +594,8 @@ describe Mongoid::Contextual::Memory do
         end
 
         context "when the localized field is embedded" do
+          with_default_i18n_configs
+
           let(:person) do
             p = Passport.new
             I18n.locale = :en
@@ -582,10 +606,6 @@ describe Mongoid::Contextual::Memory do
             Person.create!(passport: p, employer_id: 12345)
           end
 
-          after do
-            I18n.locale = :en
-          end
-
           let(:criteria) do
             Person.where(employer_id: 12345).tap do |crit|
               crit.documents = [ person ]
@@ -633,27 +653,6 @@ describe Mongoid::Contextual::Memory do
         end
       end
     end
-
-    context 'when the field name is a method name' do
-      let!(:person) do
-        Person.create!(ssn: 'secret-ssn')
-      end
-
-      let!(:address) do
-        person.addresses.create!(street: 'hobrecht')
-      end
-
-      let(:criteria) do
-        Address.all.tap do |crit|
-          crit.documents = [ address ]
-        end
-      end
-
-      it 'does not call the method' do
-        expect(address).not_to receive(:destroy)
-        expect(context.distinct(:destroy)).to eq([ nil ])
-      end
-    end
   end
 
   describe "#each" do
@@ -767,52 +766,158 @@ describe Mongoid::Contextual::Memory do
       Address.new(street: "friedel")
     end
 
-    context "when there are matching documents" do
+    let(:criteria) do
+      Address.where(street: "hobrecht").tap do |crit|
+        crit.documents = [ hobrecht, friedel ]
+      end
+    end
 
-      let(:criteria) do
-        Address.where(street: "hobrecht").tap do |crit|
-          crit.documents = [ hobrecht, friedel ]
+    context "when not passing options" do
+
+      context "when there are matching documents" do
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        it "returns true" do
+          expect(context).to be_exists
         end
       end
 
-      let(:context) do
-        described_class.new(criteria)
+      context "when there are no matching documents" do
+
+        let(:criteria) do
+          Address.where(street: "pfluger").tap do |crit|
+            crit.documents = [ hobrecht, friedel ]
+          end
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        it "returns false" do
+          expect(context).to_not be_exists
+        end
       end
 
-      it "returns true" do
-        expect(context).to be_exists
+      context 'when there is a collation on the criteria' do
+
+        let(:criteria) do
+          Address.where(street: "pfluger").tap do |crit|
+            crit.documents = [ hobrecht, friedel ]
+          end.collation(locale: 'en_US', strength: 2)
+        end
+
+        it "raises an exception" do
+          expect {
+            context
+          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end
       end
     end
 
-    context "when there are no matching documents" do
+    context "when passing an _id" do
 
-      let(:criteria) do
-        Address.where(street: "pfluger").tap do |crit|
-          crit.documents = [ hobrecht, friedel ]
+      context "when its of type BSON::ObjectId" do
+
+        context "when calling it on an empty criteria" do
+
+          it "returns true" do
+            expect(criteria.exists?(hobrecht._id)).to be true
+          end
+        end
+
+        context "when calling it on a criteria that includes the object" do
+
+          it "returns true" do
+            expect(criteria.where(street: hobrecht.street).exists?(hobrecht._id)).to be true
+          end
+        end
+
+        context "when calling it on a criteria that does not include the object" do
+
+          it "returns false" do
+            expect(criteria.where(street: "bogus").exists?(hobrecht._id)).to be false
+          end
+        end
+
+        context "when the id does not exist" do
+
+          it "returns false" do
+            expect(criteria.exists?(BSON::ObjectId.new)).to be false
+          end
         end
       end
 
-      let(:context) do
-        described_class.new(criteria)
+      context "when its of type String" do
+
+        context "when the id exists" do
+
+          it "returns true" do
+            expect(criteria.exists?(hobrecht._id.to_s)).to be true
+          end
+        end
+
+        context "when the id does not exist" do
+
+          it "returns false" do
+            expect(criteria.exists?(BSON::ObjectId.new.to_s)).to be false
+          end
+        end
       end
+    end
+
+    context "when passing a hash" do
+
+      context "when calling it on an empty criteria" do
+
+        it "returns true" do
+          expect(criteria.exists?(street: hobrecht.street)).to be true
+        end
+      end
+
+      context "when calling it on a criteria that includes the object" do
+
+        it "returns true" do
+          expect(criteria.where(_id: hobrecht._id).exists?(street: hobrecht.street)).to be true
+        end
+      end
+
+      context "when calling it on a criteria that does not include the object" do
+
+        it "returns false" do
+          expect(criteria.where(_id: BSON::ObjectId.new).exists?(street: hobrecht.street)).to be false
+        end
+      end
+
+      context "when the conditions don't match" do
+
+        it "returns false" do
+          expect(criteria.exists?(street: "bogus")).to be false
+        end
+      end
+    end
+
+    context "when passing false" do
 
       it "returns false" do
-        expect(context).to_not be_exists
+        expect(criteria.exists?(false)).to be false
       end
     end
 
-    context 'when there is a collation on the criteria' do
+    context "when passing nil" do
 
-      let(:criteria) do
-        Address.where(street: "pfluger").tap do |crit|
-          crit.documents = [ hobrecht, friedel ]
-        end.collation(locale: 'en_US', strength: 2)
+      it "returns false" do
+        expect(criteria.exists?(nil)).to be false
       end
+    end
 
-      it "raises an exception" do
-        expect {
-          context
-        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+    context "when the limit is 0" do
+
+      it "returns false" do
+        expect(criteria.limit(0).exists?).to be false
       end
     end
   end
@@ -821,6 +926,8 @@ describe Mongoid::Contextual::Memory do
 
     describe "##{method}" do
 
+      let(:method) { method }
+
       let(:hobrecht) do
         Address.new(street: "hobrecht")
       end
@@ -851,6 +958,8 @@ describe Mongoid::Contextual::Memory do
         expect(context.send(method, 1)).to eq([ hobrecht ])
       end
 
+      include_examples "returns nil when no documents"
+
       context 'when there is a collation on the criteria' do
 
         let(:criteria) do
@@ -868,8 +977,39 @@ describe Mongoid::Contextual::Memory do
     end
   end
 
+  describe "#first!" do
+
+    let(:method) { :first! }
+
+    let(:hobrecht) do
+      Address.new(street: "hobrecht")
+    end
+
+    let(:friedel) do
+      Address.new(street: "friedel")
+    end
+
+    let(:criteria) do
+      Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+        crit.documents = [ hobrecht, friedel ]
+      end
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    it "returns the first matching document" do
+      expect(context.first!).to eq(hobrecht)
+    end
+
+    include_examples "raises an error when no documents"
+  end
+
   describe "#take" do
 
+    let(:method) { :take }
+
     let(:hobrecht) do
       Address.new(street: "hobrecht")
     end
@@ -900,6 +1040,8 @@ describe Mongoid::Contextual::Memory do
       expect(context.take(1)).to eq([ hobrecht ])
     end
 
+    include_examples "returns nil when no documents"
+
     context 'when there is a collation on the criteria' do
 
       let(:criteria) do
@@ -918,6 +1060,8 @@ describe Mongoid::Contextual::Memory do
 
   describe "#take!" do
 
+    let(:method) { :take! }
+
     let(:hobrecht) do
       Address.new(street: "hobrecht")
     end
@@ -940,19 +1084,7 @@ describe Mongoid::Contextual::Memory do
       expect(context.take!).to eq(hobrecht)
     end
 
-    context "when the criteria is empty" do
-      let(:criteria) do
-        Address.where(street: "bogus").tap do |crit|
-          crit.documents = []
-        end
-      end
-
-      it "raise an error" do
-        expect do
-          context.take!
-        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Address./)
-      end
-    end
+    include_examples "raises an error when no documents"
 
     context 'when there is a collation on the criteria' do
 
@@ -1073,6 +1205,8 @@ describe Mongoid::Contextual::Memory do
 
   describe "#last" do
 
+    let(:method) { :last }
+
     let(:hobrecht) do
       Address.new(street: "hobrecht")
     end
@@ -1103,6 +1237,8 @@ describe Mongoid::Contextual::Memory do
       expect(context.last(1)).to eq([ friedel ])
     end
 
+    include_examples "returns nil when no documents"
+
     context 'when there is a collation on the criteria' do
 
       let(:criteria) do
@@ -1119,6 +1255,102 @@ describe Mongoid::Contextual::Memory do
     end
   end
 
+  describe "#last!" do
+    let(:method) { :last! }
+
+    let(:hobrecht) do
+      Address.new(street: "hobrecht")
+    end
+
+    let(:friedel) do
+      Address.new(street: "friedel")
+    end
+
+    let(:criteria) do
+      Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+        crit.documents = [ hobrecht, friedel ]
+      end
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    it "returns the last matching document" do
+      expect(context.last!).to eq(friedel)
+    end
+
+    include_examples "raises an error when no documents"
+  end
+
+  [ :second,
+    :third,
+    :fourth,
+    :fifth,
+    :second_to_last,
+    :third_to_last
+  ].each do |meth|
+    describe "##{meth}" do
+      let(:method) { meth }
+
+      let(:addresses) do
+        [
+          Address.new,
+          Address.new,
+          Address.new,
+          Address.new,
+          Address.new,
+        ]
+      end
+
+      let(:criteria) do
+        Address.all.tap do |crit|
+          crit.documents = addresses
+        end
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      it "returns the matching document" do
+        expect(context.send(method)).to eq(addresses.send(method))
+      end
+
+      include_examples "returns nil when no documents"
+    end
+
+    describe "##{meth}!" do
+      let(:method) { "#{meth}!" }
+
+      let(:addresses) do
+        [
+          Address.new,
+          Address.new,
+          Address.new,
+          Address.new,
+          Address.new,
+        ]
+      end
+
+      let(:criteria) do
+        Address.all.tap do |crit|
+          crit.documents = addresses
+        end
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      it "returns the matching document" do
+        expect(context.send(method)).to eq(addresses.send(meth))
+      end
+
+      include_examples "raises an error when no documents"
+    end
+  end
+
   [ :length, :size ].each do |method|
 
     describe "##{method}" do
@@ -1264,11 +1496,11 @@ describe Mongoid::Contextual::Memory do
       config_override :legacy_pluck_distinct, true
 
       let(:hobrecht) do
-        Address.new(street: "hobrecht")
+        Address.new(street: "hobrecht", number: 213)
       end
 
       let(:friedel) do
-        Address.new(street: "friedel")
+        Address.new(street: "friedel", number: 11)
       end
 
       let(:criteria) do
@@ -1288,6 +1520,17 @@ describe Mongoid::Contextual::Memory do
         end
       end
 
+      context "when plucking multiple fields" do
+
+        let!(:plucked) do
+          context.pluck(:street, :number)
+        end
+
+        it "returns the values as an array" do
+          expect(plucked).to eq([ ["hobrecht", 213], ["friedel", 11] ])
+        end
+      end
+
       context "when plucking a mix of empty and non-empty values" do
 
         let(:empty_doc) do
@@ -1317,7 +1560,7 @@ describe Mongoid::Contextual::Memory do
             context.pluck(:foo)
           end
 
-          it "returns a empty array" do
+          it "returns an empty array" do
             expect(plucked).to eq([nil, nil])
           end
         end
@@ -1328,7 +1571,7 @@ describe Mongoid::Contextual::Memory do
             context.pluck(:foo, :bar)
           end
 
-          it "returns a empty array" do
+          it "returns an empty array" do
             expect(plucked).to eq([[nil, nil], [nil, nil]])
           end
         end
@@ -1550,6 +1793,7 @@ describe Mongoid::Contextual::Memory do
       end
 
       context 'when plucking a localized field' do
+        with_default_i18n_configs
 
         before do
           I18n.locale = :en
@@ -1559,10 +1803,6 @@ describe Mongoid::Contextual::Memory do
           d.save!
         end
 
-        after do
-          I18n.locale = :en
-        end
-
         let(:criteria) do
           Dictionary.all.tap do |crit|
             crit.documents = [ Dictionary.first ]
@@ -1619,17 +1859,11 @@ describe Mongoid::Contextual::Memory do
         end
 
         context 'when fallbacks are enabled with a locale list' do
-          with_i18n_fallbacks
+          require_fallbacks
+          with_default_i18n_configs
 
-          around(:all) do |example|
-            prev_fallbacks = I18n.fallbacks.dup
+          before do
             I18n.fallbacks[:he] = [ :en ]
-            example.run
-            I18n.fallbacks = prev_fallbacks
-          end
-
-          after do
-            I18n.locale = :en
           end
 
           let(:plucked) do
@@ -1645,6 +1879,8 @@ describe Mongoid::Contextual::Memory do
         end
 
         context "when the localized field is embedded" do
+          with_default_i18n_configs
+
           before do
             p = Passport.new
             I18n.locale = :en
@@ -1655,10 +1891,6 @@ describe Mongoid::Contextual::Memory do
             Person.create!(passport: p, employer_id: 12345)
           end
 
-          after do
-            I18n.locale = :en
-          end
-
           let(:plucked) do
             Person.where(employer_id: 12345).pluck("pass.name").first
           end
@@ -1741,7 +1973,7 @@ describe Mongoid::Contextual::Memory do
         end
       end
 
-      context "when tallying deeply nested arrays/embedded associations" do
+      context "when plucking deeply nested arrays/embedded associations" do
 
         let(:criteria) do
           Person.all.tap do |crit|
@@ -1764,116 +1996,6 @@ describe Mongoid::Contextual::Memory do
         end
       end
     end
-
-    context 'when plucking a dynamic attribute' do
-      let(:criteria) do
-        Band.all.tap do |crit|
-          crit.documents = [ Band.create!(name: 'Depeche Mode', mood: 'dark') ]
-        end
-      end
-
-      it 'returns the value from the attributes' do
-        expect(context.pluck(:mood)).to eq([ 'dark' ])
-      end
-    end
-
-    context 'when the field name is a method name' do
-      let!(:person) do
-        Person.create!(ssn: 'secret-ssn')
-      end
-
-      let!(:address) do
-        person.addresses.create!(street: 'hobrecht')
-      end
-
-      let(:criteria) do
-        Address.all.tap do |crit|
-          crit.documents = [ address ]
-        end
-      end
-
-      it 'does not call the method' do
-        expect(address).not_to receive(:destroy)
-        expect(context.pluck(:destroy)).to eq([ nil ])
-      end
-
-      it 'does not return the attributes hash' do
-        expect(context.pluck(:attributes)).to eq([ nil ])
-      end
-
-      it 'does not traverse to the parent document' do
-        expect(context.pluck('_root.ssn')).to eq([ nil ])
-      end
-
-      it 'does not destroy the parent document' do
-        expect(context.pluck('_root.destroy')).to eq([ nil ])
-        expect(Person.where(_id: person.id).count).to eq(1)
-      end
-    end
-
-    context 'when plucking a belongs_to association' do
-      let!(:band) do
-        Band.create!(name: 'Depeche Mode')
-      end
-
-      let!(:artist) do
-        Artist.create!(band: band)
-      end
-
-      let(:criteria) do
-        Artist.all.tap do |crit|
-          crit.documents = [ artist ]
-        end
-      end
-
-      it 'traverses to the associated document' do
-        expect(context.pluck('band.name')).to eq([ 'Depeche Mode' ])
-      end
-
-      it 'returns the document for the association name' do
-        expect(context.pluck(:band)).to eq([ band ])
-      end
-
-      it 'returns the id for the foreign key' do
-        expect(context.pluck(:band_id)).to eq([ band.id ])
-      end
-    end
-
-    context 'when plucking the foreign key of a many to many association' do
-      let!(:preference) do
-        Preference.create!(name: 'nature')
-      end
-
-      let!(:person) do
-        Person.create!(preferences: [ preference ])
-      end
-
-      let(:criteria) do
-        Person.all.tap do |crit|
-          crit.documents = [ person ]
-        end
-      end
-
-      it 'returns the stored ids' do
-        expect(context.pluck(:preference_ids)).to eq([ [ preference.id ] ])
-      end
-    end
-
-    context 'when the field path has an empty segment' do
-      let!(:band) do
-        Band.create!(name: 'Depeche Mode', label: Label.new(name: 'Mute'))
-      end
-
-      let(:criteria) do
-        Band.all.tap do |crit|
-          crit.documents = [ band ]
-        end
-      end
-
-      it 'returns nil' do
-        expect(context.pluck('label..name')).to eq([ nil ])
-      end
-    end
   end
 
   describe "#pick" do
@@ -1934,27 +2056,6 @@ describe Mongoid::Contextual::Memory do
         expect(picked).to be_nil
       end
     end
-
-    context 'when the field name is a method name' do
-      let!(:person) do
-        Person.create!(ssn: 'secret-ssn')
-      end
-
-      let!(:address) do
-        person.addresses.create!(street: 'hobrecht')
-      end
-
-      let(:criteria) do
-        Address.all.tap do |crit|
-          crit.documents = [ address ]
-        end
-      end
-
-      it 'does not call the method' do
-        expect(address).not_to receive(:destroy)
-        expect(context.pick(:destroy)).to be_nil
-      end
-    end
   end
 
   describe "#tally" do
@@ -2029,6 +2130,8 @@ describe Mongoid::Contextual::Memory do
     end
 
     context "when tallying a localized field" do
+      with_default_i18n_configs
+
       let(:d1) { Dictionary.new(description: 'en1') }
       let(:d2) { Dictionary.new(description: 'en1') }
       let(:d3) { Dictionary.new(description: 'en1') }
@@ -2090,6 +2193,7 @@ describe Mongoid::Contextual::Memory do
     end
 
     context "when tallying an embedded localized field" do
+      with_default_i18n_configs
 
       let(:person1) { Person.create!(addresses: [ address1a, address1b ]) }
       let(:person2) { Person.create!(addresses: [ address2a, address2b ]) }
@@ -2406,31 +2510,6 @@ describe Mongoid::Contextual::Memory do
         )
       end
     end
-
-    context 'when the field name is a method name' do
-      let!(:person) do
-        Person.create!(ssn: 'secret-ssn')
-      end
-
-      let!(:address) do
-        person.addresses.create!(street: 'hobrecht')
-      end
-
-      let(:criteria) do
-        Address.all.tap do |crit|
-          crit.documents = [ address ]
-        end
-      end
-
-      it 'does not call the method' do
-        expect(address).not_to receive(:destroy)
-        expect(context.tally(:destroy)).to eq(nil => 1)
-      end
-
-      it 'does not disclose the parent document fields' do
-        expect(context.tally('_root.ssn')).to eq(nil => 1)
-      end
-    end
   end
 
   describe '#inc' do