mongo 1.3.0 → 1.12.5

data/test/support/hash_with_indifferent_access.rb

@@ -1,186 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-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

data/test/support_test.rb

@@ -1,18 +0,0 @@
-require './test/test_helper'
-
-class SupportTest < Test::Unit::TestCase
-
-  def test_command_response_succeeds
-    assert Support.ok?('ok' => 1)
-    assert Support.ok?('ok' => 1.0)
-    assert Support.ok?('ok' => true)
-  end
-
-  def test_command_response_fails
-    assert !Support.ok?('ok' => 0)
-    assert !Support.ok?('ok' => 0.0)
-    assert !Support.ok?('ok' => 0.0)
-    assert !Support.ok?('ok' => 'str')
-    assert !Support.ok?('ok' => false)
-  end
-end

data/test/threading/threading_with_large_pool_test.rb

@@ -1,90 +0,0 @@
-require './test/test_helper'
-
-# Essentialy the same as test_threading.rb but with an expanded pool for
-# testing multiple connections.
-class TestThreadingLargePool < Test::Unit::TestCase
-
-  include Mongo
-
-  @@db = standard_connection(:pool_size => 50, :timeout => 60).db(MONGO_TEST_DB)
-  @@coll = @@db.collection('thread-test-collection')
-
-  def set_up_safe_data
-    @@db.drop_collection('duplicate')
-    @@db.drop_collection('unique')
-    @duplicate = @@db.collection('duplicate')
-    @unique    = @@db.collection('unique')
-
-    @duplicate.insert("test" => "insert")
-    @duplicate.insert("test" => "update")
-    @unique.insert("test" => "insert")
-    @unique.insert("test" => "update")
-    @unique.create_index("test", :unique => true)
-  end
-
-  def test_safe_update
-    set_up_safe_data
-    threads = []
-    300.times do |i|
-      threads[i] = Thread.new do
-        if i % 2 == 0
-          assert_raise Mongo::OperationFailure do
-            @unique.update({"test" => "insert"}, {"$set" => {"test" => "update"}}, :safe => true)
-          end
-        else
-          @duplicate.update({"test" => "insert"}, {"$set" => {"test" => "update"}}, :safe => true)
-        end
-      end
-    end
-
-    300.times do |i|
-      threads[i].join
-    end
-  end
-
-  def test_safe_insert
-    set_up_safe_data
-    threads = []
-    300.times do |i|
-      threads[i] = Thread.new do
-        if i % 2 == 0
-          assert_raise Mongo::OperationFailure do
-            @unique.insert({"test" => "insert"}, :safe => true)
-          end
-        else
-          @duplicate.insert({"test" => "insert"}, :safe => true)
-        end
-      end
-    end
-
-    300.times do |i|
-      threads[i].join
-    end
-  end
-
-  def test_threading
-    @@coll.drop
-    @@coll = @@db.collection('thread-test-collection')
-
-    1000.times do |i|
-      @@coll.insert("x" => i)
-    end
-
-    threads = []
-
-    10.times do |i|
-      threads[i] = Thread.new do
-        sum = 0
-        @@coll.find().each do |document|
-          sum += document["x"]
-        end
-        assert_equal 499500, sum
-      end
-    end
-
-    10.times do |i|
-      threads[i].join
-    end
-  end
-
-end

data/test/threading_test.rb

@@ -1,87 +0,0 @@
-require './test/test_helper'
-
-class TestThreading < Test::Unit::TestCase
-
-  include Mongo
-
-  @@db = standard_connection(:pool_size => 1, :timeout => 30).db(MONGO_TEST_DB)
-  @@coll = @@db.collection('thread-test-collection')
-
-  def set_up_safe_data
-    @@db.drop_collection('duplicate')
-    @@db.drop_collection('unique')
-    @duplicate = @@db.collection('duplicate')
-    @unique    = @@db.collection('unique')
-
-    @duplicate.insert("test" => "insert")
-    @duplicate.insert("test" => "update")
-    @unique.insert("test" => "insert")
-    @unique.insert("test" => "update")
-    @unique.create_index("test", :unique => true)
-  end
-
-  def test_safe_update
-    set_up_safe_data
-    threads = []
-    100.times do |i|
-      threads[i] = Thread.new do
-        if i % 2 == 0
-          assert_raise Mongo::OperationFailure do
-            @unique.update({"test" => "insert"}, {"$set" => {"test" => "update"}}, :safe => true)
-          end
-        else
-          @duplicate.update({"test" => "insert"}, {"$set" => {"test" => "update"}}, :safe => true)
-        end
-      end
-    end
-
-    100.times do |i|
-      threads[i].join
-    end
-  end
-
-  def test_safe_insert
-    set_up_safe_data
-    threads = []
-    100.times do |i|
-      threads[i] = Thread.new do
-        if i % 2 == 0
-          assert_raise Mongo::OperationFailure do
-            @unique.insert({"test" => "insert"}, :safe => true)
-          end
-        else
-          @duplicate.insert({"test" => "insert"}, :safe => true)
-        end
-      end
-    end
-
-    100.times do |i|
-      threads[i].join
-    end
-  end
-
-  def test_threading
-    @@coll.drop
-    @@coll = @@db.collection('thread-test-collection')
-
-    1000.times do |i|
-      @@coll.insert("x" => i)
-    end
-
-    threads = []
-
-    10.times do |i|
-      threads[i] = Thread.new do
-        sum = 0
-        @@coll.find().each do |document|
-          sum += document["x"]
-        end
-        assert_equal 499500, sum
-      end
-    end
-
-    10.times do |i|
-      threads[i].join
-    end
-  end
-end

data/test/tools/auth_repl_set_manager.rb

@@ -1,14 +0,0 @@
-require File.join((File.expand_path(File.dirname(__FILE__))), 'repl_set_manager')
-
-class AuthReplSetManager < ReplSetManager
-  def initialize(opts={})
-    super(opts)
-
-    @key_path = opts[:key_path] || File.join(File.expand_path(File.dirname(__FILE__)), "keyfile.txt")
-    system("chmod 600 #{@key_path}")
-  end
-
-  def start_cmd(n)
-    super + " --keyFile #{@key_path}"
-  end
-end

data/test/tools/load.rb

@@ -1,58 +0,0 @@
-require 'rubygems'
-require 'mongo'
-require 'sharding_manager'
-
-class MongoLoader
-
-  def initialize
-    @mongo = Mongo::Connection.new("localhost", 50000)
-    @data  = BSON::Binary.new(File.open("tools.gz").read)
-    @count = 0
-    @manager = ShardingManager.new(:config_count => 3)
-    @manager.start_cluster
-  end
-
-  def kill
-    @manager.kill_random
-  end
-
-  def restart
-    @manager.restart_killed_nodes
-  end
-
-  def run
-    Thread.new do
-      ("a".."z").each do |p|
-        seed(p)
-      end
-    end
-  end
-
-  def seed(prefix)
-    @queue = []
-    1000.times do |n|
-      id = BSON::OrderedHash.new
-      id[:p] = prefix
-      id[:c] = n
-      @queue << {:tid => id, :data => @data}
-    end
-
-    while @queue.length > 0 do
-      begin
-        doc = @queue.pop
-        @mongo['app']['photos'].insert(doc, :safe => {:w => 3})
-        @count += 1
-        p @count
-        rescue StandardError => e
-          p e
-          p @count
-          @queue.push(doc)
-          @count -= 1
-          sleep(10)
-          retry
-      end
-    end
-  end
-end
-
-@m = MongoLoader.new