mongoid 9.0.11 → 9.1.0

data/spec/integration/criteria/default_scope_spec.rb

@@ -1,8 +1,6 @@
-# rubocop:todo all
 require 'spec_helper'
 
 describe 'Criteria and default scope' do
-
   context 'order in query' do
     let(:query) do
       Acolyte.order(status: :desc)
@@ -13,42 +11,45 @@ describe 'Criteria and default scope' do
     end
 
     it 'is added after order of default scope' do
-      sort_options.should == {'status' => -1, 'name' => 1}
+      sort_options.should eq({ 'status' => -1, 'name' => 1 })
 
       # Keys in Ruby are ordered
-      sort_options.keys.should == %w(name status)
+      sort_options.keys.should eq %w[name status]
     end
   end
 
   context 'default scope + logical operator' do
-
     context 'logical operator applied to a criteria' do
       let(:base) { Appointment.where }
 
       it 'has default scope' do
-        base.selector.should == {'active' => true}
+        base.selector.should eq({ 'active' => true })
       end
 
-      context '.or' do
+      describe '.or' do
         let(:criteria) do
           base.or(timed: true)
         end
 
         it 'adds new condition in parallel to default scope conditions' do
-          criteria.selector.should == {'$or' => [
-            {'active' => true},
-            {'timed' => true},
-          ]}
+          criteria.selector.should eq(
+            {
+              '$or' => [
+                { 'active' => true },
+                { 'timed' => true }
+              ]
+            }
+          )
         end
       end
 
-      context '.any_of' do
+      describe '.any_of' do
         let(:criteria) do
           base.any_of(timed: true)
         end
 
         it 'maintains default scope conditions' do
-          criteria.selector.should == {'active' => true, 'timed' => true}
+          criteria.selector.should eq({ 'active' => true, 'timed' => true })
         end
       end
     end
@@ -56,16 +57,20 @@ describe 'Criteria and default scope' do
     context 'logical operator called on the class' do
       let(:base) { Appointment }
 
-      context '.or' do
+      describe '.or' do
         let(:criteria) do
           base.or(timed: true)
         end
 
         it 'adds new condition in parallel to default scope conditions' do
-          criteria.selector.should == {'$or' => [
-            {'active' => true},
-            {'timed' => true},
-          ]}
+          criteria.selector.should eq(
+            {
+              '$or' => [
+                { 'active' => true },
+                { 'timed' => true }
+              ]
+            }
+          )
         end
       end
     end

data/spec/integration/criteria/logical_spec.rb

@@ -1,39 +1,38 @@
-# rubocop:todo all
 require 'spec_helper'
 
 describe 'Criteria logical operations' do
-  let!(:ap) { Band.create!(name: 'Astral Projection', origin: 'SFX', genres: ['Goa', 'Psy']) }
-  let!(:im) { Band.create!(name: 'Infected Mushroom', origin: 'Computers', genres: ['Psy']) }
-  let!(:sp) { Band.create!(name: 'Sun Project', genres: ['Goa']) }
+  let!(:ap) { Band.create!(name: 'Astral Projection', origin: 'SFX', genres: %w[Goa Psy]) }
+  let!(:im) { Band.create!(name: 'Infected Mushroom', origin: 'Computers', genres: [ 'Psy' ]) }
+  let!(:sp) { Band.create!(name: 'Sun Project', genres: [ 'Goa' ]) }
 
   describe 'and' do
     it 'combines conditions on different fields given as hashes' do
       bands = Band.where(name: /Proj/).and(genres: 'Psy')
-      expect(bands.to_a).to eq([ap])
+      expect(bands.to_a).to eq([ ap ])
     end
 
     it 'combines conditions on different fields given as scopes' do
       bands = Band.where(name: /Proj/).and(Band.where(genres: 'Psy'))
-      expect(bands.to_a).to eq([ap])
+      expect(bands.to_a).to eq([ ap ])
     end
 
     it 'combines conditions on same field given as hashes' do
       bands = Band.where(name: /Proj/).and(name: /u/)
-      expect(bands.to_a).to eq([sp])
+      expect(bands.to_a).to eq([ sp ])
     end
 
     it 'combines conditions on same field given as scopes' do
       bands = Band.where(name: /Proj/).and(Band.where(name: /u/))
-      expect(bands.to_a).to eq([sp])
+      expect(bands.to_a).to eq([ sp ])
     end
 
     it 'combines existing `$and` clause in query and `where` condition' do
-      bands = Band.where(id: 1).and({year: {'$in' => [2020]}}, {year: {'$in' => [2021]}}).where(id: 2)
+      bands = Band.where(id: 1).and({ year: { '$in' => [ 2020 ] } }, { year: { '$in' => [ 2021 ] } }).where(id: 2)
       expect(bands.selector).to eq(
         {
-          "_id"=>1,
-          "year"=>{"$in"=>[2020]},
-          "$and"=>[{"year"=>{"$in"=>[2021]}}, {"_id"=>2}]
+          '_id' => 1,
+          'year' => { '$in' => [ 2020 ] },
+          '$and' => [ { 'year' => { '$in' => [ 2021 ] } }, { '_id' => 2 } ]
         }
       )
     end
@@ -42,22 +41,22 @@ describe 'Criteria logical operations' do
   describe 'or' do
     it 'combines conditions on different fields given as hashes' do
       bands = Band.where(name: /Sun/).or(origin: 'SFX')
-      expect(bands.order_by(name: 1).to_a).to eq([ap, sp])
+      expect(bands.order_by(name: 1).to_a).to eq([ ap, sp ])
     end
 
     it 'combines conditions on different fields given as scopes' do
       bands = Band.where(name: /Sun/).or(Band.where(origin: 'SFX'))
-      expect(bands.order_by(name: 1).to_a).to eq([ap, sp])
+      expect(bands.order_by(name: 1).to_a).to eq([ ap, sp ])
     end
 
     it 'combines conditions on same field given as hashes' do
       bands = Band.where(name: /jecti/).or(name: /ush/)
-      expect(bands.order_by(name: 1).to_a).to eq([ap, im])
+      expect(bands.order_by(name: 1).to_a).to eq([ ap, im ])
     end
 
     it 'combines conditions on same field given as scopes' do
       bands = Band.where(name: /jecti/).or(Band.where(name: /ush/))
-      expect(bands.order_by(name: 1).to_a).to eq([ap, im])
+      expect(bands.order_by(name: 1).to_a).to eq([ ap, im ])
     end
 
     context 'when using a symbol operator' do
@@ -68,7 +67,7 @@ describe 'Criteria logical operations' do
           scope = Dokument.or(:created_at.lte => DateTime.now).sort(id: 1)
           # input was converted from DateTime to Time
           scope.criteria.selector['$or'].first['created_at']['$lte'].should be_a(Time)
-          scope.to_a.should == [doc]
+          scope.to_a.should eq [ doc ]
         end
       end
     end
@@ -81,7 +80,7 @@ describe 'Criteria logical operations' do
       end
 
       let(:expected) do
-        {'name' => {'$ne' => 'test'}}
+        { 'name' => { '$ne' => 'test' } }
       end
 
       it 'expands to use $ne' do
@@ -95,7 +94,7 @@ describe 'Criteria logical operations' do
       end
 
       let(:expected) do
-        {'name' => {'$not' => /test/}}
+        { 'name' => { '$not' => /test/ } }
       end
 
       it 'expands to use $not' do

data/spec/integration/criteria/range_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'spec_helper'
 
@@ -16,20 +15,21 @@ describe 'Queries with Range criteria' do
   let!(:band2) { Band.create!(likes: 1, rating: 1.0, founded: today + 1.day, updated_at: now_utc + 1.days) }
   let!(:band3) { Band.create!(likes: 2, rating: 2.9, founded: today + 2.days, updated_at: now_utc + 2.days) }
   let!(:band4) { Band.create!(likes: 3, rating: 3.0, founded: today + 3.days, updated_at: now_utc + 3.days) }
-  let!(:band5) { Band.create!(likes: 4, rating: 3.1, founded: today + 4.days, updated_at: now_utc + 4.days, labels: labels) }
+  let!(:band5) do
+    Band.create!(likes: 4, rating: 3.1, founded: today + 4.days, updated_at: now_utc + 4.days, labels: labels)
+  end
 
   context 'Range<Integer> criteria vs Integer field' do
-
     it 'returns objects within the range' do
-      expect(Band.where(likes: 1..3).to_a).to eq [band2, band3, band4]
-      expect(Band.where(likes: 1...3).to_a).to eq [band2, band3]
+      expect(Band.where(likes: 1..3).to_a).to eq [ band2, band3, band4 ]
+      expect(Band.where(likes: 1...3).to_a).to eq [ band2, band3 ]
     end
 
     context 'endless range' do
       ruby_version_gte '2.6'
 
       it 'returns all objects above the value' do
-        expect(Band.where(likes: eval('1..')).to_a).to eq [band2, band3, band4, band5]
+        expect(Band.where(likes: eval('1..')).to_a).to eq [ band2, band3, band4, band5 ]
       end
     end
 
@@ -37,24 +37,23 @@ describe 'Queries with Range criteria' do
       ruby_version_gte '2.7'
 
       it 'returns all objects under the value' do
-        expect(Band.where(likes: eval('..3')).to_a).to eq [band1, band2, band3, band4]
-        expect(Band.where(likes: eval('...3')).to_a).to eq [band1, band2, band3]
+        expect(Band.where(likes: eval('..3')).to_a).to eq [ band1, band2, band3, band4 ]
+        expect(Band.where(likes: eval('...3')).to_a).to eq [ band1, band2, band3 ]
       end
     end
   end
 
   context 'Range<Integer> criteria vs Float field' do
-
     it 'returns objects within the range' do
-      expect(Band.where(rating: 1..3).to_a).to eq [band2, band3, band4]
-      expect(Band.where(rating: 1...3).to_a).to eq [band2, band3]
+      expect(Band.where(rating: 1..3).to_a).to eq [ band2, band3, band4 ]
+      expect(Band.where(rating: 1...3).to_a).to eq [ band2, band3 ]
     end
 
     context 'endless range' do
       ruby_version_gte '2.6'
 
       it 'returns all objects above the value' do
-        expect(Band.where(rating: eval('1..')).to_a).to eq [band2, band3, band4, band5]
+        expect(Band.where(rating: eval('1..')).to_a).to eq [ band2, band3, band4, band5 ]
       end
     end
 
@@ -62,24 +61,23 @@ describe 'Queries with Range criteria' do
       ruby_version_gte '2.7'
 
       it 'returns all objects under the value' do
-        expect(Band.where(rating: eval('..3')).to_a).to eq [band1, band2, band3, band4]
-        expect(Band.where(rating: eval('...3')).to_a).to eq [band1, band2, band3]
+        expect(Band.where(rating: eval('..3')).to_a).to eq [ band1, band2, band3, band4 ]
+        expect(Band.where(rating: eval('...3')).to_a).to eq [ band1, band2, band3 ]
       end
     end
   end
 
   context 'Range<Float> criteria vs Integer field' do
-
     it 'returns objects within the range' do
-      expect(Band.where(likes: 0.95..3.05).to_a).to eq [band2, band3, band4]
-      expect(Band.where(likes: 0.95...3.0).to_a).to eq [band2, band3]
+      expect(Band.where(likes: 0.95..3.05).to_a).to eq [ band2, band3, band4 ]
+      expect(Band.where(likes: 0.95...3.0).to_a).to eq [ band2, band3 ]
     end
 
     context 'endless range' do
       ruby_version_gte '2.6'
 
       it 'returns all objects above the value' do
-        expect(Band.where(likes: eval('0.95..')).to_a).to eq [band2, band3, band4, band5]
+        expect(Band.where(likes: eval('0.95..')).to_a).to eq [ band2, band3, band4, band5 ]
       end
     end
 
@@ -87,24 +85,23 @@ describe 'Queries with Range criteria' do
       ruby_version_gte '2.7'
 
       it 'returns all objects under the value' do
-        expect(Band.where(likes: eval('..3.05')).to_a).to eq [band1, band2, band3, band4]
-        expect(Band.where(likes: eval('...3.0')).to_a).to eq [band1, band2, band3]
+        expect(Band.where(likes: eval('..3.05')).to_a).to eq [ band1, band2, band3, band4 ]
+        expect(Band.where(likes: eval('...3.0')).to_a).to eq [ band1, band2, band3 ]
       end
     end
   end
 
   context 'Range<Float> criteria vs Float field' do
-
     it 'returns objects within the range' do
-      expect(Band.where(rating: 0.95..3.05).to_a).to eq [band2, band3, band4]
-      expect(Band.where(rating: 0.95...3.0).to_a).to eq [band2, band3]
+      expect(Band.where(rating: 0.95..3.05).to_a).to eq [ band2, band3, band4 ]
+      expect(Band.where(rating: 0.95...3.0).to_a).to eq [ band2, band3 ]
     end
 
     context 'endless range' do
       ruby_version_gte '2.6'
 
       it 'returns all objects above the value' do
-        expect(Band.where(rating: eval('0.95..')).to_a).to eq [band2, band3, band4, band5]
+        expect(Band.where(rating: eval('0.95..')).to_a).to eq [ band2, band3, band4, band5 ]
       end
     end
 
@@ -112,24 +109,23 @@ describe 'Queries with Range criteria' do
       ruby_version_gte '2.7'
 
       it 'returns all objects under the value' do
-        expect(Band.where(rating: eval('..3.05')).to_a).to eq [band1, band2, band3, band4]
-        expect(Band.where(rating: eval('...3.0')).to_a).to eq [band1, band2, band3]
+        expect(Band.where(rating: eval('..3.05')).to_a).to eq [ band1, band2, band3, band4 ]
+        expect(Band.where(rating: eval('...3.0')).to_a).to eq [ band1, band2, band3 ]
       end
     end
   end
 
   context 'Range<Time> criteria vs Time field' do
-
     it 'returns objects within the range' do
-      expect(Band.where(updated_at: (now_utc + 1.day)..(now_utc + 3.days)).to_a).to eq [band2, band3, band4]
-      expect(Band.where(updated_at: (now_utc + 1.day)...(now_utc + 3.days)).to_a).to eq [band2, band3]
+      expect(Band.where(updated_at: (now_utc + 1.day)..(now_utc + 3.days)).to_a).to eq [ band2, band3, band4 ]
+      expect(Band.where(updated_at: (now_utc + 1.day)...(now_utc + 3.days)).to_a).to eq [ band2, band3 ]
     end
 
     context 'endless range' do
       ruby_version_gte '2.6'
 
       it 'returns all objects above the value' do
-        expect(Band.where(updated_at: eval('(now_utc + 1.day)..')).to_a).to eq [band2, band3, band4, band5]
+        expect(Band.where(updated_at: eval('(now_utc + 1.day)..')).to_a).to eq [ band2, band3, band4, band5 ]
       end
     end
 
@@ -137,24 +133,23 @@ describe 'Queries with Range criteria' do
       ruby_version_gte '2.7'
 
       it 'returns all objects under the value' do
-        expect(Band.where(updated_at: eval('..(now_utc + 3.days)')).to_a).to eq [band1, band2, band3, band4]
-        expect(Band.where(updated_at: eval('...(now_utc + 3.days)')).to_a).to eq [band1, band2, band3]
+        expect(Band.where(updated_at: eval('..(now_utc + 3.days)')).to_a).to eq [ band1, band2, band3, band4 ]
+        expect(Band.where(updated_at: eval('...(now_utc + 3.days)')).to_a).to eq [ band1, band2, band3 ]
       end
     end
   end
 
   context 'Range<Time> criteria vs Date field' do
-
     it 'returns objects within the range' do
-      expect(Band.where(founded: (now_utc + 1.day)..(now_utc + 3.days)).to_a).to eq [band2, band3, band4]
-      expect(Band.where(founded: (now_utc + 1.day)...(now_utc + 3.days)).to_a).to eq [band2, band3]
+      expect(Band.where(founded: (now_utc + 1.day)..(now_utc + 3.days)).to_a).to eq [ band2, band3, band4 ]
+      expect(Band.where(founded: (now_utc + 1.day)...(now_utc + 3.days)).to_a).to eq [ band2, band3 ]
     end
 
     context 'endless range' do
       ruby_version_gte '2.6'
 
       it 'returns all objects above the value' do
-        expect(Band.where(founded: eval('(now_utc + 1.day)..')).to_a).to eq [band2, band3, band4, band5]
+        expect(Band.where(founded: eval('(now_utc + 1.day)..')).to_a).to eq [ band2, band3, band4, band5 ]
       end
     end
 
@@ -162,24 +157,23 @@ describe 'Queries with Range criteria' do
       ruby_version_gte '2.7'
 
       it 'returns all objects under the value' do
-        expect(Band.where(founded: eval('..(now_utc + 3.days)')).to_a).to eq [band1, band2, band3, band4]
-        expect(Band.where(founded: eval('...(now_utc + 3.days)')).to_a).to eq [band1, band2, band3]
+        expect(Band.where(founded: eval('..(now_utc + 3.days)')).to_a).to eq [ band1, band2, band3, band4 ]
+        expect(Band.where(founded: eval('...(now_utc + 3.days)')).to_a).to eq [ band1, band2, band3 ]
       end
     end
   end
 
   context 'Range<ActiveSupport::TimeWithZone> criteria vs Time field' do
-
     it 'returns objects within the range' do
-      expect(Band.where(updated_at: (now_in_zone + 1.day)..(now_in_zone + 3.days)).to_a).to eq [band2, band3, band4]
-      expect(Band.where(updated_at: (now_in_zone + 1.day)...(now_in_zone + 3.days)).to_a).to eq [band2, band3]
+      expect(Band.where(updated_at: (now_in_zone + 1.day)..(now_in_zone + 3.days)).to_a).to eq [ band2, band3, band4 ]
+      expect(Band.where(updated_at: (now_in_zone + 1.day)...(now_in_zone + 3.days)).to_a).to eq [ band2, band3 ]
     end
 
     context 'endless range' do
       ruby_version_gte '2.6'
 
       it 'returns all objects above the value' do
-        expect(Band.where(updated_at: eval('(now_in_zone + 1.day)..')).to_a).to eq [band2, band3, band4, band5]
+        expect(Band.where(updated_at: eval('(now_in_zone + 1.day)..')).to_a).to eq [ band2, band3, band4, band5 ]
       end
     end
 
@@ -187,24 +181,23 @@ describe 'Queries with Range criteria' do
       ruby_version_gte '2.7'
 
       it 'returns all objects under the value' do
-        expect(Band.where(updated_at: eval('..(now_in_zone + 3.days)')).to_a).to eq [band1, band2, band3, band4]
-        expect(Band.where(updated_at: eval('...(now_in_zone + 3.days)')).to_a).to eq [band1, band2, band3]
+        expect(Band.where(updated_at: eval('..(now_in_zone + 3.days)')).to_a).to eq [ band1, band2, band3, band4 ]
+        expect(Band.where(updated_at: eval('...(now_in_zone + 3.days)')).to_a).to eq [ band1, band2, band3 ]
       end
     end
   end
 
   context 'Range<ActiveSupport::TimeWithZone> criteria vs Date field' do
-
     it 'returns objects within the range' do
-      expect(Band.where(founded: (now_in_zone + 1.day)..(now_in_zone + 3.days)).to_a).to eq [band3, band4, band5]
-      expect(Band.where(founded: (now_in_zone + 1.day)...(now_in_zone + 3.days)).to_a).to eq [band3, band4]
+      expect(Band.where(founded: (now_in_zone + 1.day)..(now_in_zone + 3.days)).to_a).to eq [ band3, band4, band5 ]
+      expect(Band.where(founded: (now_in_zone + 1.day)...(now_in_zone + 3.days)).to_a).to eq [ band3, band4 ]
     end
 
     context 'endless range' do
       ruby_version_gte '2.6'
 
       it 'returns all objects above the value' do
-        expect(Band.where(founded: eval('(now_in_zone + 1.day)..')).to_a).to eq [band3, band4, band5]
+        expect(Band.where(founded: eval('(now_in_zone + 1.day)..')).to_a).to eq [ band3, band4, band5 ]
       end
     end
 
@@ -212,24 +205,23 @@ describe 'Queries with Range criteria' do
       ruby_version_gte '2.7'
 
       it 'returns all objects under the value' do
-        expect(Band.where(founded: eval('..(now_in_zone + 3.days)')).to_a).to eq [band1, band2, band3, band4, band5]
-        expect(Band.where(founded: eval('...(now_in_zone + 3.days)')).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(founded: eval('..(now_in_zone + 3.days)')).to_a).to eq [ band1, band2, band3, band4, band5 ]
+        expect(Band.where(founded: eval('...(now_in_zone + 3.days)')).to_a).to eq [ band1, band2, band3, band4 ]
       end
     end
   end
 
   context 'Range<Date> criteria vs Date field' do
-
     it 'returns objects within the range' do
-      expect(Band.where(founded: (today + 1.day)..(today + 3.days)).to_a).to eq [band2, band3, band4]
-      expect(Band.where(founded: (today + 1.day)...(today + 3.days)).to_a).to eq [band2, band3]
+      expect(Band.where(founded: (today + 1.day)..(today + 3.days)).to_a).to eq [ band2, band3, band4 ]
+      expect(Band.where(founded: (today + 1.day)...(today + 3.days)).to_a).to eq [ band2, band3 ]
     end
 
     context 'endless range' do
       ruby_version_gte '2.6'
 
       it 'returns all objects above the value' do
-        expect(Band.where(founded: eval('(today + 1.day)..')).to_a).to eq [band2, band3, band4, band5]
+        expect(Band.where(founded: eval('(today + 1.day)..')).to_a).to eq [ band2, band3, band4, band5 ]
       end
     end
 
@@ -237,24 +229,23 @@ describe 'Queries with Range criteria' do
       ruby_version_gte '2.7'
 
       it 'returns all objects under the value' do
-        expect(Band.where(founded: eval('..(today + 3.days)')).to_a).to eq [band1, band2, band3, band4]
-        expect(Band.where(founded: eval('...(today + 3.days)')).to_a).to eq [band1, band2, band3]
+        expect(Band.where(founded: eval('..(today + 3.days)')).to_a).to eq [ band1, band2, band3, band4 ]
+        expect(Band.where(founded: eval('...(today + 3.days)')).to_a).to eq [ band1, band2, band3 ]
       end
     end
   end
 
   context 'Range<Date> criteria vs Time field' do
-
     it 'returns objects within the range' do
-      expect(Band.where(updated_at: (today + 1.day)..(today + 3.days)).to_a).to eq [band2, band3]
-      expect(Band.where(updated_at: (today + 1.day)...(today + 3.days)).to_a).to eq [band2, band3]
+      expect(Band.where(updated_at: (today + 1.day)..(today + 3.days)).to_a).to eq [ band2, band3 ]
+      expect(Band.where(updated_at: (today + 1.day)...(today + 3.days)).to_a).to eq [ band2, band3 ]
     end
 
     context 'endless range' do
       ruby_version_gte '2.6'
 
       it 'returns all objects above the value' do
-        expect(Band.where(updated_at: eval('(today + 1.day)..')).to_a).to eq [band2, band3, band4, band5]
+        expect(Band.where(updated_at: eval('(today + 1.day)..')).to_a).to eq [ band2, band3, band4, band5 ]
       end
     end
 
@@ -262,32 +253,31 @@ describe 'Queries with Range criteria' do
       ruby_version_gte '2.7'
 
       it 'returns all objects under the value' do
-        expect(Band.where(updated_at: eval('..(today + 3.days)')).to_a).to eq [band1, band2, band3]
-        expect(Band.where(updated_at: eval('...(today + 3.days)')).to_a).to eq [band1, band2, band3]
+        expect(Band.where(updated_at: eval('..(today + 3.days)')).to_a).to eq [ band1, band2, band3 ]
+        expect(Band.where(updated_at: eval('...(today + 3.days)')).to_a).to eq [ band1, band2, band3 ]
       end
     end
   end
 
   context 'Range<Integer> criteria vs embedded Integer field' do
-
     it 'returns objects within the range' do
-      expect(Band.where("labels.age" => 10..18).to_a).to eq [band5]
-      expect(Band.where("labels.age" => 13...16).to_a).to eq []
+      expect(Band.where('labels.age' => 10..18).to_a).to eq [ band5 ]
+      expect(Band.where('labels.age' => 13...16).to_a).to eq []
     end
 
