mongoid 9.0.11 → 9.1.0

data/spec/mongoid/findable_spec.rb

@@ -1,158 +1,141 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Findable do
-
-  describe ".distinct" do
-
+  describe '.distinct' do
     before do
-      Band.create!(name: "Tool")
-      Band.create!(name: "Photek")
+      Band.create!(name: 'Tool')
+      Band.create!(name: 'Photek')
     end
 
-    it "returns the distinct values for the field" do
-      expect(Band.distinct(:name).sort).to eq([ "Photek", "Tool" ])
+    it 'returns the distinct values for the field' do
+      expect(Band.distinct(:name).sort).to eq(%w[Photek Tool])
     end
   end
 
-  describe ".each" do
-
+  describe '.each' do
     let!(:band) do
       Band.create!
     end
 
-    it "iterates through all documents" do
-      Band.each do |band|
-        expect(band).to be_a(Band)
-      end
+    it 'iterates through all documents' do
+      expect(Band).to all(be_a(Band))
     end
   end
 
-  describe ".each_with_index" do
-
+  describe '.each_with_index' do
     let!(:band) do
       Band.create!
     end
 
-    it "iterates through all documents" do
-      Band.each_with_index do |band, index|
+    it 'iterates through all documents' do
+      Band.each_with_index do |_band, index|
         expect(index).to eq(0)
       end
     end
   end
 
-  describe ".find_one_and_update" do
-
+  describe '.find_one_and_update' do
     let!(:person) do
-      Person.create!(title: "Senior")
+      Person.create!(title: 'Senior')
     end
 
-    it "returns the document" do
-      expect(Person.find_one_and_update(title: "Junior")).to eq(person)
+    it 'returns the document' do
+      expect(Person.find_one_and_update(title: 'Junior')).to eq(person)
     end
   end
 
-  describe ".find_by" do
-
-    context "when collection is a embeds_many" do
-
+  describe '.find_by' do
+    context 'when collection is a embeds_many' do
       let(:person) do
-        Person.create!(title: "sir")
+        Person.create!(title: 'sir')
       end
 
       let!(:message) do
         person.messages.create!(body: 'foo')
       end
 
-      context "when the document is found" do
-
-        it "returns the document" do
+      context 'when the document is found' do
+        it 'returns the document' do
           expect(person.messages.find_by(body: 'foo')).to eq(message)
         end
       end
 
-      context "when the document is not found" do
-
-        context "when raising a not found error" do
+      context 'when the document is not found' do
+        context 'when raising a not found error' do
           config_override :raise_not_found_error, true
 
-          it "raises an error" do
-            expect {
+          it 'raises an error' do
+            expect do
               person.messages.find_by(body: 'bar')
-            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document not found for class Message with attributes/)
+            end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                               /Document not found for class Message with attributes/)
           end
         end
 
-        context "when raising no error" do
+        context 'when raising no error' do
           config_override :raise_not_found_error, false
 
-          it "returns nil" do
+          it 'returns nil' do
             expect(person.messages.find_by(body: 'bar')).to be_nil
           end
         end
       end
     end
 
-    context "when the document is found" do
-
+    context 'when the document is found' do
       let!(:person) do
-        Person.create!(title: "sir")
+        Person.create!(title: 'sir')
       end
 
-      context "when no block is provided" do
-
-        it "returns the document" do
-          expect(Person.find_by(title: "sir")).to eq(person)
+      context 'when no block is provided' do
+        it 'returns the document' do
+          expect(Person.find_by(title: 'sir')).to eq(person)
         end
       end
 
-      context "when a block is provided" do
-
+      context 'when a block is provided' do
         let(:result) do
-          Person.find_by(title: "sir") do |peep|
+          Person.find_by(title: 'sir') do |peep|
             peep.age = 50
           end
         end
 
-        it "yields the returned document" do
+        it 'yields the returned document' do
           expect(result.age).to eq(50)
         end
       end
     end
 
-    context "when the document is not found" do
-
-      context "when raising a not found error" do
+    context 'when the document is not found' do
+      context 'when raising a not found error' do
         config_override :raise_not_found_error, true
 
