mongoid 6.4.1 → 6.4.8

data/spec/mongoid/clients/sessions_spec.rb

@@ -16,17 +16,26 @@ describe Mongoid::Clients::Sessions do
   end
 
   let(:subscriber) do
-    Mongoid::Clients.with_name(:other).instance_variable_get(:@monitoring).subscribers['Command'].find do |s|
+    client = Mongoid::Clients.with_name(:other)
+    monitoring = if client.respond_to?(:monitoring, true)
+      client.send(:monitoring)
+    else
+      # driver 2.5
+      client.instance_variable_get('@monitoring')
+    end
+    monitoring.subscribers['Command'].find do |s|
       s.is_a?(EventSubscriber)
     end
   end
 
   let(:insert_events) do
-    subscriber.started_events.select { |event| event.command_name == :insert }
+    # Driver 2.5 sends command_name as a symbol
+    subscriber.started_events.select { |event| event.command_name.to_s == 'insert' }
   end
 
   let(:update_events) do
-    subscriber.started_events.select { |event| event.command_name == :update }
+    # Driver 2.5 sends command_name as a symbol
+    subscriber.started_events.select { |event| event.command_name.to_s == 'update' }
   end
 
   context 'when a session is used on a model class' do

data/spec/mongoid/contextual/geo_near_spec.rb

@@ -1,6 +1,7 @@
 require "spec_helper"
 
 describe Mongoid::Contextual::GeoNear do
+  max_server_version '4.0'
 
   describe "#average_distance" do
 

data/spec/mongoid/contextual/mongo_spec.rb

@@ -451,7 +451,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the distinct field values" do
-        expect(context.distinct(:years)).to eq([ 30, 25 ])
+        expect(context.distinct(:years).sort).to eq([ 25, 30 ])
       end
     end
 
@@ -2363,7 +2363,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it 'creates a pipeline with the selector as one of the $match criteria' do
-        expect(pipeline_match).to include({ :'$text' => { :'$search' => "New Order" } })
+        expect(pipeline_match).to include({ '$text' => { '$search' => "New Order" } })
       end
 
       it 'creates a pipeline with the $exists operator as one of the $match criteria' do

data/spec/mongoid/criteria/modifiable_spec.rb

@@ -1471,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
 
@@ -1499,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
@@ -1509,7 +1532,7 @@ describe Mongoid::Criteria::Modifiable do
               Person.create_with(attrs).find_or_create_by(query)
             end
 
-            it 'gives the write method args precedence' do
+            it 'gives the find method args precedence' do
               expect(new_person.username).to eq('Beet')
               expect(new_person.age).to eq(50)
             end
@@ -1536,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
@@ -1548,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
 
@@ -1558,12 +1589,11 @@ 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
             expect(criteria.create_with(attrs).new.username).to eq('Turnip')
@@ -1577,9 +1607,28 @@ describe Mongoid::Criteria::Modifiable do
             criteria.create_with(attrs).find_or_create_by(query)
           end
 
-          it 'executes the query' do
+          it 'gives the find method arg precedence' do
             expect(new_person.username).to eq('Beet')
-            expect(new_person.age).to eq(50)
+            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/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/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

data/spec/mongoid/criteria/scopable_spec.rb

@@ -388,4 +388,85 @@ describe Mongoid::Criteria::Scopable do
       end
     end
   end
