jmongo 1.0.3 → 1.1.0

data/test/unit/collection_test.rb

@@ -0,0 +1,128 @@
+require './test/test_helper'
+
+class CollectionTest < Test::Unit::TestCase
+
+  context "Basic operations: " do
+    setup do
+      @logger = mock()
+      @logger.expects(:debug)
+    end
+
+    should "send update message" do
+      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @conn['testing']
+      @coll = @db.collection('books')
+      @conn.expects(:send_message).with do |op, msg, log|
+        op == 2001
+      end
+      @coll.stubs(:log_operation)
+      @coll.update({}, {:title => 'Moby Dick'})
+    end
+
+    should "send insert message" do
+      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @conn['testing']
+      @coll = @db.collection('books')
+      @conn.expects(:send_message).with do |op, msg, log|
+        op == 2002
+      end
+      @coll.expects(:log_operation).with do |name, payload|
+        (name == :insert) && payload[:documents][0][:title].include?('Moby')
+      end
+      @coll.insert({:title => 'Moby Dick'})
+    end
+
+    should "send sort data" do
+      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @conn['testing']
+      @coll = @db.collection('books')
+      @conn.expects(:receive_message).with do |op, msg, log, sock|
+        op == 2004
+      end.returns([[], 0, 0])
+      @logger.expects(:debug)
+      @coll.find({:title => 'Moby Dick'}).sort([['title', 1], ['author', 1]]).next_document
+    end
+
+    should "not log binary data" do
+      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @conn['testing']
+      @coll = @db.collection('books')
+      data = BSON::Binary.new(("BINARY " * 1000).unpack("c*"))
+      @conn.expects(:send_message).with do |op, msg, log|
+        op == 2002
+      end
+      @coll.expects(:log_operation).with do |name, payload|
+        (name == :insert) && payload[:documents][0][:data].inspect.include?('Binary')
+      end
+      @coll.insert({:data => data})
+    end
+
+    should "send safe update message" do
+      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @conn['testing']
+      @coll = @db.collection('books')
+      @conn.expects(:send_message_with_safe_check).with do |op, msg, db_name, log|
+        op == 2001
+      end
+      @coll.expects(:log_operation).with do |name, payload|
+        (name == :update) && payload[:document][:title].include?('Moby')
+      end
+      @coll.update({}, {:title => 'Moby Dick'}, :safe => true)
+    end
+
+    should "send safe insert message" do
+      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @conn['testing']
+      @coll = @db.collection('books')
+      @conn.expects(:send_message_with_safe_check).with do |op, msg, db_name, log|
+        op == 2001
+      end
+      @coll.stubs(:log_operation)
+      @coll.update({}, {:title => 'Moby Dick'}, :safe => true)
+    end
+
+    should "not call insert for each ensure_index call" do
+      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @conn['testing']
+      @coll = @db.collection('books')
+      @coll.expects(:generate_indexes).once
+
+      @coll.ensure_index [["x", Mongo::DESCENDING]]
+      @coll.ensure_index [["x", Mongo::DESCENDING]]
+    end
+
+    should "call generate_indexes for a new direction on the same field for ensure_index" do
+      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @conn['testing']
+      @coll = @db.collection('books')
+      @coll.expects(:generate_indexes).twice
+
+      @coll.ensure_index [["x", Mongo::DESCENDING]]
+      @coll.ensure_index [["x", Mongo::ASCENDING]]
+
+    end
+
+    should "call generate_indexes twice because the cache time is 0 seconds" do
+      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @conn['testing']
+      @db.cache_time = 0
+      @coll = @db.collection('books')
+      @coll.expects(:generate_indexes).twice
+
+      @coll.ensure_index [["x", Mongo::DESCENDING]]
+      @coll.ensure_index [["x", Mongo::DESCENDING]]
+    end
+
+    should "call generate_indexes for each key when calling ensure_indexes" do
+      @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
+      @db   = @conn['testing']
+      @db.cache_time = 300
+      @coll = @db.collection('books')
+      @coll.expects(:generate_indexes).once.with do |a, b, c|
+        a == {"x"=>-1, "y"=>-1}
+      end
+
+      @coll.ensure_index [["x", Mongo::DESCENDING], ["y", Mongo::DESCENDING]]
+    end
+  end
+end

