mongo 1.0 → 1.1.5

data/test/tools/repl_set_manager.rb

@@ -0,0 +1,241 @@
+#!/usr/bin/ruby
+
+STDOUT.sync = true
+
+unless defined? Mongo
+  require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'mongo')
+end
+
+class ReplSetManager
+
+  attr_accessor :host, :start_port, :ports, :name, :mongods
+
+  def initialize(opts={})
+    @start_port = opts[:start_port] || 30000
+    @ports      = []
+    @name       = opts[:name] || 'replica-set-foo'
+    @host       = opts[:host]  || 'localhost'
+    @retries    = opts[:retries] || 60
+    @config     = {"_id" => @name, "members" => []}
+    @path       = File.join(File.expand_path(File.dirname(__FILE__)), "data")
+
+    @arbiter_count   = opts[:arbiter_count]   || 2
+    @secondary_count = opts[:secondary_count] || 1
+    @passive_count   = opts[:passive_count] || 1
+    @primary_count   = 1
+
+    @count = @primary_count + @passive_count + @arbiter_count + @secondary_count
+    if @count > 7
+      raise StandardError, "Cannot create a replica set with #{node_count} nodes. 7 is the max."
+    end
+
+    @mongods   = {}
+  end
+
+  def start_set
+    puts "** Starting a replica set with #{@count} nodes"
+
+    system("killall mongod")
+
+    n = 0
+    (@primary_count + @secondary_count).times do |n|
+      init_node(n)
+      n += 1
+    end
+
+    @passive_count.times do
+      init_node(n) do |attrs|
+        attrs['priority'] = 0
+      end
+      n += 1
+    end
+
+    @arbiter_count.times do
+      init_node(n) do |attrs|
+        attrs['arbiterOnly'] = true
+      end
+      n += 1
+    end
+
+    initiate
+    ensure_up
+  end
+
+  def init_node(n)
+    @mongods[n] ||= {}
+    port = @start_port + n
+    @ports << port
+    @mongods[n]['port'] = port
+    @mongods[n]['db_path'] = get_path("rs-#{port}")
+    @mongods[n]['log_path'] = get_path("log-#{port}")
+    system("rm -rf #{@mongods[n]['db_path']}")
+    system("mkdir -p #{@mongods[n]['db_path']}")
+
+    @mongods[n]['start'] = "mongod --replSet #{@name} --logpath '#{@mongods[n]['log_path']}' " +
+     " --dbpath #{@mongods[n]['db_path']} --port #{@mongods[n]['port']} --fork"
+
+    start(n)
+
+    member = {'_id' => n, 'host' => "#{@host}:#{@mongods[n]['port']}"}
+
+    if block_given?
+      custom_attrs = {}
+      yield custom_attrs
+      member.merge!(custom_attrs)
+      @mongods[n].merge!(custom_attrs)
+    end
+
+    @config['members'] << member
+  end
+
+  def kill(node)
+    pid = @mongods[node]['pid']
+    puts "** Killing node with pid #{pid} at port #{@mongods[node]['port']}"
+    system("kill -2 #{@mongods[node]['pid']}")
+    @mongods[node]['up'] = false
+    sleep(1)
+  end
+
+  def kill_primary
+    node = get_node_with_state(1)
+    kill(node)
+    return node
+  end
+
+  # Note that we have to rescue a connection failure
+  # when we run the StepDown command because that
+  # command will close the connection.
+  def step_down_primary
+    primary = get_node_with_state(1)
+    con = get_connection(primary)
+    begin
+      con['admin'].command({'replSetStepDown' => 90})
+    rescue Mongo::ConnectionFailure
+    end
+  end
+
+  def kill_secondary
+    node = get_node_with_state(2)
+    kill(node)
+    return node
+  end
+
+  def restart_killed_nodes
+    nodes = @mongods.keys.select do |key|
+      @mongods[key]['up'] == false
+    end
+
+    nodes.each do |node|
+      start(node)
+    end
+
+    ensure_up
+  end
+
+  def get_node_from_port(port)
+    @mongods.keys.detect { |key| @mongods[key]['port'] == port }
+  end
+
+  def start(node)
+    system(@mongods[node]['start'])
+    @mongods[node]['up'] = true
+    sleep(0.5)
+    @mongods[node]['pid'] = File.open(File.join(@mongods[node]['db_path'], 'mongod.lock')).read.strip
+  end
+  alias :restart :start
+
+  def ensure_up
+    print "** Ensuring members are up..."
+
+    attempt do
+      con = get_connection
+      status = con['admin'].command({'replSetGetStatus' => 1})
+      print "."
+      if status['members'].all? { |m| m['health'] == 1 && [1, 2, 7].include?(m['state']) } &&
+         status['members'].any? { |m| m['state'] == 1 }
+        print "all members up!\n\n"
+        return status
+      else
+        raise Mongo::OperationFailure
+      end
+    end
+  end
+
+  def primary
+    nodes = get_all_host_pairs_with_state(1)
+    nodes.empty? ? nil : nodes[0]
+  end
+
+  def secondaries
+    get_all_host_pairs_with_state(2)
+  end
+
+  def arbiters
+    get_all_host_pairs_with_state(7)
+  end
+
+  private
+
+  def initiate
+    con = get_connection
+
+    attempt do
+      con['admin'].command({'replSetInitiate' => @config})
+    end
+  end
+
+  def get_node_with_state(state)
+    status = ensure_up
+    node = status['members'].detect {|m| m['state'] == state}
+    if node
+      host_port = node['name'].split(':')
+      port = host_port[1] ? host_port[1].to_i : 27017
+      key = @mongods.keys.detect {|key| @mongods[key]['port'] == port}
+      return key
+    else
+      return false
+    end
+  end
+
+  def get_all_host_pairs_with_state(state)
+    status = ensure_up
+    nodes = status['members'].select {|m| m['state'] == state}
+    nodes.map do |node|
+      host_port = node['name'].split(':')
+      port = host_port[1] ? host_port[1].to_i : 27017
+      [host, port]
+    end
+  end
+
+  def get_connection(node=nil)
+    con = attempt do
+      if !node
+        node = @mongods.keys.detect {|key| !@mongods[key]['arbiterOnly'] && @mongods[key]['up'] }
+      end
+      con = Mongo::Connection.new(@host, @mongods[node]['port'], :slave_ok => true)
+    end
+
+    return con
+  end
+
+  def get_path(name)
+    File.join(@path, name)
+  end
+
+  def attempt
+    raise "No block given!" unless block_given?
+    count = 0
+
+    while count < @retries do
+      begin
+        return yield
+        rescue Mongo::OperationFailure, Mongo::ConnectionFailure
+          sleep(1)
+          count += 1
+      end
+    end
+
+    raise exception
+  end
+
+end

data/test/tools/test.rb

@@ -0,0 +1,13 @@
+require 'repl_set_manager'
+
+m = ReplSetManager.new
+m.start_set
+
+node = m.kill_secondary
+m.ensure_up
+
+puts "Pausing..."
+gets
+
+m.start(node)
+m.ensure_up

data/test/unit/collection_test.rb

@@ -1,4 +1,4 @@
-require 'test/test_helper'
+require File.expand_path('./test/test_helper.rb')
 
 class CollectionTest < Test::Unit::TestCase
 
@@ -12,8 +12,9 @@ class CollectionTest < Test::Unit::TestCase
       @db   = @conn['testing']
       @coll = @db.collection('books')
       @conn.expects(:send_message).with do |op, msg, log|
-        op == 2001 && log.include?("testing['books'].update")
+        op == 2001
       end
+      @logger.stubs(:debug)
       @coll.update({}, {:title => 'Moby Dick'})
     end
 
@@ -22,7 +23,10 @@ class CollectionTest < Test::Unit::TestCase
       @db   = @conn['testing']
       @coll = @db.collection('books')
       @conn.expects(:send_message).with do |op, msg, log|
-        op == 2002 && log.include?("testing['books'].insert")
+        op == 2002
+      end
+      @logger.expects(:debug).with do |msg|
+        msg.include?("Moby")
       end
       @coll.insert({:title => 'Moby Dick'})
     end