+
+  describe 'scope and where' do
+    class ScopeWhereModel
+      include Mongoid::Document
+
+      scope :foo, -> { where(foo: true) }
+    end
+
+    shared_examples_for 'restricts to both' do
+      it 'restricts to both' do
+        expect(result.selector['foo']).to eq(true)
+        expect(result.selector['hello']).to eq('world')
+      end
+    end
+
+    context 'scope is given first' do
+      let(:result) { ScopeWhereModel.foo.where(hello: 'world') }
+
+      it_behaves_like 'restricts to both'
+    end
+
+    context 'where is given first' do
+      let(:result) { ScopeWhereModel.where(hello: 'world').foo }
+
+      it_behaves_like 'restricts to both'
+    end
+  end
+
+  describe 'scope with argument and where' do
+    class ArgumentScopeWhereModel
+      include Mongoid::Document
+
+      scope :my_text_search, ->(search) { where('$text' => {'$search' => search}) }
+    end
+
+    shared_examples_for 'restricts to both' do
+      it 'restricts to both' do
+        expect(result.selector['$text']).to eq({'$search' => 'bar'})
+        expect(result.selector['hello']).to eq('world')
+      end
+    end
+
+    context 'scope is given first' do
+      let(:result) { ArgumentScopeWhereModel.my_text_search('bar').where(hello: 'world') }
+
+      it_behaves_like 'restricts to both'
+    end
+
+    context 'where is given first' do
+      let(:result) { ArgumentScopeWhereModel.where(hello: 'world').my_text_search('bar') }
+
+      it_behaves_like 'restricts to both'
+    end
+  end
+
+  describe 'built in text search scope and where' do
+    class TextSearchScopeWhereModel
+      include Mongoid::Document
+
+      # using the default text_search scope
+    end
+
+    shared_examples_for 'restricts to both' do
+      it 'restricts to both' do
+        expect(result.selector['$text']).to eq({'$search' => 'bar'})
+        expect(result.selector['hello']).to eq('world')
+      end
+    end
+
+    context 'scope is given first' do
+      let(:result) { TextSearchScopeWhereModel.text_search('bar').where(hello: 'world') }
+
+      it_behaves_like 'restricts to both'
+    end
+
+    context 'where is given first' do
+      let(:result) { TextSearchScopeWhereModel.where(hello: 'world').text_search('bar') }
+
+      it_behaves_like 'restricts to both'
+    end
+  end
 end

data/spec/mongoid/criteria_spec.rb

@@ -975,6 +975,7 @@ describe Mongoid::Criteria do
   end
 
   describe "#geo_near" do
+    max_server_version '4.0'
 
     before do
       Bar.create_indexes
@@ -3321,6 +3322,8 @@ describe Mongoid::Criteria do
   end
 
   describe "#max_scan" do
+    max_server_version '4.0'
+
     let!(:band) do
       Band.create(name: "Depeche Mode")
     end
@@ -3465,7 +3468,7 @@ describe Mongoid::Criteria do
       context "when querying on a big decimal" do
 
         let(:sales) do
-          BigDecimal.new('0.1')
+          BigDecimal('0.1')
         end
 
         let!(:band) do

data/spec/mongoid/document_spec.rb

@@ -433,6 +433,60 @@ describe Mongoid::Document do
         end
       end
     end
+
+    context ':compact option' do
+
+      before do
+        # These tests require a specific set of defined attributes
+        # on the model
+        expect(church.as_json.keys.sort).to eq(%w(_id location name))
+      end
+
+      context 'there is a nil valued attribute' do
+        let(:church) do
+          Church.create!(name: 'St. Basil')
+        end
+
+        it 'returns non-nil fields and _id only' do
+          actual = church.as_json(compact: true)
+          expect(actual).to eq('_id' => church.id, 'name' => 'St. Basil')
+        end
+      end
+
+      context 'all attrbutes are nil valued' do
+        let(:church) do
+          Church.create!
+        end
+
+        it 'returns a hash with _id only' do
+          actual = church.as_json(compact: true)
+          expect(actual).to eq('_id' => church.id)
+        end
+      end
+
+      context 'there are no nil valued attributes' do
+        let(:church) do
+          Church.create!(name: 'St. Basil', location: {})
+        end
+
+        it 'returns all fields and _id' do
+          actual = church.as_json(compact: true)
+          expect(actual).to eq('_id' => church.id, 'name' => 'St. Basil',
+            'location' => {})
+        end
+      end
+
+      context 'when option is specified as a truthy value' do
+        let(:church) do
+          Church.create!(name: 'St. Basil')
+        end
+
+        it 'returns non-nil fields and _id only' do
+          actual = church.as_json(compact: 1)
+          expect(actual).to eq('_id' => church.id, 'name' => 'St. Basil')
+        end
+      end
+    end
   end
 
   describe "#as_document" do