mongoid 5.4.0 → 6.4.8

data/spec/mongoid/criteria/modifiable_spec.rb

@@ -538,6 +538,135 @@ describe Mongoid::Criteria::Modifiable do
         it "sets the additional attributes" do
           expect(document.origin).to eq("Essex")
         end
+
+        context 'when attributes contain keys also in the criteria selector' do
+
+          context 'when the selector has symbol keys' do
+
+            context 'when the attributes use symbol keys' do
+
+              let(:document) do
+                Band.where(name: 'Tool').first_or_create(name: 'Essex')
+              end
+
+              it 'uses the values from the attributes' do
+                expect(document.name).to eq('Essex')
+              end
+            end
+
+            context 'when the attributes use string keys' do
+
+              let(:document) do
+                Band.where(name: 'Tool').first_or_create('name' => 'Essex')
+              end
+
+              it 'uses the values from the attributes' do
+                expect(document.name).to eq('Essex')
+              end
+            end
+          end
+
+          context 'when the selector has string keys' do
+
+            context 'when the attributes use symbol keys' do
+
+              let(:document) do
+                Band.where('name' => 'Tool').first_or_create(name: 'Essex')
+              end
+
+              it 'uses the values from the attributes' do
+                expect(document.name).to eq('Essex')
+              end
+            end
+
+            context 'when the attributes use string keys' do
+
+              let(:document) do
+                Band.where('name' => 'Tool').first_or_create('name' => 'Essex')
+              end
+
+              it 'uses the values from the attributes' do
+                expect(document.name).to eq('Essex')
+              end
+            end
+          end
+        end
+
+        context 'when the query criteria is on a hash attribute' do
+
+          let(:document) do
+            Person.where(map: { foo: :bar }).first_or_create
+          end
+
+          it 'uses the values from the attributes' do
+            expect(document.map).to eq({ foo: :bar })
+          end
+        end
+
+        context 'when the criteria has a selector with query operators' do
+
+          let(:document) do
+            Band.in(genres: ['Hiphop', 'Soul']).first_or_create(name: 'Smooth')
+          end
+
+          it 'does not create a document with the query operators' do
+            expect(document.attributes.keys).not_to include('genres')
+          end
+        end
+
+        context 'when the criteria has a nested selector with query operators' do
+
+          let(:band) do
+            record = Record.new(producers: ['testing'])
+            band = Band.create(records: [record])
+          end
+
+          let(:document) do
+            band.records.in(producers: ['nonexistent']).first_or_create(name: 'new-embedded-doc')
+            band.reload
+          end
+
+          it 'creates a new embedded document' do
+            expect(document.records.size).to eq(2)
+          end
+
+          it 'does not alter the existing embedded document' do
+            expect(document.records[0].producers).to eq(['testing'])
+          end
+
+          it 'does not create a document with the query operators as attributes' do
+            expect(document.records[1].producers).to be_nil
+          end
+
+          it 'applies the attribute to the new embedded document' do
+            expect(document.records[1].name).to eq('new-embedded-doc')
+          end
+        end
+
+        context 'when the criteria has a deeply-nested selector with query operators' do
+
+          let(:criteria) do
+            band = Band.create
+            Mongoid::Criteria.new(Record) do |criteria|
+              criteria.embedded = true
+              criteria.metadata = Band.reflect_on_association(:records)
+              criteria.parent_document = band
+              criteria.selector = { "records" => { "producers"=>{"$in"=>["nonexistent"] } } }
+            end
+          end
+
+          let(:document) do
+            criteria.first_or_create(name: 'new-record')
+          end
+
+          it 'does not create a document with the query operators' do
+            expect(document.attributes.keys).not_to include('producers')
+          end
+
+          it 'applies the attribute to the new embedded document' do
+            expect(document.name).to eq('new-record')
+          end
+        end
       end
 
       context "when attributes are not provided" do
@@ -736,6 +865,59 @@ describe Mongoid::Criteria::Modifiable do
           end
         end
       end
