mongo_doc 0.6.26 → 0.6.27

data/spec/collection_spec.rb

@@ -1,169 +0,0 @@
-require 'spec_helper'
-
-describe "MongoDoc::Collection" do
-
-  let(:mongo_collection) { stub('collection') }
-
-  it ".new delegates to .mongo_collection" do
-    name = 'collection_name'
-    MongoDoc::Collection.should_receive(:mongo_collection).with(name).and_return(mongo_collection)
-    MongoDoc::Collection.new(name)
-  end
-
-  context "with the underlying Mongo::Collection" do
-
-    let(:collection) do
-      MongoDoc::Collection.stub(:mongo_collection).and_return(mongo_collection)
-      MongoDoc::Collection.new('collection_name')
-    end
-
-    it "has Criteria mixed in" do
-      MongoDoc::Criteria.should === collection
-    end
-
-    it "#collection references self for Mongo context" do
-      collection.send(:collection).should == collection
-    end
-
-    %w([] clear count create_index db distinct drop drop_index drop_indexes group hint index_information map_reduce mapreduce name options pk_factory remove rename size).each do |delegated_method|
-      it "delegates #{delegated_method} to the Mongo::Collection" do
-        mongo_collection.should_receive(delegated_method)
-        collection.send(delegated_method)
-      end
-    end
-
-    context "#find" do
-      let(:cursor) { MongoDoc::Cursor.new(collection, stub('cursor', :close => nil)) }
-
-      before do
-        collection.stub(:wrapped_cursor).and_return(cursor)
-      end
-
-      it "wraps the cursor" do
-        query = {'sample' => 'data'}
-        options = { :limit => 1}
-        collection.should_receive(:wrapped_cursor).with(query, options).and_return(cursor)
-        collection.find(query, options)
-      end
-
-      it "calls the block with a wrapped cursor" do
-        collection.find {|c| @result = c}
-        @result.should == cursor
-      end
-    end
-
-    context "#find_one" do
-      let(:bson) { stub('bson') }
-
-      before do
-        mongo_collection.stub(:find_one).and_return(bson)
-      end
-
-      it "delegates to the Mongo::Collection" do
-        spec = { 'sample' => 'data' }
-        options = {:limit => 1}
-        mongo_collection.should_receive(:find_one).with(spec, options)
-        collection.find_one(spec, options)
-      end
-
-      it "converts the result back from bson" do
-        MongoDoc::BSON.should_receive(:decode).with(bson)
-        collection.find_one({ 'sample' => 'data' })
-      end
-
-      it "returns the converted result" do
-        obj = stub('obj')
-        MongoDoc::BSON.stub(:decode).and_return(obj)
-        collection.find_one({ 'sample' => 'data' }).should == obj
-      end
-
-      it "returns nil if the delegate returns nil" do
-        mongo_collection.stub(:find_one)
-        collection.find_one({ 'sample' => 'data' }).should be_nil
-      end
-    end
-
-    context "#insert" do
-      let(:doc) { {'sample' => 'data'} }
-      let(:options) { {:safe => false} }
-
-      it "delegates to the Mongo::Collection" do
-        mongo_collection.should_receive(:insert).with(doc, options)
-        collection.insert(doc, options)
-      end
-
-      it "converts the doc_or_docs to bson" do
-        doc.should_receive(:to_bson)
-        mongo_collection.stub(:insert)
-        collection.insert(doc, options)
-      end
-
-      it "returns the delegates result" do
-        result = 'result'
-        mongo_collection.stub(:insert).and_return(result)
-        collection.insert(doc).should == result
-      end
-    end
-
-    context "#save" do
-      let(:doc) { {'sample' => 'data'} }
-
-      it "delegates to the Mongo::Collection" do
-        options = {:safe => false}
-        mongo_collection.should_receive(:save).with(doc, options)
-        collection.save(doc, options)
-      end
-
-      it "converts the doc to bson" do
-        doc.should_receive(:to_bson)
-        mongo_collection.stub(:save)
-        collection.save(doc)
-      end
-
-      it "returns the delegates result" do
-        result = 'result'
-        mongo_collection.stub(:save).and_return(result)
-        collection.save(doc).should == result
-      end
-    end
-
-    context "#update" do
-      let(:spec) { {'sample' => 'old'} }
-
-      let(:doc) { {'sample' => 'data'} }
-
-      let(:options) { {:safe => false} }
-
-      before do
-        collection.stub(:last_error).and_return('updatedExisting' => true)
-        mongo_collection.stub(:update)
-      end
-
-      it "delegates to the Mongo::Collection" do
-        mongo_collection.should_receive(:update).with(spec, doc, options)
-        collection.update(spec, doc, options)
-      end
-
-      it "converts the doc to bson" do
-        doc.should_receive(:to_bson)
-        collection.update(spec, doc, options)
-      end
-
-      it "gets the last error from the database" do
-        collection.should_receive(:last_error)
-        collection.update(spec, doc, options)
-      end
-
-      it "returns the updateExisting value of get last error" do
-        result = 'check'
-        collection.stub(:last_error).and_return({'updatedExisting' => result})
-        collection.update(spec, doc, options).should == result
-      end
-
-      it "returns false otherwise" do
-        collection.stub(:last_error)
-        collection.update(spec, doc, options).should be_false
-      end
-    end
-  end
-end

