mongoid 9.0.11 → 9.1.1

data/spec/integration/criteria/raw_value_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'spec_helper'
 
@@ -11,207 +10,220 @@ describe 'Queries with Mongoid::RawValue criteria' do
     [ Label.new(age: 12), Label.new(age: 16) ]
   end
 
-  let!(:band1) { Band.create!(name: '1', likes: 0, rating: 0.9, sales: BigDecimal('90'), decibels: 20..80, founded: today, updated: now_utc) }
-  let!(:band2) { Band.create!(name: '2', likes: 1, rating: 1.0, sales: BigDecimal('100'), decibels: 30..90, founded: today, updated: now_utc + 1.days) }
-  let!(:band3) { Band.create!(name: '3', likes: 1, rating: 2.2, sales: BigDecimal('220'), decibels: 40..100, founded: today + 1.days, updated: now_utc + 2.days) }
-  let!(:band4) { Band.create!(name: '3', likes: 2, rating: 3.1, sales: BigDecimal('310'), decibels: 50..120, founded: today + 1.days, updated: now_utc + 3.days) }
-  let!(:band5) { Band.create!(name: '4', likes: 3, rating: 3.1, sales: BigDecimal('310'), decibels: 60..150, founded: today + 2.days, updated: now_utc + 3.days, labels: labels) }
+  let!(:band1) do
+    Band.create!(name: '1', likes: 0, rating: 0.9, sales: BigDecimal('90'), decibels: 20..80, founded: today,
+                 updated: now_utc)
+  end
+  let!(:band2) do
+    Band.create!(name: '2', likes: 1, rating: 1.0, sales: BigDecimal('100'), decibels: 30..90, founded: today,
+                 updated: now_utc + 1.days)
+  end
+  let!(:band3) do
+    Band.create!(name: '3', likes: 1, rating: 2.2, sales: BigDecimal('220'), decibels: 40..100, founded: today + 1.days,
+                 updated: now_utc + 2.days)
+  end
+  let!(:band4) do
+    Band.create!(name: '3', likes: 2, rating: 3.1, sales: BigDecimal('310'), decibels: 50..120, founded: today + 1.days,
+                 updated: now_utc + 3.days)
+  end
+  let!(:band5) do
+    Band.create!(name: '4', likes: 3, rating: 3.1, sales: BigDecimal('310'), decibels: 60..150, founded: today + 2.days,
+                 updated: now_utc + 3.days, labels: labels)
+  end
 
   let!(:band6) do
     id = BSON::ObjectId.new
-    Band.collection.insert_one(_id: id, name: 1, likes: '1', rating: '3.1', sales: '310', decibels: '90', founded: '2020-01-02', updated: '2020-01-04 16:00:00 UTC')
+    Band.collection.insert_one(_id: id, name: 1, likes: '1', rating: '3.1', sales: '310', decibels: '90',
+                               founded: '2020-01-02', updated: '2020-01-04 16:00:00 UTC')
     Band.find(id)
   end
 
   let!(:band7) do
     id = BSON::ObjectId.new
-    Band.collection.insert_one(_id: id, name: 1.0, decibels: 90.0, founded: 1577923200, updated: 1578153600)
+    Band.collection.insert_one(_id: id, name: 1.0, decibels: 90.0, founded: 1_577_923_200, updated: 1_578_153_600)
     Band.find(id)
   end
 
   context 'Mongoid::RawValue<String> criteria' do
-
     context 'Integer field' do
       it 'does not match objects' do
-        expect(Band.where(likes: Mongoid::RawValue('1')).to_a).to eq [band6]
+        expect(Band.where(likes: Mongoid::RawValue('1')).to_a).to eq [ band6 ]
       end
-  
+
       it 'matches objects without raw value' do
-        expect(Band.where(likes: '1').to_a).to eq [band2, band3]
+        expect(Band.where(likes: '1').to_a).to eq [ band2, band3 ]
       end
     end
-  
+
     context 'Float field' do
       it 'does not match objects' do
-        expect(Band.where(rating: Mongoid::RawValue('3.1')).to_a).to eq [band6]
+        expect(Band.where(rating: Mongoid::RawValue('3.1')).to_a).to eq [ band6 ]
       end
-  
+
       it 'matches objects with value stored as Float' do
-        expect(Band.where(rating: '3.1').to_a).to eq [band4, band5]
+        expect(Band.where(rating: '3.1').to_a).to eq [ band4, band5 ]
       end
     end
 
     context 'BigDecimal field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(sales: Mongoid::RawValue('310')).to_a).to eq [band6]
