mongoid_monkey 0.2.5 → 0.3.0

data/spec/app/models/video.rb

@@ -0,0 +1,17 @@
+class Video
+  include Mongoid::Document
+  field :title, type: String
+  field :year, type: Integer
+  field :release_dates, type: Set
+  field :genres, type: Array
+
+  embedded_in :person
+  belongs_to :post
+  belongs_to :game
+
+  default_scope asc(:title)
+
+  attr_accessible :title, as: [ :default, :admin ]
+  attr_accessible :year, as: [ :default ]
+  attr_accessible :person_attributes, as: [ :default ]
+end

data/spec/unit/aggregate_cursor_spec.rb

@@ -0,0 +1,495 @@
+require "spec_helper"
+
+if Mongoid::VERSION =~ /\A3\./
+
+describe Mongoid::Contextual::Aggregable::Mongo do
+
+  before(:each) do
+    Mongoid.purge!
+  end
+
+  describe "#aggregates" do
+
+    context "when provided a single field" do
+
+      let!(:depeche) do
+        Band.create(name: "Depeche Mode", likes: 1000, years: 1000)
+      end
+
+      let!(:tool) do
+        Band.create(name: "Tool", likes: 500, years: 800)
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      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
+            aggregates["avg"].should eq(900)
+          end
+
+          it "returns a count" do
+            aggregates["count"].should eq(2)
+          end
+
+          it "returns a max" do
+            aggregates["max"].should eq(1000)
+          end
+
+          it "returns a min" do
+            aggregates["min"].should eq(800)
+          end
+
+          it "returns a sum" do
+            aggregates["sum"].should eq(1800)
+          end
+        end
+
+        context "when more than 1 document is emitted" do
+
+          let(:aggregates) do
+            context.aggregates(:likes)
+          end
+
+          it "returns an avg" do
+            aggregates["avg"].should eq(750)
+          end
+
+          it "returns a count" do
+            aggregates["count"].should eq(2)
+          end
+
+          it "returns a max" do
+            aggregates["max"].should eq(1000)
+          end
+
+          it "returns a min" do
+            aggregates["min"].should eq(500)
+          end
+
+          it "returns a sum" do
+            aggregates["sum"].should eq(1500)
+          end
+        end
+
+        context "when only 1 document is emitted" do
+
+          let(:criteria) do
+            Band.where(name: "Depeche Mode")
+          end
+
+          let(:aggregates) do
+            context.aggregates(:likes)
+          end
+
+          it "returns an avg" do
+            aggregates["avg"].should eq(1000)
+          end
+
+          it "returns a count" do
+            aggregates["count"].should eq(1)
+          end
+
+          it "returns a max" do
+            aggregates["max"].should eq(1000)
+          end
+
+          it "returns a min" do
+            aggregates["min"].should eq(1000)
+          end
+
+          it "returns a sum" do
+            aggregates["sum"].should eq(1000)
+          end
+        end
+
+        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
+
+          let(:aggregates) do
+            context.aggregates(:likes)
+          end
+
+          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)
+          end
+
+          it "returns a max" do
+            expect(aggregates["max"]).to eq(1000)
+          end
+
+          it "returns a min" do
+            expect(aggregates["min"]).to eq(1000)
+          end
+
+          it "returns a sum" do
+            expect(aggregates["sum"]).to eq(1000)
+          end
+        end
+
+      end
+
+      context "when the field does not exist" do
+
+        let(:aggregates) do
+          context.aggregates(:non_existant)
+        end
+
+        it "returns an avg" do
+          aggregates["avg"].should eq(0)
+        end
+
+        it "returns a count" do
+          aggregates["count"].should eq(2)
+        end
+
+        it "returns a max" do
+          aggregates["max"].should be_nil
+        end
+
+        it "returns a min" do
+          aggregates["min"].should be_nil
+        end
+
+        it "returns a sum" do
+          aggregates["sum"].should eq(0)
+        end
+      end
+
+      context "when the field sometimes exists" do
+        let!(:oasis) do
+          Band.create(name: "Oasis", likes: 50)
+        end
+
+        let!(:radiohead) do
+          Band.create(name: "Radiohead")
+        end
+
+        context "and the field doesn't exist on the last document" do
+          let(:criteria) do
+            Band.all
+          end
+
+          let(:context) do
+            Mongoid::Contextual::Mongo.new(criteria)
+          end
+
+          let(:aggregates) do
+            context.aggregates(:likes)
+          end
+
+          it "returns a min" do
+            aggregates["min"].should eq(50)
+          end
+        end
+
+        context "and the field doesn't exist on the before-last document" do
+          let!(:u2) do
+            Band.create(name: "U2", likes: 100)
+          end
+
+          let(:criteria) do
+            Band.all
+          end
+
+          let(:context) do
+            Mongoid::Contextual::Mongo.new(criteria)
+          end
+
+          let(:aggregates) do
+            context.aggregates(:likes)
+          end
+
+          it "returns a min" do
+            aggregates["min"].should eq(50)
+          end
+        end
+      end
+
+      context "when there are no matching documents" do
+
+        let(:criteria) do
+          Band.where(name: "New Order")
+        end
+
+        let(:aggregates) do
+          context.aggregates(:non_existant)
+        end
+
+        it "returns nil" do
+          aggregates.should eq({ "count" => 0 })
+        end
+      end
+    end
+  end
+
+  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)
+        end
+
+        let!(:tool) do
+          Band.create(name: "Tool", likes: 500)
+        end
+
+        let(:criteria) do
+          Band.all
+        end
+
+        let(:context) do
+          Mongoid::Contextual::Mongo.new(criteria)
+        end
+
+        let(:avg) do
+          context.avg(:likes)
+        end
+
+        it "returns the avg of the provided field" do
+          avg.should eq(750)
+        end
+      end
+
+      context "when no documents match" do
+
+        let!(:depeche) do
+          Band.create(name: "Depeche Mode", likes: 1000)
+        end
+
+        let(:criteria) do
+          Band.where(name: "New Order")
+        end
+
+        let(:context) do
+          Mongoid::Contextual::Mongo.new(criteria)
+        end
+
+        let(:avg) do
+          context.avg(:likes)
+        end
+
+        it "returns nil" do
+          avg.should be_nil
+        end
+      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(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      context "when provided a symbol" do
+
+        let(:max) do
+          context.max(:likes)
+        end
+
+        it "returns the max of the provided field" do
+          max.should eq(1000)
+        end
+
+        context "when no documents match" do
+
+          let(:criteria) do
+            Band.where(name: "New Order")
+          end
+
+          let(:context) do
+            Mongoid::Contextual::Mongo.new(criteria)
+          end
+
+          let(:max) do
+            context.max(:likes)
+          end
+
+          it "returns nil" do
+            max.should 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
+          max.should eq(depeche)
+        end
+      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!(:tool) do
+        Band.create(name: "Tool", likes: 500)
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      context "when provided a symbol" do
+
+        let(:min) do
+          context.min(:likes)
+        end
+
+        it "returns the min of the provided field" do
+          min.should eq(500)
+        end
+
+        context "when no documents match" do
+
+          let(:criteria) do
+            Band.where(name: "New Order")
+          end
+
+          let(:context) do
+            Mongoid::Contextual::Mongo.new(criteria)
+          end
+
+          let(:min) do
+            context.min(:likes)
+          end
+
+          it "returns nil" do
+            min.should 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
+          min.should eq(tool)
+        end
+      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!(:tool) do
+        Band.create(name: "Tool", likes: 500)
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      context "when provided a symbol" do
+
+        let(:sum) do
+          context.sum(:likes)
+        end
+
+        it "returns the sum of the provided field" do
+          sum.should eq(1500)
+        end
+
+        context "when no documents match" do
+
+          let(:criteria) do
+            Band.where(name: "New Order")
+          end
+
+          let(:context) do
+            Mongoid::Contextual::Mongo.new(criteria)
+          end
+
+          let(:sum) do
+            context.sum(:likes)
+          end
+
+          it "returns zero" do
+            sum.should eq(0)
+          end
+        end
+      end
+
+      context "when provided a block" do
+
+        let(:sum) do
+          context.sum(&:likes)
+        end
+
+        it "returns the sum for the provided block" do
+          sum.should eq(1500)
+        end
+      end
+    end
+  end
+end
+
+end