mongoid 7.6.2 → 8.0.1

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

@@ -9,10 +9,6 @@ describe Mongoid::Contextual::Aggregable::Memory do
   end
 
   describe "#aggregates" do
-    let(:context) do
-      Mongoid::Contextual::Memory.new(criteria)
-    end
-
     subject { context.aggregates(:likes) }
 
     context 'when no documents found' do
@@ -50,384 +46,528 @@ describe Mongoid::Contextual::Aggregable::Memory do
 
   describe "#avg" do
 
-    context "when provided a single field" do
+    context "when the types are Integers" do
 
-      context "when there are matching documents" do
+      let!(:depeche) do
+        Band.create!(name: "Depeche Mode", likes: 1000)
+      end
 
-        context "when the types are integers" do
+      let!(:tool) do
+        Band.create!(name: "Tool", likes: 500)
+      end
 
-          let!(:depeche) do
-            Band.create!(name: "Depeche Mode", likes: 1000)
-          end
+      let(:criteria) do
+        Band.all.tap do |criteria|
+          criteria.documents = [ depeche, tool ]
+        end
+      end
 
-          let!(:tool) do
-            Band.create!(name: "Tool", likes: 500)
-          end
+      let(:avg) do
+        context.avg(:likes)
+      end
 
-          let(:criteria) do
-            Band.all.tap do |criteria|
-              criteria.documents = [ depeche, tool ]
-            end
-          end
+      it "returns the avg of the provided field" do
+        expect(avg).to eq(750)
+      end
 
-          let(:context) do
-            Mongoid::Contextual::Memory.new(criteria)
-          end
+      it 'returns a float' do
+        avg.should be_a(Float)
+      end
 
-          let(:avg) do
-            context.avg(:likes)
-          end
+      context 'when integers are negative' do
 
-          it "returns the avg of the provided field" do
-            expect(avg).to eq(750)
-          end
+        let!(:depeche) do
+          Band.create!(name: "Depeche Mode", likes: -1000)
         end
 
-        context "when the types are floats" do
-
-          let!(:depeche) do
-            Band.create!(name: "Depeche Mode", rating: 10)
-          end
+        it "returns the avg of the provided field" do
+          expect(avg).to eq(-250)
+        end
 
-          let!(:tool) do
-            Band.create!(name: "Tool", rating: 5)
-          end
+        it 'returns a float' do
+          avg.should be_a(Float)
+        end
+      end
+    end
 
-          let(:criteria) do
-            Band.all.tap do |criteria|
-              criteria.documents = [ depeche, tool ]
-            end
-          end
+    context "when the types are Floats" do
 
-          let(:context) do
-            Mongoid::Contextual::Memory.new(criteria)
-          end
+      let!(:depeche) do
+        Band.create!(name: "Depeche Mode", rating: 10)
+      end
 
-          let(:avg) do
-            context.avg(:rating)
-          end
+      let!(:tool) do
+        Band.create!(name: "Tool", rating: 5)
+      end
 
-          it "returns the avg of the provided field" do
-            expect(avg).to eq(7.5)
-          end
+      let(:criteria) do
+        Band.all.tap do |criteria|
+          criteria.documents = [ depeche, tool ]
         end
       end
 
-      context "when no documents match" do
+      let(:avg) do
+        context.avg(:rating)
+      end
 
-        let!(:depeche) do
-          Band.create!(name: "Depeche Mode", likes: 1000)
-        end
+      it "returns the avg of the provided field" do
+        expect(avg).to eq(7.5)
+      end
+    end
 
-        let(:criteria) do
-          Band.where(name: "New Order")
-        end
+    context "when no documents match" do
 
-        let(:context) do
-          Mongoid::Contextual::Memory.new(criteria)
-        end
+      let!(:depeche) do
+        Band.create!(name: "Depeche Mode", likes: 1000)
+      end
 
-        let(:avg) do
-          context.avg(:likes)
+      let(:criteria) do
+        Band.where(name: "New Order")
+      end
+
+      let(:avg) do
+        context.avg(:likes)
+      end
+
+      it "returns nil" do
+        expect(avg).to be_nil
+      end
+    end
+
+    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) ]
+      end
+
+      let(:criteria) do
+        Band.all.tap do |criteria|
+          criteria.documents = bands
         end
+      end
 
