mongoid 7.0.2 → 8.1.1

data/spec/mongoid/extensions/range_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Extensions::Range do
@@ -14,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 } }
 
-      let(:hash) do
-        { "min" => "a", "max" => "z", "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
 
-      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 "when the value is not nil" do
+    context 'given a normal range' do
+      let(:range) { 1..3 }
 
       it "returns the object hash" do
-        expect(Range.mongoize(1..3)).to eq({ "min" => 1, "max" => 3 })
+        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 when passed an inverse range" do
-        expect(Range.mongoize(5..1)).to eq({ "min" => 5, "max" => 1 })
+      it "returns the object hash" do
+        is_expected.to eq("min" => 1, "max" => 3, "exclude_end" => 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" })
+    context 'given a descending range' do
+      let(:range) { 5..1 }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 5, "max" => 1)
       end
     end
 
-    context "when the value is not nil with exclude end" do
+    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, "exclude_end" => true })
+        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, "exclude_end" => true })
+      let(:range) { eval('5..') }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 5)
       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 endless range not inclusive' do
+      ruby_version_gte '2.6'
+
+      let(:range) { eval('5...') }
+
+      it "returns the object hash" do
+        is_expected.to eq("min" => 5, "exclude_end" => true)
+      end
+    end
+
+    context 'given a beginning-less range' do
+      ruby_version_gte '2.7'
+
+      let(:range) { eval('..5') }
+
+      it "returns the object hash" do
+        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" 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
+
+    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

@@ -1,39 +1,89 @@
+# frozen_string_literal: true
+
 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
+
+      context "when providing a regex" do
+
+        let(:value) do
+          Regexp.send(method, /[^abc]/)
+        end
+
+        it "returns the provided value" do
+          expect(value).to eq(/[^abc]/)
+        end
+      end
+
+      context "when providing a string" do
+
+        let(:value) do
+          Regexp.send(method, "[^abc]")
+        end
+
+        it "returns the provided value as a regex" do
+          expect(value).to eq(/[^abc]/)
+        end
 
-    it "returns the provided value" do
-      expect(value).to eq(/[^abc]/)
-    end
-  end
 
-  describe ".mongoize" do
+        context "when the string is empty" do
 
-    context "when providing a regex" do
+          let(:value) do
+            Regexp.send(method, "")
+          end
 
-      let(:value) do
-        Regexp.mongoize(/[^abc]/)
+          it "returns an empty regex" do
+            expect(value).to eq(//)
+          end
+        end
       end
 
-      it "returns the provided value" do
-        expect(value).to eq(/[^abc]/)
+      context "when the value is nil" do
+
+        let(:value) do
+          Regexp.send(method, nil)
+        end
+
+        it "returns the nil" do
+          expect(value).to be_nil
+        end
       end
-    end
 
-    context "when providing a string" do
+      context "when providing a BSON::Regexp::Raw" do
+
+        let(:value) do
+          Regexp.send(method, BSON::Regexp::Raw.new("hello"))
+        end
+
+        it "returns a Regexp" do
+          expect(value).to eq(/hello/)
+        end
+      end
+
+      context "when providing an invalid regexp" do
+
+        let(:value) do
+          Regexp.send(method, "[")
+        end
 
-      let(:value) do
-        Regexp.mongoize("[^abc]")
+        it "returns nil" do
+          expect(value).to be_nil
+        end
       end
 
-      it "returns the provided value as a regex" do
-        expect(value).to eq(/[^abc]/)
+      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

data/spec/mongoid/extensions/set_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Extensions::Set do
@@ -20,6 +22,37 @@ describe Mongoid::Extensions::Set do
     end
   end
 
+  describe ".demongoize" do
+
+    context "when passing an array" do
+
+      it "returns a set" do
+        expect(Set.demongoize([ "test" ])).to eq([ "test" ].to_set)
+      end
+    end
+
+    context "when passing a set" do
+
+      it "returns a set " do
+        expect(Set.demongoize(Set.new([ "test" ]))).to eq([ "test" ].to_set)
+      end
+    end
+
+    context "when passing nil" do
+
+      it "returns nil" do
+        expect(Set.demongoize(nil)).to be_nil
+      end
+    end
+
+    context "when passing an uncastable value" do
+
+      it "returns nil" do
+        expect(Set.demongoize("bogus")).to be_nil
+      end
+    end
+  end
+
   describe "#mongoize" do
 
     let(:set) do
@@ -29,5 +62,80 @@ describe Mongoid::Extensions::Set do
     it "returns an array" do
       expect(set.mongoize).to eq([ "test" ])
     end
+
+    context "when there are mongoizable values in the container" do
+      let(:date) do
+        Date.new(2012, 1, 1)
+      end
+
+      let(:mongoized) do
+        Set.mongoize(input)
+      end
+
+      context "when the input is an array" do
+
+        let(:input) do
+          [ date ]
+        end
+
+        it "mongoizes to a set" do
+          expect(mongoized).to be_a(Array)
+        end
+
+        it "mongoizes each element in the array" do
+          expect(mongoized.first).to be_a(Time)
+        end
+
+        it "converts the elements properly" do
+          expect(mongoized.first).to eq(Time.utc(2012, 1, 1, 0, 0, 0))
+        end
+      end
+
+      context "when the input is a set" do
+        let(:input) do
+          [ date ].to_set
+        end
+
+        it "mongoizes to a set" do
+          expect(mongoized).to be_a(Array)
+        end
+
+        it "converts the elements properly" do
+          expect(mongoized.first).to eq(Time.utc(2012, 1, 1, 0, 0, 0))
+        end
+      end
+    end
+
+    context "when the mongoizer creates duplicate elements" do
+      let(:mongoized) do
+        Set.mongoize(input)
+      end
+
+      before do
+        expect(BigDecimal).to receive(:mongoize).exactly(4).times.and_wrap_original do |m, *args|
+          1
+        end
+      end
+
+      context "when the input is a set" do
+        let(:input) do
+          [ 1, 2, 3, 4 ].map(&:to_d).to_set
+        end
+
+        it "removes duplicates" do
+          expect(mongoized).to eq([ 1 ])
+        end
+      end
+
+      context "when the input is an array" do
+        let(:input) do
+          [ 1, 2, 3, 4 ].map(&:to_d)
+        end
+
+        it "removes duplicates" do
+          expect(mongoized).to eq([ 1 ])
+        end
+      end
+    end
   end
 end