mongoid 6.4.2 → 7.0.3

data/spec/mongoid/copyable_spec.rb

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
 require "spec_helper"
 
+require_relative './copyable_spec_models'
+
 describe Mongoid::Copyable do
 
   [ :clone, :dup ].each do |method|
@@ -35,6 +37,10 @@ describe Mongoid::Copyable do
         person.build_game(name: "Tron")
       end
 
+      let!(:name_translations) do
+        person.name.translations.build(language: 'en')
+      end
+
       context "when the document has an id field in the database" do
 
         let!(:band) do
@@ -86,16 +92,48 @@ describe Mongoid::Copyable do
 
         context "and dynamic attributes are not set" do
 
-          it "clones" do
-            t = StoreAsDupTest1.new(:name => "hi")
-            t.build_store_as_dup_test2(:name => "there")
-            t.save
-            copy = t.send(method)
-            expect(copy.store_as_dup_test2.name).to eq(t.store_as_dup_test2.name)
+          context 'embeds_one' do
+
+            it "clones" do
+              t = StoreAsDupTest1.new(:name => "hi")
+              t.build_store_as_dup_test2(:name => "there")
+              t.save
+              copy = t.send(method)
+              expect(copy.object_id).not_to eq(t.object_id)
+              expect(copy.store_as_dup_test2.name).to eq(t.store_as_dup_test2.name)
+            end
+          end
+
+          context 'embeds_many' do
+
+
+            it "clones" do
+              t = StoreAsDupTest3.new(:name => "hi")
+              t.store_as_dup_test4s << StoreAsDupTest4.new
+              t.save
+              copy = t.send(method)
+              expect(copy.object_id).not_to eq(t.object_id)
+              expect(copy.store_as_dup_test4s).not_to be_empty
+              expect(copy.store_as_dup_test4s.first.object_id).not_to eq(t.store_as_dup_test4s.first.object_id)
+            end
           end
         end
       end
 
+      context 'nested embeds_many' do
+        it 'works' do
+          a = CopyableSpec::A.new
+          a.locations << CopyableSpec::Location.new
+          a.locations.first.buildings << CopyableSpec::Building.new
+          a.save!
+
+          new_a = a.send(method)
+
+          expect(new_a.locations.length).to be 1
+          expect(new_a.locations.first.buildings.length).to be 1
+        end
+      end
+
       context "when cloning a document with multiple languages field" do
 
         before do
@@ -144,6 +182,40 @@ describe Mongoid::Copyable do
         end
       end
 
+      context "when cloning a document with polymorphic embedded documents with multiple language field" do
+
+        let!(:shipment_address) do
+          person.addresses.build({ shipping_name: "Title" }, ShipmentAddress)
+        end
+
+        before do
+          I18n.enforce_available_locales = false
+          I18n.locale = 'pt_BR'
+          person.addresses.type(ShipmentAddress).each { |address| address.shipping_name = "Título" }
+          person.save
+        end
+
+        after do
+          I18n.locale = :en
+        end
+
+        let!(:from_db) do
+          Person.find(person.id)
+        end
+
+        let(:copy) do
+          from_db.send(method)
+        end
+
+        it 'sets embedded translations' do
+          I18n.locale = 'pt_BR'
+          copy.addresses.type(ShipmentAddress).each do |address|
+            expect(address.shipping_name).to eq("Título")
+          end
+        end
+
+      end
+
       context "when cloning a loaded document" do
 
         before do
@@ -211,14 +283,26 @@ describe Mongoid::Copyable do
             expect(copy.addresses).to eq(person.addresses)
           end
 
+          it "copys deep embeds many documents" do
+            expect(copy.name.translations).to eq(person.name.translations)
+          end
+
           it "sets the embedded many documents as new" do
             expect(copy.addresses.first).to be_new_record
           end
 