-        it "returns nil" do
-          expect(avg).to be_nil
+      let(:avg) do
+        context.avg(:mojo)
+      end
+
+      it "coerces types to calculate avg" do
+        expect(avg).to eq(8.85)
+      end
+
+      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
+
+      let!(:bands) do
+        [ Band.create!(name: "Justin Bieber", mojo: nil) ]
+      end
+
+      let(:criteria) do
+        Band.all.tap do |criteria|
+          criteria.documents = bands
         end
       end
+
+      let(:avg) do
+        context.avg(:mojo)
+      end
+
+      it "returns avg as nil" do
+        expect(avg).to be_nil
+      end
+
+      it "database returns avg as nil" do
+        expect(Band.all.avg(:mojo)).to eq(nil)
+      end
     end
   end
 
   describe "#max" do
 
-    context "when provided a single field" do
+    let!(:depeche) do
+      Band.create!(name: "Depeche Mode", likes: 1000)
+    end
+
+    let!(:tool) do
+      Band.create!(name: "Tool", likes: 500)
+    end
 
-      let!(:depeche) do
-        Band.create!(name: "Depeche Mode", likes: 1000)
+    let(:criteria) do
+      Band.all.tap do |crit|
+        crit.documents = [ depeche, tool ]
       end
+    end
 
-      let!(:tool) do
-        Band.create!(name: "Tool", likes: 500)
-      end
+    context "when provided a Symbol" do
 
-      let(:criteria) do
-        Band.all.tap do |crit|
-          crit.documents = [ depeche, tool ]
-        end
+      let(:max) do
+        context.max(:likes)
       end
 
-      let(:context) do
-        Mongoid::Contextual::Memory.new(criteria)
+      it "returns the max of the provided field" do
+        expect(max).to eq(1000)
       end
 
-      context "when provided a symbol" do
+      context "when no documents match" do
+
+        let(:criteria) do
+          Band.where(name: "New Order")
+        end
 
         let(:max) do
           context.max(:likes)
         end
 
-        it "returns the max of the provided field" do
-          expect(max).to eq(1000)
+        it "returns nil" do
+          expect(max).to be_nil
         end
+      end
 
-        context "when no documents match" do
+      context "when there are a mix of types" do
 
-          let(:criteria) do
-            Band.where(name: "New Order")
-          end
+        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) ]
+        end
 
-          let(:context) do
-            Mongoid::Contextual::Memory.new(criteria)
+        let(:criteria) do
+          Band.all.tap do |criteria|
+            criteria.documents = bands
           end
+        end
 
-          let(:max) do
-            context.max(:likes)
-          end
+        let(:max) do
+          context.max(:mojo)
+        end
 
-          it "returns nil" do
-            expect(max).to be_nil
-          end
+        it "coerces types to calculate max" do
+          expect(max).to eq 10
+          expect(max).to be_a Integer
         end
       end
 
-      context "when provided a block" do
+      context "when there no numeric values" do
 
-        let(:max) do
-          context.max do |a, b|
-            a.likes <=> b.likes
+        let!(:bands) do
+          [ Band.create!(name: "Justin Bieber", mojo: nil) ]
+        end
+
+        let(:criteria) do
+          Band.all.tap do |criteria|
+            criteria.documents = bands
           end
         end
 
-        it "returns the document with the max value for the field" do
-          expect(max).to eq(depeche)
+        let(:max) do
+          context.avg(:mojo)
+        end
+
+        it "returns max as nil" do
+          expect(max).to be_nil
         end
       end
     end
+
+    context "when provided a block" do
+
+      let(:max) do
+        context.max do |a, b|
+          a.likes <=> b.likes
+        end
+      end
+
+      it "returns the document with the max value for the field" do
+        expect(max).to eq(depeche)
+      end
+    end
   end
 
   describe "#min" do
 
-    context "when provided a single field" do
+    let!(:depeche) do
+      Band.create!(name: "Depeche Mode", likes: 1000)
+    end
 
-      let!(:depeche) do
-        Band.create!(name: "Depeche Mode", likes: 1000)
-      end
+    let!(:tool) do
+      Band.create!(name: "Tool", likes: 500)
+    end
 
-      let!(:tool) do
-        Band.create!(name: "Tool", likes: 500)
+    let(:criteria) do
+      Band.all.tap do |crit|
+        crit.documents = [ depeche, tool ]
       end
+    end
 
-      let(:criteria) do
-        Band.all.tap do |crit|
-          crit.documents = [ depeche, tool ]
-        end
+    context "when provided a Symbol" do
+
+      let(:min) do
+        context.min(:likes)
       end
 
-      let(:context) do
-        Mongoid::Contextual::Memory.new(criteria)
+      it "returns the min of the provided field" do
+        expect(min).to eq(500)
       end
 
