mongoid 6.4.1 → 6.4.8

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

data/spec/mongoid/fields_spec.rb

@@ -1171,7 +1171,7 @@ describe Mongoid::Fields do
     end
 
     let(:decimal) do
-      BigDecimal.new("1000000.00")
+      BigDecimal("1000000.00")
     end
 
     context "when setting to a big decimal" do

data/spec/mongoid/findable_spec.rb

@@ -10,7 +10,7 @@ describe Mongoid::Findable do
     end
 
     it "returns the distinct values for the field" do
-      expect(Band.distinct(:name)).to eq([ "Tool", "Photek" ])
+      expect(Band.distinct(:name).sort).to eq([ "Photek", "Tool" ])
     end
   end
 

data/spec/mongoid/matchable/nor_spec.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Matchable::Nor do
+
+  let(:target) do
+    Person.new
+  end
+
+  let(:matcher) do
+    described_class.new("value", target)
+  end
+
+  describe "#_matches?" do
+
+    context "when provided a simple expression" do
+
+      context "when one of the hashes does not match model" do
+
+        let(:matches) do
+          matcher._matches?(
+            [ { title: "Sir" }, { title: "King" } ]
+          )
+        end
+
+        let(:target) do
+          Person.new(title: 'Queen')
+        end
+
+        it "returns true" do
+          expect(matches).to be true
+        end
+      end
+
+      context "when all of the hashes match different fields in model" do
+        let(:matches) do
+          matcher._matches?(
+            [ { age: 10 }, { title: "King" } ]
+          )
+        end
+
+        let(:target) do
+          Person.new(title: 'King', age: 10)
+        end
+
+        it "returns false" do
+          expect(matches).to be false
+        end
+      end
+
+      context "when one of the hashes matches an array field in model" do
+        let(:matches) do
+          matcher._matches?(
+            [ { af: "Sir" }, { af: "King" } ]
+          )
+        end
+
+        let(:target) do
+          ArrayField.new(af: ['King'])
+        end
+
+        it "returns false" do
+          expect(matches).to be false
+        end
+      end
+
+      context "when none of the hashes matches an array field in model" do
+        let(:matches) do
+          matcher._matches?(
+            [ { af: "Sir" }, { af: "King" } ]
+          )
+        end
+
+        let(:target) do
+          ArrayField.new(af: ['Boo'])
+        end
+
+        it "returns true" do
+          expect(matches).to be true
+        end
+      end
+
+      context "when there are no criteria" do
+
+        it "returns false" do
+          expect(matcher._matches?([])).to be false
+        end
+      end
+
+      # $nor with $not is a double negation.
+      # Whatever the argument of $not is is what the overall condition
+      # is looking for.
+      context "when the expression is a $not" do
+
+        let(:matches) do
+          matcher._matches?([ { title: {:$not => /Foobar/ } }])
+        end
+
+        context "when the value does not match $not argument" do
+
+          let(:target) do
+            Person.new(title: 'test')
+          end
+
+          it "returns false" do
+            expect(matches).to be false
+          end
+        end
+
+        context "when the value matches $not argument" do
+
+          let(:target) do
+            Person.new(title: 'Foobar baz')
+          end
+
+          it "returns true" do
+            expect(matches).to be true
+          end
+        end
+      end
+    end
+
+    context "when provided a complex expression" do
+
+      context "when none of the model values match criteria values" do
+
+        let(:matches) do
+          matcher._matches?(
+            [
+              { title: { "$in" => [ "Sir", "Madam" ] } },
+              { title: "King" }
+            ]
+          )
+        end
+
+        let(:target) do
+          Person.new(title: 'Queen')
+        end
+
+        it "returns true" do
+          expect(matches).to be true
+        end
+      end
+
+      context "when there is a matching value" do
+
+        let(:matches) do
+          matcher._matches?(
+            [
+              { title: { "$in" => [ "Prince", "Madam" ] } },
+              { title: "King" }
+            ]
+          )
+        end
+
+        let(:target) do
+          Person.new(title: 'Prince')
+        end
+
+        it "returns false" do
+          expect(matches).to be false
+        end
+      end
+
+      context "when expression contain multiple fields" do
+
+        let(:matches) do
+          matcher._matches?(
+            [
+              { title: "Sir", age: 23 },
+              { title: "King", age: 100 }
+            ]
+          )
+        end
+
+        context 'and model has different values in all of the fields' do
+          let(:target) do
+            Person.new(title: 'Queen', age: 10)
+          end
+
+          it "returns true" do
+            expect(matches).to be true
+          end
+        end
+
+        context 'and model has identical value in one of the fields' do
+          let(:target) do
+            Person.new(title: 'Queen', age: 23)
+          end
+
+          it "returns true" do
+            expect(matches).to be true
+          end
+        end
+
+        context 'and model has identical values in all of the fields' do
+          let(:target) do
+            Person.new(title: 'Sir', age: 23)
+          end
+
+          it "returns false" do
+            expect(matches).to be false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/matchable_spec.rb

@@ -86,7 +86,7 @@ describe Mongoid::Matchable do
           let(:selector) do
             { "occupants.0" => "Tim" }
           end
-          
+
           it "returns true" do
             expect(document.locations.first._matches?(selector)).to be true
           end
@@ -774,6 +774,31 @@ describe Mongoid::Matchable do
         end
       end
 
+      context "with an $nor selector" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { "$nor" => [ { number: 10 }, { number: { "$gt" => 199 } } ] }
+          end
+
+          it "returns true" do
+            expect(document._matches?(selector)).to be true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { "$nor" => [ { number: 10 }, { number: { "$gt" => 99 } } ] }
+          end
+
+          it "returns false" do
+            expect(document._matches?(selector)).to be false
+          end
+        end
+      end
+
       context "with a $size selector" do
 
         context "when the attributes match" do