@@ -32,8 +36,11 @@ class CollectionTest < Test::Unit::TestCase
       @db   = @conn['testing']
       @coll = @db.collection('books')
       @conn.expects(:receive_message).with do |op, msg, log, sock|
-        op == 2004 && log.include?("sort")
+        op == 2004
       end.returns([[], 0, 0])
+      @logger.expects(:debug).with do |msg|
+        msg.include?('Moby')
+      end
       @coll.find({:title => 'Moby Dick'}).sort([['title', 1], ['author', 1]]).next_document
     end
 
@@ -43,7 +50,10 @@ class CollectionTest < Test::Unit::TestCase
       @coll = @db.collection('books')
       data = BSON::Binary.new(("BINARY " * 1000).unpack("c*"))
       @conn.expects(:send_message).with do |op, msg, log|
-        op == 2002 && log.include?("BSON::Binary")
+        op == 2002
+      end
+      @logger.expects(:debug).with do |msg|
+        msg.include?("Binary")
       end
       @coll.insert({:data => data})
     end
@@ -53,7 +63,10 @@ class CollectionTest < Test::Unit::TestCase
       @db   = @conn['testing']
       @coll = @db.collection('books')
       @conn.expects(:send_message_with_safe_check).with do |op, msg, db_name, log|
-        op == 2001 && log.include?("testing['books'].update")
+        op == 2001
+      end
+      @logger.expects(:debug).with do |msg|
+        msg.include?("testing['books'].update")
       end
       @coll.update({}, {:title => 'Moby Dick'}, :safe => true)
     end
@@ -63,9 +76,59 @@ class CollectionTest < Test::Unit::TestCase
       @db   = @conn['testing']
       @coll = @db.collection('books')
       @conn.expects(:send_message_with_safe_check).with do |op, msg, db_name, log|
-        op == 2001 && log.include?("testing['books'].update")
+        op == 2001
       end
+      @logger.stubs(:debug)
       @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

@@ -1,12 +1,13 @@
-require 'test/test_helper'
+require './test/test_helper'
 include Mongo
 
 class ConnectionTest < Test::Unit::TestCase
   context "Initialization: " do
     setup do
-      def new_mock_socket
+      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
 
@@ -17,22 +18,22 @@ class ConnectionTest < Test::Unit::TestCase
 
     context "given a single node" do
       setup do
-        TCPSocket.stubs(:new).returns(new_mock_socket)
         @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_to_master
+        @conn.connect
       end
 
       should "set localhost and port to master" do
-        assert_equal 'localhost', @conn.host
-        assert_equal 27017, @conn.port
+        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.size
+        assert_equal 1, @conn.primary_pool.size
       end
 
       should "default slave_ok to false" do
@@ -40,45 +41,23 @@ class ConnectionTest < Test::Unit::TestCase
       end
     end
 
-    context "initializing a paired connection" do
-      should "require left and right nodes" do
-        assert_raise MongoArgumentError do
-          Connection.paired(['localhost', 27018], :connect => false)
-        end
-
-        assert_raise MongoArgumentError do
-          Connection.paired(['localhost', 27018], :connect => false)
-        end
-      end
-
-      should "store both nodes" do
-        @conn = Connection.paired([['localhost', 27017], ['localhost', 27018]], :connect => false)
-
-        assert_equal ['localhost', 27017], @conn.nodes[0]
-        assert_equal ['localhost', 27018], @conn.nodes[1]
-      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.nodes[0]
+        assert_equal ['localhost', 27017], @conn.host_to_try
       end
 