-      context "when provided a symbol" do
+      context "when no documents match" do
+
+        let(:criteria) do
+          Band.where(name: "New Order")
+        end
 
         let(:min) do
           context.min(:likes)
         end
 
-        it "returns the min of the provided field" do
-          expect(min).to eq(500)
+        it "returns nil" do
+          expect(min).to be_nil
         end
+      end
 
-        context "when no documents match" do
+      context "when there are a mix of types" do
 
-          let(:criteria) do
-            Band.where(name: "New Order")
-          end
+        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) ]
+        end
 
-          let(:context) do
-            Mongoid::Contextual::Memory.new(criteria)
+        let(:criteria) do
+          Band.all.tap do |criteria|
+            criteria.documents = bands
           end
+        end
 
-          let(:min) do
-            context.min(:likes)
-          end
+        let(:min) do
+          context.min(:mojo)
+        end
 
-          it "returns nil" do
-            expect(min).to be_nil
-          end
+        it "coerces types to calculate min" do
+          expect(min).to eq 7.7
+          expect(min).to be_a Float
         end
       end
 
-      context "when provided a block" do
+      context "when there no numeric values" do
 
-        let(:min) do
-          context.min do |a, b|
-            a.likes <=> b.likes
+        let!(:bands) do
+          [ Band.create!(name: "Justin Bieber", mojo: nil) ]
+        end
+
+        let(:criteria) do
+          Band.all.tap do |criteria|
+            criteria.documents = bands
           end
         end
 
-        it "returns the document with the min value for the field" do
-          expect(min).to eq(tool)
+        let(:min) do
+          context.min(:mojo)
+        end
+
+        it "returns min as nil" do
+          expect(min).to be_nil
         end
       end
     end
+
+    context "when provided a block" do
+
+      let(:min) do
+        context.min do |a, b|
+          a.likes <=> b.likes
+        end
+      end
+
+      it "returns the document with the min value for the field" do
+        expect(min).to eq(tool)
+      end
+    end
   end
 
   describe "#sum" do
 
-    context "when provided a single field" do
+    let!(:depeche) do
+      Band.create!(name: "Depeche Mode", likes: 1000)
+    end
 
-      let!(:depeche) do
-        Band.create!(name: "Depeche Mode", likes: 1000)
+    let!(:tool) do
+      Band.create!(name: "Tool", likes: 500)
+    end
+
+    let(:criteria) do
+      Band.all.tap do |crit|
+        crit.documents = [ depeche, tool ]
       end
+    end
 
-      let!(:tool) do
-        Band.create!(name: "Tool", likes: 500)
+    context 'when values are integers' do
+
+      let(:sum) do
+        context.sum(:likes)
       end
 
-      let(:criteria) do
-        Band.all.tap do |crit|
-          crit.documents = [ depeche, tool ]
+      shared_examples 'sums and returns an integer' do
+        it 'sums' do
+          sum.should == 1500
         end
-      end
 
-      let(:context) do
-        Mongoid::Contextual::Memory.new(criteria)
+        it 'returns integer' do
+          sum.should be_a(Integer)
+        end
       end
 
-      context "when provided a symbol" do
+      include_examples 'sums and returns an integer'
 
-        let(:sum) do
-          context.sum(:likes)
-        end
+      context 'when values are numeric strings' do
 
-        it "returns the sum of the provided field" do
-          expect(sum).to eq(1500)
+        let!(:depeche) do
+          Band.create!(name: "Depeche Mode", likes: '1000')
         end
 
-        context "when no documents match" do
+        include_examples 'sums and returns an integer'
+      end
 
-          let(:criteria) do
-            Band.where(name: "New Order")
-          end
+      context 'when values are negative integers' do
 
-          let(:context) do
-            Mongoid::Contextual::Memory.new(criteria)
-          end
+        let!(:depeche) do
+          Band.create!(name: "Depeche Mode", likes: -1000)
+        end
 
-          let(:sum) do
-            context.sum(:likes)
+        shared_examples 'sums and returns an integer' do
+          it 'sums' do
+            sum.should == -500
           end
 
-          it "returns zero" do
-            expect(sum).to eq(0)
+          it 'returns integer' do
+            sum.should be_a(Integer)
           end
         end
-      end
 
-      context "when provided a block" do
+        include_examples 'sums and returns an integer'
 
-        let(:sum) do
-          context.sum(&:likes)
-        end
+        context 'when values are negative numeric strings' do
 
