mongo 1.10.0-java

data/test/unit/mongo_sharded_client_test.rb

@@ -0,0 +1,48 @@
+# 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 MongoShardedClientUnitTest < Test::Unit::TestCase
+  include Mongo
+
+  def test_initialize_with_single_mongos_uri
+    uri = "mongodb://localhost:27017"
+    with_preserved_env_uri(uri) do
+      client = MongoShardedClient.new(:connect => false)
+      assert_equal [[ "localhost", 27017 ]], client.seeds
+    end
+  end
+
+  def test_initialize_with_multiple_mongos_uris
+    uri = "mongodb://localhost:27017,localhost:27018"
+    with_preserved_env_uri(uri) do
+      client = MongoShardedClient.new(:connect => false)
+      assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+    end
+  end
+
+  def test_from_uri_with_string
+    client = MongoShardedClient.from_uri("mongodb://localhost:27017,localhost:27018", :connect => false)
+    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+  end
+
+  def test_from_uri_with_env_variable
+    uri = "mongodb://localhost:27017,localhost:27018"
+    with_preserved_env_uri(uri) do
+      client = MongoShardedClient.from_uri(nil, :connect => false)
+      assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+    end
+  end
+end

data/test/unit/node_test.rb

@@ -0,0 +1,93 @@
+# 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 NodeUnitTest < Test::Unit::TestCase
+
+  def setup
+    @client = stub()
+    manager = mock('pool_manager')
+    manager.stubs(:update_max_sizes)
+    @client.stubs(:local_manager).returns(manager)
+  end
+
+  should "refuse to connect to node without 'hosts' key" do
+    tcp = mock()
+    node = Node.new(@client, ['localhost', 27017])
+    tcp.stubs(:new).returns(new_mock_socket)
+    @client.stubs(:socket_class).returns(tcp)
+
+    admin_db = new_mock_db
+    admin_db.stubs(:command).returns({'ok' => 1, 'ismaster' => 1})
+    @client.stubs(:[]).with('admin').returns(admin_db)
+    @client.stubs(:op_timeout).returns(nil)
+    @client.stubs(:connect_timeout).returns(nil)
+    @client.expects(:log)
+    @client.expects(:mongos?).returns(false)
+    @client.stubs(:socket_opts)
+
+    assert node.connect
+    node.config
+  end
+
+  should "load a node from an array" do
+    node = Node.new(@client, ['power.level.com', 9001])
+    assert_equal 'power.level.com', node.host
+    assert_equal 9001, node.port
+    assert_equal 'power.level.com:9001', node.address
+  end
+
+  should "should default the port for an array" do
+    node = Node.new(@client, ['power.level.com'])
+    assert_equal 'power.level.com', node.host
+    assert_equal MongoClient::DEFAULT_PORT, node.port
+    assert_equal "power.level.com:#{MongoClient::DEFAULT_PORT}", node.address
+  end
+
+  should "load a node from a string" do
+    node = Node.new(@client, 'localhost:1234')
+    assert_equal 'localhost', node.host
+    assert_equal 1234, node.port
+    assert_equal 'localhost:1234', node.address
+  end
+
+  should "should default the port for a string" do
+    node = Node.new(@client, '192.168.0.1')
+    assert_equal '192.168.0.1', node.host
+    assert_equal MongoClient::DEFAULT_PORT, node.port
+    assert_equal "192.168.0.1:#{MongoClient::DEFAULT_PORT}", node.address
+  end
+
+  should "two nodes with the same address should be equal" do
+    assert_equal Node.new(@client, '192.168.0.1'),
+      Node.new(@client, ['192.168.0.1', MongoClient::DEFAULT_PORT])
+  end
+
+  should "two nodes with the same address should have the same hash" do
+    assert_equal Node.new(@client, '192.168.0.1').hash,
+      Node.new(@client, ['192.168.0.1', MongoClient::DEFAULT_PORT]).hash
+  end
+
+  should "two nodes with different addresses should not be equal" do
+    assert_not_equal Node.new(@client, '192.168.0.2'),
+      Node.new(@client, ['192.168.0.1', MongoClient::DEFAULT_PORT])
+  end
+
+  should "two nodes with the same address should have the same hash negate" do
+    assert_not_equal Node.new(@client, '192.168.0.1').hash,
+      Node.new(@client, '1239.33.4.2393:29949').hash
+  end
+
+end

data/test/unit/pool_manager_test.rb

@@ -0,0 +1,142 @@
+# 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 PoolManagerUnitTest < Test::Unit::TestCase
+
+  context "Initialization: " do
+
+    setup do
+      TCPSocket.stubs(:new).returns(new_mock_socket)
+      @db = new_mock_db
+
+      @client = stub("MongoClient")
+      @client.stubs(:connect_timeout).returns(5)
+      @client.stubs(:op_timeout).returns(5)
+      @client.stubs(:pool_size).returns(2)
+      @client.stubs(:pool_timeout).returns(100)
+      @client.stubs(:seeds).returns(['localhost:30000'])
+      @client.stubs(:socket_class).returns(TCPSocket)
+      @client.stubs(:mongos?).returns(false)
+      @client.stubs(:[]).returns(@db)
+      @client.stubs(:socket_opts)
+
+      @client.stubs(:replica_set_name).returns(nil)
+      @client.stubs(:log)
+      @arbiters = ['localhost:27020']
+      @hosts = [
+        'localhost:27017',
+        'localhost:27018',
+        'localhost:27019',
+        'localhost:27020'
+      ]
+
+      @ismaster = {
+        'hosts' => @hosts,
+        'arbiters' => @arbiters,
+        'maxBsonObjectSize' => 1024,
+        'maxMessageSizeBytes' => 1024 * 2.5,
+        'maxWireVersion' => 1,
+        'minWireVersion' => 0
+      }
+    end
+
+    should "populate pools correctly" do
+
+      @db.stubs(:command).returns(
+        # First call to get a socket.
+        @ismaster.merge({'ismaster' => true}),
+
+        # Subsequent calls to configure pools.
+        @ismaster.merge({'ismaster' => true}),
+        @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 500}),
+        @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 700}),
+        @ismaster.merge({'arbiterOnly' => true})
+      )
+
+      seeds = [['localhost', 27017]]
+      manager = Mongo::PoolManager.new(@client, seeds)
+      @client.stubs(:local_manager).returns(manager)
+      manager.connect
+
+      assert_equal ['localhost', 27017], manager.primary
+      assert_equal 27017, manager.primary_pool.port
+      assert_equal 2, manager.secondaries.length
+      assert_equal [27018, 27019], manager.secondary_pools.map(&:port).sort
+      assert_equal [['localhost', 27020]], manager.arbiters
+      assert_equal 500, manager.max_bson_size
+      assert_equal 700, manager.max_message_size
+    end
+
+    should "populate pools with single unqueryable seed" do
+
+      @db.stubs(:command).returns(
+        # First call to recovering node
+        @ismaster.merge({'ismaster' => false, 'secondary' => false}),
+
+        # Subsequent calls to configure pools.
+        @ismaster.merge({'ismaster' => false, 'secondary' => false}),
+        @ismaster.merge({'ismaster' => true}),
+        @ismaster.merge({'secondary' => true}),
+        @ismaster.merge({'arbiterOnly' => true})
+      )
+
+      seeds = [['localhost', 27017]]
+      manager = PoolManager.new(@client, seeds)
+      @client.stubs(:local_manager).returns(manager)
+      manager.connect
+
+      assert_equal ['localhost', 27018], manager.primary
+      assert_equal 27018, manager.primary_pool.port
+      assert_equal 1, manager.secondaries.length
+      assert_equal 27019, manager.secondary_pools[0].port
+      assert_equal [['localhost', 27020]], manager.arbiters
+    end
+
+    should "return clones of pool lists" do
+
+      @db.stubs(:command).returns(
+        # First call to get a socket.
+        @ismaster.merge({'ismaster' => true}),
+
+        # Subsequent calls to configure pools.
+        @ismaster.merge({'ismaster' => true}),
+        @ismaster.merge({'secondary' => true, 'maxBsonObjectSize' => 500}),
+        @ismaster.merge({'secondary' => true, 'maxMessageSizeBytes' => 700}),
+        @ismaster.merge({'arbiterOnly' => true})
+      )
+
+      seeds = [['localhost', 27017], ['localhost', 27018]]
+      manager = Mongo::PoolManager.new(@client, seeds)
+      @client.stubs(:local_manager).returns(manager)
+      manager.connect
+
+      assert_not_equal manager.instance_variable_get(:@arbiters).object_id, manager.arbiters.object_id
+      assert_not_equal manager.instance_variable_get(:@secondaries).object_id, manager.secondaries.object_id
+      assert_not_equal manager.instance_variable_get(:@secondary_pools).object_id, manager.secondary_pools.object_id
+      assert_not_equal manager.instance_variable_get(:@hosts).object_id, manager.hosts.object_id
+      assert_not_equal manager.instance_variable_get(:@pools).object_id, manager.pools.object_id
+
+      assert_not_equal manager.instance_variable_get(:@arbiters).object_id, manager.state_snapshot[:arbiters].object_id
+      assert_not_equal manager.instance_variable_get(:@secondaries).object_id, manager.state_snapshot[:secondaries].object_id
+      assert_not_equal manager.instance_variable_get(:@secondary_pools).object_id, manager.state_snapshot[:secondary_pools].object_id
+      assert_not_equal manager.instance_variable_get(:@hosts).object_id, manager.state_snapshot[:hosts].object_id
+      assert_not_equal manager.instance_variable_get(:@pools).object_id, manager.state_snapshot[:pools].object_id
+    end
+
+  end
+
+end

