mongoid 9.0.12 → 9.1.0

data/spec/mongoid/criteria/options_spec.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Criteria::Options do
-
-
   context 'when a persistence context with options is set on the class of the criteria' do
-
     let(:context) do
       Band.with(connect_timeout: 10) do |klass|
         klass.where(name: 'FKA Twigs').persistence_context
@@ -20,13 +16,12 @@ describe Mongoid::Criteria::Options do
   end
 
   context 'when a persistence context with options is not set on the class of the criteria' do
-
     let(:context) do
       Band.where(name: 'FKA Twigs').persistence_context
     end
 
     it 'uses the persistence context of the class of the criteria' do
-      expect(context.options).to eq({ })
+      expect(context.options).to eq({})
     end
   end
 end

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

@@ -1,29 +1,24 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Criteria::Queryable::Aggregable do
-
   let(:query) do
-    Mongoid::Query.new("id" => "_id", "alias" => "a")
+    Mongoid::Query.new('id' => '_id', 'alias' => 'a')
   end
 
-  shared_examples_for "an aggregable object" do
-
-    it "clones the queryable" do
-      expect(aggregation).to_not equal(query)
+  shared_examples_for 'an aggregable object' do
+    it 'clones the queryable' do
+      expect(aggregation).not_to equal(query)
     end
 
-    it "sets the aggregating flag" do
+    it 'sets the aggregating flag' do
       expect(aggregation).to be_aggregating
     end
   end
 
-  describe "#project" do
-
-    context "when no selection or options exist" do
-
+  describe '#project' do
+    context 'when no selection or options exist' do
       let(:aggregation) do
         query.project(author: 1, title: 0)
       end
@@ -32,58 +27,54 @@ describe Mongoid::Criteria::Queryable::Aggregable do
         aggregation.pipeline
       end
 
-      it "sets the projection" do
+      it 'sets the projection' do
         expect(pipeline).to eq([
-          { "$project" => { "author" => 1, "title" => 0 }}
-        ])
+                                 { '$project' => { 'author' => 1, 'title' => 0 } }
+                               ])
       end
 
-      it_behaves_like "an aggregable object"
+      it_behaves_like 'an aggregable object'
     end
 
-    context "when the field is aliased" do
-
+    context 'when the field is aliased' do
       let(:aggregation) do
-        query.project(id: 1, title: "$docTitle")
+        query.project(id: 1, title: '$docTitle')
       end
 
       let!(:pipeline) do
         aggregation.pipeline
       end
 
-      it "sets the aliased projection" do
+      it 'sets the aliased projection' do
         expect(pipeline).to eq([
-          { "$project" => { "_id" => 1, "title" => "$docTitle" }}
-        ])
+                                 { '$project' => { '_id' => 1, 'title' => '$docTitle' } }
+                               ])
       end
 
-      it_behaves_like "an aggregable object"
+      it_behaves_like 'an aggregable object'
     end
 
-    context "when selection exists" do
-
+    context 'when selection exists' do
       let(:aggregation) do
-        query.where(name: "test").project(author: 1, title: 0)
+        query.where(name: 'test').project(author: 1, title: 0)
       end
 
       let!(:pipeline) do
         aggregation.pipeline
       end
 
-      it "converts the selection to a $match" do
+      it 'converts the selection to a $match' do
         expect(pipeline).to eq([
-          { "$match" => { "name" => "test" }},
-          { "$project" => { "author" => 1, "title" => 0 }}
-        ])
+                                 { '$match' => { 'name' => 'test' } },
+                                 { '$project' => { 'author' => 1, 'title' => 0 } }
+                               ])
       end
 
-      it_behaves_like "an aggregable object"
+      it_behaves_like 'an aggregable object'
     end
 
-    context "when options exist" do
-
-      context "when the option is a sort" do
-
+    context 'when options exist' do
+      context 'when the option is a sort' do
         let(:aggregation) do
           query.asc(:name).project(author: 1, title: 0)
         end
