mongoid 9.0.11 → 9.1.0

data/spec/mongoid/contextual/aggregable/mongo_spec.rb

@@ -1,20 +1,16 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Contextual::Aggregable::Mongo do
-
-  describe "#aggregates" do
-
-    context "when provided a single field" do
-
+  describe '#aggregates' do
+    context 'when provided a single field' do
       let!(:depeche) do
-        Band.create!(name: "Depeche Mode", likes: 1000, years: 1000)
+        Band.create!(name: 'Depeche Mode', likes: 1000, years: 1000)
       end
 
       let!(:tool) do
-        Band.create!(name: "Tool", likes: 500, years: 800)
+        Band.create!(name: 'Tool', likes: 500, years: 800)
       end
 
       let(:criteria) do
@@ -25,95 +21,90 @@ describe Mongoid::Contextual::Aggregable::Mongo do
         Mongoid::Contextual::Mongo.new(criteria)
       end
 
-      context "when aggregating on a field that exists" do
-
-        context "when aggregating on an aliased field" do
-
+      context 'when aggregating on a field that exists' do
+        context 'when aggregating on an aliased field' do
           let(:aggregates) do
             context.aggregates(:years)
           end
 
-          it "returns an avg" do
-            expect(aggregates["avg"]).to eq(900)
+          it 'returns an avg' do
+            expect(aggregates['avg']).to eq(900)
           end
 
-          it "returns a count of documents with that field" do
-            expect(aggregates["count"]).to eq(2)
+          it 'returns a count of documents with that field' do
+            expect(aggregates['count']).to eq(2)
           end
 
-          it "returns a max" do
-            expect(aggregates["max"]).to eq(1000)
+          it 'returns a max' do
+            expect(aggregates['max']).to eq(1000)
           end
 
-          it "returns a min" do
-            expect(aggregates["min"]).to eq(800)
+          it 'returns a min' do
+            expect(aggregates['min']).to eq(800)
           end
 
-          it "returns a sum" do
-            expect(aggregates["sum"]).to eq(1800)
+          it 'returns a sum' do
+            expect(aggregates['sum']).to eq(1800)
           end
         end
 
-        context "when more than 1 document is emitted" do
-
+        context 'when more than 1 document is emitted' do
           let(:aggregates) do
             context.aggregates(:likes)
           end
 
-          it "returns an avg" do
-            expect(aggregates["avg"]).to eq(750)
+          it 'returns an avg' do
+            expect(aggregates['avg']).to eq(750)
           end
 
-          it "returns a count of documents with that field" do
-            expect(aggregates["count"]).to eq(2)
+          it 'returns a count of documents with that field' do
+            expect(aggregates['count']).to eq(2)
           end
 
-          it "returns a max" do
-            expect(aggregates["max"]).to eq(1000)
+          it 'returns a max' do
+            expect(aggregates['max']).to eq(1000)
           end
 
-          it "returns a min" do
-            expect(aggregates["min"]).to eq(500)
+          it 'returns a min' do
+            expect(aggregates['min']).to eq(500)
           end
 
-          it "returns a sum" do
-            expect(aggregates["sum"]).to eq(1500)
+          it 'returns a sum' do
+            expect(aggregates['sum']).to eq(1500)
           end
         end
 
-        context "when only 1 document is emitted" do
-
+        context 'when only 1 document is emitted' do
           let(:criteria) do
-            Band.where(name: "Depeche Mode")
+            Band.where(name: 'Depeche Mode')
           end
 
           let(:aggregates) do
             context.aggregates(:likes)
           end
 
-          it "returns an avg" do
-            expect(aggregates["avg"]).to eq(1000)
+          it 'returns an avg' do
+            expect(aggregates['avg']).to eq(1000)
           end
 
-          it "returns a count of documents with that field" do
-            expect(aggregates["count"]).to eq(1)
+          it 'returns a count of documents with that field' do
+            expect(aggregates['count']).to eq(1)
           end
 
-          it "returns a max" do
-            expect(aggregates["max"]).to eq(1000)
+          it 'returns a max' do
+            expect(aggregates['max']).to eq(1000)
           end
 
-          it "returns a min" do
-            expect(aggregates["min"]).to eq(1000)
+          it 'returns a min' do
+            expect(aggregates['min']).to eq(1000)
           end
 
-          it "returns a sum" do
-            expect(aggregates["sum"]).to eq(1000)
+          it 'returns a sum' do
+            expect(aggregates['sum']).to eq(1000)
           end
         end
 
-        context "when only 1 document is emitted because of sorting, skip and limit" do
-
+        context 'when only 1 document is emitted because of sorting, skip and limit' do
           let(:criteria) do
             Band.desc(:name).skip(1).limit(1)
           end
@@ -122,62 +113,61 @@ describe Mongoid::Contextual::Aggregable::Mongo do
             context.aggregates(:likes)
           end
 
-          it "returns an avg" do
-            expect(aggregates["avg"]).to eq(1000)
+          it 'returns an avg' do
+            expect(aggregates['avg']).to eq(1000)
           end
 
-          it "returns a count of documents with that field" do
-            expect(aggregates["count"]).to eq(1)
+          it 'returns a count of documents with that field' do
+            expect(aggregates['count']).to eq(1)
           end
 
-          it "returns a max" do
-            expect(aggregates["max"]).to eq(1000)
+          it 'returns a max' do
+            expect(aggregates['max']).to eq(1000)
           end
 
-          it "returns a min" do
-            expect(aggregates["min"]).to eq(1000)
+          it 'returns a min' do
+            expect(aggregates['min']).to eq(1000)
           end
 
-          it "returns a sum" do
-            expect(aggregates["sum"]).to eq(1000)
+          it 'returns a sum' do
+            expect(aggregates['sum']).to eq(1000)
           end
         end
       end
 
-      context "when the field does not exist" do
-
+      context 'when the field does not exist' do
         let(:aggregates) do
           context.aggregates(:non_existent)
         end
 
-        it "returns an avg" do
-          expect(aggregates["avg"]).to be_nil
+        it 'returns an avg' do
+          expect(aggregates['avg']).to be_nil
         end
 
-        it "returns a count of documents with that field" do
-          expect(aggregates["count"]).to eq(0)
+        it 'returns a count of documents with that field' do
+          expect(aggregates['count']).to eq(0)
         end
 
-        it "returns a max" do
-          expect(aggregates["max"]).to be_nil
+        it 'returns a max' do
+          expect(aggregates['max']).to be_nil
         end
 
-        it "returns a min" do
-          expect(aggregates["min"]).to be_nil
+        it 'returns a min' do
+          expect(aggregates['min']).to be_nil
         end
 
-        it "returns a sum" do
-          expect(aggregates["sum"]).to eq 0
+        it 'returns a sum' do
+          expect(aggregates['sum']).to eq 0
         end
       end
 
-      context "when the field sometimes exists" do
+      context 'when the field sometimes exists' do
         let!(:oasis) do
-          Band.create!(name: "Oasis", likes: 50)
+          Band.create!(name: 'Oasis', likes: 50)
         end
 
         let!(:radiohead) do
-          Band.create!(name: "Radiohead")
+          Band.create!(name: 'Radiohead')
         end
 
         context "and the field doesn't exist on the last document" do
@@ -193,18 +183,18 @@ describe Mongoid::Contextual::Aggregable::Mongo do
             context.aggregates(:likes)
           end
 
-          it "returns a min" do
-            expect(aggregates["min"]).to eq(50)
+          it 'returns a min' do
+            expect(aggregates['min']).to eq(50)
           end
 
-          it "returns a count of documents with that field" do
-            expect(aggregates["count"]).to eq(3)
+          it 'returns a count of documents with that field' do
+            expect(aggregates['count']).to eq(3)
           end
         end
 
         context "and the field doesn't exist on the before-last document" do
           let!(:u2) do
-            Band.create!(name: "U2", likes: 100)
+            Band.create!(name: 'U2', likes: 100)
           end
 
           let(:criteria) do
@@ -219,34 +209,35 @@ describe Mongoid::Contextual::Aggregable::Mongo do
             context.aggregates(:likes)
           end
 
-          it "returns a min" do
-            expect(aggregates["min"]).to eq(50)
+          it 'returns a min' do
+            expect(aggregates['min']).to eq(50)
           end
 
-          it "returns a count of documents with that field" do
-            expect(aggregates["count"]).to eq(4)
+          it 'returns a count of documents with that field' do
+            expect(aggregates['count']).to eq(4)
           end
         end
       end
 
-      context "when there are no matching documents" do
-
+      context 'when there are no matching documents' do
         let(:criteria) do
-          Band.where(name: "New Order")
+          Band.where(name: 'New Order')
         end
 
         let(:aggregates) do
           context.aggregates(:non_existent)
         end
 
-        it "returns empty result" do
-          expect(aggregates).to eq({ "count" => 0, "sum" => 0, "avg" => nil, "min" => nil, "max" => nil })
+        it 'returns empty result' do
+          expect(aggregates).to eq({ 'count' => 0, 'sum' => 0, 'avg' => nil, 'min' => nil, 'max' => nil })
         end
       end
     end
 
     context 'regarding hints' do
       let(:client) { Person.collection.client }
+      let(:event) { subscriber.single_command_started_event('aggregate') }
+      let(:command) { event.command }
       let(:subscriber) { Mrss::EventSubscriber.new }
 
       before do
@@ -258,9 +249,6 @@ describe Mongoid::Contextual::Aggregable::Mongo do
         client.unsubscribe(Mongo::Monitoring::COMMAND, subscriber)
       end
 
-      let(:event) { subscriber.single_command_started_event('aggregate') }
-      let(:command) { event.command }
-
       context 'when no hint is provided' do
         let(:maybe_hint) { Person }
 
@@ -279,18 +267,15 @@ describe Mongoid::Contextual::Aggregable::Mongo do
     end
   end
 
-  describe "#avg" do
-
-    context "when provided a single field" do
-
-      context "when there are matching documents" do
-
+  describe '#avg' do
+    context 'when provided a single field' do
+      context 'when there are matching documents' do
         let!(:depeche) do
-          Band.create!(name: "Depeche Mode", likes: 1000)
+          Band.create!(name: 'Depeche Mode', likes: 1000)
         end
 
         let!(:tool) do
-          Band.create!(name: "Tool", likes: 500)
+          Band.create!(name: 'Tool', likes: 500)
         end
 
         let(:criteria) do
@@ -305,19 +290,18 @@ describe Mongoid::Contextual::Aggregable::Mongo do
           context.avg(:likes)
         end
 
-        it "returns the avg of the provided field" do
+        it 'returns the avg of the provided field' do
           expect(avg).to eq(750)
         end
       end
 
-      context "when no documents match" do
-
+      context 'when no documents match' do
         let!(:depeche) do
-          Band.create!(name: "Depeche Mode", likes: 1000)
+          Band.create!(name: 'Depeche Mode', likes: 1000)
         end
 
         let(:criteria) do
-          Band.where(name: "New Order")
+          Band.where(name: 'New Order')
         end
 
         let(:context) do
@@ -328,19 +312,17 @@ describe Mongoid::Contextual::Aggregable::Mongo do
           context.avg(:likes)
         end
 
-        it "returns nil" do
+        it 'returns nil' do
           expect(avg).to be_nil
         end
       end
     end
   end
 
-  describe "#max" do
-
+  describe '#max' do
     context 'when the field does not exist in any document' do
-
       let!(:depeche) do
-        Band.create!(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: 'Depeche Mode', likes: 1000)
       end
 
       let(:criteria) do
@@ -356,18 +338,17 @@ describe Mongoid::Contextual::Aggregable::Mongo do
       end
 
       it 'returns nil' do
-        expect(max).to be(nil)
+        expect(max).to be_nil
       end
     end
 
-    context "when provided a single field" do
-
+    context 'when provided a single field' do
       let!(:depeche) do
