mongoid 9.0.11 → 9.1.0

data/spec/mongoid/criteria/queryable/extensions/hash_spec.rb

@@ -1,131 +1,116 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Hash do
-
-  describe "#__add__" do
-
-    context "when the other object is a hash" do
-
-      context "when a key matches" do
-
-        context "when the existing value is a non-enumerable" do
-
-          context "when the added value is non-enumerable" do
-
-            context "when the values are unique" do
-
+  describe '#__add__' do
+    context 'when the other object is a hash' do
+      context 'when a key matches' do
+        context 'when the existing value is a non-enumerable' do
+          context 'when the added value is non-enumerable' do
+            context 'when the values are unique' do
               let(:hash) do
-                { "$in" => 5 }
+                { '$in' => 5 }
               end
 
               before do
-                hash.__add__({ "$in" => 6 })
+                hash.__add__({ '$in' => 6 })
               end
 
-              it "sets the new array" do
-                expect(hash).to eq({ "$in" => [ 5, 6 ] })
+              it 'sets the new array' do
+                expect(hash).to eq({ '$in' => [ 5, 6 ] })
               end
             end
 
-            context "when the values are not unique" do
-
+            context 'when the values are not unique' do
               let(:hash) do
-                { "$in" => 5 }
+                { '$in' => 5 }
               end
 
               before do
-                hash.__add__({ "$in" => 5 })
+                hash.__add__({ '$in' => 5 })
               end
 
-              it "keeps the old value" do
-                expect(hash).to eq({ "$in" => 5 })
+              it 'keeps the old value' do
+                expect(hash).to eq({ '$in' => 5 })
               end
             end
           end
         end
 
-        context "when the existing value is an array" do
-
-          context "when the values are unique" do
-
+        context 'when the existing value is an array' do
+          context 'when the values are unique' do
             let(:hash) do
-              { "$in" => [ 5, 6 ] }
+              { '$in' => [ 5, 6 ] }
             end
 
             before do
-              hash.__add__({ "$in" => [ 7, 8 ] })
+              hash.__add__({ '$in' => [ 7, 8 ] })
             end
 
-            it "sets the new array" do
-              expect(hash).to eq({ "$in" => [ 5, 6, 7, 8 ] })
+            it 'sets the new array' do
+              expect(hash).to eq({ '$in' => [ 5, 6, 7, 8 ] })
             end
           end
 
-          context "when the values are not unique" do
-
+          context 'when the values are not unique' do
             let(:hash) do
-              { "$in" => [ 5, 6 ] }
+              { '$in' => [ 5, 6 ] }
             end
 
             before do
-              hash.__add__({ "$in" => [ 6, 7 ] })
+              hash.__add__({ '$in' => [ 6, 7 ] })
             end
 
-            it "sets a new unique array" do
-              expect(hash).to eq({ "$in" => [ 5, 6, 7 ] })
+            it 'sets a new unique array' do
+              expect(hash).to eq({ '$in' => [ 5, 6, 7 ] })
             end
           end
         end
       end
 
-      context "when a key does not match" do
-
+      context 'when a key does not match' do
         let(:hash) do
-          { "$all" => [ 1, 2, 3 ] }
+          { '$all' => [ 1, 2, 3 ] }
         end
 
         before do
-          hash.__add__({ "$in" => [ 1, 2 ] })
+          hash.__add__({ '$in' => [ 1, 2 ] })
         end
 
-        it "merges in the new hash" do
+        it 'merges in the new hash' do
           expect(hash).to eq({
-            "$all" => [ 1, 2, 3 ],
-            "$in" => [ 1, 2 ]
-          })
+                               '$all' => [ 1, 2, 3 ],
+                               '$in' => [ 1, 2 ]
+                             })
         end
       end
     end
   end
 
-  describe "#__expand_complex" do
-
+  describe '#__expand_complex' do
     let(:hash) do
       {
         :test1.elem_match => {
           :test2.elem_match => {
-            :test3.in => ["value1"]
+            :test3.in => [ 'value1' ]
           }
         }
       }
     end
 
-    context "when the hash is nested multiple levels" do
-
+    context 'when the hash is nested multiple levels' do
       let(:expanded) do
         hash.__expand_complex__
       end
 
       let(:expected) do
         {
-          "test1"=> {
-            "$elemMatch"=> {
-              "test2"=> {
-                "$elemMatch"=> {
-                  "test3"=> { "$in"=> ["value1"] }
+          'test1' => {
+            '$elemMatch' => {
+              'test2' => {
+                '$elemMatch' => {
+                  'test3' => { '$in' => [ 'value1' ] }
                 }
               }
             }
@@ -133,181 +118,161 @@ describe Hash do
         }
       end
 
-      it "expands the nested values" do
+      it 'expands the nested values' do
         expect(expanded).to eq(expected)
       end
     end
   end
 
-  describe "#__intersect__" do
-
-    context "when the other object is a hash" do
-
-      context "when a key matches" do
-
-        context "when the existing value is a non-enumerable" do
-
-          context "when the intersected value is non-enumerable" do
-
-            context "when the values intersect" do
-
+  describe '#__intersect__' do
+    context 'when the other object is a hash' do
+      context 'when a key matches' do
+        context 'when the existing value is a non-enumerable' do
+          context 'when the intersected value is non-enumerable' do
+            context 'when the values intersect' do
               let(:hash) do
-                { "$in" => 5 }
+                { '$in' => 5 }
               end
 
               before do
-                hash.__intersect__({ "$in" => 5 })
+                hash.__intersect__({ '$in' => 5 })
               end
 
-              it "sets the intersected array" do
-                expect(hash).to eq({ "$in" => [ 5 ] })
+              it 'sets the intersected array' do
+                expect(hash).to eq({ '$in' => [ 5 ] })
               end
             end
 
-            context "when the values do not intersect" do
-
+            context 'when the values do not intersect' do
               let(:hash) do
-                { "$in" => 5 }
+                { '$in' => 5 }
               end
 
               before do
-                hash.__intersect__({ "$in" => 6 })
+                hash.__intersect__({ '$in' => 6 })
               end
 
-              it "sets the empty array" do
-                expect(hash).to eq({ "$in" => [] })
+              it 'sets the empty array' do
+                expect(hash).to eq({ '$in' => [] })
               end
             end
           end
         end
 
-        context "when the existing value is an array" do
-
-          context "when the values intersect" do
-
+        context 'when the existing value is an array' do
+          context 'when the values intersect' do
             let(:hash) do
-              { "$in" => [ 5, 6 ] }
+              { '$in' => [ 5, 6 ] }
             end
 
             before do
-              hash.__intersect__({ "$in" => [ 6, 7 ] })
+              hash.__intersect__({ '$in' => [ 6, 7 ] })
             end
 
-            it "sets the intersected array" do
-              expect(hash).to eq({ "$in" => [ 6 ] })
+            it 'sets the intersected array' do
+              expect(hash).to eq({ '$in' => [ 6 ] })
             end
           end
 
-          context "when the values do not intersect" do
-
+          context 'when the values do not intersect' do
             let(:hash) do
-              { "$in" => [ 5, 6 ] }
+              { '$in' => [ 5, 6 ] }
             end
 
             before do
-              hash.__intersect__({ "$in" => [ 7, 8 ] })
+              hash.__intersect__({ '$in' => [ 7, 8 ] })
             end
 
-            it "sets the empty array" do
-              expect(hash).to eq({ "$in" => [] })
+            it 'sets the empty array' do
+              expect(hash).to eq({ '$in' => [] })
             end
           end
         end
       end
 
-      context "when a key does not match" do
-
+      context 'when a key does not match' do
         let(:hash) do
-          { "$all" => [ 1, 2, 3 ] }
+          { '$all' => [ 1, 2, 3 ] }
         end
 
         before do
-          hash.__intersect__({ "$in" => [ 1, 2 ] })
+          hash.__intersect__({ '$in' => [ 1, 2 ] })
         end
 
-        it "merges in the new hash" do
+        it 'merges in the new hash' do
           expect(hash).to eq({
-            "$all" => [ 1, 2, 3 ],
-            "$in" => [ 1, 2 ]
-          })
+                               '$all' => [ 1, 2, 3 ],
+                               '$in' => [ 1, 2 ]
+                             })
         end
       end
     end
   end
 
-  describe "#__union__" do
-
-    context "when the other object is a hash" do
-
-      context "when a key matches" do
-
-        context "when the existing value is a non-enumerable" do
-
-          context "when the unioned value is non-enumerable" do
-
-            context "when the values are the same" do
-
+  describe '#__union__' do
+    context 'when the other object is a hash' do
+      context 'when a key matches' do
+        context 'when the existing value is a non-enumerable' do
+          context 'when the unioned value is non-enumerable' do
+            context 'when the values are the same' do
               let(:hash) do
-                { "$in" => 5 }
+                { '$in' => 5 }
               end
 
               before do
-                hash.__union__({ "$in" => 5 })
+                hash.__union__({ '$in' => 5 })
               end
 
-              it "sets the unioned array" do
-                expect(hash).to eq({ "$in" => [ 5 ] })
+              it 'sets the unioned array' do
+                expect(hash).to eq({ '$in' => [ 5 ] })
               end
             end
 
-            context "when the values are different" do
-
+            context 'when the values are different' do
               let(:hash) do
-                { "$in" => 5 }
+                { '$in' => 5 }
               end
 
               before do
-                hash.__union__({ "$in" => 6 })
+                hash.__union__({ '$in' => 6 })
               end
 
-              it "sets the empty array" do
-                expect(hash).to eq({ "$in" => [ 5, 6 ] })
+              it 'sets the empty array' do
+                expect(hash).to eq({ '$in' => [ 5, 6 ] })
               end
             end
           end
         end
 
-        context "when the existing value is an array" do
-
+        context 'when the existing value is an array' do
           let(:hash) do
-            { "$in" => [ 5, 6 ] }
+            { '$in' => [ 5, 6 ] }
           end
 
           before do
-            hash.__union__({ "$in" => [ 6, 7 ] })
+            hash.__union__({ '$in' => [ 6, 7 ] })
           end
 
-          it "sets the unioned array" do
-            expect(hash).to eq({ "$in" => [ 5, 6, 7 ] })
+          it 'sets the unioned array' do
+            expect(hash).to eq({ '$in' => [ 5, 6, 7 ] })
           end
         end
       end
 
-      context "when a key does not match" do
-
+      context 'when a key does not match' do
         let(:hash) do
-          { "$all" => [ 1, 2, 3 ] }
+          { '$all' => [ 1, 2, 3 ] }
         end
 
         before do
-          hash.__union__({ "$in" => [ 1, 2 ] })
+          hash.__union__({ '$in' => [ 1, 2 ] })
         end
 
-        it "merges in the new hash" do
+        it 'merges in the new hash' do
           expect(hash).to eq({
-            "$all" => [ 1, 2, 3 ],
-            "$in" => [ 1, 2 ]
-          })
+                               '$all' => [ 1, 2, 3 ],
+                               '$in' => [ 1, 2 ]
+                             })
         end
       end
     end

data/spec/mongoid/criteria/queryable/extensions/integer_spec.rb

@@ -1,68 +1,129 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Integer do
-
-  describe ".evolve" do
-
-    context "when provided a string" do
-
-      context "when the string is a number" do
-
-        context "when the string is an integer" do
-
-          it "returns an integer" do
-            expect(described_class.evolve("1")).to eq(1)
+  describe '.evolve' do
+    context 'when provided a string' do
+      context 'when the string is a number' do
+        context 'when the string is an integer' do
+          it 'returns an integer' do
+            expect(described_class.evolve('1')).to eq(1)
           end
         end
 
-        context "when the string is a float" do
-
-          it "converts it to a float" do
-            expect(described_class.evolve("2.23")).to eq(2.23)
+        context 'when the string is a float' do
+          it 'converts it to a float' do
+            expect(described_class.evolve('2.23')).to eq(2.23)
           end
         end
 
-        context "when the string ends in ." do
-
-          it "returns an integer" do
-            expect(described_class.evolve("2.")).to eq(2)
+        context 'when the string ends in .' do
+          it 'returns an integer' do
+            expect(described_class.evolve('2.')).to eq(2)
           end
         end
       end
 
-      context "when the string is not a number" do
+      context 'when the string is not a number' do
+        it 'returns the string' do
+          expect(described_class.evolve('testing')).to eq('testing')
+        end
+      end
+    end
+
+    context 'when provided a number' do
+      context 'when the number is an integer' do
+        it 'returns an integer' do
+          expect(described_class.evolve(1)).to eq(1)
+        end
+      end
 
-        it "returns the string" do
-          expect(described_class.evolve("testing")).to eq("testing")
+      context 'when the number is a float' do
+        it 'returns the float' do
+          expect(described_class.evolve(2.23)).to eq(2.23)
         end
       end
     end
+
+    context 'when provided nil' do
+      it 'returns nil' do
+        expect(described_class.evolve(nil)).to be_nil
+      end
+    end
   end
 
-  context "when provided a number" do
+  describe '#__evolve_time__' do
+    context 'UTC time zone' do
+      let(:time) do
+        Time.parse('2022-01-01 16:15:01 UTC')
+      end
 
-    context "when the number is an integer" do
+      let(:evolved) do
+        time.to_i.__evolve_time__
+      end
 
-      it "returns an integer" do
-        expect(described_class.evolve(1)).to eq(1)
+      it 'evolves the correct time' do
+        expect(evolved).to eq(time)
       end
     end
 
-    context "when the number is a float" do
+    context 'other time zone' do
+      let(:time) do
+        Time.parse('2022-01-01 16:15:01 +0900')
+      end
 
-      it "returns the float" do
-        expect(described_class.evolve(2.23)).to eq(2.23)
+      let(:evolved) do
+        time.to_i.__evolve_time__
+      end
+
+      it 'evolves the correct time' do
+        expect(evolved).to eq(time)
       end
     end
   end
 
-  context "when provided nil" do
+  describe '#__evolve_date__' do
+    context 'exact match' do
+      let(:date) do
+        Date.parse('2022-01-01')
+      end
+
+      let(:evolved) do
+        Time.parse('2022-01-01 0:00 UTC').to_i.__evolve_date__
+      end
+
+      it 'evolves the correct time' do
+        expect(evolved).to eq(date)
+      end
+    end
 
-    it "returns nil" do
-      expect(described_class.evolve(nil)).to be_nil
+    context 'one second earlier' do
+      let(:date) do
+        Date.parse('2021-12-31')
+      end
+
+      let(:evolved) do
+        (Time.parse('2022-01-01 0:00 UTC').to_i - 1).__evolve_date__
+      end
+
+      it 'evolves the correct time' do
+        expect(evolved).to eq(date)
+      end
+    end
+
+    context 'one second later' do
+      let(:date) do
+        Date.parse('2022-01-01')
+      end
+
+      let(:evolved) do
+        (Time.parse('2022-01-01 0:00 UTC').to_i + 1).__evolve_date__
+      end
+
+      it 'evolves the correct time' do
+        expect(evolved).to eq(date)
+      end
     end
   end
 end