@@ -92,18 +83,17 @@ describe Mongoid::Criteria::Queryable::Aggregable do
           aggregation.pipeline
         end
 
-        it "converts the option to a $sort" do
+        it 'converts the option to a $sort' do
           expect(pipeline).to eq([
-            { "$sort" => { "name" => 1 }},
-            { "$project" => { "author" => 1, "title" => 0 }}
-          ])
+                                   { '$sort' => { 'name' => 1 } },
+                                   { '$project' => { 'author' => 1, 'title' => 0 } }
+                                 ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
 
-      context "when the option is a limit" do
-
+      context 'when the option is a limit' do
         let(:aggregation) do
           query.limit(10).project(author: 1, title: 0)
         end
@@ -112,18 +102,17 @@ describe Mongoid::Criteria::Queryable::Aggregable do
           aggregation.pipeline
         end
 
-        it "converts the option to a $sort" do
+        it 'converts the option to a $sort' do
           expect(pipeline).to eq([
-            { "$limit" => 10 },
-            { "$project" => { "author" => 1, "title" => 0 }}
-          ])
+                                   { '$limit' => 10 },
+                                   { '$project' => { 'author' => 1, 'title' => 0 } }
+                                 ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
 
-      context "when the option is a skip" do
-
+      context 'when the option is a skip' do
         let(:aggregation) do
           query.skip(10).project(author: 1, title: 0)
         end
@@ -132,43 +121,40 @@ describe Mongoid::Criteria::Queryable::Aggregable do
           aggregation.pipeline
         end
 
-        it "converts the option to a $sort" do
+        it 'converts the option to a $sort' do
           expect(pipeline).to eq([
-            { "$skip" => 10 },
-            { "$project" => { "author" => 1, "title" => 0 }}
-          ])
+                                   { '$skip' => 10 },
+                                   { '$project' => { 'author' => 1, 'title' => 0 } }
+                                 ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
     end
 
-    context "when selection and options exist" do
-
+    context 'when selection and options exist' do
       let(:aggregation) do
-        query.skip(10).where(name: "test").project(author: 1, title: 0)
+        query.skip(10).where(name: 'test').project(author: 1, title: 0)
       end
 
       let!(:pipeline) do
         aggregation.pipeline
       end
 
-      it "converts the option to a $sort" do
+      it 'converts the option to a $sort' do
         expect(pipeline).to eq([
-          { "$match" => { "name" => "test" }},
-          { "$skip" => 10 },
-          { "$project" => { "author" => 1, "title" => 0 }}
-        ])
+                                 { '$match' => { 'name' => 'test' } },
+                                 { '$skip' => 10 },
+                                 { '$project' => { 'author' => 1, 'title' => 0 } }
+                               ])
       end
 
-      it_behaves_like "an aggregable object"
+      it_behaves_like 'an aggregable object'
     end
   end
 
-  describe "#unwind" do
-
-    context "when another pipeline operation exists" do
-
+  describe '#unwind' do
+    context 'when another pipeline operation exists' do
       let(:aggregation) do
         query.project(name: 1).unwind(:author)
       end
@@ -177,20 +163,18 @@ describe Mongoid::Criteria::Queryable::Aggregable do
         aggregation.pipeline
       end
 
-      it "adds the unwind to the pipeline" do
+      it 'adds the unwind to the pipeline' do
         expect(pipeline).to eq([
-          { "$project" => { "name" => 1 }},
-          { "$unwind" => "$author" }
-        ])
+                                 { '$project' => { 'name' => 1 } },
+                                 { '$unwind' => '$author' }
+                               ])
       end
 
-      it_behaves_like "an aggregable object"
+      it_behaves_like 'an aggregable object'
     end
 