data/test/unit/connection_test.rb

@@ -0,0 +1,85 @@
+require './test/test_helper'
+include Mongo
+
+class ConnectionTest < Test::Unit::TestCase
+  context "Initialization: " do
+    context "given a single node" do
+      setup do
+        @conn = Connection.new('localhost', 27017, :connect => false)
+        TCPSocket.stubs(:new).returns(new_mock_socket)
+
+        admin_db = new_mock_db
+        admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
+        @conn.expects(:[]).with('admin').returns(admin_db)
+        @conn.connect
+      end
+
+      should "set localhost and port to master" do
+        assert_equal 'localhost', @conn.primary_pool.host
+        assert_equal 27017, @conn.primary_pool.port
+      end
+
+      should "set connection pool to 1" do
+        assert_equal 1, @conn.primary_pool.size
+      end
+
+      should "default slave_ok to false" do
+        assert !@conn.slave_ok?
+      end
+    end
+
+    context "initializing with a mongodb uri" do
+      should "parse a simple uri" do
+        @conn = Connection.from_uri("mongodb://localhost", :connect => false)
+        assert_equal ['localhost', 27017], @conn.host_to_try
+      end
+
+      should "allow a complex host names" do
+        host_name = "foo.bar-12345.org"
+        @conn = Connection.from_uri("mongodb://#{host_name}", :connect => false)
+        assert_equal [host_name, 27017], @conn.host_to_try
+      end
+
+      should "parse a uri with a hyphen & underscore in the username or password" do
+        @conn = Connection.from_uri("mongodb://hyphen-user_name:p-s_s@localhost:27017/db", :connect => false)
+        assert_equal ['localhost', 27017], @conn.host_to_try
+        auth_hash = { 'db_name' => 'db', 'username' => 'hyphen-user_name', "password" => 'p-s_s' }
+        assert_equal auth_hash, @conn.auths[0]
+      end
+
+      should "attempt to connect" do
+        TCPSocket.stubs(:new).returns(new_mock_socket)
+        @conn = Connection.from_uri("mongodb://localhost", :connect => false)
+
+        admin_db = new_mock_db
+        admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
+        @conn.expects(:[]).with('admin').returns(admin_db)
+        @conn.connect
+      end
+
+      should "raise an error on invalid uris" do
+        assert_raise MongoArgumentError do
+          Connection.from_uri("mongo://localhost", :connect => false)
+        end
+
+        assert_raise MongoArgumentError do
+          Connection.from_uri("mongodb://localhost:abc", :connect => false)
+        end
+
+        assert_raise MongoArgumentError do
+          Connection.from_uri("mongodb://localhost:27017, my.db.com:27018, ", :connect => false)
+        end
+      end
+
+      should "require all of username, password, and database if any one is specified" do
+        assert_raise MongoArgumentError do
+          Connection.from_uri("mongodb://localhost/db", :connect => false)
+        end
+
+        assert_raise MongoArgumentError do
+          Connection.from_uri("mongodb://kyle:password@localhost", :connect => false)
+        end
+      end
+    end
+  end
+end

data/test/unit/cursor_test.rb

