jmongo 1.0.3 → 1.1.0

data/test/replica_sets/query_test.rb

@@ -0,0 +1,52 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/replica_sets/rs_test_helper'
+
+# NOTE: This test expects a replica set of three nodes to be running
+# on the local host.
+class ReplicaSetQueryTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = ReplSetConnection.new([RS.host, RS.ports[0], RS.ports[1]])
+    @db = @conn.db(MONGO_TEST_DB)
+    @db.drop_collection("test-sets")
+    @coll = @db.collection("test-sets")
+  end
+
+  def teardown
+    RS.restart_killed_nodes
+    @conn.close if @conn
+  end
+
+  def test_query
+    @coll.save({:a => 20}, :safe => {:w => 3})
+    @coll.save({:a => 30}, :safe => {:w => 3})
+    @coll.save({:a => 40}, :safe => {:w => 3})
+    results = []
+    @coll.find.each {|r| results << r}
+    [20, 30, 40].each do |a|
+      assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+    end
+
+    puts "Benchmark before failover: #{benchmark_queries}"
+
+    RS.kill_primary
+
+    results = []
+    rescue_connection_failure do
+      @coll.find.each {|r| results << r}
+      [20, 30, 40].each do |a|
+        assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+      end
+
+    puts "Benchmark after failover: #{benchmark_queries}"
+    end
+  end
+
+  def benchmark_queries
+    t1 = Time.now
+    10000.times { @coll.find_one }
+    Time.now - t1
+  end
+
+end

data/test/replica_sets/read_preference_test.rb

@@ -0,0 +1,43 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/replica_sets/rs_test_helper'
+
+# TODO: enable this once we enable reads from tags.
+class ReadPreferenceTest < Test::Unit::TestCase
+  include Mongo
+
+  #def setup
+  #  @conn = ReplSetConnection.new([RS.host, RS.ports[0], RS.host, RS.ports[1]], :read => :secondary, :pool_size => 50)
+  #  @db = @conn.db(MONGO_TEST_DB)
+  #  @db.drop_collection("test-sets")
+  #end
+
+  # TODO: enable this once we enable reads from tags.
+  # def test_query_tagged
+  #   col = @db['mongo-test']
+
+  #   col.insert({:a => 1}, :safe => {:w => 3})
+  #   col.find_one({}, :read => {:db => "main"})
+  #   col.find_one({}, :read => {:dc => "ny"})
+  #   col.find_one({}, :read => {:dc => "sf"})
+
+  #   assert_raise Mongo::NodeWithTagsNotFound do
+  #     col.find_one({}, :read => {:foo => "bar"})
+  #   end
+
+  #   threads = []
+  #   100.times do
+  #     threads << Thread.new do
+  #       col.find_one({}, :read => {:dc => "sf"})
+  #     end
+  #   end
+
+  #   threads.each {|t| t.join }
+
+  #   col.remove
+  # end
+
+  #def teardown
+  #  RS.restart_killed_nodes
+  #end
+
+end

data/test/replica_sets/refresh_test.rb