-        it "raises an error" do
-          expect {
-            Person.find_by(ssn: "333-22-1111")
-          }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document not found for class Person with attributes/)
+        it 'raises an error' do
+          expect do
+            Person.find_by(ssn: '333-22-1111')
+          end.to raise_error(Mongoid::Errors::DocumentNotFound, /Document not found for class Person with attributes/)
         end
       end
 
-      context "when raising no error" do
+      context 'when raising no error' do
         config_override :raise_not_found_error, false
 
-        context "when no block is provided" do
-
-          it "returns nil" do
-            expect(Person.find_by(ssn: "333-22-1111")).to be_nil
+        context 'when no block is provided' do
+          it 'returns nil' do
+            expect(Person.find_by(ssn: '333-22-1111')).to be_nil
           end
         end
 
-        context "when a block is provided" do
-
+        context 'when a block is provided' do
           let(:result) do
-            Person.find_by(ssn: "333-22-1111") do |peep|
+            Person.find_by(ssn: '333-22-1111') do |peep|
               peep.age = 50
             end
           end
 
-          it "returns nil" do
+          it 'returns nil' do
             expect(result).to be_nil
           end
         end
@@ -160,49 +143,118 @@ describe Mongoid::Findable do
     end
   end
 
-  describe "find_by!" do
+  describe '#any?' do
+    context 'when called on collection with documents' do
+      before do
+        Band.create!(name: 'Tool')
+      end
 
-    context "when the document is found" do
+      it 'returns true' do
+        expect(Band.any?).to be true
+      end
+    end
 
-      let!(:person) do
-        Person.create!(title: "sir")
+    context 'when called on collection with no documents' do
+      it 'returns false' do
+        expect(Band.any?).to be false
       end
+    end
+  end
 
-      context "when no block is provided" do
+  describe '#one?' do
+    context 'when called on collection with no documents' do
+      it 'returns false' do
+        expect(Band.one?).to be false
+      end
+    end
 
-        it "returns the document" do
-          expect(Person.find_by!(title: "sir")).to eq(person)
-        end
+    context 'when called on collection with one document' do
+      before do
+        Band.create!(name: 'Radiohead')
+      end
+
+      it 'returns true' do
+        expect(Band.one?).to be true
+      end
+    end
+
+    context 'when called on collection with multiple documents' do
+      before do
+        Band.create!(name: 'Tool')
+        Band.create!(name: 'Radiohead')
+      end
+
+      it 'returns false' do
+        expect(Band.one?).to be false
+      end
+    end
+  end
+
+  describe '#many?' do
+    context 'when called on collection with no documents' do
+      it 'returns false' do
+        expect(Band.many?).to be false
+      end
+    end
+
+    context 'when called on collection with one document' do
+      before do
+        Band.create!(name: 'Radiohead')
+      end
+
+      it 'returns false' do
+        expect(Band.many?).to be false
       end
+    end
 
-      context "when a block is provided" do
+    context 'when called on collection with multiple documents' do
+      before do
+        Band.create!(name: 'Radiohead')
+        Band.create!(name: 'Tool')
+      end
+
+      it 'returns true' do
+        expect(Band.many?).to be true
+      end
+    end
+  end
 
+  describe 'find_by!' do
+    context 'when the document is found' do
+      let!(:person) do
+        Person.create!(title: 'sir')
+      end
+
+      context 'when no block is provided' do
+        it 'returns the document' do
+          expect(Person.find_by!(title: 'sir')).to eq(person)
+        end
+      end
+
+      context 'when a block is provided' do
         let(:result) do
-          Person.find_by!(title: "sir") do |peep|
+          Person.find_by!(title: 'sir') do |peep|
             peep.age = 50
           end
         end
 
-        it "yields the returned document" do
+        it 'yields the returned document' do
           expect(result.age).to eq(50)
         end
       end
     end
 
-    context "when the document is not found" do
-
-      it "raises an error" do
-        expect {
-          Person.find_by!(ssn: "333-22-1111")
-        }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document not found for class Person with attributes/)
+    context 'when the document is not found' do
+      it 'raises an error' do
+        expect do
+          Person.find_by!(ssn: '333-22-1111')
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Document not found for class Person with attributes/)
       end
     end
   end
 