@@ -0,0 +1,127 @@
+require './test/test_helper'
+
+class CursorTest < Test::Unit::TestCase
+  context "Cursor options" do
+    setup do
+      @logger     = mock()
+      @logger.stubs(:debug)
+      @connection = stub(:class => Connection, :logger => @logger, :slave_ok? => false, :read_preference => :primary)
+      @db         = stub(:name => "testing", :slave_ok? => false, :connection => @connection, :read_preference => :primary)
+      @collection = stub(:db => @db, :name => "items", :read_preference => :primary)
+      @cursor     = Cursor.new(@collection)
+    end
+
+    should "set timeout" do
+      assert @cursor.timeout
+      assert @cursor.query_options_hash[:timeout]
+    end
+
+    should "set selector" do
+      assert_equal({}, @cursor.selector)
+
+      @cursor = Cursor.new(@collection, :selector => {:name => "Jones"})
+      assert_equal({:name => "Jones"}, @cursor.selector)
+      assert_equal({:name => "Jones"}, @cursor.query_options_hash[:selector])
+    end
+
+    should "set fields" do
+      assert_nil @cursor.fields
+
+      @cursor = Cursor.new(@collection, :fields => [:name, :date])
+      assert_equal({:name => 1, :date => 1}, @cursor.fields)
+      assert_equal({:name => 1, :date => 1}, @cursor.query_options_hash[:fields])
+    end
+
+    should "set mix fields 0 and 1" do
+      assert_nil @cursor.fields
+
+      @cursor = Cursor.new(@collection, :fields => {:name => 1, :date => 0})
+      assert_equal({:name => 1, :date => 0}, @cursor.fields)
+      assert_equal({:name => 1, :date => 0}, @cursor.query_options_hash[:fields])
+    end
+
+    should "set limit" do
+      assert_equal 0, @cursor.limit
+
+      @cursor = Cursor.new(@collection, :limit => 10)
+      assert_equal 10, @cursor.limit
+      assert_equal 10, @cursor.query_options_hash[:limit]
+    end
+
+
+    should "set skip" do
+      assert_equal 0, @cursor.skip
+
+      @cursor = Cursor.new(@collection, :skip => 5)
+      assert_equal 5, @cursor.skip
+      assert_equal 5, @cursor.query_options_hash[:skip]
+    end
+
+    should "set sort order" do
+      assert_nil @cursor.order
+
+      @cursor = Cursor.new(@collection, :order => "last_name")
+      assert_equal "last_name", @cursor.order
+      assert_equal "last_name", @cursor.query_options_hash[:order]
+    end
+
+    should "set hint" do
+      assert_nil @cursor.hint
+
+      @cursor = Cursor.new(@collection, :hint => "name")
+      assert_equal "name", @cursor.hint
+      assert_equal "name", @cursor.query_options_hash[:hint]
+    end
+
+    should "cache full collection name" do
+      assert_equal "testing.items", @cursor.full_collection_name
+    end
+    
+    should "raise error when batch_size is 1" do
+      e = assert_raise ArgumentError do
+        @cursor.batch_size(1)
+        end
+        assert_equal "Invalid value for batch_size 1; must be 0 or > 1.", e.message
+    end
+    
+    should "use the limit for batch size when it's smaller than the specified batch_size" do
+      @cursor.limit(99)
+      @cursor.batch_size(100)
+      assert_equal 99, @cursor.batch_size
+      end
+      
+    should "use the specified batch_size" do
+      @cursor.batch_size(100)
+      assert_equal 100, @cursor.batch_size
+    end
+  end
+
+  context "Query fields" do
+    setup do
+      @logger     = mock()
+      @logger.stubs(:debug)
+      @connection = stub(:class => Connection, :logger => @logger, :slave_ok? => false)
+      @db = stub(:slave_ok? => true, :name => "testing", :connection => @connection)
+      @collection = stub(:db => @db, :name => "items", :read_preference => :primary)
+    end
+
+    should "when an array should return a hash with each key" do
+      @cursor = Cursor.new(@collection, :fields => [:name, :age])
+      result  = @cursor.fields
+      assert_equal result.keys.sort{|a,b| a.to_s <=> b.to_s}, [:age, :name].sort{|a,b| a.to_s <=> b.to_s}
+      assert result.values.all? {|v| v == 1}
+    end
+
+    should "when a string, return a hash with just the key" do
+      @cursor = Cursor.new(@collection, :fields => "name")
+      result  = @cursor.fields
+      assert_equal result.keys.sort, ["name"]
+      assert result.values.all? {|v| v == 1}
+    end
+
+    should "return nil when neither hash nor string nor symbol" do
+      @cursor = Cursor.new(@collection, :fields => 1234567)
+      assert_nil @cursor.fields
+    end
+  end
+end

data/test/unit/db_test.rb

