mongoid 3.1.5 → 8.0.2

data/spec/mongoid/extensions/string_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Extensions::String do
@@ -7,18 +9,18 @@ describe Mongoid::Extensions::String do
     context "when the string is blank" do
 
       it "returns the empty string" do
-        "".__evolve_object_id__.should be_empty
+        expect("".__evolve_object_id__).to be_empty
       end
     end
 
     context "when the string is a legal object id" do
 
       let(:object_id) do
-        Moped::BSON::ObjectId.new
+        BSON::ObjectId.new
       end
 
       it "returns the object id" do
-        object_id.to_s.__evolve_object_id__.should eq(object_id)
+        expect(object_id.to_s.__evolve_object_id__).to eq(object_id)
       end
     end
 
@@ -29,7 +31,7 @@ describe Mongoid::Extensions::String do
       end
 
       it "returns the string" do
-        string.__evolve_object_id__.should eq(string)
+        expect(string.__evolve_object_id__).to eq(string)
       end
     end
   end
@@ -39,18 +41,18 @@ describe Mongoid::Extensions::String do
     context "when the string is blank" do
 
       it "returns nil" do
-        "".__mongoize_object_id__.should be_nil
+        expect("".__mongoize_object_id__).to be_nil
       end
     end
 
     context "when the string is a legal object id" do
 
       let(:object_id) do
-        Moped::BSON::ObjectId.new
+        BSON::ObjectId.new
       end
 
       it "returns the object id" do
-        object_id.to_s.__mongoize_object_id__.should eq(object_id)
+        expect(object_id.to_s.__mongoize_object_id__).to eq(object_id)
       end
     end
 
@@ -61,7 +63,7 @@ describe Mongoid::Extensions::String do
       end
 
       it "returns the string" do
-        string.__mongoize_object_id__.should eq(string)
+        expect(string.__mongoize_object_id__).to eq(string)
       end
     end
   end
@@ -69,33 +71,66 @@ describe Mongoid::Extensions::String do
   describe "#__mongoize_time__" do
 
     context "when using active support's time zone" do
+      include_context 'using AS time zone'
 
-      before do
-        Mongoid.use_activesupport_time_zone = true
-        ::Time.zone = "Tokyo"
-      end
+      context "when the string is a valid time with time zone" do
+
+        let(:string) do
+          # JST is +0900
+          "2010-11-19 00:24:49.123457 +1100"
+        end
+
+        let(:mongoized) do
+          string.__mongoize_time__
+        end
+
+        let(:expected_time) { Time.parse("2010-11-18 13:24:49.123457 +0000").in_time_zone }
+
+        it "converts to the AS time zone" do
+          expect(mongoized.zone).to eq("JST")
+        end
 
-      after do
-        ::Time.zone = "Berlin"
+        it_behaves_like 'mongoizes to AS::TimeWithZone'
+        it_behaves_like 'maintains precision when mongoized'
       end
 
-      context "when the string is a valid time" do
+      context "when the string is a valid time without time zone" do
 
         let(:string) do
-          "2010-11-19 00:24:49 +0900"
+          "2010-11-19 00:24:49.123457"
         end
 
-        let(:time) do
+        let(:mongoized) do
           string.__mongoize_time__
         end
 
-        it "converts to a time" do
-          time.should eq(Time.configured.parse(string))
+        let(:expected_time) { Time.parse("2010-11-18 15:24:49.123457 +0000").in_time_zone }
+
+        it "converts to the AS time zone" do
+          expect(mongoized.zone).to eq("JST")
         end
 
-        it "converts to the as time zone" do
-          time.zone.should eq("JST")
+        it_behaves_like 'mongoizes to AS::TimeWithZone'
+        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
@@ -113,29 +148,69 @@ describe Mongoid::Extensions::String do
     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
 
-      before do
-        Mongoid.use_activesupport_time_zone = false
+        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
 
-      after do
-        Mongoid.use_activesupport_time_zone = true
-        Time.zone = nil
+      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-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
+
+        it_behaves_like 'mongoizes to Time'
+        it_behaves_like 'maintains precision when mongoized'
       end
 
-      context "when the string is a valid time" do
+      context "when the string is a valid time without time" do
 
         let(:string) do