+        expect(Band.where(sales: Mongoid::RawValue('310')).to_a).to eq [ band6 ]
       end
 
       it 'matches objects with value stored as Decimal128' do
-        expect(Band.where(sales: '310').to_a).to eq [band4, band5]
+        expect(Band.where(sales: '310').to_a).to eq [ band4, band5 ]
       end
     end
-  
+
     context 'String field' do
       it 'matches objects' do
-        expect(Band.where(name: Mongoid::RawValue('3')).to_a).to eq [band3, band4]
+        expect(Band.where(name: Mongoid::RawValue('3')).to_a).to eq [ band3, band4 ]
       end
-  
+
       it 'matches objects without raw value' do
-        expect(Band.where(name: '3').to_a).to eq [band3, band4]
+        expect(Band.where(name: '3').to_a).to eq [ band3, band4 ]
       end
     end
-  
+
     context 'Range field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(decibels: Mongoid::RawValue('90')).to_a).to eq [band6]
+        expect(Band.where(decibels: Mongoid::RawValue('90')).to_a).to eq [ band6 ]
       end
-  
+
       it 'matches objects without raw value because String cannot be evolved to Range' do
-        expect(Band.where(decibels: '90').to_a).to eq [band6]
+        expect(Band.where(decibels: '90').to_a).to eq [ band6 ]
       end
     end
 
     context 'Date field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(founded: Mongoid::RawValue('2020-01-02')).to_a).to eq [band6]
+        expect(Band.where(founded: Mongoid::RawValue('2020-01-02')).to_a).to eq [ band6 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(founded: '2020-01-02').to_a).to eq [band3, band4]
+        expect(Band.where(founded: '2020-01-02').to_a).to eq [ band3, band4 ]
       end
     end
 
     context 'Time field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(updated: Mongoid::RawValue('2020-01-04 16:00:00 UTC')).to_a).to eq [band6]
+        expect(Band.where(updated: Mongoid::RawValue('2020-01-04 16:00:00 UTC')).to_a).to eq [ band6 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(updated: '2020-01-04 16:00:00 UTC').to_a).to eq [band4, band5]
+        expect(Band.where(updated: '2020-01-04 16:00:00 UTC').to_a).to eq [ band4, band5 ]
       end
     end
   end
 
   context 'Mongoid::RawValue<Integer>' do
-
     context 'Integer field' do
       it 'matches objects with raw value' do
-        expect(Band.where(likes: Mongoid::RawValue(1)).to_a).to eq [band2, band3]
+        expect(Band.where(likes: Mongoid::RawValue(1)).to_a).to eq [ band2, band3 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(likes: 1).to_a).to eq [band2, band3]
+        expect(Band.where(likes: 1).to_a).to eq [ band2, band3 ]
       end
     end
 
     context 'Float field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(rating: Mongoid::RawValue(1)).to_a).to eq [band2]
+        expect(Band.where(rating: Mongoid::RawValue(1)).to_a).to eq [ band2 ]
         expect(Band.where(rating: Mongoid::RawValue(3)).to_a).to eq []
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(rating: 1).to_a).to eq [band2]
+        expect(Band.where(rating: 1).to_a).to eq [ band2 ]
         expect(Band.where(rating: 3).to_a).to eq []
       end
     end
 
     context 'BigDecimal field' do
       it 'matches objects with raw value' do
-        expect(Band.where(sales: Mongoid::RawValue(310)).to_a).to eq [band4, band5]
+        expect(Band.where(sales: Mongoid::RawValue(310)).to_a).to eq [ band4, band5 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(sales: 310).to_a).to eq [band4, band5]
+        expect(Band.where(sales: 310).to_a).to eq [ band4, band5 ]
       end
     end
 
     context 'String field' do
       it 'matches objects with raw value' do
-        expect(Band.where(name: Mongoid::RawValue(1)).to_a).to eq [band6, band7]
+        expect(Band.where(name: Mongoid::RawValue(1)).to_a).to eq [ band6, band7 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(name: 3).to_a).to eq [band3, band4]
+        expect(Band.where(name: 3).to_a).to eq [ band3, band4 ]
       end
     end
 
     context 'Range field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(decibels: Mongoid::RawValue(90)).to_a).to eq [band7]
