mongoid 9.0.11 → 9.1.1

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

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Contextual::Aggregable::Memory do
-
   let(:context) do
     Mongoid::Contextual::Memory.new(criteria)
   end
 
-  describe "#aggregates" do
+  describe '#aggregates' do
     subject { context.aggregates(:likes) }
 
     context 'when no documents found' do
@@ -20,7 +18,7 @@ describe Mongoid::Contextual::Aggregable::Memory do
       end
 
       it do
-        is_expected.to eq("count" => 0, "avg" => nil, "max" => nil, "min" => nil, "sum" => 0)
+        expect(subject).to eq('count' => 0, 'avg' => nil, 'max' => nil, 'min' => nil, 'sum' => 0)
       end
     end
 
@@ -32,29 +30,27 @@ describe Mongoid::Contextual::Aggregable::Memory do
       end
 
       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
 
       it do
-        is_expected.to eq("count" => 0, "avg" => 750.0, "max" => 1000, "min" => 500, "sum" => 1500)
+        expect(subject).to eq('count' => 0, 'avg' => 750.0, 'max' => 1000, 'min' => 500, 'sum' => 1500)
       end
     end
   end
 
-  describe "#avg" do
-
-    context "when the types are Integers" do
-
+  describe '#avg' do
+    context 'when the types are Integers' 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
@@ -67,7 +63,7 @@ describe Mongoid::Contextual::Aggregable::Memory 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
 
@@ -76,12 +72,11 @@ describe Mongoid::Contextual::Aggregable::Memory do
       end
 
       context 'when integers are negative' do
-
         let!(:depeche) do
-          Band.create!(name: "Depeche Mode", likes: -1000)
+          Band.create!(name: 'Depeche Mode', likes: -1000)
         end
 
-        it "returns the avg of the provided field" do
+        it 'returns the avg of the provided field' do
           expect(avg).to eq(-250)
         end
 
@@ -91,14 +86,13 @@ describe Mongoid::Contextual::Aggregable::Memory do
       end
     end
 
-    context "when the types are Floats" do
-
+    context 'when the types are Floats' do
       let!(:depeche) do
-        Band.create!(name: "Depeche Mode", rating: 10)
+        Band.create!(name: 'Depeche Mode', rating: 10)
       end
 
       let!(:tool) do
-        Band.create!(name: "Tool", rating: 5)
+        Band.create!(name: 'Tool', rating: 5)
       end
 
       let(:criteria) do
@@ -111,36 +105,34 @@ describe Mongoid::Contextual::Aggregable::Memory do
         context.avg(:rating)
       end
 
-      it "returns the avg of the provided field" do
+      it 'returns the avg of the provided field' do
         expect(avg).to eq(7.5)
       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(:avg) do
         context.avg(:likes)
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(avg).to be_nil
       end
     end
 
-    context "when there are a mix of types" do
-
+    context 'when there are a mix of types' do
       let!(:bands) do
-        [ Band.create!(name: "The Flaming Lips", mojo: 7.7),
-          Band.create!(name: "Spirit of the Beehive", mojo: 10),
-          Band.create!(name: "Justin Bieber", mojo: nil) ]
+        [ Band.create!(name: 'The Flaming Lips', mojo: 7.7),
+          Band.create!(name: 'Spirit of the Beehive', mojo: 10),
+          Band.create!(name: 'Justin Bieber', mojo: nil) ]
       end
 
       let(:criteria) do
@@ -153,19 +145,18 @@ describe Mongoid::Contextual::Aggregable::Memory do
         context.avg(:mojo)
       end
 
-      it "coerces types to calculate avg" do
+      it 'coerces types to calculate avg' do
         expect(avg).to eq(8.85)
       end
 
-      it "database only averages Numeric types" do
+      it 'database only averages Numeric types' do
         expect(Band.all.avg(:mojo)).to be_within(0.000001).of(8.85)
       end
     end
 
-    context "when there no numeric values" do
-
+    context 'when there no numeric values' do
       let!(:bands) do
-        [ Band.create!(name: "Justin Bieber", mojo: nil) ]
+        [ Band.create!(name: 'Justin Bieber', mojo: nil) ]
       end
 
       let(:criteria) do
@@ -178,24 +169,23 @@ describe Mongoid::Contextual::Aggregable::Memory do
         context.avg(:mojo)
       end
 
-      it "returns avg as nil" do
+      it 'returns avg as nil' do
         expect(avg).to be_nil
       end
 
-      it "database returns avg as nil" do
+      it 'database returns avg as nil' do
         expect(Band.all.avg(:mojo)).to eq(nil)
       end
     end
   end
 
-  describe "#max" do
-
+  describe '#max' 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
@@ -204,37 +194,34 @@ describe Mongoid::Contextual::Aggregable::Memory do
       end
     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(:max) do
           context.max(:likes)
         end
 
-        it "returns nil" do
+        it 'returns nil' do
           expect(max).to be_nil
         end
       end
 
-      context "when there are a mix of types" do
-
+      context 'when there are a mix of types' do
         let!(:bands) do
-          [ Band.create!(name: "The Flaming Lips", mojo: 7.7),
-            Band.create!(name: "Spirit of the Beehive", mojo: 10),
-            Band.create!(name: "Justin Bieber", mojo: nil) ]
+          [ Band.create!(name: 'The Flaming Lips', mojo: 7.7),
+            Band.create!(name: 'Spirit of the Beehive', mojo: 10),
+            Band.create!(name: 'Justin Bieber', mojo: nil) ]
         end
 
         let(:criteria) do
@@ -247,16 +234,15 @@ describe Mongoid::Contextual::Aggregable::Memory do
           context.max(:mojo)
         end
 
-        it "coerces types to calculate max" do
+        it 'coerces types to calculate max' do
           expect(max).to eq 10
           expect(max).to be_a Integer
         end
       end
 
-      context "when there no numeric values" do
-
+      context 'when there no numeric values' do
         let!(:bands) do
-          [ Band.create!(name: "Justin Bieber", mojo: nil) ]
+          [ Band.create!(name: 'Justin Bieber', mojo: nil) ]
         end
 
         let(:criteria) do
@@ -269,34 +255,30 @@ describe Mongoid::Contextual::Aggregable::Memory do
           context.avg(:mojo)
         end
 
-        it "returns max as nil" do
+        it 'returns max as 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
 
-  describe "#min" do
-
+  describe '#min' 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,37 +287,34 @@ describe Mongoid::Contextual::Aggregable::Memory do
       end
     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(:min) do
           context.min(:likes)
         end
 
-        it "returns nil" do
+        it 'returns nil' do
           expect(min).to be_nil
         end
       end
 
-      context "when there are a mix of types" do
-
+      context 'when there are a mix of types' do
         let!(:bands) do
-          [ Band.create!(name: "The Flaming Lips", mojo: 7.7),
-            Band.create!(name: "Spirit of the Beehive", mojo: 10),
-            Band.create!(name: "Justin Bieber", mojo: nil) ]
+          [ Band.create!(name: 'The Flaming Lips', mojo: 7.7),
+            Band.create!(name: 'Spirit of the Beehive', mojo: 10),
+            Band.create!(name: 'Justin Bieber', mojo: nil) ]
         end
 
         let(:criteria) do
@@ -348,16 +327,15 @@ describe Mongoid::Contextual::Aggregable::Memory do
           context.min(:mojo)
         end
 
-        it "coerces types to calculate min" do
+        it 'coerces types to calculate min' do
           expect(min).to eq 7.7
           expect(min).to be_a Float
         end
       end
 
-      context "when there no numeric values" do
-
+      context 'when there no numeric values' do
         let!(:bands) do
-          [ Band.create!(name: "Justin Bieber", mojo: nil) ]
+          [ Band.create!(name: 'Justin Bieber', mojo: nil) ]
         end
 
         let(:criteria) do
@@ -370,34 +348,30 @@ describe Mongoid::Contextual::Aggregable::Memory do
           context.min(:mojo)
         end
 
-        it "returns min as nil" do
+        it 'returns min as 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
 
-  describe "#sum" do
-
+  describe '#sum' 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
@@ -407,14 +381,13 @@ describe Mongoid::Contextual::Aggregable::Memory do
     end
 
     context 'when values are integers' do
-
       let(:sum) do
         context.sum(:likes)
       end
 
       shared_examples 'sums and returns an integer' do
         it 'sums' do
-          sum.should == 1500
+          sum.should eq 1500
         end
 
         it 'returns integer' do
@@ -425,23 +398,21 @@ describe Mongoid::Contextual::Aggregable::Memory do
       include_examples 'sums and returns an integer'
 
       context 'when values are numeric strings' do
-
         let!(:depeche) do
-          Band.create!(name: "Depeche Mode", likes: '1000')
+          Band.create!(name: 'Depeche Mode', likes: '1000')
         end
 
         include_examples 'sums and returns an integer'
       end
 
       context 'when values are negative integers' do
-
         let!(:depeche) do
-          Band.create!(name: "Depeche Mode", likes: -1000)
+          Band.create!(name: 'Depeche Mode', likes: -1000)
         end
 
         shared_examples 'sums and returns an integer' do
           it 'sums' do
-            sum.should == -500
+            sum.should eq(-500)
           end
 
           it 'returns integer' do
@@ -452,9 +423,8 @@ describe Mongoid::Contextual::Aggregable::Memory do
         include_examples 'sums and returns an integer'
 
         context 'when values are negative numeric strings' do
-
           let!(:depeche) do
-            Band.create!(name: "Depeche Mode", likes: '-1000')
+            Band.create!(name: 'Depeche Mode', likes: '-1000')
           end
 
           include_examples 'sums and returns an integer'
@@ -463,9 +433,8 @@ describe Mongoid::Contextual::Aggregable::Memory do
     end
 
     context 'when values are floats' do
-
       let!(:depeche) do
-        Band.create!(name: "Depeche Mode", likes: 1000.0)
+        Band.create!(name: 'Depeche Mode', likes: 1000.0)
       end
 
       let(:sum) do
@@ -473,7 +442,7 @@ describe Mongoid::Contextual::Aggregable::Memory do
       end
 
       it 'sums' do
-        sum.should == 1500
+        sum.should eq 1500
       end
 
       it 'returns integer' do
@@ -481,37 +450,34 @@ describe Mongoid::Contextual::Aggregable::Memory do
       end
     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(:sum) do
           context.sum(:likes)
         end
 
-        it "returns zero" do
+        it 'returns zero' do
           expect(sum).to eq(0)
         end
       end
 
-      context "when there are a mix of types" do
-
+      context 'when there are a mix of types' do
         let!(:bands) do
-          [ Band.create!(name: "The Flaming Lips", mojo: 7.7),
-            Band.create!(name: "Spirit of the Beehive", mojo: 10),
-            Band.create!(name: "Justin Bieber", mojo: nil) ]
+          [ Band.create!(name: 'The Flaming Lips', mojo: 7.7),
+            Band.create!(name: 'Spirit of the Beehive', mojo: 10),
+            Band.create!(name: 'Justin Bieber', mojo: nil) ]
         end
 
         let(:criteria) do
@@ -524,20 +490,19 @@ describe Mongoid::Contextual::Aggregable::Memory do
           context.sum(:mojo)
         end
 
-        it "coerces types to calculate sum" do
+        it 'coerces types to calculate sum' do
           expect(sum).to eq 17.7
           expect(sum).to be_a Float
         end
 
-        it "database only sums Float and Integer types" do
+        it 'database only sums Float and Integer types' do
           expect(Band.all.sum(:mojo)).to be_within(Float::EPSILON).of(17.7)
         end
       end
 
-      context "when there no numeric values" do
-
+      context 'when there no numeric values' do
         let!(:bands) do
-          [ Band.create!(name: "Justin Bieber", mojo: nil) ]
+          [ Band.create!(name: 'Justin Bieber', mojo: nil) ]
         end
 
         let(:criteria) do
@@ -550,36 +515,125 @@ describe Mongoid::Contextual::Aggregable::Memory do
           context.sum(:mojo)
         end
 
-        it "returns sum as zero" do
+        it 'returns sum as zero' do
           expect(sum).to eq 0
         end
 
-        it "database returns sum as zero" do
+        it 'database returns sum as zero' do
           expect(Band.all.sum(:mojo)).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
   end
+
+  context 'when the field name is a method name' do
+    let!(:depeche) do
+      Band.create!(name: 'Depeche Mode', likes: 1000)
+    end
+
+    let(:criteria) do
+      Band.all.tap do |crit|
+        crit.documents = [ depeche ]
+      end
+    end
+
+    it 'does not call the method for sum' do
+      expect(depeche).not_to receive(:delete)
+      expect(context.sum(:delete)).to eq(0)
+    end
+
+    it 'does not call the method for min' do
+      expect(depeche).not_to receive(:delete)
+      expect(context.min(:delete)).to be_nil
+    end
+
+    it 'does not call the method for max' do
+      expect(depeche).not_to receive(:delete)
+      expect(context.max(:delete)).to be_nil
+    end
+
+    it 'does not call the method for avg' do
+      expect(depeche).not_to receive(:delete)
+      expect(context.avg(:delete)).to be_nil
+    end
+
+    it 'does not call the method for aggregates' do
+      expect(depeche).not_to receive(:delete)
+      expect(context.aggregates(:delete))
+        .to eq('count' => 0, 'avg' => nil, 'max' => nil, 'min' => nil, 'sum' => 0)
+    end
+
+    it 'does not call a private method for avg' do
+      expect(depeche).not_to receive(:exit)
+      expect(context.avg(:exit)).to be_nil
+    end
+  end
+
+  context 'when the field is not defined' do
+    let!(:depeche) do
+      Band.create!(name: 'Depeche Mode', likes: 1000)
+    end
+
+    let(:criteria) do
+      Band.all.tap do |crit|
+        crit.documents = [ depeche ]
+      end
+    end
+
+    it 'returns zero for sum' do
+      expect(context.sum(:not_a_field)).to eq(0)
+    end
+
+    it 'returns nil for min' do
+      expect(context.min(:not_a_field)).to be_nil
+    end
+
+    it 'returns nil for max' do
+      expect(context.max(:not_a_field)).to be_nil
+    end
+
+    it 'returns nil for avg' do
+      expect(context.avg(:not_a_field)).to be_nil
+    end
+  end
+
+  context 'when the field is the foreign key of a many to many association' do
+    let!(:preference) do
+      Preference.create!(name: 'nature')
+    end
+
+    let!(:person) do
+      Person.create!(preferences: [ preference ])
+    end
+
+    let(:criteria) do
+      Person.all.tap do |crit|
+        crit.documents = [ person ]
+      end
+    end
+
+    it 'aggregates the stored ids' do
+      expect(context.max(:preference_ids)).to eq([ preference.id ])
+    end
+  end
 end