mongo 1.3.0 → 1.12.5

data/test/replica_set/query_test.rb

@@ -0,0 +1,73 @@
+# 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 ReplicaSetQueryTest < Test::Unit::TestCase
+
+  def setup
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
+    @db = @client.db(TEST_DB)
+    @db.drop_collection("test-sets")
+    @coll = @db.collection("test-sets")
+  end
+
+  def teardown
+    @client.close if @client
+  end
+
+  def test_query
+    @coll.save({:a => 20}, :w => 3)
+    @coll.save({:a => 30}, :w => 3)
+    @coll.save({:a => 40}, :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
+
+    @rs.primary.stop
+
+    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
+    end
+  end
+
+  # Create a large collection and do a secondary query that returns
+  # enough records to require sending a GETMORE. In between opening
+  # the cursor and sending the GETMORE, do a :primary query. Confirm
+  # that the cursor reading from the secondary continues to talk to
+  # the secondary, rather than trying to read the cursor from the
+  # primary, where it does not exist.
+  # def test_secondary_getmore
+  #   200.times do |i|
+  #     @coll.save({:a => i}, :w => 3)
+  #   end
+  #   as = []
+  #   # Set an explicit batch size, in case the default ever changes.
+  #   @coll.find({}, { :batch_size => 100, :read => :secondary }) do |c|
+  #     c.each do |result|
+  #       as << result['a']
+  #       @coll.find({:a => result['a']}, :read => :primary).map
+  #     end
+  #   end
+  #   assert_equal(as.sort, 0.upto(199).to_a)
+  # end
+
+end

data/test/replica_set/read_preference_test.rb

@@ -0,0 +1,219 @@
+# 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 ReadPreferenceTest < Test::Unit::TestCase
+
+  def setup
+    ensure_cluster(:rs)
+    client = make_connection
+    db = client.db(TEST_DB)
+    coll = db.collection('test-sets')
+    coll.save({:a => 20}, {:w => 2})
+  end
+
+  def test_read_primary
+    client = make_connection
+    rescue_connection_failure do
+      assert client.read_primary?
+      assert client.primary?
+    end
+
+    client = make_connection(:primary_preferred)
+    rescue_connection_failure do
+      assert client.read_primary?
+      assert client.primary?
+    end
+
+    client = make_connection(:secondary)
+    rescue_connection_failure do
+      assert !client.read_primary?
+      assert !client.primary?
+    end
+
+    client = make_connection(:secondary_preferred)
+    rescue_connection_failure do
+      assert !client.read_primary?
+      assert !client.primary?
+    end
+  end
+
+  def test_connection_pools
+    client = make_connection
+    assert client.primary_pool, "No primary pool!"
+    assert client.read_pool, "No read pool!"
+    assert client.primary_pool.port == client.read_pool.port,
+      "Primary port and read port are not the same!"
+
+
+    client = make_connection(:primary_preferred)
+    assert client.primary_pool, "No primary pool!"
+    assert client.read_pool, "No read pool!"
+    assert client.primary_pool.port == client.read_pool.port,
+      "Primary port and read port are not the same!"
+
+    client = make_connection(:secondary)
+    assert client.primary_pool, "No primary pool!"
+    assert client.read_pool, "No read pool!"
+    assert client.primary_pool.port != client.read_pool.port,
+      "Primary port and read port are the same!"
+
+    client = make_connection(:secondary_preferred)
+    assert client.primary_pool, "No primary pool!"
+    assert client.read_pool, "No read pool!"
+    assert client.primary_pool.port != client.read_pool.port,
+      "Primary port and read port are the same!"
+  end
+
+  def test_read_routing
+    prepare_routing_test
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, :primary)
+    assert_query_route(@primary_preferred, :primary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
+  end
+
+  def test_read_routing_with_primary_down
+    prepare_routing_test
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, :primary)
+    assert_query_route(@primary_preferred, :primary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
+
+    # Kill the primary so the remaining two members are secondaries
+    @rs.primary.kill
+    sleep(2)
+    # Test that reads are going to the right members
+    assert_raise_error ConnectionFailure do
+      @primary[TEST_DB]['test-sets'].find_one
+    end
+    assert_query_route(@primary_preferred, :secondary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
+
+    # Restore set
+    @rs.restart
+    sleep(1)
+    @repl_cons.each { |con| con.refresh }
+    sleep(1)
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, :primary)
+    assert_query_route(@primary_preferred, :primary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
+  end
+
+  def test_read_routing_with_secondary_down
+    prepare_routing_test
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, :primary)
+    assert_query_route(@primary_preferred, :primary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
+
+    secondaries = @rs.secondaries
+    secondaries[0].kill
+    assert_query_route(@secondary_preferred, :secondary)
+
+    secondaries[1].kill
+    sleep(2)
+
+    recovered = false
+    until recovered
+      begin
+        @secondary[TEST_DB]['test-sets'].find_one
+        recovered = true
+      rescue ConnectionFailure
+      end
+    end
+
+    assert_query_route(@secondary_preferred, :secondary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@primary_preferred, :secondary)
+
+    # Restore set
+    @rs.restart
+    sleep(1)
+    @repl_cons.each { |con| con.refresh }
+    sleep(1)
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, :primary)
+    assert_query_route(@primary_preferred, :primary)
+    assert_query_route(@secondary, :secondary)
+    assert_query_route(@secondary_preferred, :secondary)
+  end
+
+  def test_write_lots_of_data
+    client = make_connection(:secondary_preferred)
+    db = client[TEST_DB]
+    coll = db.collection("test-sets", {:w => 2})
+
+    6000.times do |n|
+      coll.save({:a => n})
+    end
+
+    cursor = coll.find()
+    cursor.next
+    cursor.close
+  end
+
+  private
+
+  def prepare_routing_test
+    # Setup replica set connections
+    @primary = make_connection(:primary)
+    @primary_preferred = make_connection(:primary_preferred)
+    @secondary = make_connection(:secondary)
+    @secondary_preferred = make_connection(:secondary_preferred)
+    @repl_cons = [@primary, @primary_preferred, @secondary, @secondary_preferred]
+
+    @repl_cons.each do |client|
+      client.stubs(:pinned_pool).returns(nil)
+    end
+  end
+
+  def make_connection(mode = :primary, opts = {})
+    opts.merge!(:read => mode)
+    opts.merge!(:op_timeout => nil)
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, opts)
+    authenticate_client(client)
+  end
+
+  def query_count(connection)
+    connection['admin'].command({:serverStatus => 1})['opcounters']['query']
+  end
+
+  def assert_query_route(test_connection, type)
+    secondary = type == :secondary
+    authenticate_client(test_connection)
+    cursor = test_connection[TEST_DB]['test-sets'].find
+    assert_nothing_raised do
+      cursor.next
+    end
+    pool = cursor.instance_variable_get("@pool")
+    assert_equal secondary, secondary?(MongoClient.new(pool.host, pool.port))
+  end
+
+  def secondary?(client)
+    client['admin'].command(:isMaster => 1)['secondary']
+  end
+end

