mongoid 9.0.11 → 9.1.0

data/spec/mongoid/criteria/translator_spec.rb

@@ -1,129 +1,128 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Criteria::Translator do
-  describe "#to_direction" do
-    context "when the value is a string" do
-      context "when ascending" do
-        it "returns 1" do
-          expect(described_class.to_direction("ascending")).to eq(1)
+  describe '#to_direction' do
+    context 'when the value is a string' do
+      context 'when ascending' do
+        it 'returns 1' do
+          expect(described_class.to_direction('ascending')).to eq(1)
         end
       end
 
-      context "when asc" do
-        it "returns 1" do
-          expect(described_class.to_direction("asc")).to eq(1)
+      context 'when asc' do
+        it 'returns 1' do
+          expect(described_class.to_direction('asc')).to eq(1)
         end
       end
 
-      context "when ASCENDING" do
-        it "returns 1" do
-          expect(described_class.to_direction("ASCENDING")).to eq(1)
+      context 'when ASCENDING' do
+        it 'returns 1' do
+          expect(described_class.to_direction('ASCENDING')).to eq(1)
         end
       end
 
-      context "when ASC" do
-        it "returns 1" do
-          expect(described_class.to_direction("ASC")).to eq(1)
+      context 'when ASC' do
+        it 'returns 1' do
+          expect(described_class.to_direction('ASC')).to eq(1)
         end
       end
 
-      context "when descending" do
-        it "returns -1" do
-          expect(described_class.to_direction("descending")).to eq(-1)
+      context 'when descending' do
+        it 'returns -1' do
+          expect(described_class.to_direction('descending')).to eq(-1)
         end
       end
 
-      context "when desc" do
-        it "returns -1" do
-          expect(described_class.to_direction("desc")).to eq(-1)
+      context 'when desc' do
+        it 'returns -1' do
+          expect(described_class.to_direction('desc')).to eq(-1)
         end
       end
 
-      context "when DESCENDING" do
-        it "returns -1" do
-          expect(described_class.to_direction("DESCENDING")).to eq(-1)
+      context 'when DESCENDING' do
+        it 'returns -1' do
+          expect(described_class.to_direction('DESCENDING')).to eq(-1)
         end
       end
 
-      context "when DESC" do
-        it "returns -1" do
-          expect(described_class.to_direction("DESC")).to eq(-1)
+      context 'when DESC' do
+        it 'returns -1' do
+          expect(described_class.to_direction('DESC')).to eq(-1)
         end
       end
     end
 
-    context "when the value is a symbol" do
-      context "when ascending" do
-        it "returns 1" do
+    context 'when the value is a symbol' do
+      context 'when ascending' do
+        it 'returns 1' do
           expect(described_class.to_direction(:ascending)).to eq(1)
         end
       end
-  
-      context "when asc" do
-        it "returns 1" do
+
+      context 'when asc' do
+        it 'returns 1' do
           expect(described_class.to_direction(:asc)).to eq(1)
         end
       end
-  
-      context "when ASCENDING" do
-        it "returns 1" do
+
+      context 'when ASCENDING' do
+        it 'returns 1' do
           expect(described_class.to_direction(:ASCENDING)).to eq(1)
         end
       end
-  
-      context "when ASC" do
-        it "returns 1" do
+
+      context 'when ASC' do
+        it 'returns 1' do
           expect(described_class.to_direction(:ASC)).to eq(1)
         end
       end
-  
-      context "when descending" do
-        it "returns -1" do
+
+      context 'when descending' do
+        it 'returns -1' do
           expect(described_class.to_direction(:descending)).to eq(-1)
         end
       end
-  
-      context "when desc" do
-        it "returns -1" do
+
+      context 'when desc' do
+        it 'returns -1' do
           expect(described_class.to_direction(:desc)).to eq(-1)
         end
       end
-  
-      context "when DESCENDING" do
-        it "returns -1" do
+
+      context 'when DESCENDING' do
+        it 'returns -1' do
           expect(described_class.to_direction(:DESCENDING)).to eq(-1)
         end
       end
-  
-      context "when DESC" do
-        it "returns -1" do
+
+      context 'when DESC' do
+        it 'returns -1' do
           expect(described_class.to_direction(:DESC)).to eq(-1)
         end
       end
     end
 
-    context "when the value is numeric" do
-      it "should pass the value through unchanged" do
+    context 'when the value is numeric' do
+      it 'passes the value through unchanged' do
         expect(described_class.to_direction(1)).to eq(1)
         expect(described_class.to_direction(-1)).to eq(-1)
         expect(described_class.to_direction(Math::PI)).to eq(Math::PI)
       end
     end
 
