mongo 1.12.5 → 2.0.0

data/test/tools/mongo_config_test.rb

@@ -1,160 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'test_helper'
-
-class MongoConfig < Test::Unit::TestCase
-
-  def startup
-    @sys_proc = nil
-  end
-
-  def shutdown
-    @sys_proc.stop if @sys_proc && @sys_proc.running?
-  end
-
-  test "config defaults" do
-    [ Mongo::Config::DEFAULT_BASE_OPTS,
-      Mongo::Config::DEFAULT_REPLICA_SET,
-      Mongo::Config::DEFAULT_SHARDED_SIMPLE,
-      Mongo::Config::DEFAULT_SHARDED_REPLICA
-    ].each do |params|
-      config = Mongo::Config.cluster(params)
-      assert(config.size > 0)
-    end
-  end
-
-  test "get available port" do
-    assert_not_nil(Mongo::Config.get_available_port)
-  end
-
-  test "SysProc start" do
-    cmd = "true"
-    @sys_proc = Mongo::Config::SysProc.new(cmd)
-    assert_equal(cmd, @sys_proc.cmd)
-    assert_nil(@sys_proc.pid)
-    start_and_assert_running?(@sys_proc)
-  end
-
-  test "SysProc wait" do
-    @sys_proc = Mongo::Config::SysProc.new("true")
-    start_and_assert_running?(@sys_proc)
-    assert(@sys_proc.running?)
-    @sys_proc.wait
-    assert(!@sys_proc.running?)
-  end
-
-  test "SysProc kill" do
-    @sys_proc = Mongo::Config::SysProc.new("true")
-    start_and_assert_running?(@sys_proc)
-    @sys_proc.kill
-    @sys_proc.wait
-    assert(!@sys_proc.running?)
-  end
-
-  test "SysProc stop" do
-    @sys_proc = Mongo::Config::SysProc.new("true")
-    start_and_assert_running?(@sys_proc)
-    @sys_proc.stop
-    assert(!@sys_proc.running?)
-  end
-
-  test "SysProc zombie respawn" do
-    @sys_proc = Mongo::Config::SysProc.new("true")
-    start_and_assert_running?(@sys_proc)
-    prev_pid = @sys_proc.pid
-    @sys_proc.kill
-    # don't wait, leaving a zombie
-    assert(@sys_proc.running?)
-    start_and_assert_running?(@sys_proc)
-    assert(prev_pid && @sys_proc.pid && prev_pid != @sys_proc.pid, 'SysProc#start should spawn a new process after a zombie')
-    @sys_proc.stop
-    assert(!@sys_proc.running?)
-  end
-
-  test "Server" do
-    server = Mongo::Config::Server.new('a cmd', 'host', 1234)
-    assert_equal('a cmd', server.cmd)
-    assert_equal('host', server.host)
-    assert_equal(1234, server.port)
-  end
-
-  test "DbServer" do
-    config = Mongo::Config::DEFAULT_BASE_OPTS
-    server = Mongo::Config::DbServer.new(config)
-    assert_equal(config, server.config)
-    assert_equal("mongod --dbpath data --logpath data/log", server.cmd)
-    assert_equal(config[:host], server.host)
-    assert_equal(config[:port], server.port)
-  end
-
-  def cluster_test(opts)
-    #debug 1, opts.inspect
-    config =  Mongo::Config.cluster(opts)
-    #debug 1, config.inspect
-    manager = Mongo::Config::ClusterManager.new(config)
-    assert_equal(config, manager.config)
-    manager.start
-    yield manager
-    manager.stop
-    manager.servers.each{|s| assert(!s.running?)}
-    manager.clobber
-  end
-
-  test "cluster manager base" do
-    cluster_test(Mongo::Config::DEFAULT_BASE_OPTS) do |manager|
-
-    end
-  end
-
-  test "cluster manager replica set" do
-    cluster_test(Mongo::Config::DEFAULT_REPLICA_SET) do |manager|
-      servers = manager.servers
-      servers.each do |server|
-        assert_not_nil(Mongo::MongoClient.new(server.host, server.port))
-        assert_match(/oplogSize/, server.cmd, '--oplogSize option should be specified')
-        assert_match(/smallfiles/, server.cmd, '--smallfiles option should be specified')
-        assert_no_match(/nojournal/, server.cmd, '--nojournal option should not be specified')
-        assert_match(/noprealloc/, server.cmd, '--noprealloc option should be specified')
-      end
-    end
-  end
-
-  test "cluster manager sharded simple" do
-    cluster_test(Mongo::Config::DEFAULT_SHARDED_SIMPLE) do |manager|
-      servers = manager.shards + manager.configs
-      servers.each do |server|
-        assert_not_nil(Mongo::MongoClient.new(server.host, server.port))
-        assert_match(/oplogSize/, server.cmd, '--oplogSize option should be specified')
-        assert_match(/smallfiles/, server.cmd, '--smallfiles option should be specified')
-        assert_no_match(/nojournal/, server.cmd, '--nojournal option should not be specified')
-        assert_match(/noprealloc/, server.cmd, '--noprealloc option should be specified')
-      end
-    end
-  end
-
-  test "cluster manager sharded replica" do
-    #cluster_test(Mongo::Config::DEFAULT_SHARDED_REPLICA) # not yet supported by ClusterManager
-  end
-
-  private
-
-  def start_and_assert_running?(sys_proc)
-    assert_not_nil(sys_proc.start(0))
-    assert_not_nil(sys_proc.pid)
-    assert(sys_proc.running?)
-  end
-
-end
-

