mongo-lyon 1.2.4

data/test/unit/cursor_test.rb

@@ -0,0 +1,99 @@
+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)
+      @db         = stub(:name => "testing", :slave_ok? => false, :connection => @connection)
+      @collection = stub(:db => @db, :name => "items")
+      @cursor     = Cursor.new(@collection)
+    end
+
+    should "set timeout" do
+      assert_equal true, @cursor.timeout
+    end
+
+    should "set selector" do
+      assert @cursor.selector == {}
+
+      @cursor = Cursor.new(@collection, :selector => {:name => "Jones"})
+      assert @cursor.selector == {:name => "Jones"}
+    end
+
+    should "set fields" do
+      assert_nil @cursor.fields
+
+      @cursor = Cursor.new(@collection, :fields => [:name, :date])
+      assert @cursor.fields == {:name => 1, :date => 1}
+    end
+
+    should "set mix fields 0 and 1" do
+      assert_nil @cursor.fields
+
+      @cursor = Cursor.new(@collection, :fields => {:name => 1, :date => 0})
+      assert @cursor.fields == {:name => 1, :date => 0}
+    end
+
+    should "set limit" do
+      assert_equal 0, @cursor.limit
+
+      @cursor = Cursor.new(@collection, :limit => 10)
+      assert_equal 10, @cursor.limit
+    end
+
+
+    should "set skip" do
+      assert_equal 0, @cursor.skip
+
+      @cursor = Cursor.new(@collection, :skip => 5)
+      assert_equal 5, @cursor.skip
+    end
+
+    should "set sort order" do
+      assert_nil @cursor.order
+
+      @cursor = Cursor.new(@collection, :order => "last_name")
+      assert_equal "last_name", @cursor.order
+    end
+
+    should "set hint" do
+      assert_nil @cursor.hint
+
+      @cursor = Cursor.new(@collection, :hint => "name")
+      assert_equal "name", @cursor.hint
+    end
+
+    should "cache full collection name" do
+      assert_equal "testing.items", @cursor.full_collection_name
+    end
+  end
+
+  context "Query fields" do
+    setup do
+      @connection = stub(:class => Collection, :logger => @logger)
+      @db = stub(:slave_ok? => true, :name => "testing", :connection => @connection)
+      @collection = stub(:db => @db, :name => "items")
+    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'
+
+class DBTest < Test::Unit::TestCase
+  context "DBTest: " do
+    setup do
+      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
+    end
+
+    context "DB commands" do
+      setup do
+        @conn = stub()
+        @conn.stubs(:safe)
+        @db   = DB.new("testing", @conn)
+        @db.stubs(:safe)
+        @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,49 @@
+require './test/test_helper'
+
+class GridTest < Test::Unit::TestCase
+
+  context "GridFS: " do
+    setup do
+      @conn   = stub()
+      @conn.stubs(:safe)
+      @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)
+    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

data/test/unit/pool_test.rb

@@ -0,0 +1,9 @@
+require './test/test_helper'
+include Mongo
+
+class PoolTest < Test::Unit::TestCase
+  context "Initialization: " do
+    should "do" do
+    end
+  end
+end

data/test/unit/repl_set_connection_test.rb

@@ -0,0 +1,72 @@
+require './test/test_helper'
+include Mongo
+
+class ReplSetConnectionTest < Test::Unit::TestCase
+  context "Initialization: " do
+    setup do
+      def new_mock_socket(host='localhost', port=27017)
+        socket = Object.new
+        socket.stubs(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        socket.stubs(:close)
+        socket
+      end
+
+      def new_mock_db
+        db = Object.new
+      end
+    end
+
+    context "connecting to a replica set" do
+      setup do
+        TCPSocket.stubs(:new).returns(new_mock_socket('localhost', 27017))
+        @conn = ReplSetConnection.new(['localhost', 27017], :connect => false, :read_secondary => true)
+
+        admin_db = new_mock_db
+        @hosts = ['localhost:27018', 'localhost:27019', 'localhost:27020']
+
+        admin_db.stubs(:command).returns({'ok' => 1, 'ismaster' => 1, 'hosts' => @hosts}).
+          then.returns({'ok' => 1, 'ismaster' => 0, 'hosts' => @hosts, 'secondary' => 1}).
+          then.returns({'ok' => 1, 'ismaster' => 0, 'hosts' => @hosts, 'secondary' => 1}).
+          then.returns({'ok' => 1, 'ismaster' => 0, 'arbiterOnly' => 1})
+
+        @conn.stubs(:[]).with('admin').returns(admin_db)
+        @conn.connect
+      end
+
+      should "store the hosts returned from the ismaster command" do
+        assert_equal 'localhost', @conn.primary_pool.host
+        assert_equal 27017, @conn.primary_pool.port
+
+        assert_equal 'localhost', @conn.secondary_pools[0].host
+        assert_equal 27018, @conn.secondary_pools[0].port
+
+        assert_equal 'localhost', @conn.secondary_pools[1].host
+        assert_equal 27019, @conn.secondary_pools[1].port
+
+        assert_equal 2, @conn.secondary_pools.length
+      end
+    end
+
+    context "connecting to a replica set and providing seed nodes" do
+      setup do
+        TCPSocket.stubs(:new).returns(new_mock_socket)
+        @conn = ReplSetConnection.new(['localhost', 27017], ['localhost', 27019], :connect => false)
+
+        admin_db = new_mock_db
+        @hosts = ['localhost:27017', 'localhost:27018', 'localhost:27019']
+        admin_db.stubs(:command).returns({'ok' => 1, 'ismaster' => 1, 'hosts' => @hosts})
+        @conn.stubs(:[]).with('admin').returns(admin_db)
+        @conn.connect
+      end
+    end
+
+    context "initializing with a mongodb uri" do
+
+      should "parse a uri specifying multiple nodes" do
+        @conn = Connection.from_uri("mongodb://localhost:27017,mydb.com:27018", :connect => false)
+        assert_equal ['localhost', 27017], @conn.nodes[0]
+        assert_equal ['mydb.com', 27018], @conn.nodes[1]
+      end
+    end
+  end
+end

data/test/unit/safe_test.rb

@@ -0,0 +1,125 @@
+require File.expand_path('./test/test_helper.rb')
+
+class SafeTest < Test::Unit::TestCase
+
+  context "Safe mode on connection: " do
+    setup do
+      @safe_value = {:w => 7}
+      @con = Mongo::Connection.new('localhost', 27017, :safe => @safe_value, :connect => false)
+    end
+
+    should "propogate to DB" do
+      db = @con['foo']
+      assert_equal @safe_value, db.safe
+
+
+      db = @con.db('foo')
+      assert_equal @safe_value, db.safe
+
+      db = DB.new('foo', @con)
+      assert_equal @safe_value, db.safe
+    end
+
+    should "allow db override" do
+      db = DB.new('foo', @con, :safe => false)
+      assert_equal false, db.safe
+
+      db = @con.db('foo', :safe => false)
+      assert_equal false, db.safe
+    end
+
+    context "on DB: " do
+      setup do
+        @db = @con['foo']
+      end
+
+      should "propogate to collection" do
+        col = @db.collection('bar')
+        assert_equal @safe_value, col.safe
+
+        col = @db['bar']
+        assert_equal @safe_value, col.safe
+
+        col = Collection.new('bar', @db)
+        assert_equal @safe_value, col.safe
+      end
+
+      should "allow override on collection" do
+        col = @db.collection('bar', :safe => false)
+        assert_equal false, col.safe
+
+        col = Collection.new('bar', @db, :safe => false)
+        assert_equal false, col.safe
+      end
+    end
+
+    context "on operations supporting safe mode" do
+      setup do
+        @col = @con['foo']['bar']
+      end
+
+      should "use default value on insert" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == @safe_value
+        end
+
+        @col.insert({:a => 1})
+      end
+
+      should "allow override alternate value on insert" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == {:w => 100}
+        end
+
+        @col.insert({:a => 1}, :safe => {:w => 100})
+      end
+
+      should "allow override to disable on insert" do
+        @con.expects(:send_message)
+        @col.insert({:a => 1}, :safe => false)
+      end
+
+      should "use default value on update" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == @safe_value
+        end
+
+        @col.update({:a => 1}, {:a => 2})
+      end
+
+      should "allow override alternate value on update" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == {:w => 100}
+        end
+
+        @col.update({:a => 1}, {:a => 2}, :safe => {:w => 100})
+      end
+
+      should "allow override to disable on update" do
+        @con.expects(:send_message)
+        @col.update({:a => 1}, {:a => 2}, :safe => false)
+      end
+
+      should "use default value on remove" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == @safe_value
+        end
+
+        @col.remove
+      end
+
+      should "allow override alternate value on remove" do
+        @con.expects(:send_message_with_safe_check).with do |op, msg, log, n, safe|
+          safe == {:w => 100}
+        end
+
+        @col.remove({}, :safe => {:w => 100})
+      end
+
+      should "allow override to disable on remove" do
+        @con.expects(:send_message)
+        @col.remove({}, :safe => false)
+      end
+    end
+  end
+end