+        expect(Band.where(decibels: Mongoid::RawValue(90)).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value because Integer cannot be evolved to Range' do
-        expect(Band.where(decibels: 90).to_a).to eq [band7]
+        expect(Band.where(decibels: 90).to_a).to eq [ band7 ]
       end
     end
 
     context 'Date field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(founded: Mongoid::RawValue(1577923200)).to_a).to eq [band7]
+        expect(Band.where(founded: Mongoid::RawValue(1_577_923_200)).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(founded: 1577923200).to_a).to eq [band3, band4]
+        expect(Band.where(founded: 1_577_923_200).to_a).to eq [ band3, band4 ]
       end
     end
 
     context 'Time field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(updated: Mongoid::RawValue(1578153600)).to_a).to eq [band7]
+        expect(Band.where(updated: Mongoid::RawValue(1_578_153_600)).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(updated: 1578153600).to_a).to eq [band4, band5]
+        expect(Band.where(updated: 1_578_153_600).to_a).to eq [ band4, band5 ]
       end
     end
   end
 
   context 'Mongoid::RawValue<Float>' do
-
     context 'Integer field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(likes: Mongoid::RawValue(1.0)).to_a).to eq [band2, band3]
+        expect(Band.where(likes: Mongoid::RawValue(1.0)).to_a).to eq [ band2, band3 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(likes: 1.0).to_a).to eq [band2, band3]
+        expect(Band.where(likes: 1.0).to_a).to eq [ band2, band3 ]
       end
     end
 
     context 'Float field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(rating: Mongoid::RawValue(3.1)).to_a).to eq [band4, band5]
+        expect(Band.where(rating: Mongoid::RawValue(3.1)).to_a).to eq [ band4, band5 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(rating: 3.1).to_a).to eq [band4, band5]
+        expect(Band.where(rating: 3.1).to_a).to eq [ band4, band5 ]
       end
     end
 
     context 'BigDecimal field' do
       it 'matches objects with raw value' do
-        expect(Band.where(sales: Mongoid::RawValue(310.0)).to_a).to eq [band4, band5]
+        expect(Band.where(sales: Mongoid::RawValue(310.0)).to_a).to eq [ band4, band5 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(sales: 310.0).to_a).to eq [band4, band5]
+        expect(Band.where(sales: 310.0).to_a).to eq [ band4, band5 ]
       end
     end
 
     context 'String field' do
       it 'matches objects with raw value' do
-        expect(Band.where(name: Mongoid::RawValue(1.0)).to_a).to eq [band6, band7]
+        expect(Band.where(name: Mongoid::RawValue(1.0)).to_a).to eq [ band6, band7 ]
       end
 
       it 'matches objects without raw value' do
@@ -221,44 +233,43 @@ describe 'Queries with Mongoid::RawValue criteria' do
 
     context 'Range field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(decibels: Mongoid::RawValue(90.0)).to_a).to eq [band7]
+        expect(Band.where(decibels: Mongoid::RawValue(90.0)).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value because Float cannot be evolved to Range' do
-        expect(Band.where(decibels: 90.0).to_a).to eq [band7]
+        expect(Band.where(decibels: 90.0).to_a).to eq [ band7 ]
       end
     end
 
     context 'Date field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(founded: Mongoid::RawValue(1577923200.0)).to_a).to eq [band7]
+        expect(Band.where(founded: Mongoid::RawValue(1_577_923_200.0)).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(founded: 1577923200.0).to_a).to eq [band3, band4]
+        expect(Band.where(founded: 1_577_923_200.0).to_a).to eq [ band3, band4 ]
       end
     end
 
     context 'Time field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(updated: Mongoid::RawValue(1578153600.0)).to_a).to eq [band7]
+        expect(Band.where(updated: Mongoid::RawValue(1_578_153_600.0)).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(updated: 1578153600.0).to_a).to eq [band4, band5]
+        expect(Band.where(updated: 1_578_153_600.0).to_a).to eq [ band4, band5 ]
       end
     end
   end
 
   context 'Mongoid::RawValue<BigDecimal>' do
-
     context 'Integer field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(likes: Mongoid::RawValue(BigDecimal('1'))).to_a).to eq [band2, band3]
+        expect(Band.where(likes: Mongoid::RawValue(BigDecimal('1'))).to_a).to eq [ band2, band3 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(likes: BigDecimal('1')).to_a).to eq [band2, band3]
+        expect(Band.where(likes: BigDecimal('1')).to_a).to eq [ band2, band3 ]
       end
     end
 
@@ -268,27 +279,29 @@ describe 'Queries with Mongoid::RawValue criteria' do
       end
 
       it 'fuzzy matches objects with raw value' do
-        expect(Band.gte(rating: Mongoid::RawValue(BigDecimal('3.099'))).lte(rating: Mongoid::RawValue(BigDecimal('3.101'))).to_a).to eq [band4, band5]
+        expect(Band.gte(rating: Mongoid::RawValue(BigDecimal('3.099'))).lte(rating: Mongoid::RawValue(BigDecimal('3.101'))).to_a).to eq [
+          band4, band5
+        ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(rating: BigDecimal('3.1')).to_a).to eq [band4, band5]
+        expect(Band.where(rating: BigDecimal('3.1')).to_a).to eq [ band4, band5 ]
       end
     end
 
     context 'BigDecimal field' do
       it 'matches objects with raw value' do
-        expect(Band.where(sales: Mongoid::RawValue(BigDecimal('310'))).to_a).to eq [band4, band5]
+        expect(Band.where(sales: Mongoid::RawValue(BigDecimal('310'))).to_a).to eq [ band4, band5 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(sales: BigDecimal('310')).to_a).to eq [band4, band5]
+        expect(Band.where(sales: BigDecimal('310')).to_a).to eq [ band4, band5 ]
       end
     end
 
     context 'String field' do
       it 'matches objects with raw value' do
-        expect(Band.where(name: Mongoid::RawValue(BigDecimal('1'))).to_a).to eq [band6, band7]
+        expect(Band.where(name: Mongoid::RawValue(BigDecimal('1'))).to_a).to eq [ band6, band7 ]
       end
 
       it 'does not match objects without raw value' do
@@ -298,44 +311,43 @@ describe 'Queries with Mongoid::RawValue criteria' do
 
     context 'Range field' do
       it 'matches objects with raw value' do
-        expect(Band.where(decibels: Mongoid::RawValue(BigDecimal('90'))).to_a).to eq [band7]
+        expect(Band.where(decibels: Mongoid::RawValue(BigDecimal('90'))).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value because BigDecimal cannot be evolved to Range' do
-        expect(Band.where(decibels: BigDecimal('90')).to_a).to eq [band7]
+        expect(Band.where(decibels: BigDecimal('90')).to_a).to eq [ band7 ]
       end
     end
 
     context 'Date field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(founded: Mongoid::RawValue(BigDecimal('1577923200'))).to_a).to eq [band7]
+        expect(Band.where(founded: Mongoid::RawValue(BigDecimal('1577923200'))).to_a).to eq [ band7 ]
       end
 
-      it 'matches objects without raw value because BigDecimal cannot be evolved to Date' do
-        expect(Band.where(founded: BigDecimal('1577923200')).to_a).to eq [band7]
+      it 'matches objects without raw value' do
+        expect(Band.where(founded: BigDecimal('1577923200')).to_a).to eq [ band3, band4 ]
       end
     end
 
     context 'Time field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(updated: Mongoid::RawValue(BigDecimal('1578153600'))).to_a).to eq [band7]
+        expect(Band.where(updated: Mongoid::RawValue(BigDecimal('1578153600'))).to_a).to eq [ band7 ]
       end
 
-      it 'matches objects without raw value because BigDecimal cannot be evolved to Time' do
-        expect(Band.where(updated: BigDecimal('1578153600')).to_a).to eq [band7]
+      it 'matches objects without raw value' do
+        expect(Band.where(updated: BigDecimal('1578153600')).to_a).to eq [ band4, band5 ]
       end
     end
   end
 
   context 'Mongoid::RawValue<Range>' do
-
     context 'Integer field' do
       it 'raises a BSON error with raw value' do
         expect { Band.where(likes: Mongoid::RawValue(0..2)).to_a }.to raise_error BSON::Error::UnserializableClass
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(likes: 0..2).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(likes: 0..2).to_a).to eq [ band1, band2, band3, band4 ]
       end
     end
 
@@ -345,7 +357,7 @@ describe 'Queries with Mongoid::RawValue criteria' do
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(rating: 1..3).to_a).to eq [band2, band3]
+        expect(Band.where(rating: 1..3).to_a).to eq [ band2, band3 ]
       end
     end
 
@@ -355,7 +367,7 @@ describe 'Queries with Mongoid::RawValue criteria' do
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(sales: 100..300).to_a).to eq [band2, band3]
+        expect(Band.where(sales: 100..300).to_a).to eq [ band2, band3 ]
       end
     end
 
