mongoid 7.2.1 → 9.0.0

data/spec/mongoid/extensions/raw_value_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+require "spec_helper"
+
+describe Mongoid::RawValue do
+
+  describe "::()" do
+    subject { Mongoid::RawValue(raw_value).raw_value }
+
+    context 'when raw_value is a String' do
+      let(:raw_value) { 'Hello World!' }
+
+      it 'returns the value' do
+        is_expected.to eq 'Hello World!'
+      end
+    end
+
+    context 'when raw_value is an Integer' do
+      let(:raw_value) { 42 }
+
+      it 'returns the value' do
+        is_expected.to eq 42
+      end
+    end
+  end
+
+  describe "#raw_value" do
+    subject { described_class.new(raw_value).raw_value }
+
+    context 'when raw_value is a String' do
+      let(:raw_value) { 'Hello World!' }
+
+      it 'returns the value' do
+        is_expected.to eq 'Hello World!'
+      end
+    end
+
+    context 'when raw_value is an Integer' do
+      let(:raw_value) { 42 }
+
+      it 'returns the value' do
+        is_expected.to eq 42
+      end
+    end
+  end
+
+  describe "#inspect" do
+    subject { described_class.new(raw_value).inspect }
+
+    context 'when raw_value is a String' do
+      let(:raw_value) { 'Hello World!' }
+
+      it 'returns the inspection' do
+        is_expected.to eq 'RawValue: "Hello World!"'
+      end
+    end
+
+    context 'when raw_value is an Integer' do
+      let(:raw_value) { 42 }
+
+      it 'returns the inspection' do
+        is_expected.to eq 'RawValue: 42'
+      end
+    end
+  end
+end

data/spec/mongoid/extensions/regexp_spec.rb

@@ -1,65 +1,90 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 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,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -23,6 +23,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 +63,78 @@ 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_return(1)
+      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,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -71,8 +71,8 @@ describe Mongoid::Extensions::String do
 
   describe "#__mongoize_time__" do
 
-    context "when using active support's time zone" do
-      include_context 'using AS time zone'
+    context "when setting ActiveSupport time zone" do
+      include_context 'setting ActiveSupport time zone'
 
       context "when the string is a valid time with time zone" do
 
@@ -115,61 +115,23 @@ describe Mongoid::Extensions::String do
         it_behaves_like 'maintains precision when mongoized'
       end
 
-      context "when the string is an invalid time" do
+      context "when the string is a valid time without time" do
 
         let(:string) do
-          "shitty string"
-        end
-
-        it "raises an error" do
-          expect {
-            string.__mongoize_time__
-          }.to raise_error(ArgumentError)
+          "2010-11-19"
         end
-      end
-    end
-
-    context "when not using active support's time zone" do
-      include_context 'not using AS time zone'
-
-      context "when the string is a valid time with time zone" do
-
-        let(:string) do
-          "2010-11-19 00:24:49.123457 +1100"
-        end
-
-        let(:expected_time) { Time.parse("2010-11-18 13:24:49.123457 +0000").in_time_zone }
 
         let(:mongoized) do
           string.__mongoize_time__
         end
 
-        it_behaves_like 'mongoizes to Time'
-        it_behaves_like 'maintains precision when mongoized'
-      end
-
-      context "when the string is a valid time without time zone" do
-
-        let(:string) do
-          "2010-11-19 00:24:49.123457"
-        end
-
-        let(:utc_offset) do
-          Time.now.utc_offset
-        end
+        let(:expected_time) { Time.parse("2010-11-18 15:00:00 +0000").in_time_zone }
 
-        before 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 }
-
-        let(:mongoized) do
-          string.__mongoize_time__
+        it "converts to the AS time zone" do
+          expect(mongoized.zone).to eq("JST")
         end
 
-        it_behaves_like 'mongoizes to Time'
-        it_behaves_like 'maintains precision when mongoized'
+        it_behaves_like 'mongoizes to AS::TimeWithZone'
       end
 
       context "when the string is an invalid time" do
@@ -197,80 +159,35 @@ 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
+  [ :mongoize, :demongoize ].each do |method|
 
-    context "when the object is not a string" do
+    describe ".#{method}" 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
-
-      it "returns true" do
-        expect("id").to be_mongoid_id
-      end
-    end
-
-    context "when the string is _id" do
-
-      it "returns true" do
-        expect("_id").to be_mongoid_id
-      end
-    end
-
-    context "when the string contains id" do
-
-      it "returns false" do
-        expect("identity").to_not be_mongoid_id
-      end
-    end
-
-    context "when the string contains _id" do
+      context "when the object is not a string" do
 
-      it "returns false" do
-        expect("something_id").to_not be_mongoid_id
-      end
-    end
-  end
-
-  describe ".mongoize" do
-
-    context "when the object is not a string" do
-
-      it "returns the string" do
-        expect(String.mongoize(:test)).to eq("test")
+        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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/extensions/symbol_spec.rb

@@ -1,71 +1,33 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
 describe Mongoid::Extensions::Symbol do
 
-  describe ".demongoize" 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.demongoize("test")).to eq(:test)
-      end
-    end
+      context "when the object is not a symbol" do
 
-    context "when the object is nil" do
-
-      it "returns nil" do
-        expect(Symbol.demongoize(nil)).to be_nil
+        it "returns the symbol" do
+          expect(Symbol.send(method, "test")).to eq(:test)
+        end
       end
-    end
-  end
-
-  describe "#mongoid_id?" do
 
-    context "when the string is id" do
+      context "when the object is nil" do
 
-      it "returns true" do
-        expect(:id).to be_mongoid_id
+        it "returns nil" do
+          expect(Symbol.send(method, nil)).to be_nil
+        end
       end
-    end
-
-    context "when the string is _id" do
-
-      it "returns true" do
-        expect(:_id).to be_mongoid_id
-      end
-    end
-
-    context "when the string contains id" do
-
-      it "returns false" do
-        expect(:identity).to_not be_mongoid_id
-      end
-    end
-
-    context "when the string contains _id" do
-
-      it "returns false" do
-        expect(:something_id).to_not be_mongoid_id
-      end
-    end
-  end
-
-  describe ".mongoize" do
-
-    context "when the object is not a symbol" do
-
-      it "returns the symbol" do
-        expect(Symbol.mongoize("test")).to eq(:test)
-      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