mongo_doc 0.3.0

data/spec/contexts/enumerable_spec.rb

@@ -0,0 +1,274 @@
+require "spec_helper"
+
+describe MongoDoc::Contexts::Enumerable do
+
+  class Address
+    include MongoDoc::Document
+    include MongoDoc::Matchers
+
+    key :number
+    key :street
+  end
+
+  before do
+    @london = Address.new(:number => 1, :street => "Bond Street")
+    @shanghai = Address.new(:number => 10, :street => "Nan Jing Dong Lu")
+    @melbourne = Address.new(:number => 20, :street => "Bourke Street")
+    @new_york = Address.new(:number => 20, :street => "Broadway")
+    @docs = [ @london, @shanghai, @melbourne, @new_york ]
+    @criteria = Mongoid::Criteria.new(Address)
+    @criteria.documents = @docs
+    @criteria.where(:street => "Bourke Street").only(:number)
+    @context = MongoDoc::Contexts::Enumerable.new(@criteria)
+  end
+
+  describe "#aggregate" do
+
+    before do
+      @counts = @context.aggregate
+    end
+
+    it "groups by the fields provided in the options" do
+      @counts.size.should == 3
+    end
+
+    it "stores the counts in proper groups" do
+      @counts[1].should == 1
+      @counts[10].should == 1
+      @counts[20].should == 2
+    end
+  end
+
+  describe "#count" do
+
+    it "returns the size of the enumerable" do
+      @context.count.should == 4
+    end
+
+  end
+
+  describe "#execute" do
+
+    before do
+      @criteria = Mongoid::Criteria.new(Address)
+      @criteria.documents = @docs
+    end
+
+    it "returns the matching documents from the array" do
+      @context.execute.should == [ @melbourne ]
+    end
+
+    context "when selector is empty" do
+
+      before do
+        @criteria.only(:number)
+        @context = MongoDoc::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "returns all the documents" do
+        @context.execute.should == @docs
+      end
+    end
+
+    context "when skip and limit are in the options" do
+
+      before do
+        @criteria.skip(2).limit(2)
+        @context = MongoDoc::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "properly narrows down the matching results" do
+        @context.execute.should == [ @melbourne, @new_york ]
+      end
+    end
+
+  end
+
+  describe "#first" do
+
+    context "when a selector is present" do
+
+      it "returns the first that matches the selector" do
+        @context.first.should == @melbourne
+      end
+    end
+
+  end
+
+  describe "#group" do
+
+    before do
+      @group = @context.group
+    end
+
+    it "groups by the fields provided in the options" do
+      @group.size.should == 3
+    end
+
+    it "stores the documents in proper groups" do
+      @group[1].should == [ @london ]
+      @group[10].should == [ @shanghai ]
+      @group[20].should == [ @melbourne, @new_york ]
+    end
+
+  end
+
+  describe "#initialize" do
+
+    let(:selector) { { :field => "value"  } }
+    let(:options) { { :skip => 20 } }
+    let(:documents) { [stub] }
+
+    before do
+      @criteria = Mongoid::Criteria.new(Address)
+      @criteria.documents = documents
+      @criteria.where(selector).skip(20)
+      @context = MongoDoc::Contexts::Enumerable.new(@criteria)
+    end
+
+    it "sets the selector" do
+      @context.selector.should == selector
+    end
+
+    it "sets the options" do
+      @context.options.should == options
+    end
+
+    it "sets the documents" do
+      @context.documents.should == documents
+    end
+
+  end
+
+  describe "#iterator" do
+
+    before do
+      @criteria.where(:street => "Bourke Street")
+      @criteria.documents = @docs
+      @context = MongoDoc::Contexts::Enumerable.new(@criteria)
+    end
+
+    it "executes the criteria" do
+      acc = []
+      @context.iterate do |doc|
+        acc << doc
+      end
+      acc.should == [@melbourne]
+    end
+
+  end
+
+  describe "#last" do
+
+    it "returns the last matching in the enumerable" do
+      @context.last.should == @melbourne
+    end
+
+  end
+
+  describe "#max" do
+
+    it "returns the max value for the supplied field" do
+      @context.max(:number).should == 20
+    end
+
+  end
+
+  describe "#min" do
+
+    it "returns the min value for the supplied field" do
+      @context.min(:number).should == 1
+    end
+
+  end
+
+  describe "#one" do
+
+    it "returns the first matching in the enumerable" do
+      @context.one.should == @melbourne
+    end
+
+  end
+
+  describe "#page" do
+
+    context "when the page option exists" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Address).extras({ :page => 5 })
+        @criteria.documents = []
+        @context = MongoDoc::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "returns the page option" do
+        @context.page.should == 5
+      end
+
+    end
+
+    context "when the page option does not exist" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Address)
+        @criteria.documents = []
+        @context = MongoDoc::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "returns 1" do
+        @context.page.should == 1
+      end
+
+    end
+
+  end
+
+  describe "#paginate" do
+
+    before do
+      @criteria = Mongoid::Criteria.new(Address).skip(2).limit(2)
+      @context = MongoDoc::Contexts::Enumerable.new(@criteria)
+      @results = @context.paginate
+    end
+
+    it "executes and paginates the results" do
+      @results.current_page.should == 2
+      @results.per_page.should == 2
+    end
+
+  end
+
+  describe "#per_page" do
+
+    context "when a limit option exists" do
+
+      it "returns 20" do
+        @context.per_page.should == 20
+      end
+
+    end
+
+    context "when a limit option does not exist" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Address).limit(50)
+        @criteria.documents = []
+        @context = MongoDoc::Contexts::Enumerable.new(@criteria)
+      end
+
+      it "returns the limit" do
+        @context.per_page.should == 50
+      end
+
+    end
+
+  end
+
+  describe "#sum" do
+
+    it "returns the sum of all the field values" do
+      @context.sum(:number).should == 51
+    end
+
+  end
+
+end