-    context "when provided a symbol" do
-
-      context "when the symbol begins with $" do
-
+    context 'when provided a symbol' do
+      context 'when the symbol begins with $' do
         let(:aggregation) do
           query.unwind(:$author)
         end
@@ -199,15 +183,14 @@ describe Mongoid::Criteria::Queryable::Aggregable do
           aggregation.pipeline
         end
 
-        it "converts the symbol to a string" do
-          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        it 'converts the symbol to a string' do
+          expect(pipeline).to eq([ { '$unwind' => '$author' } ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
 
-      context "when the symbol does not begin with $" do
-
+      context 'when the symbol does not begin with $' do
         let(:aggregation) do
           query.unwind(:author)
         end
@@ -216,35 +199,32 @@ describe Mongoid::Criteria::Queryable::Aggregable do
           aggregation.pipeline
         end
 
-        it "converts the symbol to a string and prepends $" do
-          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        it 'converts the symbol to a string and prepends $' do
+          expect(pipeline).to eq([ { '$unwind' => '$author' } ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
     end
 
-    context "when provided a string" do
-
-      context "when the string begins with $" do
-
+    context 'when provided a string' do
+      context 'when the string begins with $' do
         let(:aggregation) do
-          query.unwind("$author")
+          query.unwind('$author')
         end
 
         let!(:pipeline) do
           aggregation.pipeline
         end
 
-        it "sets the string" do
-          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        it 'sets the string' do
+          expect(pipeline).to eq([ { '$unwind' => '$author' } ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
 
-      context "when the string does not begin with $" do
-
+      context 'when the string does not begin with $' do
         let(:aggregation) do
           query.unwind(:author)
         end
@@ -253,18 +233,16 @@ describe Mongoid::Criteria::Queryable::Aggregable do
           aggregation.pipeline
         end
 
-        it "prepends $ to the string" do
-          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        it 'prepends $ to the string' do
+          expect(pipeline).to eq([ { '$unwind' => '$author' } ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
     end
 
-    context "when provided a string alias" do
-
-      context "when the string does not begin with $" do
-
+    context 'when provided a string alias' do
+      context 'when the string does not begin with $' do
         let(:aggregation) do
           query.unwind(:alias)
         end
@@ -273,100 +251,93 @@ describe Mongoid::Criteria::Queryable::Aggregable do
           aggregation.pipeline
         end
 
-        it "prepends $ to the string" do
-          expect(pipeline).to eq([{ "$unwind" => "$a" }])
+        it 'prepends $ to the string' do
+          expect(pipeline).to eq([ { '$unwind' => '$a' } ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
     end
   end
 
-  describe "#group" do
-
-    context "when the expression fields are not aliased" do
-
-      context "when using full notation" do
-
+  describe '#group' do
+    context 'when the expression fields are not aliased' do
+      context 'when using full notation' do
         let(:aggregation) do
-          query.group(count: { "$sum" => 1 }, max: { "$max" => "likes" })
+          query.group(count: { '$sum' => 1 }, max: { '$max' => 'likes' })
         end
 
         let!(:pipeline) do
           aggregation.pipeline
         end
 
-        it "adds the group operation to the pipeline" do
+        it 'adds the group operation to the pipeline' do
           expect(pipeline).to eq([
-            { "$group" => { "count" => { "$sum" => 1 }, "max" => { "$max" => "likes" }}}
-          ])
+                                   { '$group' => { 'count' => { '$sum' => 1 }, 'max' => { '$max' => 'likes' } } }
+                                 ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
 
-      context "when using symbol shortcuts" do
-
+      context 'when using symbol shortcuts' do
         let(:aggregation) do
-          query.group(:count.sum => 1, :max.max => "likes")
+          query.group(:count.sum => 1, :max.max => 'likes')
         end
 
         let!(:pipeline) do
           aggregation.pipeline
         end
 
-        it "adds the group operation to the pipeline" do
+        it 'adds the group operation to the pipeline' do
           expect(pipeline).to eq([
-            { "$group" => { "count" => { "$sum" => 1 }, "max" => { "$max" => "likes" }}}
-          ])
+                                   { '$group' => { 'count' => { '$sum' => 1 }, 'max' => { '$max' => 'likes' } } }
+                                 ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
     end
 
-    context "when the expression fields are aliased" do
-
-      context "when using full notation" do
-
+    context 'when the expression fields are aliased' do
+      context 'when using full notation' do
         let(:aggregation) do
-          query.group(count: { "$sum" => 1 }, max: { "$max" => "alias" })
+          query.group(count: { '$sum' => 1 }, max: { '$max' => 'alias' })
         end
 
         let!(:pipeline) do
           aggregation.pipeline
         end
 
-        it "adds the group operation to the pipeline" do
+        it 'adds the group operation to the pipeline' do
           pending
-          fail
+          raise
           expect(pipeline).to eq([
-            { "$group" => { "count" => { "$sum" => 1 }, "max" => { "$max" => "a" }}}
-          ])
+                                   { '$group' => { 'count' => { '$sum' => 1 }, 'max' => { '$max' => 'a' } } }
+                                 ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
 
-      context "when using symbol shortcuts" do
-
+      context 'when using symbol shortcuts' do
         let(:aggregation) do
-          query.group(:count.sum => 1, :max.max => "alias")
+          query.group(:count.sum => 1, :max.max => 'alias')
         end
 
         let!(:pipeline) do
           aggregation.pipeline
         end
 
-        it "adds the group operation to the pipeline" do
+        it 'adds the group operation to the pipeline' do
           pending
-          fail
+          raise
           expect(pipeline).to eq([
-            { "$group" => { "count" => { "$sum" => 1 }, "max" => { "$max" => "a" }}}
-          ])
+                                   { '$group' => { 'count' => { '$sum' => 1 }, 'max' => { '$max' => 'a' } } }
+                                 ])
         end
 
-        it_behaves_like "an aggregable object"
+        it_behaves_like 'an aggregable object'
       end
     end
   end

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

@@ -1,19 +1,16 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Criteria::Queryable::Expandable do
-
   let(:query) do
     Mongoid::Query.new
   end
 
   describe '#expand_condition_to_array_values' do
     shared_examples_for 'expands' do
-
       it 'expands' do
-        query.send(:expand_condition_to_array_values, criterion).should == expected
+        query.send(:expand_condition_to_array_values, criterion).should eq expected
       end
 
       context 'when input is frozen' do
@@ -22,14 +19,14 @@ describe Mongoid::Criteria::Queryable::Expandable do
         end
 
         it 'expands' do
-          query.send(:expand_condition_to_array_values, criterion).should == expected
+          query.send(:expand_condition_to_array_values, criterion).should eq expected
         end
       end
 
       it 'does not modify input' do
         criterion_copy = criterion.dup.freeze
 
-        query.send(:expand_condition_to_array_values, criterion).should == expected
+        query.send(:expand_condition_to_array_values, criterion).should eq expected
 
         expect(criterion).to eq(criterion_copy)
       end
@@ -37,11 +34,11 @@ describe Mongoid::Criteria::Queryable::Expandable do
 
     context 'literal value' do
       let(:criterion) do
-        {foo: 4}
+        { foo: 4 }
       end
 
       let(:expected) do
-        {foo: [4]}
+        { foo: [ 4 ] }
       end
 
       it_behaves_like 'expands'
@@ -49,11 +46,11 @@ describe Mongoid::Criteria::Queryable::Expandable do
 
     context 'Range value' do
       let(:criterion) do
-        {foo: 1..4}
+        { foo: 1..4 }
       end
 
       let(:expected) do
-        {foo: [1, 2, 3, 4]}
+        { foo: [ 1, 2, 3, 4 ] }
       end
 
       it_behaves_like 'expands'