-          "2010-11-19 00:24:49 +0900"
+          "2010-11-19"
         end
 
-        let(:time) do
+        let(:mongoized) do
           string.__mongoize_time__
         end
 
-        it "converts to a time" do
-          time.should eq(Time.parse(string))
+        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'
       end
 
       context "when the string is an invalid time" do
@@ -163,32 +238,15 @@ describe Mongoid::Extensions::String do
         end
       end
 
-      it "returns an underscored tableized name" do
-        Medical::Patient.name.collectionize.should eq("medical_patients")
+      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
-        MixedDrink.name.collectionize.should eq("mixed_drinks")
-      end
-    end
-  end
-
-  describe ".demongoize" do
-
-    context "when the object is not a string" do
-
-      it "returns the string" do
-        String.demongoize(:test).should eq("test")
-      end
-    end
-
-    context "when the object is nil" do
-
-      it "returns nil" do
-        String.demongoize(nil).should be_nil
+      it "returns an underscored table-ized name" do
+        expect(MixedDrink.name.collectionize).to eq("mixed_drinks")
       end
     end
   end
@@ -198,45 +256,48 @@ describe Mongoid::Extensions::String do
     context "when the string is id" do
 
       it "returns true" do
-        "id".should be_mongoid_id
+        expect("id").to be_mongoid_id
       end
     end
 
     context "when the string is _id" do
 
       it "returns true" do
-        "_id".should be_mongoid_id
+        expect("_id").to be_mongoid_id
       end
     end
 
     context "when the string contains id" do
 
       it "returns false" do
-        "identity".should_not be_mongoid_id
+        expect("identity").to_not be_mongoid_id
       end
     end
 
     context "when the string contains _id" do
 
       it "returns false" do
-        "something_id".should_not be_mongoid_id
+        expect("something_id").to_not be_mongoid_id
       end
     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
-        String.mongoize(:test).should 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
-        String.mongoize(nil).should be_nil
+        it "returns nil" do
+          expect(String.send(method, nil)).to be_nil
+        end
       end
     end
   end
@@ -244,7 +305,7 @@ describe Mongoid::Extensions::String do
   describe "#mongoize" do
 
     it "returns self" do
-      "test".mongoize.should eq("test")
+      expect("test".mongoize).to eq("test")
     end
   end
 
@@ -253,21 +314,21 @@ describe Mongoid::Extensions::String do
     context "when string is a reader" do
 
       it "returns self" do
-        "attribute".reader.should eq("attribute")
+        expect("attribute".reader).to eq("attribute")
       end
     end
 
     context "when string is a writer" do
 
       it "returns the reader" do
-        "attribute=".reader.should eq("attribute")
+        expect("attribute=".reader).to eq("attribute")
       end
     end
 
     context "when the string is before_type_cast" do
 
       it "returns the reader" do
-        "attribute_before_type_cast".reader.should eq("attribute")
+        expect("attribute_before_type_cast".reader).to eq("attribute")
       end
     end
   end
@@ -277,57 +338,95 @@ describe Mongoid::Extensions::String do
     context "when the string is an integer" do
 
       it "returns true" do
-        "1234".should be_numeric
+        expect("1234".numeric?).to eq(true)
       end
     end
 
     context "when string is a float" do
 
       it "returns true" do
-        "1234.123".should be_numeric
+        expect("1234.123".numeric?).to eq(true)
       end
     end
 
     context "when the string is has exponents" do
 
       it "returns true" do
-        "1234.123123E4".should be_numeric
+        expect("1234.123123E4".numeric?).to eq(true)
       end
     end
 
     context "when the string is non numeric" do
 
       it "returns false" do
-        "blah".should_not be_numeric
+        expect("blah".numeric?).to eq(false)
       end
     end
-  end
 
-  describe "#singularize" do
+    context "when the string is NaN" do
 
-    context "when string is address" do
+      it "returns true" do
+        expect("NaN".numeric?).to eq(true)
+      end
+    end
 
-      it "returns address" do
-        "address".singularize.should eq("address")
+    context "when the string is NaN and junk in front" do
+
+      it "returns false" do
+        expect("a\nNaN".numeric?).to eq(false)
       end
     end
 