-  [ :first, :one ].each do |method|
-
+  %i[first one].each do |method|
     describe "##{method}" do
-
       let!(:person1) do
         Person.create!
       end
@@ -211,21 +263,21 @@ describe Mongoid::Findable do
         Person.create!
       end
 
-      it "returns the first matching document" do
+      it 'returns the first matching document' do
         expect(Person.send(method)).to eq(person1)
       end
 
-      it "passes the limit through" do
+      it 'passes the limit through' do
         expect(Person.send(method, 1)).to eq([ person1 ])
       end
 
-      it "returns nil when no documents are found" do
+      it 'returns nil when no documents are found' do
         expect(Band.send(method)).to be_nil
       end
     end
   end
 
-  describe "#first!" do
+  describe '#first!' do
     let!(:person1) do
       Person.create!
     end
@@ -234,18 +286,18 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the first matching document" do
+    it 'returns the first matching document' do
       expect(Person.first!).to eq(person1)
     end
 
-    it "raises an error when there are no documents" do
+    it 'raises an error when there are no documents' do
       expect do
         Band.first!
       end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
     end
   end
 
-  describe "#last" do
+  describe '#last' do
     let!(:person1) do
       Person.create!
     end
@@ -254,20 +306,20 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the first matching document" do
+    it 'returns the first matching document' do
       expect(Person.last).to eq(person2)
     end
 
-    it "passes the limit through" do
+    it 'passes the limit through' do
       expect(Person.last(1)).to eq([ person2 ])
     end
 
-    it "returns nil when no documents are found" do
+    it 'returns nil when no documents are found' do
       expect(Band.last).to be_nil
     end
   end
 
-  describe "#last!" do
+  describe '#last!' do
     let!(:person1) do
       Person.create!
     end
@@ -276,18 +328,18 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the last matching document" do
+    it 'returns the last matching document' do
       expect(Person.last!).to eq(person2)
     end
 
-    it "raises an error when there are no documents" do
+    it 'raises an error when there are no documents' do
       expect do
         Band.last!
       end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
     end
   end
 
-  describe "#second" do
+  describe '#second' do
     let!(:person1) do
       Person.create!
     end
@@ -296,16 +348,16 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the second matching document" do
+    it 'returns the second matching document' do
       expect(Person.second).to eq(person2)
     end
 
-    it "returns nil when no documents are found" do
+    it 'returns nil when no documents are found' do
       expect(Band.second).to be_nil
     end
   end
 
-  describe "#second!" do
+  describe '#second!' do
     let!(:person1) do
       Person.create!
     end
@@ -314,18 +366,18 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the second matching document" do
+    it 'returns the second matching document' do
       expect(Person.second!).to eq(person2)
     end
 
-    it "raises an error when there are no documents" do
+    it 'raises an error when there are no documents' do
       expect do
         Band.second!
       end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
     end
   end
 
-  describe "#third" do
+  describe '#third' do
     let!(:person1) do
       Person.create!
     end
@@ -338,16 +390,16 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the third matching document" do
+    it 'returns the third matching document' do
       expect(Person.third).to eq(person3)
     end
 
-    it "returns nil when no documents are found" do
+    it 'returns nil when no documents are found' do
       expect(Band.third).to be_nil
     end
   end
 
-  describe "#third!" do
+  describe '#third!' do
     let!(:person1) do
       Person.create!
     end
@@ -360,18 +412,18 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the third matching document" do
+    it 'returns the third matching document' do
       expect(Person.third!).to eq(person3)
     end
 
-    it "raises an error when there are no documents" do
+    it 'raises an error when there are no documents' do
       expect do
         Band.third!
       end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
     end
   end
 
-  describe "#fourth" do
+  describe '#fourth' do
     let!(:person1) do
       Person.create!
     end
@@ -388,16 +440,16 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the fourth matching document" do
+    it 'returns the fourth matching document' do
       expect(Person.fourth).to eq(person4)
     end
 
-    it "returns nil when no documents are found" do
+    it 'returns nil when no documents are found' do
       expect(Band.fourth).to be_nil
     end
   end
 