data/test/unit/read_pref_test.rb

@@ -0,0 +1,115 @@
+# 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 ReadPreferenceUnitTest < Test::Unit::TestCase
+
+  include ReadPreference
+
+  def setup
+    mock_pool = mock()
+    mock_pool.stubs(:ping_time).returns(Pool::MAX_PING_TIME)
+
+    stubs(:primary_pool).returns(mock_pool)
+    stubs(:secondary_pools).returns([mock_pool])
+    stubs(:pools).returns([mock_pool])
+  end
+
+  def test_select_pool
+    ReadPreference::READ_PREFERENCES.map do |rp|
+      assert select_pool({:mode => rp, :tags => [], :latency => 15})
+    end
+  end
+
+  def test_sok_mapreduce_out_string_returns_false
+    command = BSON::OrderedHash['mapreduce', 'test-collection',
+                                'out', 'new-test-collection']
+    assert_equal false, ReadPreference::secondary_ok?(command)
+  end
+
+  def test_sok_mapreduce_replace_collection_returns_false
+    command = BSON::OrderedHash['mapreduce', 'test-collection',
+                                'out', BSON::OrderedHash['replace', 'new-test-collection']]
+    assert_equal false, ReadPreference::secondary_ok?(command)
+  end
+
+  def test_sok_mapreduce_inline_collection_returns_false
+    command = BSON::OrderedHash['mapreduce', 'test-collection',
+                                'out', 'inline']
+    assert_equal false, ReadPreference::secondary_ok?(command)
+  end
+
+  def test_sok_inline_symbol_mapreduce_returns_true
+    command = BSON::OrderedHash['mapreduce', 'test-collection',
+                                'out', BSON::OrderedHash[:inline, 'true']]
+    assert_equal true, ReadPreference::secondary_ok?(command)
+  end
+
+  def test_sok_inline_string_mapreduce_returns_true
+    command = BSON::OrderedHash['mapreduce', 'test-collection',
+                                'out', BSON::OrderedHash['inline', 'true']]
+    assert_equal true, ReadPreference::secondary_ok?(command)
+  end
+
+  def test_sok_count_true
+    command = BSON::OrderedHash['count', 'test-collection',
+                                'query', BSON::OrderedHash['a', 'b']]
+    assert_equal true, ReadPreference::secondary_ok?(command)
+  end
+
+  def test_sok_server_status_returns_false
+    command = BSON::OrderedHash['serverStatus', 1]
+    assert_equal false, ReadPreference::secondary_ok?(command)
+  end
+
+  def test_cmd_reroute_with_secondary
+    ReadPreference::expects(:warn).with(regexp_matches(/rerouted to primary/))
+    command = BSON::OrderedHash['mapreduce', 'test-collection',
+                                'out', 'new-test-collection']
+    assert_equal :primary, ReadPreference::cmd_read_pref(:secondary, command)
+  end
+
+  def test_find_and_modify_reroute_with_secondary
+    ReadPreference::expects(:warn).with(regexp_matches(/rerouted to primary/))
+    command = BSON::OrderedHash['findAndModify', 'test-collection',
+                                'query', {}]
+    assert_equal :primary, ReadPreference::cmd_read_pref(:secondary, command)
+  end
+
+  def test_cmd_no_reroute_with_secondary
+    command = BSON::OrderedHash['mapreduce', 'test-collection',
+                                'out', BSON::OrderedHash['inline', 'true']]
+    assert_equal :secondary, ReadPreference::cmd_read_pref(:secondary, command)
+  end
+
+  def test_cmd_no_reroute_with_primary
+    command = BSON::OrderedHash['mapreduce', 'test-collection',
+                                'out', 'new-test-collection']
+    assert_equal :primary, ReadPreference::cmd_read_pref(:primary, command)
+  end
+
+  def test_cmd_no_reroute_with_primary_secondary_ok
+    command = BSON::OrderedHash['mapreduce', 'test-collection',
+                                'out', BSON::OrderedHash['inline', 'true']]
+    assert_equal :primary, ReadPreference::cmd_read_pref(:primary, command)
+  end
+
+  def test_parallel_scan_secondary_ok
+    command = BSON::OrderedHash['parallelCollectionScan', 'test-collection',
+                                'numCursors', 3]
+    assert_equal true, ReadPreference::secondary_ok?(command)
+  end
+
+end