+
+      context 'when attributes contain keys also in the criteria selector' do
+
+        context 'when the selector has symbol keys' do
+
+          context 'when the attributes use symbol keys' do
+
+            let(:document) do
+              Band.where(name: 'Tool').first_or_create!(name: 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+
+          context 'when the attributes use string keys' do
+
+            let(:document) do
+              Band.where(name: 'Tool').first_or_create!('name' => 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+        end
+
+        context 'when the selector has string keys' do
+
+          context 'when the attributes use symbol keys' do
+
+            let(:document) do
+              Band.where('name' => 'Tool').first_or_create!(name: 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+
+          context 'when the attributes use string keys' do
+
+            let(:document) do
+              Band.where('name' => 'Tool').first_or_create!('name' => 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+        end
+      end
     end
   end
 
@@ -830,6 +1012,59 @@ describe Mongoid::Criteria::Modifiable do
           end
         end
       end
+
+      context 'when attributes contain keys also in the criteria selector' do
+
+        context 'when the selector has symbol keys' do
+
+          context 'when the attributes use symbol keys' do
+
+            let(:document) do
+              Band.where(name: 'Tool').first_or_initialize(name: 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+
+          context 'when the attributes use string keys' do
+
+            let(:document) do
+              Band.where(name: 'Tool').first_or_initialize('name' => 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+        end
+
+        context 'when the selector has string keys' do
+
+          context 'when the attributes use symbol keys' do
+
+            let(:document) do
+              Band.where('name' => 'Tool').first_or_initialize(name: 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+
+          context 'when the attributes use string keys' do
+
+            let(:document) do
+              Band.where('name' => 'Tool').first_or_initialize('name' => 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+        end
+      end
     end
   end
 
@@ -1236,11 +1471,15 @@ describe Mongoid::Criteria::Modifiable do
         { 'username' => 'Turnip' }
       end
 
-      it 'returns a criteria with the defined attributes' do
-        expect(Person.create_with(attrs).selector).to eq(attrs)
+      it 'does not modify the selector' do
+        expect(Person.create_with(attrs).selector[:username]).to be_nil
       end
 
-      context 'when a method is chained' do
+      it 'create_attrs is modified' do
+        expect(Person.create_with(attrs).create_attrs).to eq(attrs)
+      end
+
+      context 'when a create is chained' do
 
         context 'when a write method is chained' do
 
@@ -1264,6 +1503,25 @@ 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
@@ -1274,9 +1532,8 @@ describe Mongoid::Criteria::Modifiable do
               Person.create_with(attrs).find_or_create_by(query)
             end
 
-            it 'gives the write method args precedence' do
-              #  @todo: uncomment when MONGOID-4193 is closed
-              #expect(new_person.username).to eq('Beet')
+            it 'gives the find method args precedence' do
+              expect(new_person.username).to eq('Beet')
               expect(new_person.age).to eq(50)
             end
           end
@@ -1302,8 +1559,12 @@ 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).selector).to eq(attrs)
+            expect(criteria.create_with(attrs).create_attrs).to eq(attrs)
           end
         end
       end
@@ -1314,8 +1575,12 @@ 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).selector).to eq(criteria_selector.merge!(attrs))
+          expect(criteria.create_with(attrs).create_attrs).to eq(attrs)
         end
       end
 
@@ -1324,16 +1589,14 @@ describe Mongoid::Criteria::Modifiable do
         let(:attrs) do
           { 'username' => 'Turnip' }
         end
-
         let(:query) do
           { 'username' => 'Beet', 'age' => 50 }
         end
 
-        context 'when a write method is chained' do
+        context 'when a create method is chained' do
 
           it 'executes the method' do
-            #  @todo: uncomment when MONGOID-4193 is closed
-            #expect(criteria.create_with(attrs).new.username).to eq('Beet')
+            expect(criteria.create_with(attrs).new.username).to eq('Turnip')
             expect(criteria.create_with(attrs).new.age).to eq(25)
           end
         end
@@ -1344,10 +1607,28 @@ describe Mongoid::Criteria::Modifiable do
             criteria.create_with(attrs).find_or_create_by(query)
           end
 
-          it 'executes the query' do
-            #  @todo: uncomment when MONGOID-4193 is closed
-            #expect(new_person.username).to eq('Beet')
-            #expect(new_person.age).to eq(50)
+          it 'gives the find method arg precedence' 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
           end
         end
       end

data/spec/mongoid/criteria/options_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Mongoid::Criteria::Options do
+
+
+  context 'when a persistence context with options is set on the class of the criteria' do
+
+    let(:context) do
+      Band.with(connect_timeout: 10) do |klass|
+        klass.where(name: 'FKA Twigs').persistence_context
+      end
+    end
+
+    it 'uses the persistence context of the class of the criteria' do
+      expect(context.options).to eq({ connect_timeout: 10 })
+    end
+  end
+
+  context 'when a persistence context with options is not set on the class of the criteria' do
+
+    let(:context) do
+      Band.where(name: 'FKA Twigs').persistence_context
+    end
+
+    it 'uses the persistence context of the class of the criteria' do
+      expect(context.options).to eq({ })
+    end
+  end
+end