mongoid 7.0.5 → 8.1.0

data/spec/mongoid/contextual/aggregable/memory_table.yml

@@ -0,0 +1,88 @@
+sets:
+  integers:
+    values:
+      - 324
+      - 4553
+      - -74
+      - 634
+      - 0
+      - 3484
+      - -3394
+      - 493
+    expected:
+      integer:
+        avg: 752.5
+        sum: 6020
+        min: -3394
+        max: 4553
+      float:
+        avg: 752.5
+        sum: 6020.0
+        min: -3394.0
+        max: 4553.0
+      big_decimal:
+        avg: !ruby/object:BigDecimal 36:0.7525e3
+        sum: !ruby/object:BigDecimal 18:0.602e4
+        min: !ruby/object:BigDecimal 18:-0.3394e4
+        max: !ruby/object:BigDecimal 18:0.4553e4
+
+  floats:
+    values:
+      - 233.132425
+      - -974.332
+      - 532.53323
+      - 0
+    expected:
+      integer:
+        avg: -52.25
+        sum: -209
+        min: -974
+        max: 532
+      float:
+        avg: -52.16658625
+        sum: -208.666345
+        min: -974.332
+        max: 532.53323
+      big_decimal:
+        avg: !ruby/object:BigDecimal 45:-0.5216658625e2
+        sum: !ruby/object:BigDecimal 27:-0.208666345e3
+        min: !ruby/object:BigDecimal 18:-0.974332e3
+        max: !ruby/object:BigDecimal 18:0.53253323e3
+
+  mixed:
+    values:
+      - 233
+      - '-974.332'
+      - ~ # ignored
+      - 532.45642
+      - '-5675'
+      - 348.434
+      - 'Foobar' # ignored
+      - -3394
+      - -493
+      - '' # ignored
+      - '0 1 2 3' # ignored
+      - !ruby/object:BigDecimal 18:0.53245642e3
+      - -5675
+      - '0.434'
+      - !ruby/object:BigDecimal 18:-0.97676e5
+      - 0.434
+      - 7455.96
+      - -0.0544
+      - '   ' # ignored
+    expected:
+      integer:
+        avg: -7484.7857
+        sum: -104787
+        min: -97676
+        max: 7455
+      float:
+        avg: -7484.5865
+        sum: -104784.2116
+        min: -97676.0
+        max: 7455.96
+      big_decimal:
+        avg: !ruby/object:BigDecimal 27:-0.7484586540e4
+        sum: !ruby/object:BigDecimal 27:-0.1047842116e6
+        min: !ruby/object:BigDecimal 18:-0.97676e5
+        max: !ruby/object:BigDecimal 18:0.745596e4

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Contextual::Aggregable::Memory do
+
+  let(:criteria) do
+    Band.all.tap do |crit|
+      crit.documents = documents
+    end
+  end
+
+  let(:context) do
+    Mongoid::Contextual::Memory.new(criteria)
+  end
+
+  file = File.read(File.join(File.dirname(__FILE__), 'memory_table.yml'))
+  table = if RUBY_VERSION.start_with?("2.5")
+            YAML.safe_load(file, [BigDecimal])
+          else
+            YAML.safe_load(file, permitted_classes: [BigDecimal])
+          end.deep_symbolize_keys.fetch(:sets)
+
+  table.each do |name, spec|
+    context "DB values are #{name}" do
+      let(:documents) do
+        spec[:values].map do |value|
+          Band.create!({ name: 'Foobar', views: value, rating: value, sales: value, mojo: value })
+        end
+      end
+
+      { integer: :views,
+        float: :rating,
+        big_decimal: :sales }.each do |type, field|
+
+        %i[sum avg min max].each do |method|
+          context "#{type.to_s.camelize} field :#{method}" do
+            let(:expected) do
+              spec.dig(:expected, type, method)
+            end
+
+            let(:result) do
+              context.send(method, field)
+            end
+
+            it 'produces the expected result' do
+              if result.is_a?(Integer)
+                expect(result).to eq expected
+              else
+                expect(result).to be_within(0.001).of(expected)
+              end
+            end
+
+            it 'produces the expected type' do
+              expect(result).to be_a expected.class
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Contextual::Aggregable::Mongo do
@@ -7,11 +9,11 @@ describe Mongoid::Contextual::Aggregable::Mongo 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
@@ -139,7 +141,6 @@ describe Mongoid::Contextual::Aggregable::Mongo do
             expect(aggregates["sum"]).to eq(1000)
           end
         end
-
       end
 
       context "when the field does not exist" do
@@ -164,18 +165,31 @@ describe Mongoid::Contextual::Aggregable::Mongo do
           expect(aggregates["min"]).to be_nil
         end
 
-        it "returns a sum" do
-          expect(aggregates["sum"]).to be_nil
+        context "when broken_aggregables feature flag is not set" do
+          config_override :broken_aggregables, false
+
+          it "returns a sum" do
+            expect(aggregates["sum"]).to eq 0
+          end
+        end
+
+        context "when broken_aggregables feature flag is set" do
+          config_override :broken_aggregables, true
+
+          it "returns nil" do
+            expect(aggregates["sum"]).to be_nil
+          end
         end
