mongoid 9.0.11 → 9.1.0

data/spec/mongoid/extensions/object_spec.rb

@@ -1,112 +1,96 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Extensions::Object do
-
   let(:object) do
     Object.new
   end
 
-  describe "#__evolve_object_id__" do
-
-    it "returns self" do
+  describe '#__evolve_object_id__' do
+    it 'returns self' do
       expect(object.__evolve_object_id__).to eq(object)
     end
   end
 
-  describe "#__mongoize_object_id__" do
-
-    it "returns self" do
+  describe '#__mongoize_object_id__' do
+    it 'returns self' do
       expect(object.__mongoize_object_id__).to eq(object)
     end
   end
 
-  describe ".demongoize" do
-
+  describe '.demongoize' do
     let(:object) do
-      "testing"
+      'testing'
     end
 
-    it "returns the provided object" do
+    it 'returns the provided object' do
       expect(Object.demongoize(object)).to eq(object)
     end
   end
 
-  describe ".mongoize" do
-
+  describe '.mongoize' do
     let(:object) do
-      "testing"
+      'testing'
     end
 
-    it "returns the provided object" do
+    it 'returns the provided object' do
       expect(Object.mongoize(object)).to eq(object)
     end
   end
 
-  describe "#mongoize" do
-
+  describe '#mongoize' do
     let(:object) do
-      "testing"
+      'testing'
     end
 
-    it "returns the object" do
+    it 'returns the object' do
       expect(object.mongoize).to eq(object)
     end
   end
 
-  describe "#resizable?" do
-
-    it "returns false" do
-      expect(Object.new).to_not be_resizable
+  describe '#resizable?' do
+    it 'returns false' do
+      expect(Object.new).not_to be_resizable
     end
   end
 
-  describe "#remove_ivar" do
-
-    context "when the instance variable is defined" do
-
-      let(:document) do
-        Person.new
-      end
+  describe '#remove_ivar' do
+    context 'when the instance variable is defined' do
+      let(:document) { Person.new }
+      let(:removal) { document.remove_ivar('testing') }
 
       before do
-        document.instance_variable_set(:@_testing, "testing")
-      end
-
-      let!(:removal) do
-        document.remove_ivar("testing")
+        document.instance_variable_set(:@_testing, 'testing')
+        removal
       end
 
-      it "removes the instance variable" do
+      it 'removes the instance variable' do
         expect(document.instance_variable_defined?(:@_testing)).to be false
       end
 
-      it "returns the value" do
-        expect(removal).to eq("testing")
+      it 'returns the value' do
+        expect(removal).to eq('testing')
       end
     end
 
-    context "when the instance variable is not defined" do
-
+    context 'when the instance variable is not defined' do
       let(:document) do
         Person.new
       end
 
       let!(:removal) do
-        document.remove_ivar("testing")
+        document.remove_ivar('testing')
       end
 
-      it "returns false" do
+      it 'returns false' do
         expect(removal).to be false
       end
     end
   end
 
-  describe "#numeric?" do
-
-    it "returns false" do
+  describe '#numeric?' do
+    it 'returns false' do
       expect(object.numeric?).to eq(false)
     end
   end

data/spec/mongoid/extensions/range_spec.rb

@@ -1,189 +1,186 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Extensions::Range do
-
-  describe ".demongoize" do
+  describe '.demongoize' do
     subject { Range.demongoize(hash) }
 
-    context "when the range is ascending" do
-      let(:hash) { { "min" => 1, "max" => 3 } }
+    context 'when the range is ascending' do
+      let(:hash) { { 'min' => 1, 'max' => 3 } }
 
-      it "returns an ascending range" do
-        is_expected.to eq(1..3)
+      it 'returns an ascending range' do
+        expect(subject).to eq(1..3)
       end
     end
 
-    context "when the range is ascending with exclude end" do
-      let(:hash) { { "min" => 1, "max" => 3, "exclude_end" => true } }
+    context 'when the range is ascending with exclude end' do
+      let(:hash) { { 'min' => 1, 'max' => 3, 'exclude_end' => true } }
 
-      it "returns an ascending range" do
-        is_expected.to eq(1...3)
+      it 'returns an ascending range' do
+        expect(subject).to eq(1...3)
       end
     end
 
-    context "when the range is descending" do
-      let(:hash) { { "min" => 5, "max" => 1 } }
+    context 'when the range is descending' do
+      let(:hash) { { 'min' => 5, 'max' => 1 } }
 