data/spec/connection_spec.rb

@@ -1,169 +0,0 @@
-require '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
-
-  before do
-    MongoDoc::Connection.reset
-  end
-
-  describe "#connection" do
-    let(:conn) { mock }
-
-    it "allows the connection to be set" do
-      MongoDoc::Connection.connection = conn
-      MongoDoc::Connection.connection.should == conn
-    end
-  end
-
-  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.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
-
-    class FauxApp
-      def root
-        Pathname.new('faux_app')
-      end
-    end
-
-    module FauxRails
-      extend self
-
-      def env
-        'staging'
-      end
-    end
-
-    before(:all) do
-      Object.const_set('Rails', FauxRails)
-      require 'mongo_doc/railties/config'
-    end
-
-    before do
-      MongoDoc::Railties::Config.config(FauxApp.new)
-    end
-
-    after(:all) 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.to_s.should == 'faux_app/config/mongodb.yml'
-    end
-
-    context "without a configuration" do
-      let(:connection) { stub('connection') }
-
-      before do
-        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("faux_app_staging", :strict => false)
-        MongoDoc::Connection.database
-      end
-    end
-  end
-
-  context ".verify_server_version" do
-    let(:connection) { stub('connection') }
-
-    before do
-      MongoDoc::Connection.connection = connection
-    end
-
-    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) }.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) }.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.host = host
-      MongoDoc::Connection.port = port
-      MongoDoc::Connection.options = 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

@@ -1,49 +0,0 @@
-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

@@ -1,241 +0,0 @@
-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 filtered options" do
-        collection.should_receive(:find).with({},{})
-        criteria.cache
-        context.execute
-      end
-
-      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

@@ -1,56 +0,0 @@
-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
-

data/spec/criteria/optional_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Criterion::Optional do
-  class OptionalTest
-    include MongoDoc::Document
-  end
-
-  let(:criteria) { Mongoid::Criteria.new(OptionalTest) }
-  let(:id) { BSON::ObjectID.new }
-  let(:string_id) { id.to_s }
-
-  describe "#id" do
-    it "converts a string id to bson ids" do
-      criteria.id(string_id)
-      BSON::ObjectID.should === criteria.selector[:_id]
-    end
-
-    it "converts many string ids to bson ids" do
-      criteria.id(string_id, string_id)
-      criteria.selector[:_id].should have_key('$in')
-      criteria.selector[:_id]['$in'].each do |selector_id|
-        BSON::ObjectID.should === selector_id
-      end
-    end
-  end
-end