+
       end
 
       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
@@ -202,7 +216,7 @@ describe Mongoid::Contextual::Aggregable::Mongo do
 
         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
@@ -237,8 +251,20 @@ describe Mongoid::Contextual::Aggregable::Mongo do
           context.aggregates(:non_existent)
         end
 
-        it "returns nil" do
-          expect(aggregates).to eq({ "count" => 0, "sum" => nil, "avg" => nil, "min" => nil, "max" => nil })
+        context "when broken_aggregables feature flag is not set" do
+          config_override :broken_aggregables, false
+
+          it "returns empty result" do
+            expect(aggregates).to eq({ "count" => 0, "sum" => 0, "avg" => nil, "min" => nil, "max" => nil })
+          end
+        end
+
+        context "when broken_aggregables feature flag is set" do
+          config_override :broken_aggregables, true
+
+          it "returns empty result" do
+            expect(aggregates).to eq({ "count" => 0, "sum" => nil, "avg" => nil, "min" => nil, "max" => nil })
+          end
         end
       end
     end
@@ -251,11 +277,11 @@ describe Mongoid::Contextual::Aggregable::Mongo 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
@@ -278,7 +304,7 @@ describe Mongoid::Contextual::Aggregable::Mongo 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
@@ -305,7 +331,7 @@ describe Mongoid::Contextual::Aggregable::Mongo 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
@@ -328,11 +354,11 @@ describe Mongoid::Contextual::Aggregable::Mongo 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
@@ -393,11 +419,11 @@ describe Mongoid::Contextual::Aggregable::Mongo 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
@@ -458,11 +484,11 @@ describe Mongoid::Contextual::Aggregable::Mongo 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
@@ -515,4 +541,80 @@ describe Mongoid::Contextual::Aggregable::Mongo do
       end
     end
   end
+
+  describe '#pipeline' do
+    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
+        let(:criteria) { Band.desc(:name) }
+
+        it 'should omit the $sort stage' do
+          expect(stages).to eq %w[$match $group]
+        end
+      end
+
+      context "with limit" do
+        let(:criteria) { Band.desc(:name).limit(1) }
+
+        it 'should include the $sort stage' do
+          expect(stages).to eq %w[$match $sort $limit $group]
+        end
+      end
+
+      context "with skip" do
+        let(:criteria) { Band.desc(:name).skip(1) }
+
+        it 'should include the $sort stage' do
+          expect(stages).to eq %w[$match $sort $skip $group]
+        end
+      end
+
+      context "with skip and skip" do
+        let(:criteria) { Band.desc(:name).limit(1).skip(1) }
+
+        it 'should include 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
+        let(:criteria) { Band.all }
+
+        it 'should omit the $sort stage' do
+          expect(stages).to eq %w[$match $group]
+        end
+      end
+
+      context "with limit" do
+        let(:criteria) { Band.limit(1) }
+
+        it 'should include the $sort stage' do
+          expect(stages).to eq %w[$match $limit $group]
+        end
+      end
+
+      context "with skip" do
+        let(:criteria) { Band.skip(1) }
+
+        it 'should include the $sort stage' do
+          expect(stages).to eq %w[$match $skip $group]
+        end
+      end
+
+      context "with skip and skip" do
+        let(:criteria) { Band.limit(1).skip(1) }
+
+        it 'should include the $sort stage' do
+          expect(stages).to eq %w[$match $skip $limit $group]
+        end
+      end
+    end
+  end
 end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Contextual::Aggregable::None do
+
+  before do
+    Band.create!(name: "Depeche Mode")
+  end
+
+  let(:context) do
+    Mongoid::Contextual::None.new(Band.where(name: "Depeche Mode"))
+  end
+
+  describe "#aggregates" do
+    it "returns fixed values" do
+      expect(context.aggregates(:likes)).to eq("count" => 0, "avg" => nil, "max" => nil, "min" => nil, "sum" => 0)
+    end
+  end
+
+  describe "#sum" do
+    it "returns zero" do
+      expect(context.sum).to eq(0)
+    end
+
+    context "when broken_aggregables feature flag is not set" do
+      config_override :broken_aggregables, false
+
+      it "returns zero when arg given" do
+        expect(context.sum(:likes)).to eq(0)
+      end
+    end
+
+    context "when broken_aggregables feature flag is set" do
+      config_override :broken_aggregables, true
+
+      it "returns the input when arg given" do
+        expect(context.sum(:likes)).to eq(:likes)
+      end
+    end
+  end
+
+  describe "#avg" do
+    it "returns nil" do
+      expect(context.avg(:likes)).to eq(nil)
+    end
+  end
+
+  describe "#min and #max" do
+    it "returns nil" do
+      expect(context.min).to eq(nil)
+      expect(context.max).to eq(nil)
+    end
+
+    it "returns nil when arg given" do
+      expect(context.min(:likes)).to eq(nil)
+      expect(context.max(:likes)).to eq(nil)
+    end
+  end
+end