-      it "returns an descending range" do
-        is_expected.to eq(5..1)
+      it 'returns an descending range' do
+        expect(subject).to eq(5..1)
       end
     end
 
-    context "when the range is descending with exclude end" do
-      let(:hash) { { "min" => 5, "max" => 1, "exclude_end" => true } }
+    context 'when the range is descending with exclude end' do
+      let(:hash) { { 'min' => 5, 'max' => 1, 'exclude_end' => true } }
 
-      it "returns an descending range" do
-        is_expected.to eq(5...1)
+      it 'returns an descending range' do
+        expect(subject).to eq(5...1)
       end
     end
 
-    context "when the range is letters" do
-      let(:hash) { { "min" => "a", "max" => "z" } }
+    context 'when the range is letters' do
+      let(:hash) { { 'min' => 'a', 'max' => 'z' } }
 
-      it "returns an alphabetic range" do
-        is_expected.to eq("a".."z")
+      it 'returns an alphabetic range' do
+        expect(subject).to eq('a'..'z')
       end
     end
 
-    context "when the range is letters with exclude end" do
-      let(:hash) { { "min" => "a", "max" => "z", "exclude_end" => true } }
+    context 'when the range is letters with exclude end' do
+      let(:hash) { { 'min' => 'a', 'max' => 'z', 'exclude_end' => true } }
 
-      it "returns an alphabetic range" do
-        is_expected.to eq("a"..."z")
+      it 'returns an alphabetic range' do
+        expect(subject).to eq('a'...'z')
       end
     end
 
-    context "when the range is endless" do
-      let(:hash) { { "min" => 1, "max" => nil } }
+    context 'when the range is endless' do
+      let(:hash) { { 'min' => 1, 'max' => nil } }
 
       context 'kernel can support endless range' do
         ruby_version_gte '2.6'
 
-        it "returns an alphabetic range" do
-          is_expected.to eq(eval('1..'))
+        it 'returns an alphabetic range' do
+          expect(subject).to eq(eval('1..'))
         end
       end
 
       context 'kernel cannot support endless range' do
         ruby_version_lt '2.6'
 
-        it "returns nil" do
-          is_expected.to be nil
+        it 'returns nil' do
+          expect(subject).to be_nil
         end
       end
     end
 
-    context "when the range is endless with exclude end" do
-      let(:hash) { { "min" => 1, "max" => nil, "exclude_end" => true } }
+    context 'when the range is endless with exclude end' do
+      let(:hash) { { 'min' => 1, 'max' => nil, 'exclude_end' => true } }
 
       context 'kernel can support endless range' do
         ruby_version_gte '2.6'
 
-        it "returns an alphabetic range" do
-          is_expected.to eq(eval('1...'))
+        it 'returns an alphabetic range' do
+          expect(subject).to eq(eval('1...'))
         end
       end
 
       context 'kernel cannot support endless range' do
         ruby_version_lt '2.6'
 
-        it "returns nil" do
-          is_expected.to be nil
+        it 'returns nil' do
+          expect(subject).to be_nil
         end
       end
     end
 
-    context "when the range is beginning-less" do
-      let(:hash) { { "min" => nil, "max" => 3 } }
+    context 'when the range is beginning-less' do
+      let(:hash) { { 'min' => nil, 'max' => 3 } }
 
       context 'kernel can support beginning-less range' do
         ruby_version_gte '2.7'
 
-        it "returns an alphabetic range" do
-          is_expected.to eq(nil..3)
+        it 'returns an alphabetic range' do
+          expect(subject).to eq(nil..3)
         end
       end
 
       context 'kernel cannot support beginning-less range' do
         ruby_version_lt '2.7'
 
-        it "returns nil" do
-          is_expected.to be nil
+        it 'returns nil' do
+          expect(subject).to be_nil
         end
       end
     end
 
-    context "when the range is beginning-less with exclude end" do
-      let(:hash) { { "min" => nil, "max" => 3, "exclude_end" => true } }
+    context 'when the range is beginning-less with exclude end' do
+      let(:hash) { { 'min' => nil, 'max' => 3, 'exclude_end' => true } }
 
       context 'kernel can support endless range' do
         ruby_version_gte '2.7'
 
-        it "returns an alphabetic beginning-less" do
-          is_expected.to eq(eval('...3'))
+        it 'returns an alphabetic beginning-less' do
+          expect(subject).to eq(eval('...3'))
         end
       end
 
       context 'kernel cannot support beginning-less range' do
         ruby_version_lt '2.7'
 