@@ -0,0 +1,96 @@
+require './test/test_helper'
+
+def insert_message(db, documents)
+  documents = [documents] unless documents.is_a?(Array)
+  message = ByteBuffer.new
+  message.put_int(0)
+  Mongo::BSON_CODER.serialize_cstr(message, "#{db.name}.test")
+  documents.each { |doc| message.put_array(Mongo::BSON_CODER.new.serialize(doc, true).to_a) }
+  message = db.add_message_headers(Mongo::Constants::OP_INSERT, message)
+end
+
+class DBTest < Test::Unit::TestCase
+  context "DBTest: " do
+    context "DB commands" do
+      setup do
+        @conn = stub()
+        @conn.stubs(:safe)
+        @conn.stubs(:read_preference)
+        @db   = DB.new("testing", @conn)
+        @db.stubs(:safe)
+        @db.stubs(:read_preference)
+        @collection = mock()
+        @db.stubs(:system_command_collection).returns(@collection)
+      end
+
+      should "raise an error if given a hash with more than one key" do
+        if RUBY_VERSION < '1.9'
+          assert_raise MongoArgumentError do
+            @db.command(:buildinfo => 1, :somekey => 1)
+          end
+        end
+      end
+
+      should "raise an error if the selector is omitted" do
+        assert_raise MongoArgumentError do
+          @db.command({}, :check_response => true)
+        end
+      end
+
+      should "create the proper cursor" do
+        @cursor = mock(:next_document => {"ok" => 1})
+        Cursor.expects(:new).with(@collection,
+          :limit => -1, :selector => {:buildinfo => 1}, :socket => nil).returns(@cursor)
+        command = {:buildinfo => 1}
+        @db.command(command, :check_response => true)
+      end
+
+      should "raise an error when the command fails" do
+        @cursor = mock(:next_document => {"ok" => 0})
+        Cursor.expects(:new).with(@collection,
+          :limit => -1, :selector => {:buildinfo => 1}, :socket => nil).returns(@cursor)
+        assert_raise OperationFailure do
+          command = {:buildinfo => 1}
+          @db.command(command, :check_response => true)
+        end
+      end
+
+      should "raise an error if logging out fails" do
+        @db.expects(:command).returns({})
+        @conn.expects(:pool_size).returns(1)
+        assert_raise Mongo::MongoDBError do
+          @db.logout
+        end
+      end
+
+      should "raise an error if collection creation fails" do
+        @db.expects(:collection_names).returns([])
+        @db.expects(:command).returns({'ok' => 0})
+        assert_raise Mongo::MongoDBError do
+          @db.create_collection("foo")
+        end
+      end
+
+      should "raise an error if getlasterror fails" do
+        @db.expects(:command).returns({})
+        assert_raise Mongo::MongoDBError do
+          @db.get_last_error
+        end
+      end
+
+      should "raise an error if drop_index fails" do
+        @db.expects(:command).returns({})
+        assert_raise Mongo::MongoDBError do
+          @db.drop_index("foo", "bar")
+        end
+      end
+
+      should "raise an error if set_profiling_level fails" do
+        @db.expects(:command).returns({})
+        assert_raise Mongo::MongoDBError do
+          @db.profiling_level = :slow_only
+        end
+      end
+    end
+  end
+end

data/test/unit/grid_test.rb

@@ -0,0 +1,51 @@
+require './test/test_helper'
+
+class GridTest < Test::Unit::TestCase
+
+  context "GridFS: " do
+    setup do
+      @conn   = stub()
+      @conn.stubs(:safe)
+      @conn.stubs(:read_preference)
+      @db     = DB.new("testing", @conn)
+      @files  = mock()
+      @chunks = mock()
+
+      @db.expects(:[]).with('fs.files').returns(@files)
+      @db.expects(:[]).with('fs.chunks').returns(@chunks)
+      @db.stubs(:safe)
+      @db.stubs(:read_preference)
+    end
+
+    context "Grid classe with standard connections" do
+      setup do
+        @conn.expects(:slave_ok?).returns(false)
+      end
+
+      should "create indexes for Grid" do
+        @chunks.expects(:create_index)
+        Grid.new(@db)
+      end
+
+      should "create indexes for GridFileSystem" do
+        @files.expects(:create_index)
+        @chunks.expects(:create_index)
+        GridFileSystem.new(@db)
+      end
+    end
+
+    context "Grid classes with slave connection" do
+      setup do
+        @conn.expects(:slave_ok?).returns(true)
+      end
+
+      should "not create indexes for Grid" do
+        Grid.new(@db)
+      end
+
+      should "not create indexes for GridFileSystem" do
+        GridFileSystem.new(@db)
+      end
+    end
+  end
+end