mongoid 9.0.11 → 9.1.0

data/spec/mongoid/criteria/queryable/smash_spec.rb

@@ -1,31 +1,26 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Criteria::Queryable::Smash do
-
   let(:smash) do
     described_class.new(ns: :namespace)
   end
 
-  describe "#[]" do
-
+  describe '#[]' do
     before do
       smash.store(:namespace, :default)
       smash.store(:some_field, 42)
     end
 
-    context "when accessing aliased field" do
-
-      it "returns value for original field" do
+    context 'when accessing aliased field' do
+      it 'returns value for original field' do
         expect(smash[:ns]).to eq(:default)
       end
     end
 
-    context "when accessing non-aliased field" do
-
-      it "returns value for the field" do
+    context 'when accessing non-aliased field' do
+      it 'returns value for the field' do
         expect(smash[:some_field]).to eq(42)
       end
     end

data/spec/mongoid/criteria/queryable/storable_spec.rb

@@ -1,24 +1,21 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Criteria::Queryable::Storable do
-
   let(:query) do
     Mongoid::Query.new
   end
 
   shared_examples_for 'logical operator expressions' do
-
     context '$and operator' do
       context '$and to empty query' do
         let(:modified) do
-          query.send(query_method, '$and', [{'foo' => 'bar'}])
+          query.send(query_method, '$and', [ { 'foo' => 'bar' } ])
         end
 
         it 'adds to top level' do
-          modified.selector.should == {'$and' => [{'foo' => 'bar'}]}
+          modified.selector.should eq({ '$and' => [ { 'foo' => 'bar' } ] })
         end
       end
 
@@ -28,58 +25,53 @@ describe Mongoid::Criteria::Queryable::Storable do
         end
 
         let(:modified) do
-          query.send(query_method, '$and', [{'foo' => 'bar'}])
+          query.send(query_method, '$and', [ { 'foo' => 'bar' } ])
         end
 
         it 'adds to top level' do
-          modified.selector.should == {'zoom' => 'zoom',
-            '$and' => [{'foo' => 'bar'}]}
+          modified.selector.should eq({ 'zoom' => 'zoom', '$and' => [ { 'foo' => 'bar' } ] })
         end
       end
 
       context '$and to query with $and' do
         let(:query) do
-          Mongoid::Query.new.where('$and' => [{zoom: 'zoom'}])
+          Mongoid::Query.new.where('$and' => [ { zoom: 'zoom' } ])
         end
 
         let(:modified) do
-          query.send(query_method, '$and', [{'foo' => 'bar'}])
+          query.send(query_method, '$and', [ { 'foo' => 'bar' } ])
         end
 
         it 'adds to existing $and' do
-          modified.selector.should == {
-            '$and' => [{'zoom' => 'zoom'}, {'foo' => 'bar'}]}
+          modified.selector.should eq({ '$and' => [ { 'zoom' => 'zoom' }, { 'foo' => 'bar' } ] })
         end
       end
 
       context '$and to query with $and which already has the given key' do
         let(:query) do
-          Mongoid::Query.new.where('$and' => [{foo: 'zoom'}])
+          Mongoid::Query.new.where('$and' => [ { foo: 'zoom' } ])
         end
 
         let(:modified) do
-          query.send(query_method, '$and', [{'foo' => 'bar'}])
+          query.send(query_method, '$and', [ { 'foo' => 'bar' } ])
         end
 
         it 'adds to existing $and' do
-          modified.selector.should == {
-            '$and' => [{'foo' => 'zoom'}, {'foo' => 'bar'}],
-          }
+          modified.selector.should eq({ '$and' => [ { 'foo' => 'zoom' }, { 'foo' => 'bar' } ] })
         end
       end
 
       context '$and to query with $and onto query whose first one is not $and' do
         let(:query) do
-          Mongoid::Query.new.where({'foo' => 'baz'}).where('$and' => [{zoom: 'zoom'}])
+          Mongoid::Query.new.where({ 'foo' => 'baz' }).where('$and' => [ { zoom: 'zoom' } ])
         end
 
         let(:modified) do
-          query.send(query_method, '$and', [{'foo' => 'bar'}])
+          query.send(query_method, '$and', [ { 'foo' => 'bar' } ])
         end
 
         it 'adds to existing $and' do
-          modified.selector.should == {
-            '$and' => [{'zoom' => 'zoom'}, {'foo' => 'bar'}], 'foo' => 'baz'}
+          modified.selector.should eq({ '$and' => [ { 'zoom' => 'zoom' }, { 'foo' => 'bar' } ], 'foo' => 'baz' })
         end
       end
     end