-    context "when the value is a hash" do
-      it "should pass the value through unchanged" do
+    context 'when the value is a hash' do
+      it 'passes the value through unchanged' do
         expect(described_class.to_direction({})).to eq({})
-        expect(described_class.to_direction(scope: { "$meta" => "textScore" }))
-          .to eq(scope: { "$meta" => "textScore" })
+        expect(described_class.to_direction(scope: { '$meta' => 'textScore' }))
+          .to eq(scope: { '$meta' => 'textScore' })
         expect(described_class.to_direction(a: 1, b: 2)).to eq(a: 1, b: 2)
       end
     end
 
-    context "when the value is an unrecognized type" do
-      it "should raise ArgumentError" do
+    context 'when the value is an unrecognized type' do
+      it 'raises ArgumentError' do
         expect { described_class.to_direction([]) }.to raise_error(ArgumentError)
         expect { described_class.to_direction(/a/) }.to raise_error(ArgumentError)
         expect { described_class.to_direction(Object.new) }.to raise_error(ArgumentError)

data/spec/mongoid/criteria_projection_spec.rb

@@ -1,103 +1,95 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Criteria do
-
-  describe "#only" do
-
+  describe '#only' do
     let!(:band) do
-      Band.create!(name: "Depeche Mode", likes: 3, views: 10)
+      Band.create!(name: 'Depeche Mode', likes: 3, views: 10)
     end
 
-    context "when not using inheritance" do
-
-      context "when passing splat args" do
-
+    context 'when not using inheritance' do
+      context 'when passing splat args' do
         let(:criteria) do
           Band.only(:_id)
         end
 
-        it "limits the returned fields" do
-          expect {
+        it 'limits the returned fields' do
+          expect do
             criteria.first.name
-          }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'name' on Band which was not loaded/)
+          end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                             /Attempted to access attribute 'name' on Band which was not loaded/)
         end
 
-        it "does not add _type to the fields" do
-          expect(criteria.options[:fields]["_type"]).to be_nil
+        it 'does not add _type to the fields' do
+          expect(criteria.options[:fields]['_type']).to be_nil
         end
       end
 
-      context "when not including id" do
-
+      context 'when not including id' do
         let(:criteria) do
           Band.only(:name)
         end
 
-        it "responds to id anyway" do
-          expect {
+        it 'responds to id anyway' do
+          expect do
             criteria.first.id
-          }.to_not raise_error
+          end.not_to raise_error
         end
       end
 
-      context "when passing an array" do
-
+      context 'when passing an array' do
         let(:criteria) do
-          Band.only([ :name, :likes ])
+          Band.only(%i[name likes])
         end
 
-        it "includes the limited fields" do
-          expect(criteria.first.name).to_not be_nil
+        it 'includes the limited fields' do
+          expect(criteria.first.name).not_to be_nil
         end
 
-        it "excludes the non included fields" do
-          expect {
+        it 'excludes the non included fields' do
+          expect do
             criteria.first.active
-          }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'active' on Band which was not loaded/)
+          end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                             /Attempted to access attribute 'active' on Band which was not loaded/)
         end
 
-        it "does not add _type to the fields" do
-          expect(criteria.options[:fields]["_type"]).to be_nil
+        it 'does not add _type to the fields' do
+          expect(criteria.options[:fields]['_type']).to be_nil
         end
       end
 
-      context "when instantiating a class of another type inside the iteration" do
-
+      context 'when instantiating a class of another type inside the iteration' do
         let(:criteria) do
           Band.only(:name)
         end
 
-        it "only limits the fields on the correct model" do
-          criteria.each do |band|
+        it 'only limits the fields on the correct model' do
+          criteria.each do |_band|
             expect(Person.new.age).to eq(100)
           end
         end
       end
 
-      context "when instantiating a document not in the result set" do
-
+      context 'when instantiating a document not in the result set' do
         let(:criteria) do
           Band.only(:name)
         end
 
-        it "only limits the fields on the correct criteria" do
-          criteria.each do |band|
+        it 'only limits the fields on the correct criteria' do
+          criteria.each do |_band|
             expect(Band.new.active).to be true
           end
         end
       end
 
-      context "when nesting a criteria within a criteria" do
-
+      context 'when nesting a criteria within a criteria' do
         let(:criteria) do
           Band.only(:name)
         end
 