+          it "sets the deep embedded many documents as new" do
+            expect(copy.name.translations.first).to be_new_record
+          end
+
           it "creates new embeds many instances" do
             expect(copy.addresses).to_not equal(person.addresses)
           end
 
+          it "creates new deep embeds many instances" do
+            expect(copy.name.translations).to_not equal(person.name.translations)
+          end
+
           it "copys embeds one documents" do
             expect(copy.name).to eq(person.name)
           end

data/spec/mongoid/copyable_spec_models.rb

@@ -0,0 +1,17 @@
+module CopyableSpec
+  class A
+    include Mongoid::Document
+
+    embeds_many :locations
+  end
+
+  class Location
+    include Mongoid::Document
+
+    embeds_many :buildings
+  end
+
+  class Building
+    include Mongoid::Document
+  end
+end

data/spec/mongoid/criteria/modifiable_spec.rb

@@ -49,6 +49,29 @@ describe Mongoid::Criteria::Modifiable do
         end
       end
     end
+
+    context 'when the object is polymorphic' do
+
+      let(:movie) do
+        Movie.new
+      end
+
+      let(:criteria) do
+        Rating.where(ratable: movie)
+      end
+
+      let(:document) do
+        criteria.create
+      end
+
+      it 'sets the polymorphic id' do
+        expect(document.ratable_id).to eq(movie.id)
+      end
+
+      it 'sets the type field' do
+        expect(document.ratable_type).to eq('Movie')
+      end
+    end
   end
 
   describe "#create!" do
@@ -65,6 +88,29 @@ describe Mongoid::Criteria::Modifiable do
         }.to raise_error(Mongoid::Errors::Validations)
       end
     end
+
+    context 'when the object is polymorphic' do
+
+      let(:movie) do
+        Movie.new
+      end
+
+      let(:criteria) do
+        Rating.where(ratable: movie)
+      end
+
+      let(:document) do
+        criteria.create!
+      end
+
+      it 'sets the polymorphic id' do
+        expect(document.ratable_id).to eq(movie.id)
+      end
+
+      it 'sets the type field' do
+        expect(document.ratable_type).to eq('Movie')
+      end
+    end
   end
 
   [ :delete, :delete_all, :destroy, :destroy_all ].each do |method|
@@ -295,6 +341,25 @@ describe Mongoid::Criteria::Modifiable do
           expect(person.pets).to be true
         end
       end
+
+      context 'when the object is polymorphic' do
+
+        let(:movie) do
+          Movie.new
+        end
+
+        let(:document) do
+          Rating.find_or_create_by(ratable: movie)
+        end
+
+        it 'sets the polymorphic id' do
+          expect(document.ratable_id).to eq(movie.id)
+        end
+
+        it 'sets the type field' do
+          expect(document.ratable_type).to eq('Movie')
+        end
+      end
     end
   end
 
@@ -447,6 +512,25 @@ describe Mongoid::Criteria::Modifiable do
         end
       end
     end
+
+    context 'when the object is polymorphic' do
+
+      let(:movie) do
+        Movie.new
+      end
+
+      let(:document) do
+        Rating.find_or_create_by!(ratable: movie)
+      end
+
+      it 'sets the polymorphic id' do
+        expect(document.ratable_id).to eq(movie.id)
+      end
+
+      it 'sets the type field' do
+        expect(document.ratable_type).to eq('Movie')
+      end
+    end
   end
 
   describe ".find_or_initialize_by" do
@@ -500,6 +584,25 @@ describe Mongoid::Criteria::Modifiable do
         end
       end
     end
+
+    context 'when the object is polymorphic' do
+
+      let(:movie) do
+        Movie.new
+      end
+
+      let(:document) do
+        Rating.find_or_initialize_by(ratable: movie)
+      end
+
+      it 'sets the polymorphic id' do
+        expect(document.ratable_id).to eq(movie.id)
+      end
+
+      it 'sets the type field' do
+        expect(document.ratable_type).to eq('Movie')
+      end
+    end
   end
 
   describe "first_or_create" do