-      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]
+      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 specifying multiple nodes with auth" do
-        @conn = Connection.from_uri("mongodb://kyle:s3cr3t@localhost:27017/app,mickey:m0u5e@mydb.com:27018/dsny", :connect => false)
-        assert_equal ['localhost', 27017], @conn.nodes[0]
-        assert_equal ['mydb.com', 27018], @conn.nodes[1]
-        auth_hash = {'username' => 'kyle', 'password' => 's3cr3t', 'db_name' => 'app'}
+      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]
-        auth_hash = {'username' => 'mickey', 'password' => 'm0u5e', 'db_name' => 'dsny'}
-        assert_equal auth_hash, @conn.auths[1]
       end
 
       should "attempt to connect" do
@@ -89,7 +68,7 @@ class ConnectionTest < Test::Unit::TestCase
         admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
         @conn.expects(:[]).with('admin').returns(admin_db)
         @conn.expects(:apply_saved_authentication)
-        @conn.connect_to_master
+        @conn.connect
       end
 
       should "raise an error on invalid uris" do

data/test/unit/cursor_test.rb

@@ -1,19 +1,18 @@
-require 'test/test_helper'
+require './test/test_helper'
 
 class CursorTest < Test::Unit::TestCase
   context "Cursor options" do
     setup do
-      @connection = stub(:class => Connection)
+      @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 admin to false" do
-      assert_equal false, @cursor.admin
-
-      @cursor = Cursor.new(@collection, :admin => true)
-      assert_equal true, @cursor.admin
+    should "set timeout" do
+      assert_equal true, @cursor.timeout
     end
 
     should "set selector" do
@@ -73,7 +72,7 @@ class CursorTest < Test::Unit::TestCase
 
   context "Query fields" do
     setup do
-      @connection = stub(:class => Collection)
+      @connection = stub(:class => Collection, :logger => @logger)
       @db = stub(:slave_ok? => true, :name => "testing", :connection => @connection)
       @collection = stub(:db => @db, :name => "items")
     end

data/test/unit/db_test.rb

@@ -1,4 +1,4 @@
-require 'test/test_helper'
+require './test/test_helper'
 
 class DBTest < Test::Unit::TestCase
   context "DBTest: " do
@@ -16,38 +16,42 @@ class DBTest < Test::Unit::TestCase
     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
-        assert_raise MongoArgumentError do
-          @db.command(:buildinfo => 1, :somekey => 1)
+        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({}, true)
+          @db.command({}, :check_response => true)
         end
       end
 
       should "create the proper cursor" do
         @cursor = mock(:next_document => {"ok" => 1})
-        Cursor.expects(:new).with(@collection, :admin => true,
+        Cursor.expects(:new).with(@collection,
           :limit => -1, :selector => {:buildinfo => 1}, :socket => nil).returns(@cursor)
         command = {:buildinfo => 1}
-        @db.command(command, true)
+        @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, :admin => true,
+        Cursor.expects(:new).with(@collection,
           :limit => -1, :selector => {:buildinfo => 1}, :socket => nil).returns(@cursor)
         assert_raise OperationFailure do
           command = {:buildinfo => 1}
-          @db.command(command, true, true)
+          @db.command(command, :check_response => true)
         end
       end
 
@@ -60,7 +64,7 @@ class DBTest < Test::Unit::TestCase
 
       should "raise an error if collection creation fails" do
         @db.expects(:collection_names).returns([])
-        @db.expects(:command).returns({})
+        @db.expects(:command).returns({'ok' => 0})
         assert_raise Mongo::MongoDBError do
           @db.create_collection("foo")
         end
@@ -69,14 +73,7 @@ class DBTest < Test::Unit::TestCase
       should "raise an error if getlasterror fails" do
         @db.expects(:command).returns({})
         assert_raise Mongo::MongoDBError do
-          @db.error
-        end
-      end
-
-      should "raise an error if rename fails" do
-        @db.expects(:command).returns({})
-        assert_raise Mongo::MongoDBError do
-          @db.rename_collection("foo", "bar")
+          @db.get_last_error
         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