data/test/unit/client_test.rb

@@ -1,381 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'test_helper'
-include Mongo
-
-class ClientUnitTest < Test::Unit::TestCase
-  context "Mongo::MongoClient initialization " do
-    context "given a single node" do
-      setup do
-        @client = MongoClient.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})
-        @client.expects(:[]).with('admin').returns(admin_db)
-        @client.connect
-      end
-
-      should "gle writes by default" do
-        assert_equal 1, @client.write_concern[:w]
-      end
-
-      should "set localhost and port to master" do
-        assert_equal 'localhost', @client.primary_pool.host
-        assert_equal 27017, @client.primary_pool.port
-      end
-
-      should "set connection pool to 1" do
-        assert_equal 1, @client.primary_pool.size
-      end
-
-      should "set op timeout to default" do
-        assert_equal Mongo::MongoClient::DEFAULT_OP_TIMEOUT, @client.op_timeout
-      end
-
-      should "default slave_ok to false" do
-        assert !@client.slave_ok?
-      end
-
-      should "not raise error if no host or port is supplied" do
-        assert_nothing_raised do
-          MongoClient.new(:w => 1, :connect => false)
-        end
-        assert_nothing_raised do
-          MongoClient.new('localhost', :w => 1, :connect=> false)
-        end
-      end
-
-      should "warn if invalid options are specified" do
-        client = MongoClient.allocate
-        opts = {:connect => false}
-
-        MongoReplicaSetClient::REPL_SET_OPTS.each do |opt|
-          client.expects(:warn).with("#{opt} is not a valid option for #{client.class}")
-          opts[opt] = true
-        end
-
-        args = ['localhost', 27017, opts]
-        client.send(:initialize, *args)
-      end
-
-      context 'specifying nil op timeout explicitly' do
-        setup do
-          @client = MongoClient.new('localhost', 27017, :connect => false, :op_timeout => nil)
-        end
-
-        should 'set op timeout to nil' do
-          assert_equal nil, @client.op_timeout
-        end
-      end
-
-      context 'specifying a different op timeout than default' do
-        setup do
-          @client = MongoClient.new('localhost', 27017, :connect => false, :op_timeout => 50)
-        end
-
-        should 'set op timeout to the specified value' do
-          assert_equal 50, @client.op_timeout
-        end
-      end
-
-      context "given a replica set" do
-
-        should "warn if invalid options are specified" do
-          client = MongoReplicaSetClient.allocate
-          opts = {:connect => false}
-
-          MongoClient::CLIENT_ONLY_OPTS.each do |opt|
-            client.expects(:warn).with("#{opt} is not a valid option for #{client.class}")
-            opts[opt] = true
-          end
-
-          args = [['localhost:27017'], opts]
-          client.send(:initialize, *args)
-        end
-
-        should "throw error if superflous arguments are specified" do
-          assert_raise MongoArgumentError do
-            MongoReplicaSetClient.new(['localhost:27017'], ['localhost:27018'], {:connect => false})
-          end
-        end
-      end
-    end
-
-    context "initializing with a unix socket" do
-      setup do
-        @client = MongoClient.new('/tmp/mongod.sock', :connect => false)
-        UNIXSocket.stubs(:new).returns(new_mock_unix_socket)
-      end
-      should "parse a unix socket" do
-        assert_equal "/tmp/mongod.sock", @client.host_port.first
-      end
-    end
-
-    context "initializing with a unix socket in uri" do
-      setup do
-          @client = MongoClient.from_uri("mongodb:///tmp/mongod.sock", :connect => false)
-          UNIXSocket.stubs(:new).returns(new_mock_unix_socket)
-      end
-      should "parse a unix socket" do
-          assert_equal "/tmp/mongod.sock", @client.host_port.first
-      end
-    end
-
-    context "initializing with a mongodb uri" do
-      should "parse a simple uri" do
-        @client = MongoClient.from_uri("mongodb://localhost", :connect => false)
-        assert_equal ['localhost', 27017], @client.host_port
-      end
-
-      should "set auth source" do
-        @client = MongoClient.from_uri("mongodb://user:pass@localhost?authSource=foo", :connect => false)
-        assert_equal 'foo', @client.auths.first[:source]
-      end
-
-      should "set auth mechanism" do
-        @client = MongoClient.from_uri("mongodb://user@localhost?authMechanism=MONGODB-X509", :connect => false)
-        assert_equal 'MONGODB-X509', @client.auths.first[:mechanism]
-
-        assert_raise MongoArgumentError do
-          MongoClient.from_uri("mongodb://user@localhost?authMechanism=INVALID", :connect => false)
-        end
-      end
-
-      should "allow a complex host names" do
-        host_name = "foo.bar-12345.org"
-        @client = MongoClient.from_uri("mongodb://#{host_name}", :connect => false)
-        assert_equal [host_name, 27017], @client.host_port
-      end
-
-      should "allow db without username and password" do
-        host_name = "foo.bar-12345.org"
-        @client = MongoClient.from_uri("mongodb://#{host_name}/foo", :connect => false)
-        assert_equal [host_name, 27017], @client.host_port
-      end
-
-      should "set write concern options on connection" do
-        host_name = "localhost"
-        opts = "w=2&wtimeoutMS=1000&fsync=true&journal=true"
-        @client = MongoClient.from_uri("mongodb://#{host_name}/foo?#{opts}", :connect => false)
-        assert_equal({:w => 2, :wtimeout => 1000, :fsync => true, :j => true}, @client.write_concern)
-      end
-
-      should "set timeout options on connection" do
-        host_name = "localhost"
-        opts = "connectTimeoutMS=1000&socketTimeoutMS=5000"
-        @client = MongoClient.from_uri("mongodb://#{host_name}/foo?#{opts}", :connect => false)
-        assert_equal 1, @client.connect_timeout
-        assert_equal 5, @client.op_timeout
-      end
-
-      should "parse a uri with a hyphen & underscore in the username or password" do
-        @client = MongoClient.from_uri("mongodb://hyphen-user_name:p-s_s@localhost:27017/db", :connect => false)
-        assert_equal ['localhost', 27017], @client.host_port
-
-        auth_hash = {
-          :db_name   => 'db',
-          :extra=>{},
-          :username  => 'hyphen-user_name',
-          :password  => 'p-s_s',
-          :source    => 'db',
-          :mechanism => nil
-        }
-        assert_equal auth_hash, @client.auths.first
-      end
-
-      should "attempt to connect" do
-        TCPSocket.stubs(:new).returns(new_mock_socket)
-        @client = MongoClient.from_uri("mongodb://localhost", :connect => false)
-
-        admin_db = new_mock_db
-        admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
-        @client.expects(:[]).with('admin').returns(admin_db)
-        @client.connect
-      end
-
-      should "raise an error on invalid uris" do
-        assert_raise MongoArgumentError do
-          MongoClient.from_uri("mongo://localhost", :connect => false)
-        end
-
-        assert_raise MongoArgumentError do
-          MongoClient.from_uri("mongodb://localhost:abc", :connect => false)
-        end
-      end
-
-      should "require password if using legacy auth and username present" do
-        assert MongoClient.from_uri("mongodb://kyle:jones@localhost/db", :connect => false)
-
-        assert_raise MongoArgumentError do
-          MongoClient.from_uri("mongodb://kyle:@localhost", :connect => false)
-        end
-
-        assert_raise MongoArgumentError do
-          MongoClient.from_uri("mongodb://kyle@localhost", :connect => false)
-        end
-      end
-    end
-
-    context "initializing with ENV['MONGODB_URI']" do
-      should "parse a simple uri" do
-        uri = "mongodb://localhost?connect=false"
-        with_preserved_env_uri(uri) do
-          @client = MongoClient.new
-          assert_equal ['localhost', 27017], @client.host_port
-        end
-      end
-
-      should "set auth source" do
-        uri = "mongodb://user:pass@localhost?authSource=foo&connect=false"
-        with_preserved_env_uri(uri) do
-          @client = MongoClient.new
-          assert_equal 'foo', @client.auths.first[:source]
-        end
-      end
-
-      should "set auth mechanism" do
-        uri = "mongodb://user@localhost?authMechanism=MONGODB-X509&connect=false"
-        with_preserved_env_uri(uri) do
-          @client = MongoClient.new
-          assert_equal 'MONGODB-X509', @client.auths.first[:mechanism]
-
-          ENV['MONGODB_URI'] = "mongodb://user@localhost?authMechanism=INVALID&connect=false"
-          assert_raise MongoArgumentError do
-            MongoClient.new
-          end
-        end
-      end
-
-      should "allow a complex host names" do
-        host_name = "foo.bar-12345.org"
-        uri = "mongodb://#{host_name}?connect=false"
-        with_preserved_env_uri(uri) do
-          @client = MongoClient.new
-          assert_equal [host_name, 27017], @client.host_port
-        end
-      end
-
-      should "allow db without username and password" do
-        host_name = "foo.bar-12345.org"
-        uri = "mongodb://#{host_name}/foo?connect=false"
-        with_preserved_env_uri(uri) do
-          @client = MongoClient.new
-          assert_equal [host_name, 27017], @client.host_port
-        end
-      end
-
-      should "set write concern options on connection" do
-        host_name = "localhost"
-        opts = "w=2&wtimeoutMS=1000&fsync=true&journal=true&connect=false"
-        uri = "mongodb://#{host_name}/foo?#{opts}"
-        with_preserved_env_uri(uri) do
-          @client = MongoClient.new
-          assert_equal({:w => 2, :wtimeout => 1000, :fsync => true, :j => true}, @client.write_concern)
-        end
-      end
-
-      should "set timeout options on connection" do
-        host_name = "localhost"
-        opts = "connectTimeoutMS=1000&socketTimeoutMS=5000&connect=false"
-        uri = "mongodb://#{host_name}/foo?#{opts}"
-        with_preserved_env_uri(uri) do
-          @client = MongoClient.new
-          assert_equal 1, @client.connect_timeout
-          assert_equal 5, @client.op_timeout
-        end
-      end
-
-      should "parse a uri with a hyphen & underscore in the username or password" do
-        uri = "mongodb://hyphen-user_name:p-s_s@localhost:27017/db?connect=false"
-        with_preserved_env_uri(uri) do
-          @client = MongoClient.new
-          assert_equal ['localhost', 27017], @client.host_port
-
-          auth_hash = {
-            :db_name   => 'db',
-            :extra=>{},
-            :username  => 'hyphen-user_name',
-            :password  => 'p-s_s',
-            :source    => 'db',
-            :mechanism => nil
-          }
-          assert_equal auth_hash, @client.auths.first
-        end
-      end
-
-      should "attempt to connect" do
-        TCPSocket.stubs(:new).returns(new_mock_socket)
-        uri = "mongodb://localhost?connect=false"
-        with_preserved_env_uri(uri) do
-          @client = MongoClient.new
-
-          admin_db = new_mock_db
-          admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
-          @client.expects(:[]).with('admin').returns(admin_db)
-          @client.connect
-        end
-      end
-
-      should "raise an error on invalid uris" do
-        uri = "mongo://localhost"
-        with_preserved_env_uri(uri) do
-          assert_raise MongoArgumentError do
-            MongoClient.new
-          end
-
-          ENV['MONGODB_URI'] = "mongodb://localhost:abc?connect=false"
-          assert_raise MongoArgumentError do
-            MongoClient.new
-          end
-        end
-      end
-
-      should "require password if using legacy auth and username present" do
-        uri = "mongodb://kyle:jones@localhost?connect=false"
-        with_preserved_env_uri(uri) do
-          assert MongoClient.new
-
-          ENV['MONGODB_URI'] = "mongodb://kyle:@localhost?connect=false"
-          assert_raise MongoArgumentError do
-            MongoClient.new
-          end
-
-          ENV['MONGODB_URI'] = "mongodb://kyle@localhost?connect=false"
-          assert_raise MongoArgumentError do
-            MongoClient.new
-          end
-        end
-      end
-
-      should "require password if using PLAIN auth and username present" do
-        uri = "mongodb://kyle:jones@localhost?connect=false&authMechanism=PLAIN"
-        with_preserved_env_uri(uri) do
-          assert MongoClient.new
-
-          ENV['MONGODB_URI'] = "mongodb://kyle:@localhost?connect=false&authMechanism=PLAIN"
-          assert_raise MongoArgumentError do
-            MongoClient.new
-          end
-
-          ENV['MONGODB_URI'] = "mongodb://kyle@localhost?connect=false&authMechanism=PLAIN"
-          assert_raise MongoArgumentError do
-            MongoClient.new
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/collection_test.rb