data/test/replica_set/refresh_test.rb

@@ -0,0 +1,211 @@
+# 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 ReplicaSetRefreshTest < Test::Unit::TestCase
+
+  def setup
+    ensure_cluster(:rs)
+  end
+
+  def test_connect_and_manual_refresh_with_secondary_down
+    num_secondaries = @rs.secondaries.size
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => false,
+                                       :op_timeout => TEST_OP_TIMEOUT)
+    authenticate_client(client)
+
+    assert_equal num_secondaries, client.secondaries.size
+    assert client.connected?
+    assert_equal client.read_pool, client.primary_pool
+    old_refresh_version = client.refresh_version
+
+    @rs.stop_secondary
+
+    client.refresh
+    assert_equal num_secondaries - 1, client.secondaries.size
+    assert client.connected?
+    assert_equal client.read_pool, client.primary_pool
+    assert client.refresh_version > old_refresh_version
+    old_refresh_version = client.refresh_version
+
+    # Test no changes after restart until manual refresh
+    @rs.restart
+    assert_equal num_secondaries - 1, client.secondaries.size
+    assert client.connected?
+    assert_equal client.read_pool, client.primary_pool
+    assert_equal client.refresh_version, old_refresh_version
+
+    # Refresh and ensure state
+    client.refresh
+    assert_equal num_secondaries, client.secondaries.size
+    assert client.connected?
+    assert_equal client.read_pool, client.primary_pool
+    assert client.refresh_version > old_refresh_version
+  end
+
+  def test_automated_refresh_with_secondary_down
+    num_secondaries = @rs.secondaries.size
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
+      :refresh_interval => 1, :refresh_mode => :sync, :read => :secondary_preferred,
+      :op_timeout => TEST_OP_TIMEOUT)
+    authenticate_client(client)
+
+    # Ensure secondaries are all recognized by client and client is connected
+    assert_equal num_secondaries, client.secondaries.size
+    assert client.connected?
+    assert client.secondary_pools.include?(client.read_pool)
+    pool = client.read_pool
+
+    @rs.member_by_name(pool.host_string).stop
+    sleep(2)
+
+    old_refresh_version = client.refresh_version
+    # Trigger synchronous refresh
+    client[TEST_DB]['rs-refresh-test'].find_one
+
+    assert client.connected?
+    assert client.refresh_version > old_refresh_version
+    assert_equal num_secondaries - 1, client.secondaries.size
+    assert client.secondary_pools.include?(client.read_pool)
+    assert_not_equal pool, client.read_pool
+
+    # Restart nodes and ensure refresh interval has passed
+    @rs.restart
+    sleep(2)
+
+    old_refresh_version = client.refresh_version
+    # Trigger synchronous refresh
+    client[TEST_DB]['rs-refresh-test'].find_one
+
+    assert client.connected?
+    assert client.refresh_version > old_refresh_version,
+      "Refresh version hasn't changed."
+    assert_equal num_secondaries, client.secondaries.size
+      "No secondaries have been added."
+    assert_equal num_secondaries, client.secondary_pools.size
+  end
+
+  def test_concurrent_refreshes
+    factor = 5
+    nthreads = factor * 10
+    threads = []
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :refresh_mode => :sync,
+                                       :refresh_interval => 1, :op_timeout => TEST_OP_TIMEOUT)
+    authenticate_client(client)
+
+    nthreads.times do |i|
+      threads << Thread.new do
+        # force a connection failure every couple of threads that causes a refresh
+        if i % factor == 0
+          cursor = client[TEST_DB]['rs-refresh-test'].find
+          cursor.stubs(:checkout_socket_from_connection).raises(ConnectionFailure)
+          begin
+            cursor.next
+          rescue => ex
+            raise ex unless ex.class == ConnectionFailure
+            next
+          end
+        else
+          # synchronous refreshes will happen every couple of find_ones
+          cursor = client[TEST_DB]['rs-refresh-test'].find_one
+        end
+      end
+    end
+
+    threads.each do |t|
+      t.join
+    end
+  end
+
+  def test_manager_recursive_locking
+  # See RUBY-775
+  # This tests that there isn't recursive locking when a pool manager reconnects
+  # to all replica set members. The bug in RUBY-775 occurred because the same lock
+  # acquired in order to connect the pool manager was used to read the pool manager's
+  # state.
+    client = MongoReplicaSetClient.from_uri(@uri)
+
+    cursor = client[TEST_DB]['rs-refresh-test'].find
+    client.stubs(:receive_message).raises(ConnectionFailure)
+    client.manager.stubs(:refresh_required?).returns(true)
+    client.manager.stubs(:check_connection_health).returns(true)
+    assert_raise ConnectionFailure do
+       cursor.next
+    end
+  end
+
+  def test_ping_with_op_timeout
+    [nil, 10].each do |op_timeout|
+      client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :op_timeout => op_timeout)
+      pool = client.primary_pool
+      admin_db = pool.client['admin']
+      admin_db.expects(:command).with({:ping => 1}, :socket => pool.node.socket,
+                                      :timeout => op_timeout || MongoClient::DEFAULT_OP_TIMEOUT).returns({'ok' => 1})
+      client.expects(:[]).with('admin').returns(admin_db)
+      assert pool.ping
+    end
+  end
+
+=begin
+  def test_automated_refresh_with_removed_node
+    client = MongoReplicaSetClient.new(@rs.repl_set_seeds,
+      :refresh_interval => 1, :refresh_mode => :sync)
+    authenticate_client(client)
+
+    num_secondaries = client.secondary_pools.length
+    old_refresh_version = client.refresh_version
+
+    n = @rs.repl_set_remove_node(2)
+    sleep(2)
+
+    rescue_connection_failure do
+      client[TEST_DB]['rs-refresh-test'].find_one
+    end
+
+    assert client.refresh_version > old_refresh_version,
+      "Refresh version hasn't changed."
+    assert_equal num_secondaries - 1, client.secondaries.length
+    assert_equal num_secondaries - 1, client.secondary_pools.length
+
+    #@rs.add_node(n)
+  end
+
+  def test_adding_and_removing_nodes
+    client = MongoReplicaSetClient.new(build_seeds(3),
+      :refresh_interval => 2, :refresh_mode => :sync)
+
+    @rs.add_node
+    sleep(4)
+    client[TEST_DB]['rs-refresh-test'].find_one
+
+    @conn2 = MongoReplicaSetClient.new(build_seeds(3),
+      :refresh_interval => 2, :refresh_mode => :sync)
+
+    assert @conn2.secondaries.sort == client.secondaries.sort,
+      "Second connection secondaries not equal to first."
+    assert_equal 3, client.secondary_pools.length
+    assert_equal 3, client.secondaries.length
+
+    config = client['admin'].command({:ismaster => 1})
+
+    @rs.remove_secondary_node
+    sleep(4)
+    config = client['admin'].command({:ismaster => 1})
+
+    assert_equal 2, client.secondary_pools.length
+    assert_equal 2, client.secondaries.length
+  end
+=end
+end