-        Band.create!(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: 'Depeche Mode', likes: 1000)
       end
 
       let!(:tool) do
-        Band.create!(name: "Tool", likes: 500)
+        Band.create!(name: 'Tool', likes: 500)
       end
 
       let(:criteria) do
@@ -378,20 +359,18 @@ describe Mongoid::Contextual::Aggregable::Mongo do
         Mongoid::Contextual::Mongo.new(criteria)
       end
 
-      context "when provided a symbol" do
-
+      context 'when provided a symbol' do
         let(:max) do
           context.max(:likes)
         end
 
-        it "returns the max of the provided field" do
+        it 'returns the max of the provided field' do
           expect(max).to eq(1000)
         end
 
-        context "when no documents match" do
-
+        context 'when no documents match' do
           let(:criteria) do
-            Band.where(name: "New Order")
+            Band.where(name: 'New Order')
           end
 
           let(:context) do
@@ -402,37 +381,32 @@ describe Mongoid::Contextual::Aggregable::Mongo do
             context.max(:likes)
           end
 
-          it "returns nil" do
+          it 'returns nil' do
             expect(max).to be_nil
           end
         end
       end
 
-      context "when provided a block" do
-
+      context 'when provided a block' do
         let(:max) do
-          context.max do |a, b|
-            a.likes <=> b.likes
-          end
+          context.max_by(&:likes)
         end
 
-        it "returns the document with the max value for the field" do
+        it 'returns the document with the max value for the field' do
           expect(max).to eq(depeche)
         end
       end
     end
   end
 
-  describe "#min" do
-
-    context "when provided a single field" do
-
+  describe '#min' do
+    context 'when provided a single field' do
       let!(:depeche) do
-        Band.create!(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: 'Depeche Mode', likes: 1000)
       end
 
       let!(:tool) do
-        Band.create!(name: "Tool", likes: 500)
+        Band.create!(name: 'Tool', likes: 500)
       end
 
       let(:criteria) do
@@ -443,20 +417,18 @@ describe Mongoid::Contextual::Aggregable::Mongo do
         Mongoid::Contextual::Mongo.new(criteria)
       end
 
-      context "when provided a symbol" do
-
+      context 'when provided a symbol' do
         let(:min) do
           context.min(:likes)
         end
 
-        it "returns the min of the provided field" do
+        it 'returns the min of the provided field' do
           expect(min).to eq(500)
         end
 
-        context "when no documents match" do
-
+        context 'when no documents match' do
           let(:criteria) do
-            Band.where(name: "New Order")
+            Band.where(name: 'New Order')
           end
 
           let(:context) do
@@ -467,37 +439,32 @@ describe Mongoid::Contextual::Aggregable::Mongo do
             context.min(:likes)
           end
 
-          it "returns nil" do
+          it 'returns nil' do
             expect(min).to be_nil
           end
         end
       end
 
-      context "when provided a block" do
-
+      context 'when provided a block' do
         let(:min) do
-          context.min do |a, b|
-            a.likes <=> b.likes
-          end
+          context.min_by(&:likes)
         end
 
-        it "returns the document with the min value for the field" do
+        it 'returns the document with the min value for the field' do
           expect(min).to eq(tool)
         end
       end
     end
   end
 
-  describe "#sum" do
-
-    context "when provided a single field" do
-
+  describe '#sum' do
+    context 'when provided a single field' do
       let!(:depeche) do
-        Band.create!(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: 'Depeche Mode', likes: 1000)
       end
 
       let!(:tool) do
-        Band.create!(name: "Tool", likes: 500)
+        Band.create!(name: 'Tool', likes: 500)
       end
 
       let(:criteria) do
@@ -508,20 +475,18 @@ describe Mongoid::Contextual::Aggregable::Mongo do
         Mongoid::Contextual::Mongo.new(criteria)
       end
 
-      context "when provided a symbol" do
-
+      context 'when provided a symbol' do
         let(:sum) do
           context.sum(:likes)
         end
 
-        it "returns the sum of the provided field" do
+        it 'returns the sum of the provided field' do
           expect(sum).to eq(1500)
         end
 
-        context "when no documents match" do
-
+        context 'when no documents match' do
           let(:criteria) do
-            Band.where(name: "New Order")
+            Band.where(name: 'New Order')
           end
 
           let(:context) do
@@ -532,30 +497,28 @@ describe Mongoid::Contextual::Aggregable::Mongo do
             context.sum(:likes)
           end
 
-          it "returns zero" do
+          it 'returns zero' do
             expect(sum).to eq(0)
           end
         end
       end
 
-      context "when provided a block" do
-
+      context 'when provided a block' do
         let(:sum) do
           context.sum(&:likes)
         end
 
-        it "returns the sum for the provided block" do
+        it 'returns the sum for the provided block' do
           expect(sum).to eq(1500)
         end
       end
 
-      context "when provided a block with initial value" do
-
+      context 'when provided a block with initial value' do
         let(:sum) do
           context.sum(500, &:likes)
         end
 
-        it "returns the sum for the provided block starting from initial value" do
+        it 'returns the sum for the provided block starting from initial value' do
           expect(sum).to eq(2000)
         end
       end
@@ -563,75 +526,74 @@ describe Mongoid::Contextual::Aggregable::Mongo do
   end
 
   describe '#pipeline' do
+    subject(:stages) { pipeline.map { |s| s.keys.first } }
+
     let(:context) { Mongoid::Contextual::Mongo.new(criteria) }
     let(:pipeline) { context.send(:pipeline, :likes) }
-    subject(:stages) { pipeline.map {|s| s.keys.first } }
 
-    context "with sort" do
-
-      context "without limit or skip" do
+    context 'with sort' do
+      context 'without limit or skip' do
         let(:criteria) { Band.desc(:name) }
 
-        it 'should omit the $sort stage' do
+        it 'omits the $sort stage' do
           expect(stages).to eq %w[$match $group]
         end
       end
 
-      context "with limit" do
+      context 'with limit' do
         let(:criteria) { Band.desc(:name).limit(1) }
 
-        it 'should include the $sort stage' do
+        it 'includes the $sort stage' do
           expect(stages).to eq %w[$match $sort $limit $group]
         end
       end
 
-      context "with skip" do
+      context 'with skip' do
         let(:criteria) { Band.desc(:name).skip(1) }
 
-        it 'should include the $sort stage' do
+        it 'includes the $sort stage' do
           expect(stages).to eq %w[$match $sort $skip $group]
         end
       end
 
-      context "with skip and skip" do
+      context 'with skip and skip' do
         let(:criteria) { Band.desc(:name).limit(1).skip(1) }
 
-        it 'should include the $sort stage' do
+        it 'includes the $sort stage' do
           expect(stages).to eq %w[$match $sort $skip $limit $group]
         end
       end
     end
 
-    context "without sort" do
-
-      context "without limit or skip" do
+    context 'without sort' do
+      context 'without limit or skip' do
         let(:criteria) { Band.all }
 
-        it 'should omit the $sort stage' do
+        it 'omits the $sort stage' do
           expect(stages).to eq %w[$match $group]
         end
       end
 
-      context "with limit" do
+      context 'with limit' do
         let(:criteria) { Band.limit(1) }
 
-        it 'should include the $sort stage' do
+        it 'includes the $sort stage' do
           expect(stages).to eq %w[$match $limit $group]
         end
       end
 
-      context "with skip" do
+      context 'with skip' do
         let(:criteria) { Band.skip(1) }
 
-        it 'should include the $sort stage' do
+        it 'includes the $sort stage' do
           expect(stages).to eq %w[$match $skip $group]
         end
       end
 
-      context "with skip and skip" do
+      context 'with skip and skip' do
         let(:criteria) { Band.limit(1).skip(1) }
 
-        it 'should include the $sort stage' do
+        it 'includes the $sort stage' do
           expect(stages).to eq %w[$match $skip $limit $group]
         end
       end