mongodoc 0.2.1 → 0.2.2

data/spec/collection_spec.rb

@@ -1,179 +1,160 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "MongoDoc::Collection" do
-  it ".mongo_collection creates a Mongo::Collection of the appropriate name" do
-    name = 'collection_name'
-    db = stub('db')
-    db.should_receive(:collection).with(name)
-    MongoDoc.should_receive(:database).and_return(db)
-    MongoDoc::Collection.mongo_collection(name)
-  end
 
-  it ".new generates a Mongo::Collection by calling .mongo_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)
+    MongoDoc::Collection.should_receive(:mongo_collection).with(name).and_return(mongo_collection)
     MongoDoc::Collection.new(name)
   end
 
   context "with the underlying Mongo::Collection" do
-    before do
-      @mongo_collection = stub('collection')
-      MongoDoc::Collection.stub(:mongo_collection).and_return(@mongo_collection)
-    end
 
-    it "#_collection is the underlying Mongo::Collection" do
-      MongoDoc::Collection.new('collection_name')._collection.should == @mongo_collection
+    let(:collection) do
+      MongoDoc::Collection.stub(:mongo_collection).and_return(mongo_collection)
+      MongoDoc::Collection.new('collection_name')
     end
 
-    %w([] clear count create_index db drop drop_index drop_indexes group hint index_information name options remove rename size).each do |delegated_method|
+    %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)
-        MongoDoc::Collection.new('collection_name').send(delegated_method)
+        mongo_collection.should_receive(delegated_method)
+        collection.send(delegated_method)
       end
     end
 
     context "#find" do
-      before do
-        @query = { 'sample' => 'data' }
-        @options = {:limit => 1}
-        @block = lambda {}
-        @cursor = stub('cursor', :close => nil)
-        @collection = MongoDoc::Collection.new('collection_name')
-        @mongo_collection.stub(:find).and_return(@cursor)
-        MongoDoc::Cursor.stub(:new).and_return(@cursor)
-      end
+      let(:cursor) { MongoDoc::Cursor.new(collection, stub('cursor', :close => nil)) }
 
-      it "delegates to the Mongo::Collection" do
-        @mongo_collection.should_receive(:find).with(@query, @options, &@block).and_return(@cursor)
-        @collection.find(@query, @options, &@block)
+      before do
+        collection.stub(:wrapped_cursor).and_return(cursor)
       end
 
       it "wraps the cursor" do
-        MongoDoc::Cursor.should_receive(:new).with(@cursor).and_return(@cursor)
-        @collection.find(@query, @options, &@block)
+        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(@query, @options) {|cursor| @result = cursor}
-        @result.should == @cursor
+        collection.find {|c| @result = c}
+        @result.should == cursor
       end
     end
 
     context "#find_one" do
+      let(:bson) { stub('bson') }
+
       before do
-        @spec_or_object_id = { 'sample' => 'data' }
-        @options = {:limit => 1}
-        @collection = MongoDoc::Collection.new('collection_name')
-        @bson = stub('bson')
-        @mongo_collection.stub(:find_one).and_return(@bson)
+        mongo_collection.stub(:find_one).and_return(bson)
       end
 
       it "delegates to the Mongo::Collection" do
-        @mongo_collection.should_receive(:find_one).with(@spec_or_object_id, @options)
-        @collection.find_one(@spec_or_object_id, @options)
+        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(@spec_or_object_id, @options)
+        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(@spec_or_object_id, @options).should == 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(@spec_or_object_id, @options).should be_nil
+        mongo_collection.stub(:find_one)
+        collection.find_one({ 'sample' => 'data' }).should be_nil
       end
     end
 
     context "#insert" do
-      before do
-        @doc = { 'sample' => 'data' }
-        @options = {:safe => false}
-      end
+      let(:doc) { {'sample' => 'data'} }
 
       it "delegates to the Mongo::Collection" do
-        @mongo_collection.should_receive(:insert).with(@doc, @options)
-        MongoDoc::Collection.new('collection_name').insert(@doc, @options)
+        options = {:safe => false}
+        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)
-        MongoDoc::Collection.new('collection_name').insert(@doc, @options)
+        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)
-        MongoDoc::Collection.new('collection_name').insert(@doc, @options).should == result
+        mongo_collection.stub(:insert).and_return(result)
+        collection.insert(doc).should == result
       end
     end
 
     context "#save" do
-      before do
-        @doc = { 'sample' => 'data' }
-        @options = {:safe => false}
-      end
+      let(:doc) { {'sample' => 'data'} }
 
       it "delegates to the Mongo::Collection" do