@@ -649,7 +752,7 @@ describe Mongoid::Criteria::Modifiable do
             band = Band.create
             Mongoid::Criteria.new(Record) do |criteria|
               criteria.embedded = true
-              criteria.metadata = Band.reflect_on_association(:records)
+              criteria.association = Band.reflect_on_association(:records)
               criteria.parent_document = band
               criteria.selector = { "records" => { "producers"=>{"$in"=>["nonexistent"] } } }
             end
@@ -703,6 +806,29 @@ describe Mongoid::Criteria::Modifiable do
         end
       end
 
+      context 'when the object is polymorphic' do
+
+        let(:movie) do
+          Movie.new
+        end
+
+        let(:criteria) do
+          Rating.where(ratable: movie)
+        end
+
+        let(:document) do
+          criteria.first_or_create
+        end
+
+        it 'sets the polymorphic id' do
+          expect(document.ratable_id).to eq(movie.id)
+        end
+
+        it 'sets the type field' do
+          expect(document.ratable_type).to eq('Movie')
+        end
+      end
+
       context "when a block is provided" do
 
         let(:document) do
@@ -919,6 +1045,29 @@ describe Mongoid::Criteria::Modifiable do
         end
       end
     end
+
+    context 'when the object is polymorphic' do
+
+      let(:movie) do
+        Movie.new
+      end
+
+      let(:criteria) do
+        Rating.where(ratable: movie)
+      end
+
+      let(:document) do
+        criteria.first_or_create!
+      end
+
+      it 'sets the polymorphic id' do
+        expect(document.ratable_id).to eq(movie.id)
+      end
+
+      it 'sets the type field' do
+        expect(document.ratable_type).to eq('Movie')
+      end
+    end
   end
 
   describe "first_or_initialize" do
@@ -938,6 +1087,29 @@ describe Mongoid::Criteria::Modifiable do
       end
     end
 
+    context 'when the object is polymorphic' do
+
+      let(:movie) do
+        Movie.new
+      end
+
+      let(:criteria) do
+        Rating.where(ratable: movie)
+      end
+
+      let(:document) do
+        criteria.first_or_initialize
+      end
+
+      it 'sets the polymorphic id' do
+        expect(document.ratable_id).to eq(movie.id)
+      end
+
+      it 'sets the type field' do
+        expect(document.ratable_type).to eq('Movie')
+      end
+    end
+
     context "when the document is not found" do
 
       context "when attributes are provided" do
@@ -1471,15 +1643,11 @@ describe Mongoid::Criteria::Modifiable do
         { 'username' => 'Turnip' }
       end
 
-      it 'does not modify the selector' do
-        expect(Person.create_with(attrs).selector[:username]).to be_nil
-      end
-
-      it 'create_attrs is modified' do
-        expect(Person.create_with(attrs).create_attrs).to eq(attrs)
+      it 'returns a criteria with the defined attributes' do
+        expect(Person.create_with(attrs).selector).to eq(attrs)
       end
 
-      context 'when a create is chained' do
+      context 'when a method is chained' do
 
         context 'when a write method is chained' do
 
@@ -1503,25 +1671,6 @@ describe Mongoid::Criteria::Modifiable do
             expect(new_person.age).to eq(50)
           end
 
-          context 'when a matching document is already in the collection' do
-            let(:query) do
-              { 'username' => 'foo', 'age' => 12 }
-            end
-
-            let(:person) do
-              Person.create!(query)
-            end
-
-            let(:found_person) do
-              Person.create_with(attrs).find_or_create_by(query)
-            end
-
-            it 'finds the matching document' do
-              person
-              expect(found_person.id).to eq(person.id)
-            end
-          end
-
           context 'when the attributes are shared with the write method args' do
 
             let(:query) do
@@ -1532,7 +1681,7 @@ describe Mongoid::Criteria::Modifiable do
               Person.create_with(attrs).find_or_create_by(query)
             end
 