-    context "when string is address_profiles" do
+    context "when the string is NaN and whitespace at end" do
 
-      it "returns address_profile" do
-        "address_profiles".singularize.should eq("address_profile")
+      it "returns false" do
+        expect("NaN\n".numeric?).to eq(false)
+      end
+    end
+
+    context "when the string is Infinity" do
+
+      it "returns true" do
+        expect("Infinity".numeric?).to eq(true)
+      end
+    end
+
+    context "when the string contains Infinity and junk in front" do
+
+      it "returns false" do
+        expect("a\nInfinity".numeric?).to eq(false)
+      end
+    end
+
+    context "when the string contains Infinity and whitespace at end" do
+
+      it "returns false" do
+        expect("Infinity\n".numeric?).to eq(false)
+      end
+    end
+
+    context "when the string is -Infinity" do
+
+      it "returns true" do
+        expect("-Infinity".numeric?).to eq(true)
       end
     end
   end
 
-  describe "#to_a" do
+  describe "#singularize" do
+
+    context "when string is address" do
 
-    let(:value) do
-      "Disintegration is the best album ever!"
+      it "returns address" do
+        expect("address".singularize).to eq("address")
+      end
     end
 
-    it "returns an array with the string in it" do
-      value.to_a.should eq([ value ])
+    context "when string is address_profiles" do
+
+      it "returns address_profile" do
+        expect("address_profiles".singularize).to eq("address_profile")
+      end
     end
   end
 
@@ -336,14 +435,14 @@ describe Mongoid::Extensions::String do
     context "when string is a reader" do
 
       it "returns false" do
-        "attribute".writer?.should be_false
+        expect("attribute".writer?).to be false
       end
     end
 
     context "when string is a writer" do
 
       it "returns true" do
-        "attribute=".writer?.should be_true
+        expect("attribute=".writer?).to be true
       end
     end
   end
@@ -353,14 +452,14 @@ describe Mongoid::Extensions::String do
     context "when string is a reader" do
 
       it "returns false" do
-        "attribute".before_type_cast?.should be_false
+        expect("attribute".before_type_cast?).to be false
       end
     end
 
     context "when string is before_type_cast" do
 
       it "returns true" do
-        "attribute_before_type_cast".before_type_cast?.should be_true
+        expect("attribute_before_type_cast".before_type_cast?).to be true
       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,68 +1,63 @@
+# frozen_string_literal: true
+
 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
-        Symbol.demongoize("test").should eq(:test)
-      end
-    end
-
-    context "when the object is nil" do
-
-      it "returns nil" do
-        Symbol.demongoize(nil).should be_nil
-      end
-    end
-  end
-
   describe "#mongoid_id?" do
 
     context "when the string is id" do
 
       it "returns true" do
-        :id.should be_mongoid_id
+        expect(:id).to be_mongoid_id
       end
     end
 
     context "when the string is _id" do
 
       it "returns true" do
-        :_id.should be_mongoid_id
+        expect(:_id).to be_mongoid_id
       end
     end
 
     context "when the string contains id" do
 
       it "returns false" do
-        :identity.should_not be_mongoid_id
+        expect(:identity).to_not be_mongoid_id
       end
     end
 
     context "when the string contains _id" do
 
       it "returns false" do
-        :something_id.should_not be_mongoid_id
+        expect(:something_id).to_not be_mongoid_id
       end
     end
   end
 
-  describe ".mongoize" do
+  [ :mongoize, :demongoize ].each do |method|
+
+    describe ".mongoize" do
 
-    context "when the object is not a symbol" do
+      context "when the object is not a symbol" do
 
-      it "returns the symbol" do
-        Symbol.mongoize("test").should eq(:test)
+        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
-        Symbol.mongoize(nil).should be_nil
+        it "returns nil" do
+          expect(Symbol.send(method, [])).to be_nil
+        end
       end
     end
   end
@@ -70,7 +65,7 @@ describe Mongoid::Extensions::Symbol do
   describe "#mongoize" do
 
     it "returns self" do
-      :test.mongoize.should eq(:test)
+      expect(:test.mongoize).to eq(:test)
     end
   end
 end