@@ -0,0 +1,123 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/replica_sets/rs_test_helper'
+require 'benchmark'
+
+# on ports TEST_PORT, RS.ports[1], and TEST + 2.
+class ReplicaSetRefreshTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = nil
+  end
+
+  def teardown
+    RS.restart_killed_nodes
+    @conn.close if @conn
+  end
+
+  def test_connect_speed
+    Benchmark.bm do |x|
+      x.report("Connect") do
+        10.times do
+          ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
+            [RS.host, RS.ports[2]], :background_refresh => false)
+        end
+      end
+
+          @con = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
+            [RS.host, RS.ports[2]], :background_refresh => false)
+
+      x.report("manager") do
+        man = Mongo::PoolManager.new(@con, @con.seeds)
+        10.times do
+          man.connect
+        end
+      end
+    end
+  end
+
+  def test_connect_and_manual_refresh_with_secondaries_down
+    RS.kill_all_secondaries
+
+    rescue_connection_failure do
+      @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
+        [RS.host, RS.ports[2]], :background_refresh => false)
+    end
+
+    assert_equal [], @conn.secondaries
+    assert @conn.connected?
+    assert_equal @conn.read_pool, @conn.primary_pool
+
+    # Refresh with no change to set
+    @conn.refresh
+    assert_equal [], @conn.secondaries
+    assert @conn.connected?
+    assert_equal @conn.read_pool, @conn.primary_pool
+
+    RS.restart_killed_nodes
+    assert_equal [], @conn.secondaries
+    assert @conn.connected?
+    assert_equal @conn.read_pool, @conn.primary_pool
+
+    # Refresh with everything up
+    @conn.refresh
+    assert @conn.read_pool
+    assert @conn.secondaries.length > 0
+  end
+
+  def test_automated_refresh_with_secondaries_down
+    RS.kill_all_secondaries
+
+    rescue_connection_failure do
+      @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
+        [RS.host, RS.ports[2]], :refresh_interval => 2, :background_refresh => true)
+    end
+
+    assert_equal [], @conn.secondaries
+    assert @conn.connected?
+    assert_equal @conn.read_pool, @conn.primary_pool
+
+    RS.restart_killed_nodes
+
+    sleep(3)
+
+    assert @conn.read_pool != @conn.primary_pool, "Read pool and primary pool are identical."
+    assert @conn.secondaries.length > 0, "No secondaries have been added."
+  end
+
+  def test_automated_refresh_with_removed_node
+    @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
+      [RS.host, RS.ports[2]], :refresh_interval => 2, :background_refresh => true)
+
+    assert_equal 2, @conn.secondary_pools.length
+    assert_equal 2, @conn.secondaries.length
+
+    n = RS.remove_secondary_node
+    sleep(4)
+
+    assert_equal 1, @conn.secondaries.length
+    assert_equal 1, @conn.secondary_pools.length
+
+    RS.add_node(n)
+  end
+
+  def test_adding_and_removing_nodes
+    @conn = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
+      [RS.host, RS.ports[2]], :refresh_interval => 2, :background_refresh => true)
+
+    RS.add_node
+    sleep(5)
+
+    @conn2 = ReplSetConnection.new([RS.host, RS.ports[0]], [RS.host, RS.ports[1]],
+      [RS.host, RS.ports[2]], :refresh_interval => 2, :background_refresh => true)
+
+    assert @conn2.secondaries == @conn.secondaries
+    assert_equal 3, @conn.secondary_pools.length
+    assert_equal 3, @conn.secondaries.length
+
+    RS.remove_secondary_node
+    sleep(4)
+    assert_equal 2, @conn.secondary_pools.length
+    assert_equal 2, @conn.secondaries.length
+  end
+end

data/test/replica_sets/replication_ack_test.rb

@@ -0,0 +1,71 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/replica_sets/rs_test_helper'
+
+# NOTE: This test expects a replica set of three nodes to be running on local host.
+class ReplicaSetAckTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    RS.ensure_up
+
+    @conn = ReplSetConnection.new([RS.host, RS.ports[0]])
+
+    @slave1 = Connection.new(@conn.secondary_pools[0].host,
+      @conn.secondary_pools[0].port, :slave_ok => true)
+
+    assert !@slave1.read_primary?
+
+    @db = @conn.db(MONGO_TEST_DB)
+    @db.drop_collection("test-sets")
+    @col = @db.collection("test-sets")
+  end
+
+  def teardown
+    RS.restart_killed_nodes
+    @conn.close if @conn
+  end
+
+  def test_safe_mode_with_w_failure
+    assert_raise_error OperationFailure, "timeout" do
+      @col.insert({:foo => 1}, :safe => {:w => 4, :wtimeout => 1, :fsync => true})
+    end
+    assert_raise_error OperationFailure, "timeout" do
+      @col.update({:foo => 1}, {:foo => 2}, :safe => {:w => 4, :wtimeout => 1, :fsync => true})
+    end
+    assert_raise_error OperationFailure, "timeout" do
+      @col.remove({:foo => 2}, :safe => {:w => 4, :wtimeout => 1, :fsync => true})
+    end
+  end
+
+  def test_safe_mode_replication_ack
+    @col.insert({:baz => "bar"}, :safe => {:w => 3, :wtimeout => 5000})
+
+    assert @col.insert({:foo => "0" * 5000}, :safe => {:w => 3, :wtimeout => 5000})
+    assert_equal 2, @slave1[MONGO_TEST_DB]["test-sets"].count
+
+    assert @col.update({:baz => "bar"}, {:baz => "foo"}, :safe => {:w => 3, :wtimeout => 5000})
+    assert @slave1[MONGO_TEST_DB]["test-sets"].find_one({:baz => "foo"})
+
+    assert @col.remove({}, :safe => {:w => 3, :wtimeout => 5000})
+    assert_equal 0, @slave1[MONGO_TEST_DB]["test-sets"].count
+  end
+
+  def test_last_error_responses
+    20.times { @col.insert({:baz => "bar"}) }
+    response = @db.get_last_error(:w => 2, :wtimeout => 5000)
+    assert response['ok'] == 1
+    assert response['lastOp']
+
+    @col.update({}, {:baz => "foo"}, :multi => true)
+    response = @db.get_last_error(:w => 2, :wtimeout => 5000)
+    assert response['ok'] == 1
+    assert response['lastOp']
+
+    @col.remove({})
+    response =  @db.get_last_error(:w => 2, :wtimeout => 5000)
+    assert response['ok'] == 1
+    assert response['n'] == 20
+    assert response['lastOp']
+  end
+
+end

