mongoid 7.2.1 → 9.0.0

data/spec/mongoid/extensions/float_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -21,133 +21,105 @@ describe Mongoid::Extensions::Float do
 
     let(:expected_time) { Time.at(float).in_time_zone }
 
-    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'
 
       it_behaves_like 'mongoizes to AS::TimeWithZone'
       it_behaves_like 'maintains precision when mongoized'
     end
-
-    context "when not using active support's time zone" do
-      include_context 'not using AS time zone'
-
-      it_behaves_like 'mongoizes to Time'
-      it_behaves_like 'maintains precision when mongoized'
-    end
   end
 
-  describe ".demongoize" do
-
-    context "when the value is a float" do
-
-      it "returns a float" do
-        expect(Float.demongoize(number)).to eq(number)
-      end
-    end
-
-    context "when the value is nil" do
-
-      it "returns nil" do
-        expect(Float.demongoize(nil)).to be_nil
-      end
-    end
-
-    context "when the value is a float string" do
-
-      it "returns a float" do
-        expect(Float.demongoize(number.to_s)).to eq(number)
-      end
-    end
-
-    context "when the value is not a float string" do
+  [ :mongoize, :demongoize ].each do |method|
 
-      it "returns a float" do
-        expect(Float.demongoize('asdf')).to eq(0)
-      end
-    end
-  end
+    describe ".#{method}" do
 
-  describe ".mongoize" do
+      context "when the value is a number" do
 
-    context "when the value is a number" do
+        context "when the value is an float" do
 
-      context "when the value is an float" do
+          context "when the value is small" do
 
-        context "when the value is small" do
+            it "it returns the float" do
+              expect(Float.send(method, 3)).to eq(3)
+            end
 
-          it "it returns the float" do
-            expect(Float.mongoize(3)).to eq(3)
+            it "returns the number as type float" do
+              expect(Float.send(method, 3)).to be_a(Float)
+            end
           end
 
-          it "returns the number as type float" do
-            expect(Float.mongoize(3)).to be_a(Float)
+          context "when the value is large" do
+
+            it "returns the float" do
+              expect(Float.send(method, 1024**2).to_s).to eq("1048576.0")
+            end
           end
         end
 
-        context "when the value is large" do
+        context "when the value is a decimal" do
 
-          it "returns the float" do
-            expect(Float.mongoize(1024**2).to_s).to eq("1048576.0")
+          it "casts to float" do
+            expect(Float.send(method, 2.5)).to eq(2.5)
           end
         end
-      end
 
-      context "when the value is a decimal" do
+        context "when the value is floating point zero" do
 