@@ -365,7 +377,7 @@ describe 'Queries with Mongoid::RawValue criteria' do
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(name: 1..3).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(name: 1..3).to_a).to eq [ band1, band2, band3, band4 ]
       end
     end
 
@@ -375,28 +387,28 @@ describe 'Queries with Mongoid::RawValue criteria' do
       end
 
       it 'matches objects without raw value because Range is evolved into a gte/lte query range' do
-        expect(Band.where(decibels: 30..90).to_a).to eq [band7]
-        expect(Band.where(decibels: 20..100).to_a).to eq [band7]
+        expect(Band.where(decibels: 30..90).to_a).to eq [ band7 ]
+        expect(Band.where(decibels: 20..100).to_a).to eq [ band7 ]
       end
     end
 
     context 'Date field' do
       it 'raises a BSON error with raw value' do
-        expect { Band.where(founded: Mongoid::RawValue(1577923199..1577923201)).to_a }.to raise_error BSON::Error::UnserializableClass
+        expect { Band.where(founded: Mongoid::RawValue(1_577_923_199..1_577_923_201)).to_a }.to raise_error BSON::Error::UnserializableClass
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(founded: 1577923199..1577923201).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(founded: 1_577_923_199..1_577_923_201).to_a).to eq [ band1, band2, band3, band4 ]
       end
     end
 
     context 'Time field' do
       it 'raises a BSON error with raw value' do