-  describe "#fourth!" do
+  describe '#fourth!' do
     let!(:person1) do
       Person.create!
     end
@@ -414,18 +466,18 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the fourth matching document" do
+    it 'returns the fourth matching document' do
       expect(Person.fourth!).to eq(person4)
     end
 
-    it "raises an error when there are no documents" do
+    it 'raises an error when there are no documents' do
       expect do
         Band.fourth!
       end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
     end
   end
 
-  describe "#fifth" do
+  describe '#fifth' do
     let!(:person1) do
       Person.create!
     end
@@ -446,16 +498,16 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the fifth matching document" do
+    it 'returns the fifth matching document' do
       expect(Person.fifth).to eq(person5)
     end
 
-    it "returns nil when no documents are found" do
+    it 'returns nil when no documents are found' do
       expect(Band.fifth).to be_nil
     end
   end
 
-  describe "#fifth!" do
+  describe '#fifth!' do
     let!(:person1) do
       Person.create!
     end
@@ -476,18 +528,18 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the fifth matching document" do
+    it 'returns the fifth matching document' do
       expect(Person.fifth!).to eq(person5)
     end
 
-    it "raises an error when there are no documents" do
+    it 'raises an error when there are no documents' do
       expect do
         Band.fifth!
       end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
     end
   end
 
-  describe "#second_to_last" do
+  describe '#second_to_last' do
     let!(:person1) do
       Person.create!
     end
@@ -508,16 +560,16 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the second to last matching document" do
+    it 'returns the second to last matching document' do
       expect(Person.second_to_last).to eq(person4)
     end
 
-    it "returns nil when no documents are found" do
+    it 'returns nil when no documents are found' do
       expect(Band.second_to_last).to be_nil
     end
   end
 
-  describe "#second_to_last!" do
+  describe '#second_to_last!' do
     let!(:person1) do
       Person.create!
     end
@@ -538,18 +590,18 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the second to last matching document" do
+    it 'returns the second to last matching document' do
       expect(Person.second_to_last!).to eq(person4)
     end
 
-    it "raises an error when there are no documents" do
+    it 'raises an error when there are no documents' do
       expect do
         Band.second_to_last!
       end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
     end
   end
 
-  describe "#third_to_last" do
+  describe '#third_to_last' do
     let!(:person1) do
       Person.create!
     end
@@ -570,16 +622,16 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the third to last matching document" do
+    it 'returns the third to last matching document' do
       expect(Person.third_to_last).to eq(person3)
     end
 
-    it "returns nil when no documents are found" do
+    it 'returns nil when no documents are found' do
       expect(Band.third_to_last).to be_nil
     end
   end
 
-  describe "#third_to_last!" do
+  describe '#third_to_last!' do
     let!(:person1) do
       Person.create!
     end
@@ -600,34 +652,30 @@ describe Mongoid::Findable do
       Person.create!
     end
 
-    it "returns the third to last matching document" do
+    it 'returns the third to last matching document' do
       expect(Person.third_to_last!).to eq(person3)
     end
 
-    it "raises an error when there are no documents" do
+    it 'raises an error when there are no documents' do
       expect do
         Band.third_to_last!
       end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
     end
   end
 
-  describe ".first_or_create" do
-
-    context "when the document is found" do
-
+  describe '.first_or_create' do
+    context 'when the document is found' do
       let!(:person) do
         Person.create!
       end
 
-      it "returns the document" do
+      it 'returns the document' do
         expect(Person.first_or_create).to eq(person)
       end
     end
 
-    context "when the document is not found" do
-
-      context "when providing a document" do
-
+    context 'when the document is not found' do
+      context 'when providing a document' do
         let!(:person) do
           Person.create!
         end
@@ -636,66 +684,60 @@ describe Mongoid::Findable do
           Game.first_or_create(person: person)
         end
 
-        it "returns the new document" do
+        it 'returns the new document' do
           expect(from_db.person).to eq(person)
         end
       end
 
-      context "when not providing a block" do
-
+      context 'when not providing a block' do
         let!(:person) do
-          Person.first_or_create(title: "Senorita")
+          Person.first_or_create(title: 'Senorita')
         end
 
-        it "creates a persisted document" do
+        it 'creates a persisted document' do
           expect(person).to be_persisted
         end
 
-        it "sets the attributes" do
-          expect(person.title).to eq("Senorita")
+        it 'sets the attributes' do
+          expect(person.title).to eq('Senorita')
         end
       end
 
-      context "when providing a block" do
-
+      context 'when providing a block' do
         let!(:person) do
-          Person.first_or_create(title: "Senorita") do |person|
+          Person.first_or_create(title: 'Senorita') do |person|
             person.pets = true
           end
         end
 
-        it "creates a persisted document" do
+        it 'creates a persisted document' do
           expect(person).to be_persisted
         end
 
-        it "sets the attributes" do
-          expect(person.title).to eq("Senorita")
+        it 'sets the attributes' do
+          expect(person.title).to eq('Senorita')
         end
 
-        it "calls the block" do
+        it 'calls the block' do
           expect(person.pets).to be true
         end
       end
     end
   end
 
-  describe ".first_or_initialize" do
-
-    context "when the document is found" do
-
+  describe '.first_or_initialize' do
+    context 'when the document is found' do
       let!(:person) do
         Person.create!
       end
 
-      it "returns the document" do
+      it 'returns the document' do
         expect(Person.first_or_create).to eq(person)
       end
     end
 
-    context "when the document is not found" do
-
-      context "when providing a document" do
-
+    context 'when the document is not found' do
+      context 'when providing a document' do
         let!(:person) do
           Person.create!
         end
@@ -704,155 +746,147 @@ describe Mongoid::Findable do
           Game.first_or_initialize(person: person)
         end
 
-        it "returns the new document" do
+        it 'returns the new document' do
           expect(found.person).to eq(person)
         end
 
-        it "does not save the document" do
-          expect(found).to_not be_persisted
+        it 'does not save the document' do
+          expect(found).not_to be_persisted
         end
       end
 
-      context "when not providing a block" do
-
+      context 'when not providing a block' do
         before do
           Person.delete_all
         end
 
         let!(:person) do
-          Person.first_or_initialize(title: "esquire")
+          Person.first_or_initialize(title: 'esquire')
         end
 
-        it "creates a non persisted document" do
-          expect(person).to_not be_persisted
+        it 'creates a non persisted document' do
+          expect(person).not_to be_persisted
         end
 
-        it "sets the attributes" do
-          expect(person.title).to eq("esquire")
+        it 'sets the attributes' do
+          expect(person.title).to eq('esquire')
         end
       end
 
-      context "when providing a block" do
-
+      context 'when providing a block' do
         let!(:person) do
-          Person.first_or_initialize(title: "Senorita") do |person|
+          Person.first_or_initialize(title: 'Senorita') do |person|
             person.pets = true
           end
         end
 
-        it "creates a new document" do
-          expect(person).to_not be_persisted
+        it 'creates a new document' do
+          expect(person).not_to be_persisted
         end
 
-        it "sets the attributes" do
-          expect(person.title).to eq("Senorita")
+        it 'sets the attributes' do
+          expect(person.title).to eq('Senorita')
         end
 
-        it "calls the block" do
+        it 'calls the block' do
           expect(person.pets).to be true
         end
       end
     end
   end
 
-  describe ".none" do
-
+  describe '.none' do
     let!(:depeche) do
-      Band.create!(name: "Depeche Mode", likes: 3)
+      Band.create!(name: 'Depeche Mode', likes: 3)
     end
 
-    context "when not chaining any criteria" do
-
-      it "returns no records" do
+    context 'when not chaining any criteria' do
+      it 'returns no records' do
         expect(Band.none).to be_empty
       end
 
-      it "has an empty count" do
+      it 'has an empty count' do
         expect(Band.none.count).to eq(0)
       end
 
-      it "returns nil for first" do
+      it 'returns nil for first' do
         expect(Band.none.first).to be_nil
       end
 
-      it "returns nil for last" do
+      it 'returns nil for last' do
         expect(Band.none.last).to be_nil
       end
 
-      it "returns zero for length" do
+      it 'returns zero for length' do
         expect(Band.none.length).to eq(0)
       end
 
