mongoid 5.4.0 → 6.4.8

data/spec/mongoid/errors/invalid_relation_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Mongoid::Errors::InvalidRelation do
+
+  describe "#message" do
+
+    module MyModule
+      def crazy_method; self; end
+    end
+
+    before do
+      Object.send(:include, MyModule)
+    end
+
+    let(:error) do
+      described_class.new(Person, :crazy_method)
+    end
+
+    it "contains the problem in the message" do
+      expect(error.message).to include(
+                                   "Defining a relation named 'crazy_method' is not allowed."
+                               )
+    end
+
+    it "contains the summary in the message" do
+      expect(error.message).to include(
+                                   "Defining this relation would override the method 'crazy_method'"
+                               )
+    end
+
+    it "contains the resolution in the message" do
+      expect(error.message).to include(
+                                   "Use Mongoid.destructive_fields to see what names are not allowed"
+                               )
+    end
+  end
+end

data/spec/mongoid/errors/mongoid_error_spec.rb

@@ -50,15 +50,18 @@ describe Mongoid::Errors::MongoidError do
   describe "#to_json" do
 
     it "has problem" do
-      expect(error.to_json).to include('"problem":"message"')
+      # @todo: uncomment if https://github.com/rails/rails/pull/24628 is merged
+      #expect(error.to_json).to include('"problem":"message"')
     end
 
     it "has summary" do
-      expect(error.to_json).to include('"summary":"summary"')
+      # @todo: uncomment if https://github.com/rails/rails/pull/24628 is merged
+      #expect(error.to_json).to include('"summary":"summary"')
     end
 
     it "has resolution" do
-      expect(error.to_json).to include('"resolution":"resolution"')
+      # @todo: uncomment if https://github.com/rails/rails/pull/24628 is merged
+      #expect(error.to_json).to include('"resolution":"resolution"')
     end
   end
 end

data/spec/mongoid/extensions/big_decimal_spec.rb

@@ -2,16 +2,64 @@ require "spec_helper"
 
 describe Mongoid::Extensions::BigDecimal do
 
-  let(:number) do
-    BigDecimal.new("123456.789")
+  let(:big_decimal) do
+    BigDecimal("123456.789")
   end
 
   describe ".demongoize" do
 
-    context "when the the value is a string" do
+    context "when the value is an empty String" do
 
-      it "returns a big decimal" do
-        expect(BigDecimal.demongoize(number.to_s)).to eq(number)
+      let(:string) do
+        ""
+      end
+
+      it "returns nil" do
+        expect(BigDecimal.demongoize(string)).to be_nil
+      end
+    end
+
+    context "when the value is a numeric String" do
+
+      let(:string) do
+        "123456.789"
+      end
+
+      it "returns a BigDecimal" do
+        expect(BigDecimal.demongoize(string)).to eq(BigDecimal(string))
+      end
+    end
+
+    context "when the value is the numeric String zero" do
+
+      let(:string) do
+        "0.0"
+      end
+
+      it "returns a BigDecimal" do
+        expect(BigDecimal.demongoize(string)).to eq(BigDecimal(string))
+      end
+    end
+
+    context "when the value is the numeric String negative zero" do
+
+      let(:string) do
+        "-0.0"
+      end
+
+      it "returns a BigDecimal" do
+        expect(BigDecimal.demongoize(string)).to eq(BigDecimal(string))
+      end
+    end
+
+    context "when the value is a non-numeric String" do
+
+      let(:string) do
+        "1a2"
+      end
+
+      it "returns nil" do
+        expect(BigDecimal.demongoize(string)).to be_nil
       end
     end
 
@@ -22,18 +70,29 @@ describe Mongoid::Extensions::BigDecimal do
       end
     end
 
-    context "when the value is a float" do
+    context "when the value is true" do
 
-      let(:float) do
-        123456.789
+      let(:value) do
+        true
       end
 