data/test/replica_sets/rs_test_helper.rb

@@ -0,0 +1,27 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/test_helper'
+require './test/tools/repl_set_manager'
+
+unless defined? RS
+  RS = ReplSetManager.new
+  RS.start_set
+end
+
+class Test::Unit::TestCase
+
+  # Generic code for rescuing connection failures and retrying operations.
+  # This could be combined with some timeout functionality.
+  def rescue_connection_failure(max_retries=30)
+    retries = 0
+    begin
+      yield
+    rescue Mongo::ConnectionFailure => ex
+      puts "Rescue attempt #{retries}: from #{ex}"
+      retries += 1
+      raise ex if retries > max_retries
+      sleep(2)
+      retry
+    end
+  end
+
+end

data/test/safe_test.rb

@@ -0,0 +1,68 @@
+require './test/test_helper'
+include Mongo
+
+class SafeTest < Test::Unit::TestCase
+  context "Safe mode propogation: " do
+    setup do
+      @con = standard_connection(:safe => {:w => 1})
+      @db  = @con[MONGO_TEST_DB]
+      @col = @db['test-safe']
+      @col.create_index([[:a, 1]], :unique => true)
+      @col.remove
+    end
+
+    should "propogate safe option on insert" do
+      @col.insert({:a => 1})
+
+      assert_raise_error(OperationFailure, "duplicate key") do
+        @col.insert({:a => 1})
+      end
+    end
+
+    should "allow safe override on insert" do
+      @col.insert({:a => 1})
+      @col.insert({:a => 1}, :safe => false)
+    end
+
+    should "propogate safe option on update" do
+      @col.insert({:a => 1})
+      @col.insert({:a => 2})
+
+      assert_raise_error(OperationFailure, "duplicate key") do
+        @col.update({:a => 2}, {:a => 1})
+      end
+    end
+
+    should "allow safe override on update" do
+      @col.insert({:a => 1})
+      @col.insert({:a => 2})
+      @col.update({:a => 2}, {:a => 1}, :safe => false)
+    end
+  end
+
+  context "Safe error objects" do
+    setup do
+      @con = standard_connection
+      @db  = @con[MONGO_TEST_DB]
+      @col = @db['test']
+      @col.remove
+      @col.insert({:a => 1})
+      @col.insert({:a => 1})
+      @col.insert({:a => 1})
+    end
+
+    should "return object on update" do
+      response = @col.update({:a => 1}, {"$set" => {:a => 2}},
+                             :multi => true, :safe => true)
+
+      assert response['updatedExisting']
+      assert_equal 3, response['n']
+    end
+
+    should "return object on remove" do
+      response = @col.remove({}, :safe => true)
+      assert_equal 3, response['n']
+    end
+  end
+
+end

data/test/support/hash_with_indifferent_access.rb

@@ -0,0 +1,186 @@
+# Note: HashWithIndifferentAccess is so commonly used
+# that we always need to make sure that the driver works
+# with it.
+#require File.join(File.dirname(__FILE__), 'keys.rb')
+
+# This class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
+
+class Hash
+  # Return a new hash with all keys converted to strings.
+  def stringify_keys
+    dup.stringify_keys!
+  end
+
+  # Destructively convert all keys to strings.
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+.
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+
+  alias_method :to_options,  :symbolize_keys
+  #alias_method :to_options!, :symbolize_keys!
+end
+
+module ActiveSupport
+  class HashWithIndifferentAccess < Hash
+    def extractable_options?
+      true
+    end
+
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      ActiveSupport::HashWithIndifferentAccess.new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # Updates the instantized hash with values from the second:
+    #
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    #
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      HashWithIndifferentAccess.new(self)
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+    def reverse_merge(other_hash)
+      super self.class.new_from_hash_copying_default(other_hash)
+    end
+
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def stringify_keys; dup end
+    def symbolize_keys; to_hash.symbolize_keys end
+    def to_options!; self end
+
+    # Convert to a Hash with String keys.
+    def to_hash
+      Hash.new(default).merge!(self)
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value)
+        case value
+        when Hash
+          self.class.new_from_hash_copying_default(value)
+        when Array
+          value.collect { |e| e.is_a?(Hash) ? self.class.new_from_hash_copying_default(e) : e }
+        else
+          value
+        end
+      end
+  end
+end
+
+HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess