mongoid 9.0.11 → 9.1.0

data/spec/integration/matcher_examples_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'spec_helper'
 
@@ -11,12 +10,11 @@ require 'spec_helper'
 describe 'Matcher' do
   context 'when attribute is a scalar' do
     describe 'exact match' do
-
       let!(:slave) do
         Slave.create!(address_numbers: [
-          AddressNumber.new(number: '123'),
-          AddressNumber.new(number: '456'),
-        ])
+                        AddressNumber.new(number: '123'),
+                        AddressNumber.new(number: '456')
+                      ])
       end
 
       describe 'MongoDB query' do
@@ -41,12 +39,11 @@ describe 'Matcher' do
     end
 
     describe 'regexp match on string' do
-
       let!(:slave) do
         Slave.create!(address_numbers: [
-          AddressNumber.new(number: '123'),
-          AddressNumber.new(number: '456'),
-        ])
+                        AddressNumber.new(number: '123'),
+                        AddressNumber.new(number: '456')
+                      ])
       end
 
       describe 'MongoDB query' do
@@ -71,12 +68,11 @@ describe 'Matcher' do
     end
 
     describe 'range match on scalar' do
-
       let!(:circuit) do
         Circuit.create!(buses: [
-          Bus.new(number: 10),
-          Bus.new(number: 30),
-        ])
+                          Bus.new(number: 10),
+                          Bus.new(number: 30)
+                        ])
       end
 
       describe 'MongoDB query' do
@@ -93,7 +89,7 @@ describe 'Matcher' do
         end
 
         it 'does not find' do
-          expect(not_found_circuit).to be nil
+          expect(not_found_circuit).to be_nil
         end
       end
 
@@ -111,7 +107,7 @@ describe 'Matcher' do
         end
 
         it 'does not find' do
-          expect(not_found_bus).to be nil
+          expect(not_found_bus).to be_nil
         end
       end
     end
@@ -126,7 +122,7 @@ describe 'Matcher' do
 
         context 'not matching condition' do
           it 'does not find' do
-            expect(actual_object_not_matching_condition).to be nil
+            expect(actual_object_not_matching_condition).to be_nil
           end
         end
       end
@@ -145,16 +141,15 @@ describe 'Matcher' do
     end
 
     describe '$eq' do
-
       let!(:circuit) do
         Circuit.new(buses: [
-          Bus.new(number: '10'),
-          Bus.new(number: '30'),
-        ])
+                      Bus.new(number: '10'),
+                      Bus.new(number: '30')
+                    ])
       end
 
       let(:actual_object_matching_condition) do
-        circuit.buses.where(number: {operator => 10}).first
+        circuit.buses.where(number: { operator => 10 }).first
       end
 
       let(:expected_object_matching_condition) do
@@ -162,22 +157,21 @@ describe 'Matcher' do
       end
 
       let(:actual_object_not_matching_condition) do
-        circuit.buses.where(number: {operator => 20}).first
+        circuit.buses.where(number: { operator => 20 }).first
       end
 
       it_behaves_like 'a field operator', '$eq'
     end
 
     describe '$ne' do
-
       let!(:circuit) do
         Circuit.new(buses: [
-          Bus.new(number: '30'),
-        ])
+                      Bus.new(number: '30')
+                    ])
       end
 
       let(:actual_object_matching_condition) do
-        circuit.buses.where(number: {operator => 10}).first
+        circuit.buses.where(number: { operator => 10 }).first
       end
 
       let(:expected_object_matching_condition) do
@@ -185,23 +179,22 @@ describe 'Matcher' do
       end
 
       let(:actual_object_not_matching_condition) do
-        circuit.buses.where(number: {operator => 30}).first
+        circuit.buses.where(number: { operator => 30 }).first
       end
 
       it_behaves_like 'a field operator', '$ne'
     end
 
     describe '$exists' do
-
       context 'true value' do
         let!(:circuit) do
           Circuit.new(buses: [
-            Bus.new(number: '30'),
-          ])
+                        Bus.new(number: '30')
+                      ])
         end
 
         let(:actual_object_matching_condition) do
-          circuit.buses.where(number: {operator => true}).first
+          circuit.buses.where(number: { operator => true }).first
         end
 
         let(:expected_object_matching_condition) do
@@ -209,7 +202,7 @@ describe 'Matcher' do
         end
 
         let(:actual_object_not_matching_condition) do
-          circuit.buses.where(number: {operator => false}).first
+          circuit.buses.where(number: { operator => false }).first
         end
 
         it_behaves_like 'a field operator', '$exists'
@@ -218,12 +211,12 @@ describe 'Matcher' do
       context 'false value' do
         let!(:circuit) do
           Circuit.new(buses: [
-            Bus.new,
-          ])
+                        Bus.new
+                      ])
         end
 
         let(:actual_object_matching_condition) do
-          circuit.buses.where(number: {operator => false}).first
+          circuit.buses.where(number: { operator => false }).first
         end
 
         let(:expected_object_matching_condition) do
@@ -231,7 +224,7 @@ describe 'Matcher' do
         end
 
         let(:actual_object_not_matching_condition) do
-          circuit.buses.where(number: {operator => true}).first
+          circuit.buses.where(number: { operator => true }).first
         end
 
         it_behaves_like 'a field operator', '$exists'
@@ -239,16 +232,15 @@ describe 'Matcher' do
     end
 
     describe '$gt' do
-
       let!(:circuit) do
         Circuit.new(buses: [
-          Bus.new(number: '10'),
-          Bus.new(number: '30'),
-        ])
+                      Bus.new(number: '10'),
+                      Bus.new(number: '30')
+                    ])
       end
 
       let(:actual_object_matching_condition) do
-        circuit.buses.where(number: {operator => 15}).first
+        circuit.buses.where(number: { operator => 15 }).first
       end
 
       let(:expected_object_matching_condition) do
@@ -257,24 +249,23 @@ describe 'Matcher' do
 
       let(:actual_object_not_matching_condition) do
         # Intentionally equal to the largest bus number
-        circuit.buses.where(number: {operator => 30}).first
+        circuit.buses.where(number: { operator => 30 }).first
       end
 
       it_behaves_like 'a field operator', '$gt'
     end
 
     describe '$gte' do
-
       let!(:circuit) do
         Circuit.new(buses: [
-          Bus.new(number: '10'),
-          Bus.new(number: '30'),
-        ])
+                      Bus.new(number: '10'),
+                      Bus.new(number: '30')
+                    ])
       end
 
       let(:actual_object_matching_condition) do
         # Intentionally equal to the largest bus number
-        circuit.buses.where(number: {operator => 30}).first
+        circuit.buses.where(number: { operator => 30 }).first
       end
 
       let(:expected_object_matching_condition) do
@@ -282,23 +273,22 @@ describe 'Matcher' do
       end
 
       let(:actual_object_not_matching_condition) do
-        circuit.buses.where(number: {operator => 31}).first
+        circuit.buses.where(number: { operator => 31 }).first
       end
 
       it_behaves_like 'a field operator', '$gte'
     end
 
     describe '$lt' do
-
       let!(:circuit) do
         Circuit.new(buses: [
-          Bus.new(number: '10'),
-          Bus.new(number: '30'),
-        ])
+                      Bus.new(number: '10'),
+                      Bus.new(number: '30')
+                    ])
       end
 
       let(:actual_object_matching_condition) do
-        circuit.buses.where(number: {operator => 15}).first
+        circuit.buses.where(number: { operator => 15 }).first
       end
 
       let(:expected_object_matching_condition) do
@@ -307,24 +297,23 @@ describe 'Matcher' do
 
       let(:actual_object_not_matching_condition) do
         # Intentionally equal to the smallest bus number
-        circuit.buses.where(number: {operator => 10}).first
+        circuit.buses.where(number: { operator => 10 }).first
       end
 
       it_behaves_like 'a field operator', '$lt'
     end
 
     describe '$lte' do
-
       let!(:circuit) do
         Circuit.new(buses: [
-          Bus.new(number: '10'),
-          Bus.new(number: '30'),
-        ])
+                      Bus.new(number: '10'),
+                      Bus.new(number: '30')
+                    ])
       end
 
       let(:actual_object_matching_condition) do
         # Intentionally equal to the smallest bus number
-        circuit.buses.where(number: {operator => 10}).first
+        circuit.buses.where(number: { operator => 10 }).first
       end
 
       let(:expected_object_matching_condition) do
@@ -332,23 +321,22 @@ describe 'Matcher' do
       end
 
       let(:actual_object_not_matching_condition) do
-        circuit.buses.where(number: {operator => 9}).first
+        circuit.buses.where(number: { operator => 9 }).first
       end
 
       it_behaves_like 'a field operator', '$lte'
     end
 
     describe '$in' do
-
       let!(:circuit) do
         Circuit.new(buses: [
-          Bus.new(number: '10'),
-          Bus.new(number: '30'),
-        ])
+                      Bus.new(number: '10'),
+                      Bus.new(number: '30')
+                    ])
       end
 
       let(:actual_object_matching_condition) do
-        circuit.buses.where(number: {operator => [10, 20]}).first
+        circuit.buses.where(number: { operator => [ 10, 20 ] }).first
       end
 
       let(:expected_object_matching_condition) do
@@ -356,23 +344,22 @@ describe 'Matcher' do
       end
 
       let(:actual_object_not_matching_condition) do
-        circuit.buses.where(number: {operator => [5]}).first
+        circuit.buses.where(number: { operator => [ 5 ] }).first
       end
 
       it_behaves_like 'a field operator', '$in'
     end
 
     describe '$nin' do
-
       let!(:circuit) do
         Circuit.new(buses: [
-          Bus.new(number: '10'),
-          Bus.new(number: '30'),
-        ])
+                      Bus.new(number: '10'),
+                      Bus.new(number: '30')
+                    ])
       end
 
       let(:actual_object_matching_condition) do
-        circuit.buses.where(number: {operator => [5, 10]}).first
+        circuit.buses.where(number: { operator => [ 5, 10 ] }).first
       end
 
       let(:expected_object_matching_condition) do
@@ -380,23 +367,22 @@ describe 'Matcher' do
       end
 
       let(:actual_object_not_matching_condition) do
-        circuit.buses.where(number: {operator => [10, 30]}).first
+        circuit.buses.where(number: { operator => [ 10, 30 ] }).first
       end
 
       it_behaves_like 'a field operator', '$nin'
     end
 
     describe '$size' do
-
       let!(:person) do
         Person.new(addresses: [
-          Address.new(locations: [Location.new]),
-          Address.new(locations: [Location.new, Location.new]),
-        ])
+                     Address.new(locations: [ Location.new ]),
+                     Address.new(locations: [ Location.new, Location.new ])
+                   ])
       end
 
       let(:actual_object_matching_condition) do
-        person.addresses.where('locations' => {operator => 2}).first
+        person.addresses.where('locations' => { operator => 2 }).first
       end
 
       let(:expected_object_matching_condition) do
@@ -404,7 +390,7 @@ describe 'Matcher' do
       end
 
       let(:actual_object_not_matching_condition) do
-        person.addresses.where('locations' => {operator => 3}).first
+        person.addresses.where('locations' => { operator => 3 }).first
       end
 
       it_behaves_like 'a field operator', '$size'
@@ -413,20 +399,20 @@ describe 'Matcher' do
     describe '$and' do
       let!(:person) do
         Person.new(addresses: [
-          Address.new(locations: [Location.new(name: 'City')]),
-          Address.new(locations: [
-            # Both criteria are on the same object
-            Location.new(name: 'Hall', number: 1),
-            Location.new(number: 3),
-          ]),
-        ])
+                     Address.new(locations: [ Location.new(name: 'City') ]),
+                     Address.new(locations: [
+                                   # Both criteria are on the same object
+                                   Location.new(name: 'Hall', number: 1),
+                                   Location.new(number: 3)
+                                 ])
+                   ])
       end
 
       let(:actual_object_matching_condition) do
         person.addresses.where(operator => [
-          {'locations.name' => 'Hall'},
-          {'locations.number' => 1},
-        ]).first
+                                 { 'locations.name' => 'Hall' },
+                                 { 'locations.number' => 1 }
+                               ]).first
       end
 
       let(:expected_object_matching_condition) do
@@ -435,9 +421,9 @@ describe 'Matcher' do
 
       let(:actual_object_not_matching_condition) do
         person.addresses.where(operator => [
-          {'locations.name' => 'Hall'},
-          {'locations.number' => 2},
-        ]).first
+                                 { 'locations.name' => 'Hall' },
+                                 { 'locations.number' => 2 }
+                               ]).first
       end
 
       it_behaves_like 'a field operator', '$and'
@@ -445,12 +431,12 @@ describe 'Matcher' do
       context 'when branches match different embedded objects' do
         let!(:person) do
           Person.new(addresses: [
-            Address.new(locations: [Location.new(name: 'City')]),
-            Address.new(locations: [
-              Location.new(name: 'Hall'),
-              Location.new(number: 1),
-            ]),
-          ])
+                       Address.new(locations: [ Location.new(name: 'City') ]),
+                       Address.new(locations: [
+                                     Location.new(name: 'Hall'),
+                                     Location.new(number: 1)
+                                   ])
+                     ])
         end
 
         let(:operator) { :$and }
@@ -461,10 +447,10 @@ describe 'Matcher' do
 
         context 'when $and is on field level' do
           let(:actual_object_matching_condition) do
-            person.addresses.where('locations' => {operator => [
-              {'name' => 'Hall'},
-              {'number' => 1},
-            ]}).first
+            person.addresses.where('locations' => { operator => [
+                                     { 'name' => 'Hall' },
+                                     { 'number' => 1 }
+                                   ] }).first
           end
 
           it 'is prohibited' do
@@ -479,20 +465,20 @@ describe 'Matcher' do
     describe '$or' do
       let!(:person) do
         Person.new(addresses: [
-          Address.new(locations: [Location.new(name: 'City')]),
-          Address.new(locations: [
-            # Both criteria are on the same object
-            Location.new(name: 'Hall', number: 1),
-            Location.new(number: 3),
-          ]),
-        ])
+                     Address.new(locations: [ Location.new(name: 'City') ]),
+                     Address.new(locations: [
+                                   # Both criteria are on the same object
+                                   Location.new(name: 'Hall', number: 1),
+                                   Location.new(number: 3)
+                                 ])
+                   ])
       end
 
       let(:actual_object_matching_condition) do
         person.addresses.where(operator => [
-          {'locations.name' => 'Hall'},
-          {'locations.number' => 4},
-        ]).first
+                                 { 'locations.name' => 'Hall' },
+                                 { 'locations.number' => 4 }
+                               ]).first
       end
 
       let(:expected_object_matching_condition) do
@@ -501,9 +487,9 @@ describe 'Matcher' do
 
       let(:actual_object_not_matching_condition) do
         person.addresses.where(operator => [
-          {'locations.name' => 'Town'},
-          {'locations.number' => 4},
-        ]).first
+                                 { 'locations.name' => 'Town' },
+                                 { 'locations.number' => 4 }
+                               ]).first
       end
 
       it_behaves_like 'a field operator', '$or'
@@ -513,10 +499,10 @@ describe 'Matcher' do
 
         context 'when $or is on field level' do
           let(:actual_object_matching_condition) do
-            person.addresses.where('locations' => {operator => [
-              {'name' => 'Hall'},
-              {'number' => 1},
-            ]}).first
+            person.addresses.where('locations' => { operator => [
+                                     { 'name' => 'Hall' },
+                                     { 'number' => 1 }
+                                   ] }).first
           end
 
           it 'is prohibited' do
@@ -531,18 +517,17 @@ describe 'Matcher' do
     describe '$not' do
       let!(:person) do
         Person.new(addresses: [
-          Address.new(locations: [
-            # Both criteria are on the same object
-            Location.new(name: 'Hall', number: 1),
-            Location.new(number: 3),
-          ]),
-        ])
+                     Address.new(locations: [
+                                   # Both criteria are on the same object
+                                   Location.new(name: 'Hall', number: 1),
+                                   Location.new(number: 3)
+                                 ])
+                   ])
       end
 
       let(:actual_object_matching_condition) do
-        person.addresses.where('locations.name' => {operator =>
-          {'$eq' => 'City'},
-        }).first
+        person.addresses.where('locations.name' => { operator =>
+          { '$eq' => 'City' } }).first
       end
 
       let(:expected_object_matching_condition) do
@@ -550,9 +535,8 @@ describe 'Matcher' do
       end
 
       let(:actual_object_not_matching_condition) do
-        person.addresses.where('locations.name' => {operator =>
-          {'$eq' => 'Hall'},
-        }).first
+        person.addresses.where('locations.name' => { operator =>
+          { '$eq' => 'Hall' } }).first
       end
 
       it_behaves_like 'a field operator', '$not'
@@ -560,12 +544,12 @@ describe 'Matcher' do
       context 'when branches match different embedded objects' do
         let!(:person) do
           Person.new(addresses: [
-            Address.new(locations: [Location.new(name: 'City')]),
-            Address.new(locations: [
-              Location.new(name: 'Hall'),
-              Location.new(number: 1),
-            ]),
-          ])
+                       Address.new(locations: [ Location.new(name: 'City') ]),
+                       Address.new(locations: [
+                                     Location.new(name: 'Hall'),
+                                     Location.new(number: 1)
+                                   ])
+                     ])
         end
 
         let(:operator) { :$not }
@@ -576,10 +560,10 @@ describe 'Matcher' do
 
         context 'when $not is on field level' do
           let(:actual_object_matching_condition) do
-            person.addresses.where('locations' => {operator => [
-              {'name' => 'Hall'},
-              {'number' => 1},
-            ]}).first
+            person.addresses.where('locations' => { operator => [
+                                     { 'name' => 'Hall' },
+                                     { 'number' => 1 }
+                                   ] }).first
           end
 
           it 'is prohibited' do
@@ -594,11 +578,10 @@ describe 'Matcher' do
 
   context 'when attribute is an array' do
     describe 'exact match of array element' do
-
       let!(:band) do
         Band.create!(records: [
-          Record.new(producers: ['Ferguson', 'Fallon']),
-        ])
+                       Record.new(producers: %w[Ferguson Fallon])
+                     ])
       end
 
       describe 'MongoDB query' do
@@ -623,11 +606,10 @@ describe 'Matcher' do
     end
 
     describe 'regexp match on array element' do
-
       let!(:band) do
         Band.create!(records: [
-          Record.new(producers: ['Ferguson', 'Fallon']),
-        ])
+                       Record.new(producers: %w[Ferguson Fallon])
+                     ])
       end
 
       describe 'MongoDB query' do
@@ -652,9 +634,8 @@ describe 'Matcher' do
     end
 
     describe 'range match on array element' do
-
       let(:record) do
-        Record.new(producers: [123, 456])
+        Record.new(producers: [ 123, 456 ])
       end
 
       let!(:band) do
@@ -671,15 +652,14 @@ describe 'Matcher' do
         end
 
         context 'no match' do
-
           let!(:band) do
             Band.create!(records: [
-              Record.new(producers: [50, 250]),
-            ])
+                           Record.new(producers: [ 50, 250 ])
+                         ])
           end
 
           it 'does not find' do
-            expect(found_band).to be nil
+            expect(found_band).to be_nil
           end
         end
       end
@@ -697,7 +677,7 @@ describe 'Matcher' do
           expect(found_record).to eq(record)
         end
 
-        it "correctly does not find" do
+        it 'correctly does not find' do
           expect(no_record).to eq(nil)
         end
       end
@@ -709,43 +689,40 @@ describe 'Matcher' do
       context 'string value' do
         let(:band) do
           Band.new(records: [
-            Record.new(producers: ['Sunrise']),
-          ])
+                     Record.new(producers: [ 'Sunrise' ])
+                   ])
         end
 
         it 'does not find' do
-          band.records.where(producers: {'$elemMatch': {foo: 'bar'}}).first.should be nil
+          band.records.where(producers: { '$elemMatch': { foo: 'bar' } }).first.should be_nil
         end
 
         context 'primitive value query' do
-
           it 'does not find' do
             lambda do
-              band.records.where(producers: {'$elemMatch': 'bar'}).first
+              band.records.where(producers: { '$elemMatch': 'bar' }).first
             end.should raise_error(Mongoid::Errors::InvalidQuery, /elemMatch requires a Hash operand/)
           end
         end
 
         context '$not with primitive value' do
-
           it 'does not find' do
             lambda do
-              band.records.where(producers: {'$elemMatch': {'$not': 'bar'}}).first
-            end.should raise_error(Mongoid::Errors::InvalidQuery, /\$not argument must be a Hash or a regular expression/)
+              band.records.where(producers: { '$elemMatch': { '$not': 'bar' } }).first
+            end.should raise_error(Mongoid::Errors::InvalidQuery,
+                                   /\$not argument must be a Hash or a regular expression/)
           end
         end
 
         context '$not with regexp' do
-
           it 'finds' do
-            band.records.where(producers: {'$elemMatch': {'$not': /bar/}}).count.should == 1
+            band.records.where(producers: { '$elemMatch': { '$not': /bar/ } }).count.should eq 1
           end
         end
 
         context '$not with operator' do
-
           it 'finds' do
-            band.records.where(producers: {'$elemMatch': {'$not': {'$eq': 'bar'}}}).count.should == 1
+            band.records.where(producers: { '$elemMatch': { '$not': { '$eq': 'bar' } } }).count.should eq 1
           end
         end
       end
@@ -753,12 +730,12 @@ describe 'Matcher' do
       context 'integer value' do
         let(:band) do
           Band.new(records: [
-            Record.new(producers: [42]),
-          ])
+                     Record.new(producers: [ 42 ])
+                   ])
         end
 
         it 'does not find' do
-          band.records.where(producers: {'$elemMatch': {foo: 'bar'}}).first.should be nil
+          band.records.where(producers: { '$elemMatch': { foo: 'bar' } }).first.should be_nil
         end
       end
     end