-      it "returns a float" do
-        expect(BigDecimal.demongoize(float)).to eq(float)
+      it "returns nil" do
+        expect(BigDecimal.demongoize(value)).to be_nil
       end
     end
 
-    context "when the value is an integer" do
+    context "when the value is false" do
+
+      let(:value) do
+        false
+      end
+
+      it "returns nil" do
+        expect(BigDecimal.demongoize(value)).to be_nil
+      end
+    end
+
+    context "when the value is an Integer" do
 
       let(:integer) do
         123456
@@ -44,7 +103,18 @@ describe Mongoid::Extensions::BigDecimal do
       end
     end
 
-    context "when the value is NaN" do
+    context "when the value is a Float" do
+
+      let(:float) do
+        123456.789
+      end
+
+      it "returns a float" do
+        expect(BigDecimal.demongoize(float)).to eq(float)
+      end
+    end
+
+    context "when the value is the String 'NaN'" do
 
       let(:nan) do
         "NaN"
@@ -54,22 +124,126 @@ describe Mongoid::Extensions::BigDecimal do
         BigDecimal.demongoize(nan)
       end
 
-      it "returns a big decimal" do
+      it "returns a BigDecimal" do
         expect(demongoized).to be_a(BigDecimal)
       end
 
-      it "is a NaN big decimal" do
+      it "is a NaN BigDecimal" do
         expect(demongoized).to be_nan
       end
     end
+
+    context "when the value is the String 'Infinity'" do
+
+      let(:infinity) do
+        "Infinity"
+      end
+
+      let(:demongoized) do
+        BigDecimal.demongoize(infinity)
+      end
+
+      it "returns a BigDecimal" do
+        expect(demongoized).to be_a(BigDecimal)
+      end
+
+      it "is a infinity BigDecimal" do
+        expect(demongoized.infinite?).to eq 1
+      end
+    end
+
+    context "when the value is the String '-Infinity'" do
+
+      let(:neg_infinity) do
+        "-Infinity"
+      end
+
+      let(:demongoized) do
+        BigDecimal.demongoize(neg_infinity)
+      end
+
+      it "returns a BigDecimal" do
+        expect(demongoized).to be_a(BigDecimal)
+      end
+
+      it "is a negative infinity BigDecimal" do
+        expect(demongoized.infinite?).to eq -1
+      end
+    end
   end
 
   describe ".mongoize" do
 
-    context "when the value is a big decimal" do
+    context "when the value is a BigDecimal" do
 
       it "returns a string" do
-        expect(BigDecimal.mongoize(number)).to eq(number.to_s)
+        expect(BigDecimal.mongoize(big_decimal)).to eq(big_decimal.to_s)
+      end
+    end
+
+    context "when the value is the BigDecimal zero" do
+
+      let(:big_decimal) do
+        BigDecimal("0.0")
+      end
+
+      it "returns a BigDecimal" do
+        expect(BigDecimal.mongoize(big_decimal)).to eq(big_decimal.to_s)
+      end
+    end
+
+    context "when the value is the BigDecimal negative zero" do
+
+      let(:big_decimal) do
+        BigDecimal("-0.0")
+      end
+
+      it "returns a BigDecimal" do
+        expect(BigDecimal.mongoize(big_decimal)).to eq(big_decimal.to_s)
+      end
+    end
+
+    context "when the value is an empty String" do
+
+      let(:string) do
+        ""
+      end
+
+      it "returns nil" do
+        expect(BigDecimal.mongoize(string)).to be_nil
+      end
+    end
+
+    context "when the value is an integer numeric String" do
+
+      let(:string) do
+        "123456"
+      end
+
+      it "returns the String" do
+        expect(BigDecimal.mongoize(string)).to eq string
+      end
+    end
+
+    context "when the value is a float numeric String" do
+
+      let(:string) do
+        "123456.789"
+      end
+
+      it "returns the String" do
+        expect(BigDecimal.mongoize(string)).to eq string
+      end
+    end
+
+    context "when the value is a non-numeric String" do
+
+      let(:string) do
+        "1a2"
+      end
+
+      it "returns nil" do
+        expect(BigDecimal.mongoize(string)).to be_nil
       end
     end
 
