mongoid 7.1.1 → 8.1.0

data/spec/mongoid/extensions/regexp_spec.rb

@@ -1,65 +1,89 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 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

data/spec/mongoid/extensions/set_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 
@@ -23,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
@@ -32,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

data/spec/mongoid/extensions/string_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 
@@ -115,6 +114,25 @@ describe Mongoid::Extensions::String do
         it_behaves_like 'maintains precision when mongoized'
       end
 
+      context "when the string is a valid time without time" do
+
+        let(:string) do
+          "2010-11-19"
+        end
+
+        let(:mongoized) do
+          string.__mongoize_time__
+        end
+
+        let(:expected_time) { Time.parse("2010-11-18 15:00:00 +0000").in_time_zone }
+
+        it "converts to the AS time zone" do
+          expect(mongoized.zone).to eq("JST")
+        end
+
+        it_behaves_like 'mongoizes to AS::TimeWithZone'
+      end
+
       context "when the string is an invalid time" do
 
         let(:string) do
@@ -158,18 +176,41 @@ describe Mongoid::Extensions::String do
           Time.now.utc_offset
         end
 
-        before do
+        let(:expected_time) { Time.parse("2010-11-19 00:24:49.123457 +0000") - Time.parse(string).utc_offset }
+
+        let(:mongoized) do
+          string.__mongoize_time__
+        end
+
+        it 'test operates in multiple time zones' do
           expect(utc_offset).not_to eq(Time.zone.now.utc_offset)
         end
 
-        let(:expected_time) { Time.parse("2010-11-19 00:24:49.123457 +0000").in_time_zone - utc_offset }
+        it_behaves_like 'mongoizes to Time'
+        it_behaves_like 'maintains precision when mongoized'
+      end
+
+      context "when the string is a valid time without time" do
+
+        let(:string) do
+          "2010-11-19"
+        end
 
         let(:mongoized) do
           string.__mongoize_time__
         end
 
+        let(:utc_offset) do
+          Time.now.utc_offset
+        end
+
+        let(:expected_time) { Time.parse("2010-11-19 00:00:00 +0000") - Time.parse(string).utc_offset }
+
+        it 'test operates in multiple time zones' do
+          expect(utc_offset).not_to eq(Time.zone.now.utc_offset)
+        end
+
         it_behaves_like 'mongoizes to Time'
-        it_behaves_like 'maintains precision when mongoized'
       end
 
       context "when the string is an invalid time" do
@@ -197,36 +238,19 @@ describe Mongoid::Extensions::String do
         end
       end
 
-      it "returns an underscored tableized name" do
+      it "returns an underscored table-ized name" do
         expect(Medical::Patient.name.collectionize).to eq("medical_patients")
       end
     end
 
     context "when class is not namespaced" do
 
-      it "returns an underscored tableized name" do
+      it "returns an underscored table-ized name" do
         expect(MixedDrink.name.collectionize).to eq("mixed_drinks")
       end
     end
   end
 
-  describe ".demongoize" do
-
-    context "when the object is not a string" do
-
-      it "returns the string" do
-        expect(String.demongoize(:test)).to eq("test")
-      end
-    end
-
-    context "when the object is nil" do
-
-      it "returns nil" do
-        expect(String.demongoize(nil)).to be_nil
-      end
-    end
-  end
-
   describe "#mongoid_id?" do
 
     context "when the string is id" do
@@ -258,19 +282,22 @@ describe Mongoid::Extensions::String do
     end
   end
 
-  describe ".mongoize" do
+  [ :mongoize, :demongoize ].each do |method|
 
-    context "when the object is not a string" do
+    describe ".#{method}" do
 
-      it "returns the string" do
-        expect(String.mongoize(:test)).to eq("test")
+      context "when the object is not a string" do
+
+        it "returns the string" do
+          expect(String.send(method, :test)).to eq("test")
+        end
       end
-    end
 
-    context "when the object is nil" do
+      context "when the object is nil" do
 
-      it "returns nil" do
-        expect(String.mongoize(nil)).to be_nil
+        it "returns nil" do
+          expect(String.send(method, nil)).to be_nil
+        end
       end
     end
   end

data/spec/mongoid/extensions/stringified_symbol_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::StringifiedSymbol do
+
+  describe ".demongoize" do
+
+    context "when the object is not a symbol" do
+
+      it "returns the symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize("test")).to eq(:test)
+      end
+    end
+
+    context "when the object is a symbol" do
+
+      it "returns the symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize(:test)).to eq(:test)
+      end
+    end
+
+    context "when the object is a BSON Symbol" do
+
+      it "returns a symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize(BSON::Symbol::Raw.new(:test))).to eq(:test)
+      end
+    end
+
+
+    context "when the object is an integer" do
+
+      it "returns a symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize(14)).to eq(:"14")
+      end
+    end
+
+    context "when the object is nil" do
+
+      it "returns nil" do
+        expect(Mongoid::StringifiedSymbol.demongoize(nil)).to be_nil
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    context "when the object is not a symbol" do
+
+      it "returns the object" do
+        expect(Mongoid::StringifiedSymbol.mongoize("test")).to eq("test")
+      end
+
+      it "returns the string" do
+        expect(Mongoid::StringifiedSymbol.mongoize([0,1,2])).to eq("[0, 1, 2]")
+      end
+
+      it "returns the string" do
+        expect(Mongoid::StringifiedSymbol.mongoize(2)).to eq("2")
+      end
+    end
+
+    context "when the object is a symbol" do
+
+      it "returns a string" do
+        expect(Mongoid::StringifiedSymbol.mongoize(:test)).to eq("test")
+      end
+    end
+
+    context "when the object is nil" do
+
+      it "returns nil" do
+        expect(Mongoid::StringifiedSymbol.mongoize(nil)).to be_nil
+      end
+    end
+  end
+
+  describe "#mongoize" do
+
+    it "returns self" do
+      expect(:test.mongoize).to eq(:test)
+    end
+  end
+end

data/spec/mongoid/extensions/symbol_spec.rb

@@ -1,27 +1,9 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 
 describe Mongoid::Extensions::Symbol do
 
-  describe ".demongoize" do
-
-    context "when the object is not a symbol" do
-
-      it "returns the symbol" do
-        expect(Symbol.demongoize("test")).to eq(:test)
-      end
-    end
-
-    context "when the object is nil" do
-
-      it "returns nil" do
-        expect(Symbol.demongoize(nil)).to be_nil
-      end
-    end
-  end
-
   describe "#mongoid_id?" do
 
     context "when the string is id" do
@@ -53,19 +35,29 @@ describe Mongoid::Extensions::Symbol do
     end
   end
 
-  describe ".mongoize" do
+  [ :mongoize, :demongoize ].each do |method|
 
-    context "when the object is not a symbol" do
+    describe ".mongoize" do
 
-      it "returns the symbol" do
-        expect(Symbol.mongoize("test")).to eq(:test)
+      context "when the object is not a symbol" do
+
+        it "returns the symbol" do
+          expect(Symbol.send(method, "test")).to eq(:test)
+        end
+      end
+
+      context "when the object is nil" do
+
+        it "returns nil" do
+          expect(Symbol.send(method, nil)).to be_nil
+        end
       end
-    end
 
-    context "when the object is nil" do
+      context "when the object is uncastable" do
 
-      it "returns nil" do
-        expect(Symbol.mongoize(nil)).to be_nil
+        it "returns nil" do
+          expect(Symbol.send(method, [])).to be_nil
+        end
       end
     end
   end