-    it "does not return objects out of range" do
-      expect(Band.where("labels.age" => 13..14).to_a).to eq []
+    it 'does not return objects out of range' do
+      expect(Band.where('labels.age' => 13..14).to_a).to eq []
     end
 
     context 'endless range' do
       ruby_version_gte '2.6'
 
       it 'returns all objects above the value' do
-        expect(Band.where("labels.age": eval('1..')).to_a).to eq [band5]
+        expect(Band.where('labels.age': eval('1..')).to_a).to eq [ band5 ]
       end
 
       it 'does not return the objects under the value' do
-        expect(Band.where("labels.age": eval('100..')).to_a).to eq []
+        expect(Band.where('labels.age': eval('100..')).to_a).to eq []
       end
     end
 
@@ -295,47 +285,48 @@ describe 'Queries with Range criteria' do
       ruby_version_gte '2.7'
 
       it 'returns all objects under the value' do
-        expect(Band.where("labels.age": eval('..16')).to_a).to eq [band5]
+        expect(Band.where('labels.age': eval('..16')).to_a).to eq [ band5 ]
       end
+
       it 'does not return the objects above the value' do
-        expect(Band.where("labels.age": eval('...12')).to_a).to eq []
+        expect(Band.where('labels.age': eval('...12')).to_a).to eq []
       end
     end
   end
 
   context 'Range<Integer> criteria vs Array<Integer>' do
-    let!(:band6) { Band.create!(genres: [12, 16]) }
+    let!(:band6) { Band.create!(genres: [ 12, 16 ]) }
 
     it 'returns objects within the range' do
-      expect(Band.where("genres" => 10..18).to_a).to eq [band6]
+      expect(Band.where('genres' => 10..18).to_a).to eq [ band6 ]
     end
 
-    it "does not return objects out of range" do
-      expect(Band.where("genres" => 13..14).to_a).to eq []
+    it 'does not return objects out of range' do
+      expect(Band.where('genres' => 13..14).to_a).to eq []
     end
   end
 
   context 'Range<Integer> criteria vs aliased Array<Integer>' do
-    let!(:person) { Person.create!(array: [12, 16]) }
+    let!(:person) { Person.create!(array: [ 12, 16 ]) }
 
     it 'returns objects within the range' do
-      expect(Person.where("array" => 10..18).to_a).to eq [person]
+      expect(Person.where('array' => 10..18).to_a).to eq [ person ]
     end
 
-    it "does not return objects out of range" do
-      expect(Person.where("array" => 13..14).to_a).to eq []
+    it 'does not return objects out of range' do
+      expect(Person.where('array' => 13..14).to_a).to eq []
     end
   end
 
   context 'Range<Integer> criteria vs Array<Hash<Symbol, Integer>>' do
-    let!(:band6) { Band.create!(genres: [{x: 12}, {x: 16}]) }
+    let!(:band6) { Band.create!(genres: [ { x: 12 }, { x: 16 } ]) }
 
     it 'returns objects within the range' do
-      expect(Band.where("genres.x" => 10..18).to_a).to eq [band6]
+      expect(Band.where('genres.x' => 10..18).to_a).to eq [ band6 ]
     end
 
-    it "does not return objects out of range" do
-      expect(Band.where("genres.x" => 13..14).to_a).to eq []
+    it 'does not return objects out of range' do
+      expect(Band.where('genres.x' => 13..14).to_a).to eq []
     end
   end
 
@@ -348,11 +339,11 @@ describe 'Queries with Range criteria' do
     end
 
     it 'returns objects within the range' do
-      expect(Person.where("passport.passport_pages.num_stamps" => 10..18).to_a).to eq [person]
+      expect(Person.where('passport.passport_pages.num_stamps' => 10..18).to_a).to eq [ person ]
     end
 
-    it "does not return objects out of range" do
-      expect(Person.where("passport.passport_pages.num_stamps" => 13..14).to_a).to eq []
+    it 'does not return objects out of range' do
+      expect(Person.where('passport.passport_pages.num_stamps' => 13..14).to_a).to eq []
     end
   end
 end