-        it "returns the sum for the provided block" do
-          expect(sum).to eq(1500)
+          let!(:depeche) do
+            Band.create!(name: "Depeche Mode", likes: '-1000')
+          end
+
+          include_examples 'sums and returns an integer'
         end
       end
     end
-  end
 
-  context "when the field name is a method name" do
+    context 'when values are floats' do
 
-    let!(:depeche) do
-      Band.create!(name: "Depeche Mode", likes: 1000)
-    end
+      let!(:depeche) do
+        Band.create!(name: "Depeche Mode", likes: 1000.0)
+      end
 
-    let(:criteria) do
-      Band.all.tap do |crit|
-        crit.documents = [ depeche ]
+      let(:sum) do
+        context.sum(:likes)
       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 'sums' do
+        sum.should == 1500
+      end
 
-    it "does not call the method for min" do
-      expect(depeche).not_to receive(:delete)
-      expect(context.min(:delete)).to be_nil
+      it 'returns integer' do
+        sum.should be_a(Integer)
+      end
     end
 
-    it "does not call the method for max" do
-      expect(depeche).not_to receive(:delete)
-      expect(context.max(:delete)).to be_nil
-    end
+    context "when provided a Symbol" do
 
-    it "does not call the method for avg" do
-      expect(depeche).not_to receive(:delete)
-      expect(context.avg(:delete)).to eq(0.0)
-    end
+      let(:sum) do
+        context.sum(:likes)
+      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" => 0.0, "max" => nil, "min" => nil, "sum" => 0)
-    end
+      it "returns the sum of the provided field" do
+        expect(sum).to eq(1500)
+      end
 
-    it "does not call a private method for avg" do
-      expect(depeche).not_to receive(:exit)
-      expect(context.avg(:exit)).to eq(0.0)
-    end
-  end
+      context "when no documents match" do
 
-  context "when the field is not defined" do
+        let(:criteria) do
+          Band.where(name: "New Order")
+        end
 
-    let!(:depeche) do
-      Band.create!(name: "Depeche Mode", likes: 1000)
-    end
+        let(:sum) do
+          context.sum(:likes)
+        end
 
-    let(:criteria) do
-      Band.all.tap do |crit|
-        crit.documents = [ depeche ]
+        it "returns zero" do
+          expect(sum).to eq(0)
+        end
       end
-    end
 
-    it "returns zero for sum" do
-      expect(context.sum(:not_a_field)).to eq(0)
-    end
+      context "when there are a mix of types" do
 
-    it "returns nil for min" do
-      expect(context.min(:not_a_field)).to be_nil
-    end
+        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) ]
+        end
 
-    it "returns nil for max" do
-      expect(context.max(:not_a_field)).to be_nil
-    end
+        let(:criteria) do
+          Band.all.tap do |criteria|
+            criteria.documents = bands
+          end
+        end
 
-    it "returns zero for avg" do
-      expect(context.avg(:not_a_field)).to eq(0.0)
-    end
-  end
+        let(:sum) do
+          context.sum(:mojo)
+        end
 
-  context "when the field is the foreign key of a many to many association" do
+        it "coerces types to calculate sum" do
+          expect(sum).to eq 17.7
+          expect(sum).to be_a Float
+        end
 
-    let!(:preference) do
-      Preference.create!(name: "nature")
-    end
+        it "database only sums Float and Integer types" do
+          expect(Band.all.sum(:mojo)).to be_within(Float::EPSILON).of(17.7)
+        end
+      end
 
-    let!(:person) do
-      Person.new(preferences: [ preference ])
-    end
+      context "when there no numeric values" do
 
-    let(:criteria) do
-      Person.all.tap do |crit|
-        crit.documents = [ person ]
+        let!(:bands) do
+          [ Band.create!(name: "Justin Bieber", mojo: nil) ]
+        end
+
+        let(:criteria) do
+          Band.all.tap do |criteria|
+            criteria.documents = bands
+          end
+        end
+
+        let(:sum) do
+          context.sum(:mojo)
+        end
+
+        it "returns sum as zero" do
+          expect(sum).to eq 0
+        end
+
+        it "database returns sum as zero" do
+          expect(Band.all.sum(:mojo)).to eq(0)
+        end
       end
     end
 
-    it "aggregates the stored ids" do
-      expect(context.max(:preference_ids)).to eq([ preference.id ])
+    context "when provided a block" do
+
+      let(:sum) do
+        context.sum(&:likes)
+      end
+
+      it "returns the sum for the provided block" do
+        expect(sum).to eq(1500)
+      end
     end
   end
 end