@@ -1,166 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'test_helper'
-
-module Mongo
-  class Collection
-    attr_reader :operation_writer,
-                :command_writer
-  end
-end
-
-class CollectionUnitTest < Test::Unit::TestCase
-
-  context "Basic operations: " do
-    setup do
-      @logger = mock()
-      @logger.stubs(:level => 0)
-      @logger.expects(:debug)
-
-      @client = MongoClient.new('localhost', 27017, :logger => @logger, :connect => false)
-      @db     = @client[TEST_DB]
-      @coll   = @db.collection('collection-unit-test')
-    end
-
-    should "send update message" do
-      @client.expects(:send_message_with_gle).with do |op, msg, log|
-        op == 2001
-      end
-      @coll.operation_writer.stubs(:log_operation)
-      @coll.update({}, {:title => 'Moby Dick'})
-    end
-
-    should "send insert message" do
-      @client.expects(:send_message_with_gle).with do |op, msg, log|
-        op == 2002
-      end
-      @coll.operation_writer.expects(:log_operation).with do |name, payload|
-        (name == :insert) && payload[:documents][:title].include?('Moby')
-      end
-      @coll.insert({:title => 'Moby Dick'})
-    end
-
-    should "send sort data" do
-      @client.expects(:checkout_reader).returns(new_mock_socket)
-      @client.expects(:receive_message).with do |op, msg, log, sock|
-        op == 2004
-      end.returns([[], 0, 0])
-      @logger.expects(:debug)
-      @coll.find({:title => 'Moby Dick'}).sort([['title', 1], ['author', 1]]).next_document
-    end
-
-    should "not log binary data" do
-      data = BSON::Binary.new(("BINARY " * 1000).unpack("c*"))
-      @client.expects(:send_message_with_gle).with do |op, msg, log|
-        op == 2002
-      end
-      @coll.operation_writer.expects(:log_operation).with do |name, payload|
-        (name == :insert) && payload[:documents][:data].inspect.include?('Binary')
-      end
-      @coll.insert({:data => data})
-    end
-
-    should "send safe update message" do
-      @client.expects(:send_message_with_gle).with do |op, msg, db_name, log|
-        op == 2001
-      end
-      @coll.operation_writer.expects(:log_operation).with do |name, payload|
-        (name == :update) && payload[:documents][:title].include?('Moby')
-      end
-      @coll.update({}, {:title => 'Moby Dick'})
-    end
-
-    should "send safe update message with legacy" do
-      connection = Connection.new('localhost', 27017, :safe => true, :connect => false)
-      db         = connection[TEST_DB]
-      coll       = db.collection('collection-unit-test')
-      connection.expects(:send_message_with_gle).with do |op, msg, db_name, log|
-        op == 2001
-      end
-      coll.operation_writer.expects(:log_operation).with do |name, payload|
-        (name == :update) && payload[:documents][:title].include?('Moby')
-      end
-      coll.update({}, {:title => 'Moby Dick'})
-    end
-
-    should "send safe insert message" do
-      @client.expects(:send_message_with_gle).with do |op, msg, db_name, log|
-        op == 2001
-      end
-      @coll.operation_writer.stubs(:log_operation)
-      @coll.update({}, {:title => 'Moby Dick'})
-    end
-
-    should "not call insert for each ensure_index call" do
-      @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 type on the same field for ensure_index" do
-      @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
-      @db.cache_time = 0
-      @coll = @db.collection('collection-unit-test')
-      @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
-      @db.cache_time = 300
-      @coll = @db.collection('collection-unit-test')
-      @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
-
-    should "call generate_indexes for each key when calling ensure_indexes with a hash" do
-      @db.cache_time = 300
-      @coll = @db.collection('collection-unit-test')
-      oh = BSON::OrderedHash.new
-      oh['x'] = Mongo::DESCENDING
-      oh['y'] = Mongo::DESCENDING
-      @coll.expects(:generate_indexes).once.with do |a, b, c|
-        a == oh
-      end
-
-      if RUBY_VERSION > '1.9'
-          @coll.ensure_index({"x" => Mongo::DESCENDING, "y" => Mongo::DESCENDING})
-      else
-          ordered_hash = BSON::OrderedHash.new
-          ordered_hash['x'] = Mongo::DESCENDING
-          ordered_hash['y'] = Mongo::DESCENDING
-          @coll.ensure_index(ordered_hash)
-      end
-    end
-
-    should "use the connection's logger" do
-      @logger.expects(:warn).with do |msg|
-        msg == "MONGODB [WARNING] test warning"
-      end
-      @coll.log(:warn, "test warning")
-    end
-  end
-end