data/spec/contexts/ids_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "MongoDoc::Contexts::Ids" do
+
+  class Address
+    include MongoDoc::Document
+    include MongoDoc::Matchers
+
+    key :number
+    key :street
+  end
+
+  let(:criteria) { Mongoid::Criteria.new(Address) }
+  let(:context) { criteria.context }
+
+  context "#id_criteria" do
+    context "single id" do
+      let(:id) { 'a' * 24 }
+      let(:obj_id) { Mongo::ObjectID.from_string(id) }
+
+      it "converts strings to an object id" do
+        criteria.should_receive(:id).with(obj_id)
+        context.stub(:one)
+        context.id_criteria(id)
+      end
+
+      it "delegates to one if passed a string or ObjectID" do
+        context.should_receive(:one)
+        context.id_criteria(id)
+      end
+    end
+
+    context "mutliple ids" do
+      let(:ids) { ['a' * 24, 'b' * 24] }
+      let(:obj_ids) { [Mongo::ObjectID.from_string(ids.first), Mongo::ObjectID.from_string(ids.last)] }
+
+      it "converts strings to an object id" do
+        criteria.should_receive(:id).with(obj_ids)
+        criteria.stub(:entries)
+        context.id_criteria(ids)
+      end
+
+      it "delegates to entries if passed an array" do
+        criteria.should_receive(:entries)
+        context.id_criteria(ids)
+      end
+    end
+  end
+end