-            it 'gives the find method args precedence' do
+            it 'gives the write method args precedence' do
               expect(new_person.username).to eq('Beet')
               expect(new_person.age).to eq(50)
             end
@@ -1559,12 +1708,8 @@ describe Mongoid::Criteria::Modifiable do
             { 'username' => 'Beet', 'age' => 50 }
           end
 
-          it 'does not modify the selector' do
-            expect(criteria.create_with(attrs).selector).to eq(criteria_selector)
-          end
-
           it 'overwrites all the original attributes' do
-            expect(criteria.create_with(attrs).create_attrs).to eq(attrs)
+            expect(criteria.create_with(attrs).selector).to eq(attrs)
           end
         end
       end
@@ -1575,12 +1720,8 @@ describe Mongoid::Criteria::Modifiable do
           { 'username' => 'Beet' }
         end
 
-        it 'does not modify the selector' do
-          expect(criteria.create_with(attrs).selector).to eq(criteria_selector)
-        end
-
         it 'only overwrites the shared attributes' do
-          expect(criteria.create_with(attrs).create_attrs).to eq(attrs)
+          expect(criteria.create_with(attrs).selector).to eq(criteria_selector.merge!(attrs))
         end
       end
 
@@ -1589,11 +1730,12 @@ describe Mongoid::Criteria::Modifiable do
         let(:attrs) do
           { 'username' => 'Turnip' }
         end
+
         let(:query) do
           { 'username' => 'Beet', 'age' => 50 }
         end
 
-        context 'when a create method is chained' do
+        context 'when a write method is chained' do
 
           it 'executes the method' do
             expect(criteria.create_with(attrs).new.username).to eq('Turnip')
@@ -1607,28 +1749,9 @@ describe Mongoid::Criteria::Modifiable do
             criteria.create_with(attrs).find_or_create_by(query)
           end
 
-          it 'gives the find method arg precedence' do
+          it 'executes the query' do
             expect(new_person.username).to eq('Beet')
-            expect(new_person.age).to be(50)
-          end
-
-          context 'when a matching document is already in the collection' do
-            let(:query) do
-              { 'username' => 'foo', 'age' => 12 }
-            end
-
-            let(:person) do
-              Person.create!(query)
-            end
-
-            let(:found_person) do
-              criteria.create_with(attrs).find_or_create_by(query)
-            end
-
-            it 'finds the matching document' do
-              person
-              expect(found_person.id).to eq(person.id)
-            end
+            expect(new_person.age).to eq(50)
           end
         end
       end

data/spec/mongoid/criteria/queryable/extensions/big_decimal_spec.rb

@@ -7,7 +7,7 @@ describe BigDecimal do
     context "when provided a big decimal" do
 
       let(:big_decimal) do
-        BigDecimal.new("123456.789")
+        BigDecimal("123456.789")
       end
 
       it "returns the decimal as a string" do
@@ -25,11 +25,11 @@ describe BigDecimal do
     context "when provided an array of big decimals" do
 
       let(:bd_one) do
-        BigDecimal.new("123456.789")
+        BigDecimal("123456.789")
       end
 
       let(:bd_two) do
-        BigDecimal.new("123333.789")
+        BigDecimal("123333.789")
       end
 
       let(:array) do

data/spec/mongoid/criteria/queryable/extensions/string_spec.rb

@@ -66,6 +66,49 @@ describe String do
         expect(evolved).to eq(Time.new(2010, 1, 1, 11, 0, 0, 0).utc)
       end
     end
