jonbell-mongo 1.3.1.2

data/test/replica_sets/query_test.rb

@@ -0,0 +1,51 @@
+$:.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]])
+    @db = @conn.db(MONGO_TEST_DB)
+    @db.drop_collection("test-sets")
+    @coll = @db.collection("test-sets")
+  end
+
+  def teardown
+    RS.restart_killed_nodes
+  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/replication_ack_test.rb

@@ -0,0 +1,66 @@
+$:.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 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 => 2, :wtimeout => 5000})
+
+    assert @col.insert({:foo => "0" * 5000}, :safe => {:w => 2, :wtimeout => 5000})
+    assert_equal 2, @slave1[MONGO_TEST_DB]["test-sets"].count
+
+    assert @col.update({:baz => "bar"}, {:baz => "foo"}, :safe => {:w => 2, :wtimeout => 5000})
+    assert @slave1[MONGO_TEST_DB]["test-sets"].find_one({:baz => "foo"})
+
+    assert @col.remove({}, :safe => {:w => 2, :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=60)
+    retries = 0
+    begin
+      yield
+    rescue Mongo::ConnectionFailure => ex
+      puts "Rescue attempt #{retries}: from #{ex}"
+      retries += 1
+      raise ex if retries > max_retries
+      sleep(1)
+      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

data/test/support/keys.rb

@@ -0,0 +1,45 @@
+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!
+
+  # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+  # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+  # as keys, this will fail.
+  #
+  # ==== Examples
+  #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): name, age"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    unknown_keys = keys - [valid_keys].flatten
+    raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+  end
+end