data/spec/contexts/mongo_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+describe "MongoDoc::Contexts::MongoDoc" do
+
+  class Address
+    include MongoDoc::Document
+    include MongoDoc::Matchers
+
+    key :number
+    key :street
+  end
+
+  let(:criteria) { Mongoid::Criteria.new(Address) }
+  let(:context) { criteria.context }
+
+  context "#initialize" do
+    it "sets the criteria" do
+      context.criteria.should == criteria
+    end
+  end
+
+  context "#collection" do
+    it "delegates to klass" do
+      klass = mock('klass', :collection => true)
+      context.should_receive(:klass).and_return(klass)
+      context.collection
+    end
+  end
+
+  context "querying" do
+    let(:collection) { stub('collection') }
+
+    before { context.stub(:collection).and_return(collection) }
+
+    context "#aggregate" do
+      it "uses group with the appropriate JS" do
+        collection.should_receive(:group).with(nil, {}, {:count=>0}, MongoDoc::Contexts::Mongo::AGGREGATE_REDUCE, true)
+        context.aggregate
+      end
+    end
+
+    context "#count" do
+      it "uses find and count" do
+        result = stub('result')
+        result.should_receive(:count)
+        collection.should_receive(:find).and_return(result)
+        context.count
+      end
+    end
+
+    context "#execute" do
+      it "uses find" do
+        collection.should_receive(:find)
+        context.execute
+      end
+
+      it "returns [] if nothing returned from find" do
+        collection.stub(:find => nil)
+        context.execute.should == []
+      end
+
+      it "returns the cursor if one is returned from find" do
+        cursor = stub('cursor')
+        collection.stub(:find => cursor)
+        context.execute.should == cursor
+      end
+
+      it "memoizes the count if paginating" do
+        count = 20
+        cursor = stub('cursor', :count => count)
+        collection.stub(:find => cursor)
+        context.execute
+        context.count.should == count
+      end
+    end
+
+    context "#group" do
+      it "uses group with the appropriate JS" do
+        collection.should_receive(:group).with(nil, {}, {:group=>[]}, MongoDoc::Contexts::Mongo::GROUP_REDUCE, true).and_return([])
+        context.group
+      end
+
+      it "decodes returned documents" do
+        doc = stub('doc')
+        collection.stub(:group).and_return([{:group => [doc]}])
+        MongoDoc::BSON.should_receive(:decode).and_return(doc)
+        context.group
+      end
+    end
+
+    context "#iterate" do
+
+      it "delegates to caching if cached" do
+        context.should_receive(:caching)
+        criteria.cache
+        context.iterate
+      end
+
+      it "iterates over the results of execute" do
+        item = stub('item')
+        context.stub(:execute).and_return([item])
+        context.iterate do |doc|
+          doc.should == item
+        end
+      end
+
+      context "#caching" do
+        let(:item) { stub('item') }
+
+        before do
+          criteria.cache
+        end
+
+        context "when not previously cached" do
+          it "iterates over the results of execute" do
+            context.stub(:execute).and_return([item])
+            context.iterate do |doc|
+              doc.should == item
+            end
+          end
+
+          it "memoizes the result" do
+            context.stub(:execute).and_return([item])
+            context.iterate
+            context.cache.should == [item]
+          end
+        end
+
+        context "when previously cached" do
+          before do
+            context.instance_variable_set(:@cache, [item])
+          end
+
+          it "does not execute" do
+            context.should_not_receive(:execute)
+            context.iterate do |doc|
+              doc.should == item
+            end
+          end
+
+          it "iterates over the results of execute" do
+            context.should_not_receive(:execute)
+            acc = []
+            context.iterate do |doc|
+              acc << doc
+            end
+            acc.should == [item]
+          end
+        end
+      end
+    end
+
+    context "#last" do
+      it "delegates to find_one" do
+        collection.should_receive(:find_one).with({}, {:sort=>[[:_id, :desc]]})
+        context.last
+      end
+    end
+
+    context "#max" do
+      it "delegates to grouped" do
+        context.should_receive(:grouped).with(:max, "number", MongoDoc::Contexts::Mongo::MAX_REDUCE)
+        context.max(:number)
+      end
+    end
+
+    context "#min" do
+      it "delegates to grouped" do
+        context.should_receive(:grouped).with(:min, "number", MongoDoc::Contexts::Mongo::MIN_REDUCE)
+        context.min(:number)
+      end
+    end
+
+    context "#one" do
+      it "delegates to find_one" do
+        collection.should_receive(:find_one).with({}, {})
+        context.one
+      end
+    end
+
+    context "#sum" do
+      it "delegates to grouped" do
+        context.should_receive(:grouped).with(:sum, "number", MongoDoc::Contexts::Mongo::SUM_REDUCE)
+        context.sum(:number)
+      end
+    end
+
+    context "#grouped" do
+      it "delegates to group" do
+        op = 'op'
+        field = 'name'
+        reduce = '[field]'
+        collection.should_receive(:group).with(nil, {}, {op =>"start"}, field, true).and_return([])
+        context.send(:grouped, op, field, reduce)
+      end
+    end
+  end
+end

data/spec/contexts_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe MongoDoc::Contexts do
+
+  context ".context_for" do
+    let(:criteria) { stub('criteria', :klass => klass) }
+
+    context "when criteria is for a top-level MongoDoc::Document" do
+      let(:klass) { stub('klass', :collection => stub('collection')) }
+
+      it "creates a MongoDoc context" do
+        MongoDoc::Contexts::Mongo.should_receive(:new).with(criteria)
+        Mongoid::Contexts.context_for(criteria)
+      end
+    end
+
+    context "when criteria is for an embedded MongoDoc::Document" do
+      let(:klass) { stub('klass') }
+
+      it "creates an Enumerable context" do
+        MongoDoc::Contexts::Enumerable.should_receive(:new).with(criteria)
+        Mongoid::Contexts.context_for(criteria)
+      end
+    end
+  end
+
+end
+