data/test/unit/read_test.rb

@@ -0,0 +1,159 @@
+# 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 ReadUnitTest < Test::Unit::TestCase
+
+  context "Read mode on standard connection: " do
+    setup do
+      @read = :secondary
+      @client = MongoClient.new('localhost', 27017, :read => @read, :connect => false)
+    end
+
+  end
+
+  context "Read preferences on replica set connection: " do
+    setup do
+      @read = :secondary_preferred
+      @acceptable_latency = 100
+      @tags = {"dc" => "Tyler", "rack" => "Brock"}
+      @bad_tags = {"wow" => "cool"}
+      @client = MongoReplicaSetClient.new(
+        ['localhost:27017'],
+        :read => @read,
+        :tag_sets => @tags,
+        :secondary_acceptable_latency_ms => @acceptable_latency,
+        :connect => false
+      )
+    end
+
+    should "store read preference on MongoClient" do
+      assert_equal @read, @client.read
+      assert_equal @tags, @client.tag_sets
+      assert_equal @acceptable_latency, @client.acceptable_latency
+    end
+
+    should "propogate to DB" do
+      db = @client[TEST_DB]
+      assert_equal @read, db.read
+      assert_equal @tags, db.tag_sets
+      assert_equal @acceptable_latency, db.acceptable_latency
+
+      db = @client.db(TEST_DB)
+      assert_equal @read, db.read
+      assert_equal @tags, db.tag_sets
+      assert_equal @acceptable_latency, db.acceptable_latency
+
+      db = DB.new(TEST_DB, @client)
+      assert_equal @read, db.read
+      assert_equal @tags, db.tag_sets
+      assert_equal @acceptable_latency, db.acceptable_latency
+    end
+
+    should "allow db override" do
+      db = DB.new(TEST_DB, @client, :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
+      assert_equal :primary, db.read
+      assert_equal @bad_tags, db.tag_sets
+      assert_equal 25, db.acceptable_latency
+
+      db = @client.db(TEST_DB, :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
+      assert_equal :primary, db.read
+      assert_equal @bad_tags, db.tag_sets
+      assert_equal 25, db.acceptable_latency
+    end
+
+    context "on DB: " do
+      setup do
+        @db = @client[TEST_DB]
+      end
+
+      should "propogate to collection" do
+        col = @db.collection('read-unit-test')
+        assert_equal @read, col.read
+        assert_equal @tags, col.tag_sets
+        assert_equal @acceptable_latency, col.acceptable_latency
+
+        col = @db['read-unit-test']
+        assert_equal @read, col.read
+        assert_equal @tags, col.tag_sets
+        assert_equal @acceptable_latency, col.acceptable_latency
+
+        col = Collection.new('read-unit-test', @db)
+        assert_equal @read, col.read
+        assert_equal @tags, col.tag_sets
+        assert_equal @acceptable_latency, col.acceptable_latency
+      end
+
+      should "allow override on collection" do
+        col = @db.collection('read-unit-test', :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
+        assert_equal :primary, col.read
+        assert_equal @bad_tags, col.tag_sets
+        assert_equal 25, col.acceptable_latency
+
+        col = Collection.new('read-unit-test', @db, :read => :primary, :tag_sets => @bad_tags, :acceptable_latency => 25)
+        assert_equal :primary, col.read
+        assert_equal @bad_tags, col.tag_sets
+        assert_equal 25, col.acceptable_latency
+      end
+    end
+
+    context "on read mode ops" do
+      setup do
+        @col = @client[TEST_DB]['read-unit-test']
+        @mock_socket = new_mock_socket
+      end
+
+      should "use default value on query" do
+        @cursor = @col.find({:a => 1})
+        sock = new_mock_socket
+        read_pool = stub(:checkin => true)
+        @client.stubs(:read_pool).returns(read_pool)
+        local_manager = PoolManager.new(@client, @client.seeds)
+        @client.stubs(:local_manager).returns(local_manager)
+        primary_pool = stub(:checkin => true)
+        sock.stubs(:pool).returns(primary_pool)
+        @client.stubs(:primary_pool).returns(primary_pool)
+        @client.expects(:checkout_reader).returns(sock)
+        @client.expects(:receive_message).with do |o, m, l, s, c, r|
+          r == nil
+        end.returns([[], 0, 0])
+
+        @cursor.next
+      end
+
+      should "allow override default value on query" do
+        @cursor = @col.find({:a => 1}, :read => :primary)
+        sock = new_mock_socket
+        local_manager = PoolManager.new(@client, @client.seeds)
+        @client.stubs(:local_manager).returns(local_manager)
+        primary_pool = stub(:checkin => true)
+        sock.stubs(:pool).returns(primary_pool)
+        @client.stubs(:primary_pool).returns(primary_pool)
+        @client.expects(:checkout_reader).returns(sock)
+        @client.expects(:receive_message).with do |o, m, l, s, c, r|
+          r == nil
+        end.returns([[], 0, 0])
+
+        @cursor.next
+      end
+
+      should "allow override alternate value on query" do
+        assert_raise MongoArgumentError do
+          @col.find_one({:a => 1}, :read => {:dc => "ny"})
+        end
+      end
+    end
+  end
+end