mongoid 6.4.0 → 6.4.7

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

data/spec/mongoid/extensions/big_decimal_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe Mongoid::Extensions::BigDecimal do
 
   let(:big_decimal) do
-    BigDecimal.new("123456.789")
+    BigDecimal("123456.789")
   end
 
   describe ".demongoize" do
@@ -26,7 +26,7 @@ describe Mongoid::Extensions::BigDecimal do
       end
 
       it "returns a BigDecimal" do
-        expect(BigDecimal.demongoize(string)).to eq(BigDecimal.new(string))
+        expect(BigDecimal.demongoize(string)).to eq(BigDecimal(string))
       end
     end
 
@@ -37,7 +37,7 @@ describe Mongoid::Extensions::BigDecimal do
       end
 
       it "returns a BigDecimal" do
-        expect(BigDecimal.demongoize(string)).to eq(BigDecimal.new(string))
+        expect(BigDecimal.demongoize(string)).to eq(BigDecimal(string))
       end
     end
 
@@ -48,7 +48,7 @@ describe Mongoid::Extensions::BigDecimal do
       end
 
       it "returns a BigDecimal" do
-        expect(BigDecimal.demongoize(string)).to eq(BigDecimal.new(string))
+        expect(BigDecimal.demongoize(string)).to eq(BigDecimal(string))
       end
     end
 
@@ -184,7 +184,7 @@ describe Mongoid::Extensions::BigDecimal do
     context "when the value is the BigDecimal zero" do
 
       let(:big_decimal) do
-        BigDecimal.new("0.0")
+        BigDecimal("0.0")
       end
 
       it "returns a BigDecimal" do
@@ -195,7 +195,7 @@ describe Mongoid::Extensions::BigDecimal do
     context "when the value is the BigDecimal negative zero" do
 
       let(:big_decimal) do
-        BigDecimal.new("-0.0")
+        BigDecimal("-0.0")
       end
 
       it "returns a BigDecimal" do
@@ -326,7 +326,7 @@ describe Mongoid::Extensions::BigDecimal do
     context "when the value is BigDecimal NaN" do
 
       let(:nan) do
-        BigDecimal.new("NaN")
+        BigDecimal("NaN")
       end
 
       it "returns a String" do
@@ -337,7 +337,7 @@ describe Mongoid::Extensions::BigDecimal do
     context "when the value is BigDecimal Infinity" do
 
       let(:infinity) do
-        BigDecimal.new("Infinity")
+        BigDecimal("Infinity")
       end
 
       it "returns a String" do
@@ -348,7 +348,7 @@ describe Mongoid::Extensions::BigDecimal do
     context "when the value is BigDecimal negative Infinity" do
 
       let(:neg_infinity) do
-        BigDecimal.new("-Infinity")
+        BigDecimal("-Infinity")
       end
 
       it "returns a String" do

data/spec/mongoid/extensions/regexp_spec.rb

@@ -35,6 +35,29 @@ describe Mongoid::Extensions::Regexp do
       it "returns the provided value as a regex" do
         expect(value).to eq(/[^abc]/)
       end
+
+
+      context "when the string is empty" do
+
+        let(:value) do
+          Regexp.mongoize("")
+        end
+
+        it "returns an empty regex" do
+          expect(value).to eq(//)
+        end
+      end
+    end
+
+    context "when the value is nil" do
+
+      let(:value) do
+        Regexp.mongoize(nil)
+      end
+
+      it "returns the nil" do
+        expect(value).to be_nil
+      end
     end
   end
 

data/spec/mongoid/extensions/string_spec.rb

@@ -277,49 +277,77 @@ describe Mongoid::Extensions::String do
     context "when the string is an integer" do
 
       it "returns true" do
-        expect("1234").to be_numeric
+        expect("1234".numeric?).to eq(true)
       end
     end
 
     context "when string is a float" do
 
       it "returns true" do
-        expect("1234.123").to be_numeric
+        expect("1234.123".numeric?).to eq(true)
       end
     end
 
     context "when the string is has exponents" do
 
       it "returns true" do
-        expect("1234.123123E4").to be_numeric
+        expect("1234.123123E4".numeric?).to eq(true)
       end
     end
 
     context "when the string is non numeric" do
 
       it "returns false" do
-        expect("blah").to_not be_numeric
+        expect("blah".numeric?).to eq(false)
       end
     end
 
     context "when the string is NaN" do
 
       it "returns true" do
-        expect("NaN").to be_numeric
+        expect("NaN".numeric?).to eq(true)
+      end
+    end
+
+    context "when the string is NaN and junk in front" do
+
+      it "returns false" do
+        expect("a\nNaN".numeric?).to eq(false)
+      end
+    end
+
+    context "when the string is NaN and whitespace at end" do
+
+      it "returns false" do
+        expect("NaN\n".numeric?).to eq(false)
       end
     end
 
     context "when the string is Infinity" do
 
       it "returns true" do
-        expect("Infinity").to be_numeric
+        expect("Infinity".numeric?).to eq(true)
+      end
+    end
+
+    context "when the string contains Infinity and junk in front" do
+
+      it "returns false" do
+        expect("a\nInfinity".numeric?).to eq(false)
+      end
+    end
+
+    context "when the string contains Infinity and whitespace at end" do
+
+      it "returns false" do
+        expect("Infinity\n".numeric?).to eq(false)
       end
     end
 
     context "when the string is -Infinity" do
 
       it "returns true" do
-        expect("-Infinity").to be_numeric
+        expect("-Infinity".numeric?).to eq(true)
       end
     end
   end