-      it "returns zero for size" do
+      it 'returns zero for size' do
         expect(Band.none.size).to eq(0)
       end
     end
 
-    context "when chaining criteria after the none" do
-
+    context 'when chaining criteria after the none' do
       let(:criteria) do
-        Band.none.where(name: "Depeche Mode")
+        Band.none.where(name: 'Depeche Mode')
       end
 
-      it "returns no records" do
+      it 'returns no records' do
         expect(criteria).to be_empty
       end
 
-      it "has an empty count" do
+      it 'has an empty count' do
         expect(criteria.count).to eq(0)
       end
 
-      it "returns nil for first" do
+      it 'returns nil for first' do
         expect(criteria.first).to be_nil
       end
 
-      it "returns nil for last" do
+      it 'returns nil for last' do
         expect(criteria.last).to be_nil
       end
 
-      it "returns zero for length" do
+      it 'returns zero for length' do
         expect(criteria.length).to eq(0)
       end
 
-      it "returns zero for size" do
+      it 'returns zero for size' do
         expect(criteria.size).to eq(0)
       end
     end
   end
 
-  describe ".pluck" do
-
+  describe '.pluck' do
     let!(:depeche) do
-      Band.create!(name: "Depeche Mode", likes: 3)
+      Band.create!(name: 'Depeche Mode', likes: 3)
     end
 
     let!(:tool) do
-      Band.create!(name: "Tool", likes: 3)
+      Band.create!(name: 'Tool', likes: 3)
     end
 
     let!(:photek) do
-      Band.create!(name: "Photek", likes: 1)
+      Band.create!(name: 'Photek', likes: 1)
     end
 
-    context "when field values exist" do
-
+    context 'when field values exist' do
       let(:plucked) do
         Band.pluck(:name)
       end
 
-      it "returns the field values" do
-        expect(plucked).to eq([ "Depeche Mode", "Tool", "Photek" ])
+      it 'returns the field values' do
+        expect(plucked).to eq([ 'Depeche Mode', 'Tool', 'Photek' ])
       end
     end
 
-    context "when field values do not exist" do
-
+    context 'when field values do not exist' do
       let(:plucked) do
         Band.pluck(:follows)
       end
 
-      it "returns an array with nil values" do
-        expect(plucked).to eq([nil, nil, nil])
+      it 'returns an array with nil values' do
+        expect(plucked).to eq([ nil, nil, nil ])
       end
     end
   end
@@ -860,11 +894,11 @@ describe Mongoid::Findable do
   describe '.count' do
     context 'when the collection is not empty' do
       before do
-        Band.create!(name: "Tool")
-        Band.create!(name: "Photek")
+        Band.create!(name: 'Tool')
+        Band.create!(name: 'Photek')
       end
 
-      it 'returns the currect count' do
+      it 'returns the correct count' do
         expect(Band.count).to eq(2)
       end
     end
@@ -873,8 +907,8 @@ describe Mongoid::Findable do
   describe '.estimated_count' do
     context 'when the collection is not empty' do
       before do
-        Band.create!(name: "Tool")
-        Band.create!(name: "Photek")
+        Band.create!(name: 'Tool')
+        Band.create!(name: 'Photek')
       end
 
       it 'returns the correct count' do
@@ -890,9 +924,7 @@ describe Mongoid::Findable do
   end
 
   Mongoid::Criteria::Queryable::Selectable.forwardables.each do |method|
-
     describe "##{method}" do
-
       it "forwards the #{method} to the criteria" do
         expect(Band).to respond_to(method)
       end
@@ -901,7 +933,7 @@ describe Mongoid::Findable do
 
   context 'when Mongoid is configured to use activesupport time zone' do
     config_override :use_utc, false
-    time_zone_override "Asia/Kolkata"
+    time_zone_override 'Asia/Kolkata'
 
     let!(:time) do
       Time.current.tap do |t|
@@ -924,7 +956,7 @@ describe Mongoid::Findable do
     end
 
     it 'loads other fields accurately' do
-      expect(User.distinct(:name)).to match_array(['Tom'])
+      expect(User.distinct(:name)).to contain_exactly('Tom')
     end
   end
 end