-        it "returns nil" do
-          is_expected.to be nil
+        it 'returns nil' do
+          expect(subject).to be_nil
         end
       end
     end
 
     context "when the range doesn't have any correct keys" do
-      let(:hash) { { "min^" => "a", "max^" => "z", "exclude_end^" => true } }
+      let(:hash) { { 'min^' => 'a', 'max^' => 'z', 'exclude_end^' => true } }
 
-      it "returns nil" do
-        is_expected.to be nil
+      it 'returns nil' do
+        expect(subject).to be_nil
       end
     end
 
-    context "when the range has symbol keys" do
+    context 'when the range has symbol keys' do
       let(:hash) { { min: 1, max: 3 } }
 
-      it "returns an ascending range" do
-        is_expected.to eq(1..3)
+      it 'returns an ascending range' do
+        expect(subject).to eq(1..3)
       end
     end
   end
 
   shared_examples_for 'mongoize range' do
-
     context 'given a normal range' do
       let(:range) { 1..3 }
 
-      it "returns the object hash" do
-        is_expected.to eq("min" => 1, "max" => 3)
+      it 'returns the object hash' do
+        expect(subject).to eq('min' => 1, 'max' => 3)
       end
     end
 
     context 'given a normal range not inclusive' do
       let(:range) { 1...3 }
 
-      it "returns the object hash" do
-        is_expected.to eq("min" => 1, "max" => 3, "exclude_end" => true)
+      it 'returns the object hash' do
+        expect(subject).to eq('min' => 1, 'max' => 3, 'exclude_end' => true)
       end
     end
 
     context 'given a descending range' do
       let(:range) { 5..1 }
 
-      it "returns the object hash" do
-        is_expected.to eq("min" => 5, "max" => 1)
+      it 'returns the object hash' do
+        expect(subject).to eq('min' => 5, 'max' => 1)
       end
     end
 
     context 'given a descending range not inclusive' do
       let(:range) { 5...1 }
 
-      it "returns the object hash" do
-        is_expected.to eq("min" => 5, "max" => 1, "exclude_end" => true)
+      it 'returns the object hash' do
+        expect(subject).to eq('min' => 5, 'max' => 1, 'exclude_end' => true)
       end
     end
 
@@ -192,8 +189,8 @@ describe Mongoid::Extensions::Range do
 
       let(:range) { eval('5..') }
 
-      it "returns the object hash" do
-        is_expected.to eq("min" => 5)
+      it 'returns the object hash' do
+        expect(subject).to eq('min' => 5)
       end
     end
 
@@ -202,8 +199,8 @@ describe Mongoid::Extensions::Range do
 
       let(:range) { eval('5...') }
 
-      it "returns the object hash" do
-        is_expected.to eq("min" => 5, "exclude_end" => true)
+      it 'returns the object hash' do
+        expect(subject).to eq('min' => 5, 'exclude_end' => true)
       end
     end
 
@@ -212,8 +209,8 @@ describe Mongoid::Extensions::Range do
 
       let(:range) { eval('..5') }
 
-      it "returns the object hash" do
-        is_expected.to eq("max" => 5)
+      it 'returns the object hash' do
+        expect(subject).to eq('max' => 5)
       end
     end
 
@@ -222,132 +219,132 @@ describe Mongoid::Extensions::Range do
 
       let(:range) { eval('...5') }
 
-      it "returns the object hash" do
-        is_expected.to eq("max" => 5, "exclude_end" => true)
+      it 'returns the object hash' do
+        expect(subject).to eq('max' => 5, 'exclude_end' => true)
       end
     end
 
     context 'given a letter range' do
       let(:range) { 'a'..'z' }
 
-      it "returns the object hash" do
-        is_expected.to eq("min" => "a", "max" => "z")
+      it 'returns the object hash' do
+        expect(subject).to eq('min' => 'a', 'max' => 'z')
       end
     end
 
     context 'given a letter range not inclusive' do
       let(:range) { 'a'...'z' }
 
-      it "returns the object hash" do
-        is_expected.to eq("min" => "a", "max" => "z", "exclude_end" => true)
+      it 'returns the object hash' do
+        expect(subject).to eq('min' => 'a', 'max' => 'z', 'exclude_end' => true)
       end
     end
 
     context 'given a Time range' do
       let(:range) { Time.at(0)..Time.at(1) }
 