data/test/replica_set/replication_ack_test.rb

@@ -0,0 +1,95 @@
+# 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 ReplicaSetAckTest < Test::Unit::TestCase
+
+  def setup
+    ensure_cluster(:rs)
+    @client = MongoReplicaSetClient.from_uri(@uri, :op_timeout => TEST_OP_TIMEOUT)
+
+    @slave1 = MongoClient.new(
+      @client.secondary_pools.first.host,
+      @client.secondary_pools.first.port, :slave_ok => true)
+    authenticate_client(@slave1)
+
+    assert !@slave1.read_primary?
+
+    @db = @client.db(TEST_DB)
+    @db.drop_collection("test-sets")
+    @col = @db.collection("test-sets")
+  end
+
+  def teardown
+    @client.close if @client
+  end
+
+  def test_safe_mode_with_w_failure
+    assert_raise_error WriteConcernError do
+      @col.insert({:foo => 1}, :w => 4, :wtimeout => 1, :fsync => true)
+    end
+    assert_raise_error WriteConcernError do
+      @col.update({:foo => 1}, {:foo => 2}, :w => 4, :wtimeout => 1, :fsync => true)
+    end
+    assert_raise_error WriteConcernError do
+      @col.remove({:foo => 2}, :w => 4, :wtimeout => 1, :fsync => true)
+    end
+    if @client.server_version >= '2.5.4'
+      assert_raise_error WriteConcernError do
+        @col.insert({:foo => 3}, :w => "test-tag")
+      end
+    else # indistinguishable "errmsg"=>"exception: unrecognized getLastError mode: test-tag"
+      assert_raise_error OperationFailure do
+        @col.insert({:foo => 3}, :w => "test-tag")
+      end
+    end
+  end
+
+  def test_safe_mode_replication_ack
+    @col.insert({:baz => "bar"}, :w => 3, :wtimeout => 5000)
+
+    assert @col.insert({:foo => "0" * 5000}, :w => 3, :wtimeout => 5000)
+    assert_equal 2, @slave1[TEST_DB]["test-sets"].count
+
+    assert @col.update({:baz => "bar"}, {:baz => "foo"}, :w => 3, :wtimeout => 5000)
+    assert @slave1[TEST_DB]["test-sets"].find_one({:baz => "foo"})
+
+    assert @col.insert({:foo => "bar"}, :w => "majority")
+
+    assert @col.insert({:bar => "baz"}, :w => :majority)
+
+    assert @col.remove({}, :w => 3, :wtimeout => 5000)
+    assert_equal 0, @slave1[TEST_DB]["test-sets"].count
+  end
+
+  def test_last_error_responses
+    20.times { @col.insert({:baz => "bar"}) }
+    response = @db.get_last_error(:w => 3, :wtimeout => 5000)
+    assert response['ok'] == 1
+    assert response['lastOp']
+
+    @col.update({}, {:baz => "foo"})
+    response = @db.get_last_error(:w => 3, :wtimeout => 5000)
+    assert response['ok'] == 1
+    assert response['lastOp']
+
+    @col.remove({})
+    response =  @db.get_last_error(:w => 3, :wtimeout => 5000)
+    assert response['ok'] == 1
+    assert response['n'] == 20
+    assert response['lastOp']
+  end
+
+end

data/test/replica_set/ssl_test.rb

@@ -0,0 +1,32 @@
+# 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'
+require 'shared/ssl_shared'
+
+class ReplicaSetSSLTest < Test::Unit::TestCase
+  include Mongo
+  include SSLTests
+
+  SEEDS     = ['server:3000','server:3001','server:3002']
+  BAD_SEEDS = ['localhost:3000','localhost:3001','localhost:3002']
+
+  def setup
+    @client_class     = MongoReplicaSetClient
+    @uri_info         = SEEDS.join(',')
+    @connect_info     = SEEDS
+    @bad_connect_info = BAD_SEEDS
+  end
+
+end