@@ -80,25 +254,153 @@ describe Mongoid::Extensions::BigDecimal do
       end
     end
 
-    context "when the value is an integer" do
+    context "when the value is true" do
+
+      let(:value) do
+        true
+      end
+
+      it "returns nil" do
+        expect(BigDecimal.mongoize(value)).to be_nil
+      end
+    end
+
+    context "when the value is false" do
+
+      let(:value) do
+        false
+      end
+
+      it "returns nil" do
+        expect(BigDecimal.mongoize(value)).to be_nil
+      end
+    end
+
+    context "when the value is an Integer" do
 
       it "returns a string" do
         expect(BigDecimal.mongoize(123456)).to eq("123456")
       end
     end
 
-    context "when the value is a float" do
+    context "when the value is a Float" do
 
       it "returns a string" do
         expect(BigDecimal.mongoize(123456.789)).to eq("123456.789")
       end
     end
+
+    context "when the value is String NaN" do
+
+      let(:nan) do
+        "NaN"
+      end
+
+      it "returns a String" do
+        expect(BigDecimal.mongoize(nan)).to eq("NaN")
+      end
+    end
+
+    context "when the value is String Infinity" do
+
+      let(:infinity) do
+        "Infinity"
+      end
+
+      it "returns a String" do
+        expect(BigDecimal.mongoize(infinity)).to eq("Infinity")
+      end
+    end
+
+    context "when the value is String negative Infinity" do
+
+      let(:neg_infinity) do
+        "-Infinity"
+      end
+
+      it "returns a String" do
+        expect(BigDecimal.mongoize(neg_infinity)).to eq("-Infinity")
+      end
+    end
+
+    context "when the value is BigDecimal NaN" do
+
+      let(:nan) do
+        BigDecimal("NaN")
+      end
+
+      it "returns a String" do
+        expect(BigDecimal.mongoize(nan)).to eq("NaN")
+      end
+    end
+
+    context "when the value is BigDecimal Infinity" do
+
+      let(:infinity) do
+        BigDecimal("Infinity")
+      end
+
+      it "returns a String" do
+        expect(BigDecimal.mongoize(infinity)).to eq("Infinity")
+      end
+    end
+
+    context "when the value is BigDecimal negative Infinity" do
+
+      let(:neg_infinity) do
+        BigDecimal("-Infinity")
+      end
+
+      it "returns a String" do
+        expect(BigDecimal.mongoize(neg_infinity)).to eq("-Infinity")
+      end
+    end
+
+    context "when the value is the constant Float::NAN" do
+
+      let(:nan) do
+        Float::NAN
+      end
+
+      it "returns a String" do
+        expect(BigDecimal.mongoize(nan)).to eq("NaN")
+      end
+    end
+
+    context "when the value is constant Float::INFINITY" do
+
+      let(:infinity) do
+        Float::INFINITY
+      end
+
+      it "returns a String" do
+        expect(BigDecimal.mongoize(infinity)).to eq("Infinity")
+      end
+    end
+
+    context "when the value is constant Float::INFINITY * -1" do
+
+      let(:neg_infinity) do
+        Float::INFINITY * -1
+      end
+
+      it "returns a String" do
+        expect(BigDecimal.mongoize(neg_infinity)).to eq("-Infinity")
+      end
+    end
   end
 
   describe "#mongoize" do
 
     it "returns a string" do
-      expect(number.mongoize).to eq(number.to_s)
+      expect(big_decimal.mongoize).to eq(big_decimal.to_s)
+    end
+  end
+
+  describe "#numeric?" do
+
+    it "returns true" do
+      expect(big_decimal.numeric?).to eq(true)
     end
   end
 end

data/spec/mongoid/extensions/boolean_spec.rb