-      it "returns the object hash" do
-        is_expected.to eq("min" => Time.at(0), "max" => Time.at(1))
-        expect(subject["min"].utc?).to be(true)
-        expect(subject["max"].utc?).to be(true)
+      it 'returns the object hash' do
+        expect(subject).to eq('min' => Time.at(0), 'max' => Time.at(1))
+        expect(subject['min'].utc?).to be(true)
+        expect(subject['max'].utc?).to be(true)
       end
     end
 
     context 'given an ActiveSupport::TimeWithZone range' do
       let(:range) { Time.at(0)..Time.at(1) }
 
-      it "returns the object hash" do
-        is_expected.to eq("min" => Time.at(0).in_time_zone, "max" => Time.at(1).in_time_zone)
-        expect(subject["min"].utc?).to be(true)
-        expect(subject["max"].utc?).to be(true)
+      it 'returns the object hash' do
+        expect(subject).to eq('min' => Time.at(0).in_time_zone, 'max' => Time.at(1).in_time_zone)
+        expect(subject['min'].utc?).to be(true)
+        expect(subject['max'].utc?).to be(true)
       end
     end
 
     context 'given a Date range' do
       let(:range) { Date.new(2020, 1, 1)..Date.new(2020, 1, 2) }
 
-      it "returns the object hash" do
-        is_expected.to eq("min" => Time.utc(2020, 1, 1), "max" => Time.utc(2020, 1, 2))
-        expect(subject["min"].utc?).to be(true)
-        expect(subject["max"].utc?).to be(true)
+      it 'returns the object hash' do
+        expect(subject).to eq('min' => Time.utc(2020, 1, 1), 'max' => Time.utc(2020, 1, 2))
+        expect(subject['min'].utc?).to be(true)
+        expect(subject['max'].utc?).to be(true)
       end
     end
 
-    context "given nil" do
+    context 'given nil' do
       let(:range) { nil }
 
-      it "returns nil" do
-        is_expected.to be_nil
+      it 'returns nil' do
+        expect(subject).to be_nil
       end
     end
 
-    context "given a hash" do
+    context 'given a hash' do
       let(:range) { { 'min' => 1, 'max' => 5, 'exclude_end' => true } }
 
-      it "returns the hash" do
-        is_expected.to eq(range)
+      it 'returns the hash' do
+        expect(subject).to eq(range)
       end
     end
 
-    context "given a hash missing fields" do
+    context 'given a hash missing fields' do
       let(:range) { { 'min' => 1 } }
 
-      it "returns the hash" do
-        is_expected.to eq(range)
+      it 'returns the hash' do
+        expect(subject).to eq(range)
       end
     end
   end
 
-  describe "#mongoize" do
+  describe '#mongoize' do
     subject { range.mongoize }
 
     context 'given a String' do
       let(:range) { '3' }
 
       it 'returns a string' do
-        is_expected.to eq('3')
+        expect(subject).to eq('3')
       end
     end
 
     it_behaves_like 'mongoize range'
   end
 
-  describe ".mongoize" do
+  describe '.mongoize' do
     subject { Range.mongoize(range) }
 
     context 'given a String' do
       let(:range) { '3' }
 
-      it "returns nil" do
-        is_expected.to be_nil
+      it 'returns nil' do
+        expect(subject).to be_nil
       end
     end
 
-    context "given a hash with wrong fields" do
-      let(:range) { { 'min' => 1, 'max' => 5, 'exclude_end^' => true} }
+    context 'given a hash with wrong fields' do
+      let(:range) { { 'min' => 1, 'max' => 5, 'exclude_end^' => true } }
 
-      it "removes the bogus fields" do
-        is_expected.to eq({ 'min' => 1, 'max' => 5 })
+      it 'removes the bogus fields' do
+        expect(subject).to eq({ 'min' => 1, 'max' => 5 })
       end
     end
 
-    context "given a hash with no correct fields" do
-      let(:range) { { 'min^' => 1, 'max^' => 5, 'exclude_end^' => true} }
+    context 'given a hash with no correct fields' do
+      let(:range) { { 'min^' => 1, 'max^' => 5, 'exclude_end^' => true } }
 
-      it "returns nil" do
-        is_expected.to be_nil
+      it 'returns nil' do
+        expect(subject).to be_nil
       end
     end
 
     it_behaves_like 'mongoize range'
   end
 
-  describe "#resizable?" do
+  describe '#resizable?' do
     let(:range) do
       1...3
     end
 
-    it "returns true" do
+    it 'returns true' do
       expect(range).to be_resizable
     end
   end