-        it "only limits the fields on the correct criteria" do
-          criteria.each do |band|
+        it 'only limits the fields on the correct criteria' do
+          criteria.each do |_band|
             Band.all.each do |b|
               expect(b.active).to be true
             end
@@ -106,20 +98,20 @@ describe Mongoid::Criteria do
       end
     end
 
-    context "when using inheritance" do
-      context "when using the default discriminator key" do
+    context 'when using inheritance' do
+      context 'when using the default discriminator key' do
         let(:criteria) do
           Doctor.only(:_id)
         end
 
-        it "adds _type to the fields" do
-          expect(criteria.options[:fields]).to include("_type")
+        it 'adds _type to the fields' do
+          expect(criteria.options[:fields]).to include('_type')
         end
       end
 
-      context "when setting a custom discriminator key" do
+      context 'when setting a custom discriminator key' do
         before do
-          Person.discriminator_key = "dkey"
+          Person.discriminator_key = 'dkey'
         end
 
         after do
@@ -130,26 +122,24 @@ describe Mongoid::Criteria do
           Doctor.only(:_id)
         end
 
-        it "adds custom discriminator key to the fields" do
-          expect(criteria.options[:fields]).to include("dkey")
+        it 'adds custom discriminator key to the fields' do
+          expect(criteria.options[:fields]).to include('dkey')
         end
 
-        it "does not add _type to the fields" do
-          expect(criteria.options[:fields]).to_not include("_type")
+        it 'does not add _type to the fields' do
+          expect(criteria.options[:fields]).not_to include('_type')
         end
       end
     end
 
-    context "when limiting to embedded documents" do
-
-      context "when the embedded documents are aliased" do
-
+    context 'when limiting to embedded documents' do
+      context 'when the embedded documents are aliased' do
         let(:criteria) do
           Person.only(:phones)
         end
 
-        it "properly uses the database field name" do
-          expect(criteria.options).to eq(fields: { "_id" => 1, "mobile_phones" => 1 })
+        it 'properly uses the database field name' do
+          expect(criteria.options).to eq(fields: { '_id' => 1, 'mobile_phones' => 1 })
         end
       end
     end
@@ -166,7 +156,6 @@ describe Mongoid::Criteria do
       end
 
       context 'when entire field is included' do
-
         let(:dictionary) do
           Dictionary.only(:description).first
         end
@@ -184,14 +173,13 @@ describe Mongoid::Criteria do
       end
 
       context 'when a specific locale is included' do
-
         let(:dictionary) do
           Dictionary.only(:'description.de').first
         end
 
         it 'loads translations only for the included locale' do
           expect(dictionary.description_translations.keys).to include('de')
-          expect(dictionary.description_translations.keys).to_not include('en')
+          expect(dictionary.description_translations.keys).not_to include('en')
         end
 
         it 'returns the field value for the included locale' do
@@ -203,28 +191,26 @@ describe Mongoid::Criteria do
       end
 
       context 'when entire field is excluded' do
-
         let(:dictionary) do
           Dictionary.without(:description).first
         end
 
         it 'does not load all translations' do
-          expect(dictionary.description_translations.keys).to_not include('de', 'en')
+          expect(dictionary.description_translations.keys).not_to include('de', 'en')
         end
 
         it 'raises an Mongoid::Errors::AttributeNotLoaded when attempting to access the field' do
-          expect{dictionary.description}.to raise_error Mongoid::Errors::AttributeNotLoaded
+          expect { dictionary.description }.to raise_error Mongoid::Errors::AttributeNotLoaded
         end
       end
 
       context 'when a specific locale is excluded' do
-
         let(:dictionary) do
           Dictionary.without(:'description.de').first
         end
 
         it 'does not load excluded translations' do
-          expect(dictionary.description_translations.keys).to_not include('de')
+          expect(dictionary.description_translations.keys).not_to include('de')
           expect(dictionary.description_translations.keys).to include('en')
         end
 
@@ -238,15 +224,14 @@ describe Mongoid::Criteria do
     end
 
     context 'when restricting to id' do
-
       context 'when id is aliased to _id' do
         shared_examples 'requests _id field' do
           it 'requests _id field' do
-            criteria.options[:fields].should == {'_id' => 1}
+            criteria.options[:fields].should eq({ '_id' => 1 })
           end
         end
 
-        ['id', '_id', :id, :_id].each do |field|
+        [ 'id', '_id', :id, :_id ].each do |field|
           context "using #{field.inspect}" do
             let(:criteria) do
               Band.where.only(field)
@@ -262,7 +247,7 @@ describe Mongoid::Criteria do
           end
 
           it 'requests content field and _id field' do