data/spec/criteria_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe MongoDoc::Criteria do
+
+  class CriteriaTest
+    extend MongoDoc::Criteria
+  end
+
+  context ".criteria" do
+    it "creates a new criteria for the document" do
+      CriteriaTest.criteria.should be_a_kind_of(Mongoid::Criteria)
+    end
+
+    it "sets the criteria klass" do
+      CriteriaTest.criteria.klass.should == CriteriaTest
+    end
+  end
+
+  context "criteria delegates" do
+    let(:criteria) { stub('criteria').as_null_object }
+
+    before do
+      CriteriaTest.stub(:criteria).and_return(criteria)
+    end
+
+    %w(and cache enslave excludes extras id in limit not_in offset only order_by page per_page skip where).each do |criteria_op|
+      it "#{criteria_op} delegates to the criteria" do
+        criteria.should_receive(criteria_op)
+        CriteriaTest.send(criteria_op)
+      end
+    end
+  end
+end

data/spec/cursor_spec.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "MongoDoc::Cursor" do
+  let(:mongo_cursor) { stub('cursor') }
+
+  let(:collection) { stub('collection') }
+
+  let(:cursor) { MongoDoc::Cursor.new(collection, mongo_cursor) }
+
+  it "is Enumerable" do
+    Enumerable.should === cursor
+  end
+
+  it ".new wraps a Mongo::Cursor" do
+    cursor._cursor.should == mongo_cursor
+  end
+
+  it "#collection returns the MongoDoc::Collection for this cursor" do
+    cursor.collection.should == collection
+    cursor._collection.should == collection
+  end
+
+  context "with the underlying cursor" do
+    %w(admin close closed? count explain fields full_collection_name hint limit order query_options_hash query_opts selector skip snapshot sort timeout).each do |delegated_method|
+      it "delegates #{delegated_method} to the Mongo::Cursor" do
+        mongo_cursor.should_receive(delegated_method)
+        cursor.send(delegated_method)
+      end
+    end
+  end
+
+  context "#each" do
+    it "delegates to the cursor" do
+      mongo_cursor.should_receive(:each)
+      cursor.each
+    end
+
+    it "decodes the return from the delegate" do
+      bson = stub('bson')
+      cursor.stub(:_cursor).and_return([bson])
+      MongoDoc::BSON.should_receive(:decode).with(bson)
+      cursor.each {}
+    end
+
+    it "calls the block with the decoded return" do
+      result = stub('bson')
+      cursor.stub(:_cursor).and_return([result])
+      MongoDoc::BSON.stub(:decode).and_return(result)
+      cursor.each {|obj| @obj = obj}
+      @obj.should == result
+    end
+  end
+
+  context "#next_document" do
+    it "delegates to the cursor" do
+      mongo_cursor.should_receive(:next_document)
+      cursor.next_document
+    end
+
+    it "decodes the return from the delegate" do
+      bson = stub('bson')
+      mongo_cursor.stub(:next_document).and_return(bson)
+      MongoDoc::BSON.should_receive(:decode).with(bson)
+      cursor.next_document
+    end
+
+    it "returns nil if the delegate returns nil" do
+      mongo_cursor.stub(:next_document)
+      cursor.next_document.should be_nil
+    end
+  end
+
+  context "#to_a" do
+    it "delegates to the cursor" do
+      mongo_cursor.should_receive(:to_a)
+      cursor.to_a
+    end
+
+    it "decodes the return from the delegate" do
+      array = stub('array')
+      mongo_cursor.stub(:to_a).and_return(array)
+      MongoDoc::BSON.should_receive(:decode).with(array)
+      cursor.to_a
+    end
+
+    it "returns [] if the delegate returns []" do
+      mongo_cursor.stub(:to_a).and_return([])
+      cursor.to_a.should == []
+    end
+  end
+end

data/spec/document_ext.rb

@@ -0,0 +1,9 @@
+module MongoDoc
+  module Document
+    def errors_on(attribute)
+      self.valid?
+      [self.errors.on(attribute)].flatten.compact
+    end
+    alias :error_on :errors_on
+  end
+end