+
+    context "when the string without timezone" do
+
+      context "when using active support's time zone" do
+
+        before do
+          Mongoid.use_activesupport_time_zone = true
+          ::Time.zone = "Tokyo"
+        end
+
+        let(:date) do
+          "2010-01-01 5:00:00"
+        end
+
+        let(:evolved) do
+          date.__evolve_time__
+        end
+
+        it "parses string using active support's time zone" do
+          expect(evolved).to eq(Time.zone.parse(date).utc)
+        end
+      end
+
+      context "when not using active support's time zone" do
+
+        before do
+          Mongoid.use_activesupport_time_zone = false
+          ::Time.zone = nil
+        end
+
+        let(:date) do
+          "2010-01-01 5:00:00"
+        end
+
+        let(:evolved) do
+          date.__evolve_time__
+        end
+
+        it "parses string using system time zone" do
+          expect(evolved).to eq(Time.parse(date).utc)
+        end
+      end
+    end
   end
 
   describe "#__sort_option__" do

data/spec/mongoid/criteria/queryable/pipeline_spec.rb

@@ -196,5 +196,17 @@ describe Mongoid::Criteria::Queryable::Pipeline do
         end
       end
     end
+
+    context "when provided a hash" do
+      before do
+        pipeline.unwind(path: "$author", "includeArrayIndex" => "author_index", preserveNullAndEmptyArrays: true)
+      end
+
+      it "sets the hash" do
+        expect(pipeline).to eq([
+          { "$unwind" => { path: "$author", "includeArrayIndex" => "author_index", preserveNullAndEmptyArrays: true } }
+        ])
+      end
+    end
   end
 end

data/spec/mongoid/criteria/queryable/selectable_spec.rb

@@ -1073,6 +1073,26 @@ describe Mongoid::Criteria::Queryable::Selectable do
           })
         end
 
+        context "when used with the $box operator ($geoWithin query) " do
+          let(:selection) do
+            query.geo_spacial(
+              :location.within_box => [[ 1, 10 ], [ 2, 10 ]]
+            )
+          end
+  
+          it "adds the $geoIntersects expression" do
+            expect(selection.selector).to eq({
+              "location" => {
+                "$geoWithin" => {
+                  "$box" => [
+                    [ 1, 10 ], [ 2, 10 ]
+                  ]
+                }
+              }
+            })
+          end
+        end
+
         it_behaves_like "a cloning selection"
       end
     end
@@ -3369,7 +3389,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
 
       it "constructs a text search document" do
-        expect(selection.selector).to eq({ :$text => { :$search => "testing" }})
+        expect(selection.selector).to eq({ '$text' => { '$search' => "testing" }})
       end
 
       it "returns the cloned selectable" do
@@ -3383,16 +3403,35 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
 
         it "constructs a text search document" do
-          expect(selection.selector[:$text][:$search]).to eq("essais")
+          expect(selection.selector['$text']['$search']).to eq("essais")
         end
 
         it "add the options to the text search document" do
-          expect(selection.selector[:$text][:$language]).to eq("fr")
+          expect(selection.selector['$text'][:$language]).to eq("fr")
         end
 
         it_behaves_like "a cloning selection"
       end
     end
+
+    context 'when given more than once' do
+      let(:selection) do
+        query.text_search("one").text_search('two')
+      end
+
+      # MongoDB server can only handle one text expression at a time,
+      # per https://docs.mongodb.com/manual/reference/operator/query/text/.
+      # Nonetheless we test that the query is built correctly when
+      # a user supplies more than one text condition.
+      it 'merges conditions' do
+        expect(Mongoid.logger).to receive(:warn)
+        expect(selection.selector).to eq('$and' => [
+            {'$text' => {'$search' => 'one'}}
+          ],
+          '$text' => {'$search' => 'two'},
+        )
+      end
+    end
   end
 
   describe "#where" do

data/spec/mongoid/criteria/queryable/selector_spec.rb

@@ -370,11 +370,11 @@ describe Mongoid::Criteria::Queryable::Selector do
         context "when providing an array" do
 
           let(:big_one) do
-            BigDecimal.new("1.2321")
+            BigDecimal("1.2321")
           end
 
           let(:big_two) do
-            BigDecimal.new("4.2222")
+            BigDecimal("4.2222")
           end
 
           let(:array) do