@@ -87,11 +79,11 @@ describe Mongoid::Criteria::Queryable::Storable do
     context '$or operator' do
       context '$or to empty query' do
         let(:modified) do
-          query.send(query_method, '$or', [{'foo' => 'bar'}])
+          query.send(query_method, '$or', [ { 'foo' => 'bar' } ])
         end
 
         it 'adds to top level' do
-          modified.selector.should == {'$or' => [{'foo' => 'bar'}]}
+          modified.selector.should eq({ '$or' => [ { 'foo' => 'bar' } ] })
         end
       end
 
@@ -101,32 +93,27 @@ describe Mongoid::Criteria::Queryable::Storable do
         end
 
         let(:modified) do
-          query.send(query_method, '$or', [{'foo' => 'bar'}])
+          query.send(query_method, '$or', [ { 'foo' => 'bar' } ])
         end
 
         it 'adds the new conditions' do
-          modified.selector.should == {
-            'zoom' => 'zoom',
-            '$or' => ['foo' => 'bar'],
-          }
+          modified.selector.should eq({ 'zoom' => 'zoom', '$or' => [ { 'foo' => 'bar' } ] })
         end
       end
 
       context '$or to query with $or' do
         let(:query) do
-          Mongoid::Query.new.where('$or' => [{zoom: 'zoom'}])
+          Mongoid::Query.new.where('$or' => [ { zoom: 'zoom' } ])
         end
 
         let(:modified) do
-          query.send(query_method, '$or', [{'foo' => 'bar'}])
+          query.send(query_method, '$or', [ { 'foo' => 'bar' } ])
         end
 
         it 'adds to existing $or' do
-          modified.selector.should == {
-            '$or' => [{'zoom' => 'zoom'}, {'foo' => 'bar'}]}
+          modified.selector.should eq({ '$or' => [ { 'zoom' => 'zoom' }, { 'foo' => 'bar' } ] })
         end
       end
-
     end
   end
 
@@ -137,15 +124,13 @@ describe Mongoid::Criteria::Queryable::Storable do
       end
 
       it 'adds the condition' do
-        modified.selector.should == {
-          'foo' => 'bar'
-        }
+        modified.selector.should eq({ 'foo' => 'bar' })
       end
     end
 
     context 'an operator write' do
       let(:modified) do
-        query.add_field_expression('$eq', {'foo' => 'bar'})
+        query.add_field_expression('$eq', { 'foo' => 'bar' })
       end
 
       it 'is not allowed' do
@@ -165,10 +150,7 @@ describe Mongoid::Criteria::Queryable::Storable do
       end
 
       it 'adds the condition' do
-        modified.selector.should == {
-          'foo' => 'bar',
-          'zoom' => 'zoom',
-        }
+        modified.selector.should eq({ 'foo' => 'bar', 'zoom' => 'zoom' })
       end
     end
 
@@ -182,85 +164,76 @@ describe Mongoid::Criteria::Queryable::Storable do
       end
 
       it 'adds the new condition using $and' do
-        modified.selector.should == {
-          'foo' => 'bar',
-          '$and' => ['foo' => 'zoom'],
-        }
+        modified.selector.should eq({ 'foo' => 'bar', '$and' => [ { 'foo' => 'zoom' } ] })
       end
     end
 
     context 'when value is a hash combine values with different operator keys' do
       let(:base) do
-        query.add_field_expression('foo', {'$in' => ['bar']})
+        query.add_field_expression('foo', { '$in' => [ 'bar' ] })
       end
 
       let(:modified) do
-        base.add_field_expression('foo', {'$nin' => ['zoom']})
+        base.add_field_expression('foo', { '$nin' => [ 'zoom' ] })
       end
 
       it 'combines the conditions using $and' do
-        modified.selector.should == {
-          'foo' => {
-            '$in' => ['bar'],
-            '$nin' => ['zoom']
-          }
-        }
+        modified.selector.should eq({ 'foo' => { '$in' => [ 'bar' ], '$nin' => [ 'zoom' ] } })
       end
     end
 
     context 'when value is a hash with symbol operator key combine values with different operator keys' do
       let(:base) do
-        query.add_field_expression('foo', {:$in => ['bar']})
+        query.add_field_expression('foo', { :$in => [ 'bar' ] })
       end
 
       let(:modified) do
-        base.add_field_expression('foo', {:$nin => ['zoom']})
+        base.add_field_expression('foo', { :$nin => [ 'zoom' ] })
       end
 
       it 'combines the conditions using $and' do