-            criteria.options[:fields].should == {'_id' => 1, 'name' => 1}
+            criteria.options[:fields].should eq({ '_id' => 1, 'name' => 1 })
           end
         end
       end
@@ -270,17 +255,17 @@ describe Mongoid::Criteria do
       context 'when id is not aliased to _id' do
         shared_examples 'requests _id field' do
           it 'requests _id field' do
-            criteria.options[:fields].should == {'_id' => 1}
+            criteria.options[:fields].should eq({ '_id' => 1 })
           end
         end
 
         shared_examples 'requests id field and _id field' do
           it 'requests id field and _id field' do
-            criteria.options[:fields].should == {'_id' => 1, 'id' => 1}
+            criteria.options[:fields].should eq({ '_id' => 1, 'id' => 1 })
           end
         end
 
-        ['_id', :_id].each do |field|
+        [ '_id', :_id ].each do |field|
           context "using #{field.inspect}" do
             let(:criteria) do
               Shirt.where.only(field)
@@ -290,7 +275,7 @@ describe Mongoid::Criteria do
           end
         end
 
-        ['id', :id].each do |field|
+        [ 'id', :id ].each do |field|
           context "using #{field.inspect}" do
             let(:criteria) do
               Shirt.where.only(field)
@@ -303,68 +288,65 @@ describe Mongoid::Criteria do
     end
   end
 
-  describe "#without" do
-
+  describe '#without' do
     let!(:person) do
-      Person.create!(username: "davinci", age: 50, pets: false)
+      Person.create!(username: 'davinci', age: 50, pets: false)
     end
 
-    context "when omitting to embedded documents" do
-
-      context "when the embedded documents are aliased" do
-
+    context 'when omitting to embedded documents' do
+      context 'when the embedded documents are aliased' do
         let(:criteria) do
           Person.without(:phones)
         end
 
-        it "properly uses the database field name" do
-          expect(criteria.options).to eq(fields: { "mobile_phones" => 0 })
+        it 'properly uses the database field name' do
+          expect(criteria.options).to eq(fields: { 'mobile_phones' => 0 })
         end
       end
     end
 
-    context "when excluding id fields" do
-
+    context 'when excluding id fields' do
       shared_examples 'does not raise error' do
-        it "does not raise error" do
-          expect {
+        it 'does not raise error' do
+          expect do
             criteria.first._id
-          }.to_not raise_error
+          end.not_to raise_error
         end
       end
 
       shared_examples 'does not unproject _id' do
         it 'does not unproject _id' do
-          criteria.options[:fields].should be nil
+          criteria.options[:fields].should be_nil
         end
 
-        it "returns id anyway" do
-          expect(criteria.first.id).to_not be_nil
+        it 'returns id anyway' do
+          expect(criteria.first.id).not_to be_nil
         end
       end
 
       shared_examples 'unprojects id' do
         it 'does not unproject _id' do
-          criteria.options[:fields].should == {'id' => 0}
+          criteria.options[:fields].should eq({ 'id' => 0 })
         end
 
         let(:instance) { criteria.first }
 
-        it "returns _id" do
-          instance._id.should == 'foo'
+        it 'returns _id' do
+          instance._id.should eq 'foo'
         end
 
         it 'does not return id' do
           lambda do
             instance.id
-          end.should raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'id' on Shirt which was not loaded/)
+          end.should raise_error(Mongoid::Errors::AttributeNotLoaded,
+                                 /Attempted to access attribute 'id' on Shirt which was not loaded/)
         end
       end
 
       context 'model with id aliased to _id' do
         context 'id field' do
           let(:criteria) do
-            Person.without(:id, "id")
+            Person.without(:id, 'id')
           end
 
           include_examples 'does not raise error'
@@ -373,7 +355,7 @@ describe Mongoid::Criteria do
 
         context '_id field' do
           let(:criteria) do
-            Person.without(:_id, "_id")
+            Person.without(:_id, '_id')
           end
 
           include_examples 'does not raise error'
@@ -386,7 +368,7 @@ describe Mongoid::Criteria do
 
         context 'id field' do
           let(:criteria) do
-            Shirt.without(:id, "id")
+            Shirt.without(:id, 'id')
           end
 
           include_examples 'does not raise error'
@@ -395,7 +377,7 @@ describe Mongoid::Criteria do
 
         context '_id field' do
           let(:criteria) do
-            Shirt.without(:_id, "_id")
+            Shirt.without(:_id, '_id')
           end
 
           include_examples 'does not raise error'