mongoid 7.5.1 → 8.1.2

data/spec/mongoid/extensions/integer_spec.rb

@@ -33,107 +33,93 @@ describe Mongoid::Extensions::Integer do
     end
   end
 
-  describe ".demongoize" do
+  [ :mongoize, :demongoize ].each do |method|
 
-    context "when the value is an integer" do
+    describe ".#{method}" do
 
-      it "returns a integer" do
-        expect(Integer.demongoize(number)).to eq(number)
-      end
-    end
+      context "when the value is a number" do
 
-    context "when the value is nil" do
-
-      it "returns nil" do
-        expect(Integer.demongoize(nil)).to be_nil
-      end
-    end
+        context "when the value is an integer" do
 
-    context "when the value is not an integer" do
+          context "when the value is small" do
 
-      it "converts the value to an integer" do
-        expect(Integer.demongoize("1.0")).to eq(1)
-      end
-    end
-  end
-
-  describe ".mongoize" do
-
-    context "when the value is a number" do
-
-      context "when the value is an integer" do
+            it "it returns the integer" do
+              expect(Integer.send(method, 3)).to eq(3)
+            end
+          end
 
-        context "when the value is small" do
+          context "when the value is large" do
 
-          it "it returns the integer" do
-            expect(Integer.mongoize(3)).to eq(3)
+            it "returns the integer" do
+              expect(Integer.send(method, 1024**2).to_s).to eq("1048576")
+            end
           end
         end
 
-        context "when the value is large" do
+        context "when the value is a decimal" do
 
-          it "returns the integer" do
-            expect(Integer.mongoize(1024**2).to_s).to eq("1048576")
+          it "casts to integer" do
+            expect(Integer.send(method, 2.5)).to eq(2)
           end
         end
-      end
 
-      context "when the value is a decimal" do
+        context "when the value is floating point zero" do
 
-        it "casts to integer" do
-          expect(Integer.mongoize(2.5)).to eq(2)
+          it "returns the integer zero" do
+            expect(Integer.send(method, 0.00000)).to eq(0)
+          end
         end
-      end
 
-      context "when the value is floating point zero" do
+        context "when the value is a floating point integer" do
 
-        it "returns the integer zero" do
-          expect(Integer.mongoize(0.00000)).to eq(0)
+          it "returns the integer number" do
+            expect(Integer.send(method, 4.00000)).to eq(4)
+          end
         end
-      end
 
-      context "when the value is a floating point integer" do
+        context "when the value has leading zeros" do
 
-        it "returns the integer number" do
-          expect(Integer.mongoize(4.00000)).to eq(4)
+          it "returns the stripped integer" do
+            expect(Integer.send(method, "000011")).to eq(11)
+          end
         end
       end
 
-      context "when the value has leading zeros" do
+      context "when the string is not a number" do
 
-        it "returns the stripped integer" do
-          expect(Integer.mongoize("000011")).to eq(11)
-        end
-      end
-    end
+        context "when the string is non numerical" do
 
-    context "when the string is not a number" do
+          it "returns nil" do
+            expect(Integer.send(method, "foo")).to be_nil
+          end
+        end
 
-      context "when the string is non numerical" do
+        context "when the string starts with a number" do
 
-        it "returns 0" do
-          expect(Integer.mongoize("foo")).to eq(0)
+          it "returns nil" do
+            expect(Integer.send(method, "42bogus")).to be_nil
+          end
         end
-      end
 
-      context "when the string is numerical" do
+        context "when the string is empty" do
 
-        it "returns the integer value for the string" do
-          expect(Integer.mongoize("3")).to eq(3)
+          it "returns nil" do
+            expect(Integer.send(method, "")).to be_nil
+          end
         end
-      end
 
-      context "when the string is empty" do
+        context "when the string is nil" do
 
-        it "returns nil" do
-          expect(Integer.mongoize("")).to be_nil
+          it "returns nil" do
+            expect(Integer.send(method, nil)).to be_nil
+          end
         end
-      end
 
-      context "when the string is nil" do
+        context "when giving an object that is castable to an Integer" do
 
-        it "returns nil" do
-          expect(Integer.mongoize(nil)).to be_nil
+          it "returns the integer value" do
+            expect(Integer.send(method, 2.hours)).to eq(7200)
+          end
         end
       end
     end

data/spec/mongoid/extensions/range_spec.rb

@@ -16,142 +16,343 @@ describe Mongoid::Extensions::Range do
   end
 
   describe ".demongoize" do
+    subject { Range.demongoize(hash) }
 
     context "when the range is ascending" do
-
-      let(:hash) do
-        { "min" => 1, "max" => 3 }
-      end
+      let(:hash) { { "min" => 1, "max" => 3 } }
 
       it "returns an ascending range" do
-        expect(Range.demongoize(hash)).to eq(1..3)
+        is_expected.to eq(1..3)
       end
     end
 
     context "when the range is ascending with exclude end" do
-
-      let(:hash) do
-        { "min" => 1, "max" => 3, "exclude_end" => true }
-      end
+      let(:hash) { { "min" => 1, "max" => 3, "exclude_end" => true } }
 
       it "returns an ascending range" do
-        expect(Range.demongoize(hash)).to eq(1...3)
+        is_expected.to eq(1...3)
       end
     end
 
     context "when the range is descending" do
-
-      let(:hash) do
-        { "min" => 5, "max" => 1 }
-      end
+      let(:hash) { { "min" => 5, "max" => 1 } }
 
       it "returns an descending range" do
-        expect(Range.demongoize(hash)).to eq(5..1)
+        is_expected.to eq(5..1)
       end
     end
 
     context "when the range is descending with exclude end" do
-
-      let(:hash) do
-        { "min" => 5, "max" => 1, "exclude_end" => true }
-      end
+      let(:hash) { { "min" => 5, "max" => 1, "exclude_end" => true } }
 
       it "returns an descending range" do
-        expect(Range.demongoize(hash)).to eq(5...1)
+        is_expected.to eq(5...1)
       end
     end
 
     context "when the range is letters" do
+      let(:hash) { { "min" => "a", "max" => "z" } }
 
-      let(:hash) do
-        { "min" => "a", "max" => "z" }
+      it "returns an alphabetic range" do
+        is_expected.to eq("a".."z")
       end
+    end
+
+    context "when the range is letters with exclude end" do
+      let(:hash) { { "min" => "a", "max" => "z", "exclude_end" => true } }
 
       it "returns an alphabetic range" do
-        expect(Range.demongoize(hash)).to eq("a".."z")
+        is_expected.to eq("a"..."z")
       end
     end
 
-    context "when the range is letters with exclude end" do
+    context "when the range is endless" do
+      let(:hash) { { "min" => 1, "max" => nil } }
+
+      context 'kernel can support endless range' do
+        ruby_version_gte '2.6'
 
-      let(:hash) do
-        { "min" => "a", "max" => "z", "exclude_end" => true }
+        it "returns an alphabetic range" do
+          is_expected.to eq(eval('1..'))
+        end
       end
 
-      it "returns an alphabetic range" do
-        expect(Range.demongoize(hash)).to eq("a"..."z")
+      context 'kernel cannot support endless range' do
+        ruby_version_lt '2.6'
+
+        it "returns nil" do
+          is_expected.to be nil
+        end
+      end
+    end
+
+    context "when the range is endless with exclude end" do
+      let(:hash) { { "min" => 1, "max" => nil, "exclude_end" => true } }
+
+      context 'kernel can support endless range' do
+        ruby_version_gte '2.6'
+
+        it "returns an alphabetic range" do
+          is_expected.to eq(eval('1...'))
+        end
+      end
+
+      context 'kernel cannot support endless range' do
+        ruby_version_lt '2.6'
+
+        it "returns nil" do
+          is_expected.to be nil
+        end
+      end
+    end
+
+    context "when the range is beginning-less" do
+      let(:hash) { { "min" => nil, "max" => 3 } }
+
+      context 'kernel can support beginning-less range' do
+        ruby_version_gte '2.7'
+
+        it "returns an alphabetic range" do
+          is_expected.to eq(nil..3)
+        end
+      end
+
+      context 'kernel cannot support beginning-less range' do
+        ruby_version_lt '2.7'
+
+        it "returns nil" do
+          is_expected.to be nil
+        end
+      end
+    end
+
+    context "when the range is beginning-less with exclude end" do
+      let(:hash) { { "min" => nil, "max" => 3, "exclude_end" => true } }
+
+      context 'kernel can support endless range' do
+        ruby_version_gte '2.7'
+
+        it "returns an alphabetic beginning-less" do
+          is_expected.to eq(eval('...3'))
+        end
+      end
+
+      context 'kernel cannot support beginning-less range' do
+        ruby_version_lt '2.7'
+
+        it "returns nil" do
+          is_expected.to be nil
+        end
+      end
+    end
+
+    context "when the range doesn't have any correct keys" do
+      let(:hash) { { "min^" => "a", "max^" => "z", "exclude_end^" => true } }
+
+      it "returns nil" do
+        is_expected.to be nil
+      end
+    end
+
+    context "when the range has symbol keys" do
+      let(:hash) { { min: 1, max: 3 } }
+
+      it "returns an ascending range" do
+        is_expected.to eq(1..3)
       end
     end
   end
 
-  describe ".mongoize" do
+  shared_examples_for 'mongoize range' do
+
+    context 'given a normal range' do
+      let(:range) { 1..3 }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 1, "max" => 3)
+      end
+    end
+
+    context 'given a normal range not inclusive' do
+      let(:range) { 1...3 }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 1, "max" => 3, "exclude_end" => true)
+      end
+    end
+
+    context 'given a descending range' do
+      let(:range) { 5..1 }
 
-    context "when the value is not nil" do
+      it "returns the object hash" do
+        is_expected.to eq("min" => 5, "max" => 1)
+      end
+    end
+
+    context 'given a descending range not inclusive' do
+      let(:range) { 5...1 }
 
       it "returns the object hash" do
-        expect(Range.mongoize(1..3)).to eq({ "min" => 1, "max" => 3 })
+        is_expected.to eq("min" => 5, "max" => 1, "exclude_end" => true)
       end
+    end
+
+    context 'given an endless range' do
+      ruby_version_gte '2.6'
 
-      it "returns the object hash when passed an inverse range" do
-        expect(Range.mongoize(5..1)).to eq({ "min" => 5, "max" => 1 })
+      let(:range) { eval('5..') }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 5)
       end
+    end
+
+    context 'given an endless range not inclusive' do
+      ruby_version_gte '2.6'
 
-      it "returns the object hash when passed a letter range" do
-        expect(Range.mongoize("a".."z")).to eq({ "min" => "a", "max" => "z" })
+      let(:range) { eval('5...') }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 5, "exclude_end" => true)
       end
     end
 
-    context "when the value is not nil with exclude end" do
+    context 'given a beginning-less range' do
+      ruby_version_gte '2.7'
+
+      let(:range) { eval('..5') }
 
       it "returns the object hash" do
-        expect(Range.mongoize(1...3)).to eq({ "min" => 1, "max" => 3, "exclude_end" => true })
+        is_expected.to eq("max" => 5)
       end
+    end
+
+    context 'given an endless range not inclusive' do
+      ruby_version_gte '2.7'
+
+      let(:range) { eval('...5') }
+
+      it "returns the object hash" do
+        is_expected.to eq("max" => 5, "exclude_end" => true)
+      end
+    end
+
+    context 'given a letter range' do
+      let(:range) { 'a'..'z' }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => "a", "max" => "z")
+      end
+    end
+
+    context 'given a letter range not inclusive' do
+      let(:range) { 'a'...'z' }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => "a", "max" => "z", "exclude_end" => true)
+      end
+    end
+
+    context 'given a Time range' do
+      let(:range) { Time.at(0)..Time.at(1) }
 
-      it "returns the object hash when passed an inverse range" do
-        expect(Range.mongoize(5...1)).to eq({ "min" => 5, "max" => 1, "exclude_end" => true })
+      it "returns the object hash" do
+        is_expected.to eq("min" => Time.at(0), "max" => Time.at(1))
+        expect(subject["min"].utc?).to be(true)
+        expect(subject["max"].utc?).to be(true)
       end
+    end
 
-      it "returns the object hash when passed a letter range" do
-        expect(Range.mongoize("a"..."z")).to eq({ "min" => "a", "max" => "z", "exclude_end" => true })
+    context 'given an ActiveSupport::TimeWithZone range' do
+      let(:range) { Time.at(0)..Time.at(1) }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => Time.at(0).in_time_zone, "max" => Time.at(1).in_time_zone)
+        expect(subject["min"].utc?).to be(true)
+        expect(subject["max"].utc?).to be(true)
       end
+    end
+
+    context 'given a Date range' do
+      let(:range) { Date.new(2020, 1, 1)..Date.new(2020, 1, 2) }
 
+      it "returns the object hash" do
+        is_expected.to eq("min" => Time.utc(2020, 1, 1), "max" => Time.utc(2020, 1, 2))
+        expect(subject["min"].utc?).to be(true)
+        expect(subject["max"].utc?).to be(true)
+      end
     end
 
-    context "when the value is nil" do
+    context "given nil" do
+      let(:range) { nil }
 
       it "returns nil" do
-        expect(Range.mongoize(nil)).to be_nil
+        is_expected.to be_nil
+      end
+    end
+
+    context "given a hash" do
+      let(:range) { { 'min' => 1, 'max' => 5, 'exclude_end' => true } }
+
+      it "returns the hash" do
+        is_expected.to eq(range)
+      end
+    end
+
+    context "given a hash missing fields" do
+      let(:range) { { 'min' => 1 } }
+
+      it "returns the hash" do
+        is_expected.to eq(range)
       end
     end
   end
 
   describe "#mongoize" do
+    subject { range.mongoize }
 
-    context "when the value is not nil" do
+    context 'given a String' do
+      let(:range) { '3' }
 
-      it "returns the object hash" do
-        expect((1..3).mongoize).to eq({ "min" => 1, "max" => 3 })
+      it 'returns a string' do
+        is_expected.to eq('3')
       end
+    end
+
+    it_behaves_like 'mongoize range'
+  end
+
+  describe ".mongoize" do
+    subject { Range.mongoize(range) }
+
+    context 'given a String' do
+      let(:range) { '3' }
 
-      it "returns the object hash when passed an inverse range" do
-        expect((5..1).mongoize).to eq({ "min" => 5, "max" => 1 })
+      it "returns nil" do
+        is_expected.to be_nil
       end
+    end
 
-      it "returns the object hash when passed a letter range" do
-        expect(("a".."z").mongoize).to eq({ "min" => "a", "max" => "z" })
+    context "given a hash with wrong fields" do
+      let(:range) { { 'min' => 1, 'max' => 5, 'exclude_end^' => true} }
+
+      it "removes the bogus fields" do
+        is_expected.to eq({ 'min' => 1, 'max' => 5 })
       end
     end
 
-    context 'when the value is a string' do
+    context "given a hash with no correct fields" do
+      let(:range) { { 'min^' => 1, 'max^' => 5, 'exclude_end^' => true} }
 
-      it 'returns a string' do
-        expect(Range.mongoize('3')).to eq('3')
+      it "returns nil" do
+        is_expected.to be_nil
       end
     end
+
+    it_behaves_like 'mongoize range'
   end
 
   describe "#resizable?" do
-
     let(:range) do
       1...3
     end

data/spec/mongoid/extensions/regexp_spec.rb

@@ -4,61 +4,86 @@ require "spec_helper"
 
 describe Mongoid::Extensions::Regexp do
 
-  describe ".demongoize" do
+  [ :mongoize, :demongoize ].each do |method|
 
-    let(:value) do
-      Regexp.demongoize(/[^abc]/)
-    end
+    describe ".#{method}" do
 
-    it "returns the provided value" do
-      expect(value).to eq(/[^abc]/)
-    end
-  end
+      context "when providing a regex" do
 
-  describe ".mongoize" do
-
-    context "when providing a regex" do
+        let(:value) do
+          Regexp.send(method, /[^abc]/)
+        end
 
-      let(:value) do
-        Regexp.mongoize(/[^abc]/)
+        it "returns the provided value" do
+          expect(value).to eq(/[^abc]/)
+        end
       end
 
-      it "returns the provided value" do
-        expect(value).to eq(/[^abc]/)
-      end
-    end
+      context "when providing a string" do
 
-    context "when providing a string" do
+        let(:value) do
+          Regexp.send(method, "[^abc]")
+        end
 
-      let(:value) do
-        Regexp.mongoize("[^abc]")
-      end
+        it "returns the provided value as a regex" do
+          expect(value).to eq(/[^abc]/)
+        end
 
-      it "returns the provided value as a regex" do
-        expect(value).to eq(/[^abc]/)
+
+        context "when the string is empty" do
+
+          let(:value) do
+            Regexp.send(method, "")
+          end
+
+          it "returns an empty regex" do
+            expect(value).to eq(//)
+          end
+        end
       end
 
+      context "when the value is nil" do
 
-      context "when the string is empty" do
+        let(:value) do
+          Regexp.send(method, nil)
+        end
+
+        it "returns the nil" do
+          expect(value).to be_nil
+        end
+      end
+
+      context "when providing a BSON::Regexp::Raw" do
 
         let(:value) do
-          Regexp.mongoize("")
+          Regexp.send(method, BSON::Regexp::Raw.new("hello"))
         end
 
-        it "returns an empty regex" do
-          expect(value).to eq(//)
+        it "returns a Regexp" do
+          expect(value).to eq(/hello/)
         end
       end
-    end
 
-    context "when the value is nil" do
+      context "when providing an invalid regexp" do
+
+        let(:value) do
+          Regexp.send(method, "[")
+        end
 
-      let(:value) do
-        Regexp.mongoize(nil)
+        it "returns nil" do
+          expect(value).to be_nil
+        end
       end
 
-      it "returns the nil" do
-        expect(value).to be_nil
+      context "when providing an invalid Regexp to a BSON::Regexp::Raw" do
+
+        let(:value) do
+          Regexp.send(method, BSON::Regexp::Raw.new("["))
+        end
+
+        it "returns nil" do
+          expect(value).to be_nil
+        end
       end
     end
   end