mongo_doc_rails2 0.6.1

data/spec/connection_spec.rb

@@ -0,0 +1,147 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# Resets for testing
+module MongoDoc
+  module Connection
+
+    def reset
+      @config_path = nil
+      @configuration = nil
+      @connection = nil
+      @database = nil
+      @host = nil
+      @name = nil
+      @options = nil
+      @port = nil
+      @strict = nil
+    end
+
+  end
+end
+
+describe "MongoDoc::Connection.Connections" do
+
+  context "Non-rails environment" do
+
+    it "does not see Rails" do
+      Object.const_defined?('Rails').should be_false
+    end
+
+    it "default the configuration location to './mongodb.yml'" do
+      MongoDoc::Connection.config_path.should == './mongodb.yml'
+    end
+
+    context "without a configuration" do
+      let(:connection) { stub('connection') }
+
+      before do
+        MongoDoc::Connection.reset
+        MongoDoc::Connection.stub(:connect).and_return(connection)
+      end
+
+      it "creates a default connection" do
+        MongoDoc::Connection.should_receive(:connect).and_return(connection)
+        MongoDoc::Connection.connection
+      end
+
+      it "creates a default database with strict false" do
+        connection.should_receive(:db).with("mongo_doc", :strict => false)
+        MongoDoc::Connection.database
+      end
+    end
+  end
+
+  context "Rails environment" do
+
+    module FauxRails
+      extend self
+
+      def env
+        'development'
+      end
+
+      def root
+        Pathname.new('rails_root')
+      end
+    end
+
+    before do
+      Object.const_set('Rails', FauxRails)
+    end
+
+    after do
+      Object.send(:remove_const, 'Rails')
+    end
+
+    it "sees Rails" do
+      Object.const_defined?('Rails').should be_true
+    end
+
+    it "default the configuration location to Rails.root + '/config/mongodb.yml'" do
+      MongoDoc::Connection.config_path.should == FauxRails.root + 'config/mongodb.yml'
+    end
+
+    context "without a configuration" do
+      let(:connection) { stub('connection') }
+
+      before do
+        MongoDoc::Connection.reset
+        MongoDoc::Connection.stub(:connect).and_return(connection)
+      end
+
+      it "creates a default connection" do
+        MongoDoc::Connection.should_receive(:connect).and_return(connection)
+        MongoDoc::Connection.connection
+      end
+
+      it "creates a default database with strict false" do
+        connection.should_receive(:db).with("rails_root_development", :strict => false)
+        MongoDoc::Connection.database
+      end
+    end
+  end
+
+  context ".verify_server_version" do
+    let(:connection) { stub('connection') }
+
+    it "raises when the server version is unsupported" do
+      connection.stub(:server_version).and_return(Mongo::ServerVersion.new('1.3.4'))
+      lambda { MongoDoc::Connection.send(:verify_server_version, connection) }.should raise_error(MongoDoc::UnsupportedServerVersionError)
+    end
+
+    it "returns when the server version is supported" do
+      connection.stub(:server_version).and_return(Mongo::ServerVersion.new('1.4.0'))
+      lambda { MongoDoc::Connection.send(:verify_server_version, connection) }.should_not raise_error(MongoDoc::UnsupportedServerVersionError)
+    end
+  end
+
+  describe ".connect" do
+    let(:connection) { stub('connection') }
+
+    before do
+      MongoDoc::Connection.stub(:verify_server_version)
+    end
+
+    it "creates a Mongo::Connection" do
+      host = 'host'
+      port = 'port'
+      options = 'options'
+      MongoDoc::Connection.stub(:host).and_return(host)
+      MongoDoc::Connection.stub(:port).and_return(port)
+      MongoDoc::Connection.stub(:options).and_return(options)
+      Mongo::Connection.should_receive(:new).with(host, port, options).and_return(connection)
+      MongoDoc::Connection.send(:connect)
+    end
+
+    it "raises NoConnectionError if the connection fails" do
+      Mongo::Connection.stub(:new).and_return(nil)
+      lambda { MongoDoc::Connection.send(:connect) }.should raise_error(MongoDoc::NoConnectionError)
+    end
+
+    it "verifies the connection version" do
+      Mongo::Connection.stub(:new).and_return(connection)
+      MongoDoc::Connection.should_receive(:verify_server_version)
+      MongoDoc::Connection.send(:connect)
+    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
+
+    attr_accessor :number
+    attr_accessor :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) { BSON::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) { [BSON::ObjectID.from_string(ids.first), BSON::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,235 @@
+require 'spec_helper'
+
+describe "MongoDoc::Contexts::Mongo" do
+
+  class Address
+    include MongoDoc::Document
+    include MongoDoc::Matchers
+
+    attr_accessor :number
+    attr_accessor :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 "#avg" do
+      it "is the sum/count" do
+        context.should_receive(:count).and_return(1)
+        context.should_receive(:sum).with(:field_name).and_return(1)
+        context.avg(:field_name)
+      end
+
+      it "returns nil if there is no sum" do
+        context.stub(:sum).and_return(nil)
+        context.avg(:field_name).should be_nil
+      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 "#distinct" do
+      it "uses distinct" do
+        collection.should_receive(:distinct).with(:field_name, {})
+        context.distinct(:field_name)
+      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
+
+    context "#empty? or #blank?" do
+      it "delegates to find_one" do
+        collection.should_receive(:find_one).with({}, {})
+        context.empty?
+      end
+
+      it "returns true if find_one returns no result" do
+        collection.stub(:find_one).and_return(nil)
+        context.should be_blank
+      end
+
+      it "returns false if find_one returns any result" do
+        collection.stub(:find_one).and_return(stub('result'))
+        context.should_not be_empty
+      end
+    end
+  end
+end

data/spec/contexts_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe MongoDoc::Contexts do
+
+  class ContextTest
+    include MongoDoc::Document
+
+    embed_many :children
+  end
+
+  context ".context_for" do
+    let(:criteria) { stub('criteria', :klass => klass) }
+
+    context "when criteria is for a top-level MongoDoc::Document" do
+      let(:klass) { ContextTest }
+
+      it "creates a Mongo context" do
+        MongoDoc::Contexts::Mongo.should_receive(:new).with(criteria)
+        Mongoid::Contexts.context_for(criteria)
+      end
+    end
+
+    context "when criteria is for an association" do
+      let(:klass) { ContextTest.new.children }
+
+      it "creates an Enumerable context" do
+        Mongoid::Contexts::Enumerable.should_receive(:new).with(criteria)
+        Mongoid::Contexts.context_for(criteria)
+      end
+    end
+
+    context "when criteria is for a MongoDoc::Collection" do
+      let(:klass) { MongoDoc::Collection.new('collection') }
+
+      before do
+        MongoDoc::Collection.stub(:mongo_collection).and_return(stub('collection'))
+      end
+
+      it "creates a Mongo context" do
+        MongoDoc::Contexts::Mongo.should_receive(:new).with(criteria)
+        Mongoid::Contexts.context_for(criteria)
+      end
+    end
+
+    context "when criteria is not recognized" do
+      let(:klass) { Object }
+
+      it "raises an exception" do
+        expect do
+          Mongoid::Contexts.context_for(criteria)
+        end.should raise_error(Mongoid::Contexts::UnknownContext)
+      end
+    end
+  end
+end
+