-        modified.selector.should == {
-          'foo' => {
-            :$in => ['bar'],
-            :$nin => ['zoom']
-          }
-        }
+        modified.selector.should eq({ 'foo' => { :$in => [ 'bar' ], :$nin => [ 'zoom' ] } })
       end
     end
 
     context 'when value is a hash add values with same operator keys using $and' do
       let(:base) do
-        query.add_field_expression('foo', {'$in' => ['bar']})
+        query.add_field_expression('foo', { '$in' => [ 'bar' ] })
       end
 
       let(:modified) do
-        base.add_field_expression('foo', {'$in' => ['zoom']})
+        base.add_field_expression('foo', { '$in' => [ 'zoom' ] })
       end
 
       it 'adds the new condition using $and' do
-        modified.selector.should == {
-          'foo' => {'$in' => ['bar']},
-          '$and' => ['foo' => {'$in' => ['zoom']}]
-        }
+        modified.selector.should eq(
+          {
+            'foo' => { '$in' => [ 'bar' ] },
+            '$and' => [ { 'foo' => { '$in' => [ 'zoom' ] } } ]
+          }
+        )
       end
     end
 
-  context 'when value is a hash with symbol operator key add values with same operator keys using $and' do
-    let(:base) do
-      query.add_field_expression('foo', {:$in => ['bar']})
-    end
+    context 'when value is a hash with symbol operator key add values with same operator keys using $and' do
+      let(:base) do
+        query.add_field_expression('foo', { :$in => [ 'bar' ] })
+      end
 
-    let(:modified) do
-      base.add_field_expression('foo', {:$in => ['zoom']})
-    end
+      let(:modified) do
+        base.add_field_expression('foo', { :$in => [ 'zoom' ] })
+      end
 
-    it 'adds the new condition using $and' do
-      modified.selector.should == {
-        'foo' => {:$in => ['bar']},
-        '$and' => ['foo' => {:$in => ['zoom']}]
-      }
+      it 'adds the new condition using $and' do
+        modified.selector.should eq(
+          {
+            'foo' => { :$in => [ 'bar' ] },
+            '$and' => [ { 'foo' => { :$in => [ 'zoom' ] } } ]
+          }
+        )
+      end
     end
   end
-end
 
   describe '#add_operator_expression' do
     let(:query_method) { :add_operator_expression }

data/spec/mongoid/criteria/queryable_mql_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal:true
+
+require 'spec_helper'
+
+describe Mongoid::Criteria::Queryable do
+  let(:db) do
+    Mongoid.default_client.database.name
+  end
+
+  let(:collection) do
+    Band.collection_name.to_s
+  end
+
+  shared_examples 'translatable to mql' do
+    it 'returns mql' do
+      expect(criteria.to_mql).to eq(mql)
+    end
+  end
+
+  describe '#to_mql' do
+    context 'when simple where' do
+      let(:criteria) do
+        Band.where(name: 'Depeche Mode')
+      end
+
+      let(:mql) do
+        {
+          '$db': db,
+          find: collection,
+          filter: { 'name' => 'Depeche Mode' }
+        }
+      end
+
+      it_behaves_like 'translatable to mql'
+    end
+
+    context 'with storage field name' do
+      let(:criteria) do
+        Band.where(:origin.ne => 'UK')
+            .in(years: [ 1995, 1996 ])
+      end
+
+      let(:mql) do
+        {
+          '$db': db,
+          find: collection,
+          filter: {
+            'origin' => { '$ne' => 'UK' },
+            'y' => { '$in' => [ 1995, 1996 ] }
+          }
+        }
+      end
+
+      it_behaves_like 'translatable to mql'
+    end
+
+    context 'with alias attribute' do
+      let(:criteria) do
+        Band.where(d: true)
+      end
+
+      let(:mql) do
+        {
+          '$db': db,
+          find: collection,
+          filter: { 'deleted' => true }
+        }
+      end
+
+      it_behaves_like 'translatable to mql'
+    end
+
+    context 'with options' do
+      let(:criteria) do
+        Band.where(genres: %w[rock hip-hop]).order(founded: 1).limit(100).skip(200)
+      end
+
+      let(:mql) do
+        {
+          '$db': db,
+          find: collection,
+          filter: { 'genres' => %w[rock hip-hop] },
+          limit: 100,
+          skip: 200,
+          sort: { 'founded' => 1 }
+        }
+      end
+
+      it_behaves_like 'translatable to mql'
+    end
+  end
+end