-        @mongo_collection.should_receive(:save).with(@doc, @options)
-        MongoDoc::Collection.new('collection_name').save(@doc, @options)
+        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)
-        MongoDoc::Collection.new('collection_name').save(@doc, @options)
+        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)
-        MongoDoc::Collection.new('collection_name').save(@doc, @options).should == 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
-        @spec = { 'sample' => 'old' }
-        @doc = { 'sample' => 'data' }
-        @options = {:safe => false}
-        @database = stub('database', :command => nil)
-        MongoDoc.stub(:database).and_return(@database)
+        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)
-        MongoDoc::Collection.new('collection_name').update(@spec, @doc, @options)
+        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)
-        @mongo_collection.stub(:update)
-        MongoDoc::Collection.new('collection_name').update(@spec, @doc, @options)
+        doc.should_receive(:to_bson)
+        collection.update(spec, doc, options)
       end
 
       it "gets the last error from the database" do
-        @mongo_collection.stub(:update)
-        @database.should_receive(:command).with({'getlasterror' => 1})
-        MongoDoc::Collection.new('collection_name').update(@spec, @doc, @options)
+        collection.should_receive(:last_error)
+        collection.update(spec, doc, options)
       end
 
       it "returns the updateExisting value of get last error" do
         result = 'check'
-        @mongo_collection.stub(:update)
-        @database.stub(:command).and_return({'updatedExisting' => result})
-        MongoDoc::Collection.new('collection_name').update(@spec, @doc, @options).should == result
+        collection.stub(:last_error).and_return({'updatedExisting' => result})
+        collection.update(spec, doc, options).should == result
       end
 
       it "returns false otherwise" do
-        @mongo_collection.stub(:update)
-        MongoDoc::Collection.new('collection_name').update(@spec, @doc, @options).should be_false
+        collection.stub(:last_error)
+        collection.update(spec, doc, options).should be_false
       end
     end
   end

data/spec/connection_spec.rb

@@ -1,199 +1,147 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "MongoDoc Connections" do
+# 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
 
-  it "default the configuration location to './mongodb.yml'" do
-    MongoDoc.config_path.should == './mongodb.yml'
   end
+end
 
-  describe ".connect" do
-    before do
-      MongoDoc.config_path = nil
-      MongoDoc.connection = nil
-      MongoDoc.config = nil
-      @connection = stub('connection')
-    end
+describe "MongoDoc::Connection.Connections" do
 
-    it "when called with no params just connects" do
-      Mongo::Connection.should_receive(:new).and_return(@connection)
-      MongoDoc.connect
-    end
+  context "Non-rails environment" do
 
-    it "sets the connection" do
-      Mongo::Connection.stub(:new).and_return(@connection)
-      MongoDoc.connect
-      MongoDoc.connection.should == @connection
+    it "does not see Rails" do
+      Object.const_defined?('Rails').should be_false
     end
 
-    it "raises NoConnectionError if the connection fails" do
-      Mongo::Connection.stub(:new).and_return(nil)
-      lambda { MongoDoc.connect }.should raise_error(MongoDoc::NoConnectionError)
+    it "default the configuration location to './mongodb.yml'" do
+      MongoDoc::Connection.config_path.should == './mongodb.yml'
     end
 
-    context "mimics the Mongo::Connection API" do
-      it "accepts the host param" do
-        host = 'localhost'
-        Mongo::Connection.should_receive(:new).with(host, nil, {}).and_return(@connection)
-        MongoDoc.connect(host)
-      end
+    context "without a configuration" do
+      let(:connection) { stub('connection') }
 
-      it "accepts the port param" do
-        host = 'localhost'
-        port = 3000
-        Mongo::Connection.should_receive(:new).with(host, 3000, {}).and_return(@connection)
-        MongoDoc.connect(host, port)
+      before do
+        MongoDoc::Connection.reset
+        MongoDoc::Connection.stub(:connect).and_return(connection)
       end
 
-      it "accepts an options hash" do
-        opts = {:slave_ok => true}
-        Mongo::Connection.should_receive(:new).with(nil, nil, opts).and_return(@connection)
-        MongoDoc.connect(opts)
+      it "creates a default connection" do
+        MongoDoc::Connection.should_receive(:connect).and_return(connection)
+        MongoDoc::Connection.connection
       end
 
-      it "accepts host, port, and options" do
-        host = 'localhost'
-        port = 3000
-        opts = {:slave_ok => true}
-        Mongo::Connection.should_receive(:new).with(host, 3000, opts).and_return(@connection)
-        MongoDoc.connect(host, port, opts)
+      it "creates a default database with strict false" do
+        connection.should_receive(:db).with("mongodoc", :strict => false)
+        MongoDoc::Connection.database
       end
     end
+  end
 
-    context "when there is a config file" do
-      before do
-        MongoDoc.config_path = './spec/mongodb.yml'
-        config = YAML.load_file(MongoDoc.config_path)
-        @host = config['host']
-        @port = config['port']
-        @db_options = config['options']
-      end
-
-      context "with a host config file" do
+  context "Rails environment" do
 
-        it "and no params connects to the database with the values from the file" do
-          Mongo::Connection.should_receive(:new).with(@host, @port, @db_options).and_return(@connection)
-          MongoDoc.connect
-        end
+    module FauxRails
+      extend self
 