@@ -82,6 +82,13 @@ describe Mongoid::Boolean do
         end
       end
 
+      context "when provided on" do
+
+        it "returns true" do
+          expect(described_class.mongoize("on")).to eq(true)
+        end
+      end
+
       context "when provided false" do
 
         it "returns false" do
@@ -123,6 +130,13 @@ describe Mongoid::Boolean do
           expect(described_class.mongoize("n")).to eq(false)
         end
       end
+
+      context "when provided off" do
+
+        it "returns true" do
+          expect(described_class.mongoize("off")).to eq(false)
+        end
+      end
     end
   end
 

data/spec/mongoid/extensions/date_spec.rb

@@ -135,12 +135,8 @@ describe Mongoid::Extensions::Date do
 
       context "when the string is an invalid time" do
 
-        let(:epoch) do
-          Date.new(1970, 1, 1)
-        end
-
-        it "returns epoch" do
-          expect(Date.mongoize("time")).to eq(epoch)
+        it "returns nil" do
+          expect(Date.mongoize("time")).to eq(nil)
         end
       end
     end

data/spec/mongoid/extensions/date_time_spec.rb

@@ -129,12 +129,8 @@ describe Mongoid::Extensions::DateTime do
 
     context "when the string is an invalid time" do
 
-      let(:epoch) do
-        Time.utc(1970, 1, 1, 0, 0, 0, 0)
-      end
-
-      it "returns epoch" do
-        expect(DateTime.mongoize("time")).to eq(epoch)
+      it "returns nil" do
+        expect(DateTime.mongoize("time")).to eq(nil)
       end
     end
   end

data/spec/mongoid/extensions/decimal128_spec.rb

@@ -41,4 +41,4 @@ describe Mongoid::Extensions::Decimal128 do
       end
     end
   end
-end
+end

data/spec/mongoid/extensions/float_spec.rb

@@ -23,7 +23,7 @@ describe Mongoid::Extensions::Float do
 
   describe ".demongoize" do
 
-    context "when the the value is a float" do
+    context "when the value is a float" do
 
       it "returns a float" do
         expect(Float.demongoize(number)).to eq(number)
@@ -144,4 +144,11 @@ describe Mongoid::Extensions::Float do
       expect(number.mongoize).to eq(number)
     end
   end
+
+  describe "#numeric?" do
+
+    it "returns true" do
+      expect(number.numeric?).to eq(true)
+    end
+  end
 end

data/spec/mongoid/extensions/hash_spec.rb

@@ -247,6 +247,21 @@ describe Mongoid::Extensions::Hash do
     end
   end
 
+  context "when the parent key is not present" do
+
+    let(:hash) do
+      { "101" => { "name" => "hundred and one" } }
+    end
+
+    let(:nested) do
+      hash.__nested__("100.name")
+    end
+
+    it "should return nil" do
+      expect(nested).to eq(nil)
+    end
+  end
+
   describe ".demongoize" do
 
     let(:hash) do

data/spec/mongoid/extensions/integer_spec.rb

@@ -23,7 +23,7 @@ describe Mongoid::Extensions::Integer do
 
   describe ".demongoize" do
 
-    context "when the the value is an integer" do
+    context "when the value is an integer" do
 
       it "returns a integer" do
         expect(Integer.demongoize(number)).to eq(number)
@@ -133,4 +133,11 @@ describe Mongoid::Extensions::Integer do
       expect(number.mongoize).to eq(number)
     end
   end
+
+  describe "#numeric?" do
+
+    it "returns true" do
+      expect(number.numeric?).to eq(true)
+    end
+  end
 end

data/spec/mongoid/extensions/object_spec.rb

@@ -289,4 +289,15 @@ describe Mongoid::Extensions::Object do
       end
     end
   end
+
+  describe "#numeric?" do
+
+    let(:object) do
+      Object.new
+    end
+
+    it "returns false" do
+      expect(object.numeric?).to eq(false)
+    end
+  end
 end

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