-        expect { Band.where(founded: Mongoid::RawValue(1578153599..1578153600)).to_a }.to raise_error BSON::Error::UnserializableClass
+        expect { Band.where(founded: Mongoid::RawValue(1_578_153_599..1_578_153_600)).to_a }.to raise_error BSON::Error::UnserializableClass
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(updated: 1578153599..1578153600).to_a).to eq [band4, band5]
+        expect(Band.where(updated: 1_578_153_599..1_578_153_600).to_a).to eq [ band4, band5 ]
       end
     end
   end
@@ -404,43 +416,44 @@ describe 'Queries with Mongoid::RawValue criteria' do
   context 'Mongoid::RawValue<Time>' do
     let!(:band7) do
       id = BSON::ObjectId.new
-      Band.collection.insert_one(_id: id, name: Time.at(1), likes: Time.at(1), rating: Time.at(3.1), sales: Time.at(310), decibels: Time.at(90))
+      Band.collection.insert_one(_id: id, name: Time.at(1), likes: Time.at(1), rating: Time.at(3.1),
+                                 sales: Time.at(310), decibels: Time.at(90))
       Band.find(id)
     end
 
     context 'Integer field' do
       it 'does not match objects with raw value' do
-        expect(Band.where(likes: Mongoid::RawValue(Time.at(1))).to_a).to eq [band7]
+        expect(Band.where(likes: Mongoid::RawValue(Time.at(1))).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(likes: Time.at(1)).to_a).to eq [band2, band3]
+        expect(Band.where(likes: Time.at(1)).to_a).to eq [ band2, band3 ]
       end
     end
 
     context 'Float field' do
       it 'matches objects with raw value' do
-        expect(Band.where(rating: Mongoid::RawValue(Time.at(3.1))).to_a).to eq [band7]
+        expect(Band.where(rating: Mongoid::RawValue(Time.at(3.1))).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(rating: Time.at(3.1)).to_a).to eq [band4, band5]
+        expect(Band.where(rating: Time.at(3.1)).to_a).to eq [ band4, band5 ]
       end
     end
 
     context 'BigDecimal field' do
       it 'matches objects with raw value' do