-        it "and params connects to the database with the params" do
-          host = 'p_host'
-          port = 890
-          options = {:option => 'p_opt'}
-          Mongo::Connection.should_receive(:new).with(host, port, options).and_return(@connection)
-          MongoDoc.connect(host, port, options)
-        end
+      def env
+        'development'
       end
 
-      context "with a host pairs config file" do
-        before do
-          MongoDoc.config_path = './spec/mongodb_pairs.yml'
-          config = YAML.load_file(MongoDoc.config_path)
-          @host_pairs = config['host_pairs']
-          @port = config['port']
-          @db_options = config['options']
-        end
-
-        it "connects to the database with the host pairs value from the file" do
-          Mongo::Connection.should_receive(:new).with(@host_pairs, @port, @db_options).and_return(@connection)
-          MongoDoc.connect
-        end
+      def root
+        Pathname.new('rails_root')
       end
     end
-  end
 
-  describe ".connect_to_database" do
     before do
-      MongoDoc.database = nil
-      MongoDoc.connection = nil
-      MongoDoc.config = nil
+      Object.const_set('Rails', FauxRails)
     end
 
-    it "raises a no database error when the database connect failed" do
-      connection = stub("connection", :db => nil)
-      MongoDoc.stub(:connect).and_return(connection)
-      lambda {MongoDoc.connect_to_database}.should raise_error(MongoDoc::NoDatabaseError)
+    after do
+      Object.send(:remove_const, 'Rails')
     end
 
-    it "returns the database" do
-      db = 'db'
-      connection = stub("connection", :db => db)
-      MongoDoc.stub(:connect).and_return(connection)
-      MongoDoc.connect_to_database.should == db
+    it "sees Rails" do
+      Object.const_defined?('Rails').should be_true
     end
 
-    context "when a connection exists" do
+    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
-        @db = 'db'
-        @connection = stub("connection", :db => @db)
+        MongoDoc::Connection.reset
+        MongoDoc::Connection.stub(:connect).and_return(connection)
       end
 
-      it "uses the exsiting connection if already connected" do
-        MongoDoc.should_receive(:connection).and_return(@connection)
-        MongoDoc.should_not_receive(:connect)
-        MongoDoc.connect_to_database.should == @db
+      it "creates a default connection" do
+        MongoDoc::Connection.should_receive(:connect).and_return(connection)
+        MongoDoc::Connection.connection
       end
 
-      it "connects if force connect is true" do
-        MongoDoc.should_not_receive(:connection)
-        MongoDoc.should_receive(:connect).and_return(@connection)
-        MongoDoc.connect_to_database(nil, nil, nil, nil, true).should == @db
+      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.1'))
+      lambda { MongoDoc::Connection.send(:verify_server_version, connection) }.should raise_error(MongoDoc::UnsupportedServerVersionError)
+    end
 
-    context "when there is no config file" do
-      before do
-        MongoDoc.config_path = nil
-        @db = 'db'
-        @name = 'name'
-        @connection = stub('connection')
-      end
+    it "returns when the server version is supported" do
+      connection.stub(:server_version).and_return(Mongo::ServerVersion.new('1.3.2'))
+      lambda { MongoDoc::Connection.send(:verify_server_version, connection) }.should_not raise_error(MongoDoc::UnsupportedServerVersionError)
+    end
+  end
 
-      it "connects with defaults when not given parameters" do
-        @connection.should_receive(:db).with(@name).and_return(@db)
-        MongoDoc.should_receive(:connect).and_return(@connection)
-        MongoDoc.connect_to_database(@name)
-      end
+  describe ".connect" do
+    let(:connection) { stub('connection') }
 
-      it "connects with the given parameters" do
-        host = 'host'
-        port = 123
-        options = { :auto_reconnect => true }
-        @connection.should_receive(:db).with(@name).and_return(@db)
-        MongoDoc.should_receive(:connect).with(host, port, options).and_return(@connection)
-        MongoDoc.connect_to_database(@name, host, port, options)
-      end
+    before do
+      MongoDoc::Connection.stub(:verify_server_version)
     end
 
-    context "when there is a config file" do
-      before do
-        @db = 'db'
-        MongoDoc.config_path = './spec/mongodb.yml'
-        config = YAML.load_file(MongoDoc.config_path)
-        @database = config['name']
-        @host = config['host']
-        @port = config['port']
-        @db_options = config['options']
-        @connection = stub('connection')
-      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
 
-      context "with a host config file" do
-
-        it "without a name uses configured name" do
-          @connection.should_receive(:db).with(@database).and_return(@db)
-          MongoDoc.stub(:connect).and_return(@connection)
-          MongoDoc.connect_to_database
-        end
-
-        it "and params connects to the database with the params" do
-          database = 'p_database'
-          host = 'p_host'
-          port = 890
-          options = {:option => 'p_opt'}
-          @connection.should_receive(:db).with(database).and_return(@db)
-          MongoDoc.should_receive(:connect).with(host, port, options).and_return(@connection)
-          MongoDoc.connect_to_database(database, host, port, options)
-        end
-      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