-        it "casts to float" do
-          expect(Float.mongoize(2.5)).to eq(2.5)
+          it "returns the float zero" do
+            expect(Float.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 float" do
 
-        it "returns the float zero" do
-          expect(Float.mongoize(0.00000)).to eq(0)
+          it "returns the float number" do
+            expect(Float.send(method, 4.00000)).to eq(4)
+          end
         end
-      end
 
-      context "when the value is a floating point float" do
+        context "when the value has leading zeros" do
 
-        it "returns the float number" do
-          expect(Float.mongoize(4.00000)).to eq(4)
+          it "returns the stripped float" do
+            expect(Float.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 float" do
-          expect(Float.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(Float.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(Float.mongoize("foo")).to eq(0.0)
+          it "returns nil" do
+            expect(Float.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 float value for the string" do
-          expect(Float.mongoize("3")).to eq(3)
+          it "returns nil" do
+            expect(Float.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(Float.mongoize("")).to be_nil
+          it "returns nil" do
+            expect(Float.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 Float" do
 
-        it "returns nil" do
-          expect(Float.mongoize(nil)).to be_nil
+          it "returns the integer value" do
+            expect(Float.send(method, 2.hours)).to eq(7200)
+          end
         end
       end
     end

data/spec/mongoid/extensions/hash_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -163,133 +163,34 @@ describe Mongoid::Extensions::Hash do
     end
   end
 
-  describe "#__consolidate__" do
-
-    context "when the hash already contains the key" do
-
-      context "when the $set is first" do
-
-        let(:hash) do
-          { "$set" => { name: "Tool" }, likes: 10, "$inc" => { plays: 1 }}
-        end
-
-        let(:consolidated) do
-          hash.__consolidate__(Band)
-        end
-
-        it "moves the non hash values under the provided key" do
-          expect(consolidated).to eq({
-            "$set" => { name: "Tool", likes: 10 }, "$inc" => { plays: 1 }
-          })
-        end
-      end
-
-      context "when the $set is not first" do
-
-        let(:hash) do
-          { likes: 10, "$inc" => { plays: 1 }, "$set" => { name: "Tool" }}
-        end
-
-        let(:consolidated) do
-          hash.__consolidate__(Band)
-        end
-
-        it "moves the non hash values under the provided key" do
-          expect(consolidated).to eq({
-            "$set" => { likes: 10, name: "Tool" }, "$inc" => { plays: 1 }
-          })
-        end
-      end
-    end
-
-    context "when the hash does not contain the key" do
-
-      let(:hash) do
-        { likes: 10, "$inc" => { plays: 1 }, name: "Tool"}
-      end
-
-      let(:consolidated) do
-        hash.__consolidate__(Band)
-      end
-
-      it "moves the non hash values under the provided key" do
-        expect(consolidated).to eq({
-          "$set" => { likes: 10, name: "Tool" }, "$inc" => { plays: 1 }
-        })
-      end
-    end
-  end
-
-  context "when the hash key is a string" do
+  describe ".demongoize" do
 
     let(:hash) do
-      { "100" => { "name" => "hundred" } }
-    end
-
-    let(:nested) do
-      hash.__nested__("100.name")
+      { field: 1 }
     end
 
-    it "should retrieve a nested value under the provided key" do
-      expect(nested).to eq "hundred"
+    it "returns the hash" do
+      expect(Hash.demongoize(hash)).to eq(hash)
     end
 
-    context 'and the value is falsey' do
-      let(:hash) do
-        { "100" => { "name" => false } }
-      end
-      it "should retrieve the falsey nested value under the provided key" do
-        expect(nested).to eq false
+    context "when object is nil" do
+      let(:demongoized) do
+        Hash.demongoize(nil)
       end
-    end
 
-    context 'and the value is nil' do
-      let(:hash) do
-        { "100" => { 0 => "Please don't return this value!" } }
-      end
-      it "should retrieve the nil nested value under the provided key" do
-        expect(nested).to eq nil
+      it "returns nil" do
+        expect(demongoized).to be_nil
       end
     end
-  end
 
-  context "when the hash key is an integer" do
-    let(:hash) do
-      { 100 => { "name" => "hundred" } }
-    end
-
-    let(:nested) do
-      hash.__nested__("100.name")
-    end
-
-    it "should retrieve a nested value under the provided key" do
-      expect(nested).to eq("hundred")
-    end
-  end
-
-  context "when the parent key is not present" do
-
-    let(:hash) do
-      { "101" => { "name" => "hundred and one" } }
-    end
-
-    let(:nested) do
-      hash.__nested__("100.name")
-    end
-
-    it "should return nil" do
-      expect(nested).to eq(nil)
-    end
-  end
-
-  describe ".demongoize" do
-
-    let(:hash) do
-      { field: 1 }
-    end
+    context "when the object is uncastable" do
+      let(:demongoized) do
+        Hash.demongoize(1)
+      end
 
-    it "returns the hash" do
-      expect(Hash.demongoize(hash)).to eq(hash)
+      it "returns the object" do
+        expect(demongoized).to eq(1)
+      end
     end
   end
 
@@ -316,6 +217,10 @@ describe Mongoid::Extensions::Hash do
       it "converts the elements properly" do
         expect(mongoized[:date]).to eq(Time.utc(2012, 1, 1, 0, 0, 0))
       end
+
+      it "mongoizes to a BSON::Document" do
+        expect(mongoized).to be_a(BSON::Document)
+      end
     end
 
     context "when object is nil" do
@@ -327,6 +232,30 @@ describe Mongoid::Extensions::Hash do
         expect(mongoized).to be_nil
       end
     end
+
+    context "when the object is uncastable" do
+      let(:mongoized) do
+        Hash.mongoize(1)
+      end
+
+      it "returns nil" do
+        expect(mongoized).to be_nil
+      end
+    end
+
+    describe "when mongoizing a BSON::Document" do
+      let(:mongoized) do
+        Hash.mongoize(BSON::Document.new({ x: 1, y: 2 }))
+      end
+
+      it "returns the same hash" do
+        expect(mongoized).to eq({ "x" => 1, "y" => 2 })
+      end
+
+      it "returns a BSON::Document" do
+        expect(mongoized).to be_a(BSON::Document)
+      end
+    end
   end
 
   describe "#mongoize" do
@@ -365,107 +294,4 @@ describe Mongoid::Extensions::Hash do
       expect(Hash).to be_resizable
     end
   end
-
-  shared_examples_for 'unsatisfiable criteria method' do
-
-    context "when the hash has only an empty _id criteria" do
-
-      let(:hash) do
-        { "_id" => { "$in" => [] }}
-      end
-
-      it "is true" do
-        expect(hash.send(meth)).to be true
-      end
-    end
-
-    context "when the hash has an empty _id criteria and another criteria" do
-
-      let(:hash) do
-        { "_id" => { "$in" => [] }, 'foo' => 'bar'}
-      end
-
-      it "is false" do
-        expect(hash.send(meth)).to be false
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $and" do
-
-      let(:hash) do
-        {'$and' => [{ "_id" => { "$in" => [] }}]}
-      end
-
-      it "is true" do
-        expect(hash.send(meth)).to be true
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $and and another criteria at top level" do
-
-      let(:hash) do
-        {'$and' => [{ "_id" => { "$in" => [] }}], 'foo' => 'bar'}
-      end
-
-      it "is false" do
-        expect(hash.send(meth)).to be false
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $and and another criteria in $and" do
-
-      let(:hash) do
-        {'$and' => [{ "_id" => { "$in" => [] }}, {'foo' => 'bar'}]}
-      end
-
-      it "is true" do
-        expect(hash.send(meth)).to be true
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $and and another criteria in $and value" do
-
-      let(:hash) do
-        {'$and' => [{ "_id" => { "$in" => [] }, 'foo' => 'bar'}]}
-      end
-
-      it "is false" do
-        expect(hash.send(meth)).to be false
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $or" do
-
-      let(:hash) do
-        {'$or' => [{ "_id" => { "$in" => [] }}]}
-      end
-
-      it "is false" do
-        expect(hash.send(meth)).to be false
-      end
-    end
-
-    context "when the hash has an empty _id criteria via $nor" do
-
-      let(:hash) do
-        {'$nor' => [{ "_id" => { "$in" => [] }}]}
-      end
-
-      it "is false" do
-        expect(hash.send(meth)).to be false
-      end
-    end
-  end
-
-  describe "#blank_criteria?" do
-    let(:meth) { :blank_criteria? }
-
-    it_behaves_like 'unsatisfiable criteria method'
-  end
-
-  describe "#_mongoid_unsatisfiable_criteria?" do
-    let(:meth) { :_mongoid_unsatisfiable_criteria? }
-
-    it_behaves_like 'unsatisfiable criteria method'
-  end
 end

data/spec/mongoid/extensions/integer_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -21,120 +21,100 @@ describe Mongoid::Extensions::Integer do
 
     let(:expected_time) { Time.at(integer).in_time_zone }
 
-    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'
 
       it_behaves_like 'mongoizes to AS::TimeWithZone'
     end
-
-    context "when not using active support's time zone" do
-      include_context 'not using AS time zone'
-
-      it_behaves_like 'mongoizes to Time'
-    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
+        context "when the value is an integer" do
 
-      it "returns nil" do
-        expect(Integer.demongoize(nil)).to be_nil
-      end
-    end
+          context "when the value is small" do
 
-    context "when the value is not an integer" 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/module_spec.rb

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