-        expect(Band.where(sales: Mongoid::RawValue(Time.at(310))).to_a).to eq [band7]
+        expect(Band.where(sales: Mongoid::RawValue(Time.at(310))).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value because Time does not evolve into BigDecimal' do
-        expect(Band.where(sales: Time.at(310)).to_a).to eq [band7]
+        expect(Band.where(sales: Time.at(310)).to_a).to eq [ band7 ]
       end
     end
 
     context 'String field' do
       it 'matches objects with raw value' do
-        expect(Band.where(name: Mongoid::RawValue(Time.at(1))).to_a).to eq [band7]
+        expect(Band.where(name: Mongoid::RawValue(Time.at(1))).to_a).to eq [ band7 ]
       end
 
       it 'does not match objects without raw value' do
@@ -450,74 +463,74 @@ describe 'Queries with Mongoid::RawValue criteria' do
 
     context 'Range field' do
       it 'matches objects with raw value' do
-        expect(Band.where(decibels: Mongoid::RawValue(Time.at(90))).to_a).to eq [band7]
+        expect(Band.where(decibels: Mongoid::RawValue(Time.at(90))).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value because BigDecimal cannot be evolved to Range' do
-        expect(Band.where(decibels: Time.at(90)).to_a).to eq [band7]
+        expect(Band.where(decibels: Time.at(90)).to_a).to eq [ band7 ]
       end
     end
 
     context 'Date field' do
       it 'matches objects with raw value when exact' do
-        expect(Band.where(founded: Mongoid::RawValue(Time.at(1577923200))).to_a).to eq [band3, band4]
+        expect(Band.where(founded: Mongoid::RawValue(Time.at(1_577_923_200))).to_a).to eq [ band3, band4 ]
       end
 
       it 'does not match objects with raw value when non-exact' do
-        expect(Band.where(founded: Mongoid::RawValue(Time.at(1577923199))).to_a).to eq []
+        expect(Band.where(founded: Mongoid::RawValue(Time.at(1_577_923_199))).to_a).to eq []
       end
 
       it 'matches objects without raw value when exact' do
-        expect(Band.where(founded: Time.at(1577923200).utc).to_a).to eq [band3, band4]
+        expect(Band.where(founded: Time.at(1_577_923_200).utc).to_a).to eq [ band3, band4 ]
       end
 
       it 'matches objects without raw value when 1 second before midnight' do
-        expect(Band.where(founded: Time.at(1577923199).utc).to_a).to eq [band1, band2]
+        expect(Band.where(founded: Time.at(1_577_923_199).utc).to_a).to eq [ band1, band2 ]
       end
 
       it 'matches objects without raw value when 1 second after midnight' do
-        expect(Band.where(founded: Time.at(1577923201).utc).to_a).to eq [band3, band4]
+        expect(Band.where(founded: Time.at(1_577_923_201).utc).to_a).to eq [ band3, band4 ]
       end
     end
 
     context 'Time field' do
       it 'matches objects with raw value' do
-        expect(Band.where(updated: Mongoid::RawValue(Time.at(1578153600))).to_a).to eq [band4, band5]
+        expect(Band.where(updated: Mongoid::RawValue(Time.at(1_578_153_600))).to_a).to eq [ band4, band5 ]
       end
 
       it 'matches objects without raw value' do
-        expect(Band.where(updated: Time.at(1578153600)).to_a).to eq [band4, band5]
+        expect(Band.where(updated: Time.at(1_578_153_600)).to_a).to eq [ band4, band5 ]
       end
     end
   end
 
   context 'Mongoid::RawValue<Date>' do
-    let!(:band7) { Band.create!(updated: Time.at(1577923200)) }
+    let!(:band7) { Band.create!(updated: Time.at(1_577_923_200)) }
 
     context 'Date field' do
       it 'matches objects with raw value' do
-        expect(Band.where(founded: Mongoid::RawValue(Time.at(1577923200).utc.to_date)).to_a).to eq [band3, band4]
+        expect(Band.where(founded: Mongoid::RawValue(Time.at(1_577_923_200).utc.to_date)).to_a).to eq [ band3, band4 ]
       end
 
       it 'matches objects without raw value when non-exact' do
-        expect(Band.where(founded: Time.at(1577923200).utc.to_date).to_a).to eq [band3, band4]
+        expect(Band.where(founded: Time.at(1_577_923_200).utc.to_date).to_a).to eq [ band3, band4 ]
       end
     end
 
     context 'Time field' do
       it 'matches objects with raw value' do
-        expect(Band.where(updated: Mongoid::RawValue(Time.at(1577923200).utc.to_date)).to_a).to eq [band7]
+        expect(Band.where(updated: Mongoid::RawValue(Time.at(1_577_923_200).utc.to_date)).to_a).to eq [ band7 ]
       end
 
       it 'matches objects without raw value' do
         Time.use_zone('UTC') do
-          expect(Band.where(updated: Time.at(1577923200).utc.to_date).to_a).to eq [band7]
+          expect(Band.where(updated: Time.at(1_577_923_200).utc.to_date).to_a).to eq [ band7 ]
         end
       end
 
       it 'does not matches objects without raw value when in other timezone' do
         Time.use_zone('Asia/Tokyo') do
-          expect(Band.where(updated: Time.at(1577923200).utc.to_date).to_a).to eq []
+          expect(Band.where(updated: Time.at(1_577_923_200).utc.to_date).to_a).to eq []
         end
       end
     end