mongo 1.3.0 → 1.12.5

data/test/sharded_cluster/basic_test.rb

@@ -0,0 +1,203 @@
+# 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 Cursor
+  public :construct_query_spec
+end
+
+class ShardedClusterBasicTest < Test::Unit::TestCase
+
+  def setup
+    ensure_cluster(:sc)
+    @document = { "name" => "test_user" }
+    @seeds    = @sc.mongos_seeds
+  end
+
+  # TODO member.primary? ==> true
+  def test_connect
+    @client = sharded_connection
+    assert @client.connected?
+    assert_equal(@seeds.size, @client.seeds.size)
+    probe(@seeds.size)
+    @client.close
+  end
+
+  def test_connect_from_standard_client
+    mongos = @seeds.first
+    @client = MongoClient.new(*mongos.split(':'))
+    assert @client.connected?
+    assert @client.mongos?
+    @client.close
+  end
+
+  def test_read_from_client
+    host, port = @seeds.first.split(':')
+    tags = [{:dc => "mongolia"}]
+    @client = MongoClient.new(host, port, {:read => :secondary, :tag_sets => tags})
+    assert @client.connected?
+    cursor = Cursor.new(@client[TEST_DB]['whatever'], {})
+    assert_equal cursor.construct_query_spec['$readPreference'], {:mode => 'secondary', :tags => tags}
+  end
+
+  def test_find_one_with_read_secondary
+    @client = sharded_connection(:read => :secondary)
+    @client[TEST_DB]["users"].insert([ @document ])
+    assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
+  end
+
+  def test_find_one_with_read_secondary_preferred
+    @client = sharded_connection(:read => :secondary_preferred)
+    @client[TEST_DB]["users"].insert([ @document ])
+    assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
+  end
+
+  def test_find_one_with_read_primary
+    @client = sharded_connection(:read => :primary)
+    @client[TEST_DB]["users"].insert([ @document ])
+    assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
+  end
+
+  def test_find_one_with_read_primary_preferred
+    @client = sharded_connection(:read => :primary_preferred)
+    @client[TEST_DB]["users"].insert([ @document ])
+    assert_equal @client[TEST_DB]['users'].find_one["name"], "test_user"
+  end
+
+  def test_read_from_sharded_client
+    tags = [{:dc => "mongolia"}]
+    @client = sharded_connection(:read => :secondary, :tag_sets => tags)
+    assert @client.connected?
+    cursor = Cursor.new(@client[TEST_DB]['whatever'], {})
+    assert_equal cursor.construct_query_spec['$readPreference'], {:mode => 'secondary', :tags => tags}
+  end
+
+  def test_hard_refresh
+    @client = sharded_connection
+    assert @client.connected?
+    @client.hard_refresh!
+    assert @client.connected?
+    @client.close
+  end
+
+  def test_reconnect
+    @client = sharded_connection
+    assert @client.connected?
+    router = @sc.servers(:routers).first
+    router.stop
+    probe(@seeds.size)
+    assert @client.connected?
+    @client.close
+  end
+
+  def test_mongos_failover
+    @client = sharded_connection(:refresh_interval => 5, :refresh_mode => :sync)
+    assert @client.connected?
+    # do a find to pin a pool
+    @client[TEST_DB]['test'].find_one
+    original_primary = @client.manager.primary
+    # stop the pinned member
+    @sc.member_by_name("#{original_primary[0]}:#{original_primary[1]}").stop
+    # assert that the client fails over to the next available mongos
+    assert_nothing_raised do
+      @client[TEST_DB]['test'].find_one
+    end
+
+    assert_not_equal original_primary, @client.manager.primary
+    assert @client.connected?
+    @client.close
+  end
+
+  def test_all_down
+    @client = sharded_connection
+    assert @client.connected?
+    @sc.servers(:routers).each{|router| router.stop}
+    assert_raises Mongo::ConnectionFailure do
+      probe(@seeds.size)
+    end
+    assert_false @client.connected?
+    @client.close
+  end
+
+  def test_cycle
+    @client = sharded_connection
+    assert @client.connected?
+    routers = @sc.servers(:routers)
+    while routers.size > 0 do
+      rescue_connection_failure do
+        probe(@seeds.size)
+      end
+      probe(@seeds.size)
+      router = routers.detect{|r| r.port == @client.manager.primary.last}
+      routers.delete(router)
+      router.stop
+    end
+    assert_raises Mongo::ConnectionFailure do
+      probe(@seeds.size)
+    end
+    assert_false @client.connected?
+    routers = @sc.servers(:routers).reverse
+    routers.each do |r|
+      r.start
+      @client.hard_refresh!
+      rescue_connection_failure do
+        probe(@seeds.size)
+      end
+      probe(@seeds.size)
+    end
+    @client.close
+  end
+
+  def test_wire_version_not_in_range
+    [
+      [Mongo::MongoClient::MAX_WIRE_VERSION+1, Mongo::MongoClient::MAX_WIRE_VERSION+1],
+      [Mongo::MongoClient::MIN_WIRE_VERSION-1, Mongo::MongoClient::MIN_WIRE_VERSION-1]
+    ].each do |min_wire_version_value, max_wire_version_value|
+      Mongo.module_eval <<-EVAL
+        class ShardingPoolManager
+          def max_wire_version
+            return #{max_wire_version_value}
+          end
+          def min_wire_version
+            return #{min_wire_version_value}
+          end
+        end
+      EVAL
+      @client = MongoShardedClient.new(@seeds, :connect => false)
+      assert !@client.connected?
+      assert_raises Mongo::ConnectionFailure do
+        @client.connect
+      end
+    end
+    Mongo.module_eval <<-EVAL
+      class ShardingPoolManager
+        attr_reader :max_wire_version, :min_wire_version
+      end
+    EVAL
+  end
+
+  private
+
+  def sharded_connection(opts={})
+    client = MongoShardedClient.new(@seeds, opts)
+    authenticate_client(client)
+  end
+
+  def probe(size)
+    authenticate_client(@client)
+    assert_equal(size, @client['config']['mongos'].find.to_a.size)
+  end
+end

data/test/shared/authentication/basic_auth_shared.rb

@@ -0,0 +1,260 @@
+# 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.
+
+module BasicAuthTests
+
+  def init_auth_basic
+    @test_user = 'bob'
+    @test_user_pwd = 'user'
+
+    # db user for cleanup (for pre-2.4)
+    @db.add_user('admin', 'cleanup', nil, :roles => [])
+  end
+
+  def teardown
+    return unless @client && @db
+    unless has_auth?(TEST_DB, TEST_USER)
+      @client[TEST_DB].authenticate(TEST_USER, TEST_USER_PWD)
+    end
+
+    if @client.server_version < '2.5'
+      @db['system.users'].remove
+    else
+      @db.command(:dropAllUsersFromDatabase => 1)
+    end
+  end
+
+  def remove_user(database, username, password)
+    database.authenticate(username, password) unless has_auth?(database.name, username)
+    database.remove_user(username)
+    database.logout
+  end
+
+  def has_auth?(db_name, username)
+    @client.auths.any? { |a| a[:source] == db_name && a[:username] == username }
+  end
+
+  def test_descriptive_mech_error
+    assert_raise_error Mongo::MongoArgumentError, Mongo::Authentication::MECHANISM_ERROR do
+      @db.authenticate('emily', nil, nil, nil, 'FAKE_MECHANISM')
+    end
+    assert_raise_error Mongo::MongoArgumentError, Mongo::Authentication::MECHANISM_ERROR do
+      uri = "mongodb://user:pwd@host:port/example?authSource=$external&authMechanism=FAKE_MECHANISM"
+      Mongo::MongoClient.from_uri(uri)
+    end
+  end
+
+  def test_add_remove_user
+    init_auth_basic
+
+    # add user
+    silently { @db.add_user(@test_user, @test_user_pwd) }
+    assert @db.authenticate(@test_user, @test_user_pwd)
+
+    # remove user
+    assert @db.remove_user(@test_user)
+  end
+
+  def test_update_user
+    init_auth_basic
+
+    # add user
+    silently { @db.add_user(@test_user, @test_user_pwd) }
+    assert @db.authenticate(@test_user, @test_user_pwd)
+    @db.logout
+
+    # update user
+    silently { @db.add_user(@test_user, 'updated') }
+    assert_raise Mongo::AuthenticationError do
+      @db.authenticate('bob', 'user')
+    end
+    assert @db.authenticate('bob', 'updated')
+  end
+
+  def test_remove_non_existent_user
+    init_auth_basic
+
+    if @client.server_version < '2.5'
+      assert_equal false, @db.remove_user('joe')
+    else
+      assert_raise Mongo::OperationFailure do
+        assert @db.remove_user('joe')
+      end
+    end
+  end
+
+  def test_authenticate
+    init_auth_basic
+    silently { @db.add_user(@test_user, @test_user_pwd) }
+    assert @db.authenticate(@test_user, @test_user_pwd)
+  end
+
+  def test_authenticate_non_existent_user
+    init_auth_basic
+    assert_raise Mongo::AuthenticationError do
+      @db.authenticate('frank', 'thetank')
+    end
+  end
+
+  def test_logout
+    init_auth_basic
+    silently { @db.add_user(@test_user, @test_user_pwd) }
+    assert @db.authenticate(@test_user, @test_user_pwd)
+    assert @db.logout
+  end
+
+  def test_authenticate_with_special_characters
+    init_auth_basic
+    silently { assert @db.add_user('foo:bar','@foo') }
+    assert @db.authenticate('foo:bar','@foo')
+  end
+
+  def test_authenticate_read_only
+    init_auth_basic
+    silently { @db.add_user(@test_user, @test_user_pwd, true) }
+    assert @db.authenticate(@test_user, @test_user_pwd)
+  end
+
+  def test_authenticate_with_connection_uri
+    init_auth_basic
+    silently { @db.add_user(@test_user, @test_user_pwd) }
+
+    uri    = "mongodb://#{@test_user}:#{@test_user_pwd}@#{@host_info}/#{@db.name}"
+    client = Mongo::URIParser.new(uri).connection
+
+    assert client
+    assert_equal client.auths.size, 1
+    assert client[@db.name]['auth_test'].count
+
+    auth = client.auths.first
+    assert_equal @db.name, auth[:db_name]
+    assert_equal @test_user, auth[:username]
+    assert_equal @test_user_pwd, auth[:password]
+  end
+
+  def test_socket_auths
+    init_auth_basic
+    # setup
+    db_a = @client[TEST_DB + '_a']
+    silently { db_a.add_user('user_a', 'password') }
+    assert db_a.authenticate('user_a', 'password')
+
+    db_b = @client[TEST_DB + '_b']
+    silently { db_b.add_user('user_b', 'password') }
+    assert db_b.authenticate('user_b', 'password')
+
+    db_c = @client[TEST_DB + '_c']
+    silently { db_c.add_user('user_c', 'password') }
+    assert db_c.authenticate('user_c', 'password')
+
+    # client auths should be applied to socket on checkout
+    socket = @client.checkout_reader(:mode => :primary)
+    assert_equal 4, socket.auths.size
+    assert_equal @client.auths, socket.auths
+    @client.checkin(socket)
+
+    # logout should remove saved auth on socket and client
+    assert db_b.logout
+    socket = @client.checkout_reader(:mode => :primary)
+    assert_equal 3, socket.auths.size
+    assert_equal @client.auths, socket.auths
+    @client.checkin(socket)
+
+    # clean-up
+    db_b.authenticate('user_b', 'password')
+    remove_user(db_a, 'user_a', 'password')
+    remove_user(db_b, 'user_b', 'password')
+    remove_user(db_c, 'user_c', 'password')
+  end
+
+  def test_default_roles_non_admin
+    init_auth_basic
+    @db.stubs(:command).returns({}, true)
+    @db.expects(:command).with do |command, cmd_opts|
+      command[:createUser] == @test_user
+      cmd_opts[:roles] == ['dbOwner'] if cmd_opts
+    end
+
+    silently { @db.add_user(@test_user, @test_user_pwd) }
+  end
+
+  def test_default_roles_non_admin_read_only
+    init_auth_basic
+    @db.stubs(:command).returns({}, true)
+    @db.expects(:command).with do |command, cmd_opts|
+      command[:createUser] == @test_user
+      cmd_opts[:roles] == ['read'] if cmd_opts
+    end
+    silently { @db.add_user(@test_user, @test_user_pwd, true) }
+  end
+
+  def test_delegated_authentication
+    return unless @client.server_version >= '2.4' && @client.server_version < '2.5'
+    with_auth(@client) do
+      init_auth_basic
+      # create user in test databases
+      accounts = @client[TEST_DB + '_accounts']
+      silently do
+        accounts.add_user('emily', 'password')
+        @db.add_user('emily', nil, nil, :roles => ['read'], :userSource => accounts.name)
+      end
+      @admin.logout
+
+      # validate that direct authentication is not allowed
+      assert_raise Mongo::AuthenticationError do
+        @db.authenticate('emily', 'password')
+      end
+
+      # validate delegated authentication
+      assert accounts.authenticate('emily', 'password')
+      assert @db.collection_names
+      accounts.logout
+      assert_raise Mongo::OperationFailure do
+        @db.collection_names
+      end
+
+      # validate auth using source database
+      @db.authenticate('emily', 'password', nil, accounts.name)
+      assert @db.collection_names
+      accounts.logout
+      assert_raise Mongo::OperationFailure do
+        @db.collection_names
+      end
+
+      remove_user(accounts, 'emily', 'password')
+    end
+  end
+
+  def test_update_user_to_read_only
+    with_auth(@client) do
+      init_auth_basic
+      silently { @db.add_user(@test_user, @test_user_pwd) }
+      @admin.logout
+      @db.authenticate(@test_user, @test_user_pwd)
+      @db['test'].insert({})
+      @db.logout
+
+      @admin.authenticate(TEST_USER, TEST_USER_PWD)
+      silently { @db.add_user('emily', 'password', true) }
+      @admin.logout
+
+      silently { @db.authenticate('emily', 'password') }
+      assert_raise Mongo::OperationFailure do
+        @db['test'].insert({})
+      end
+      @db.logout
+      @admin.authenticate(TEST_USER, TEST_USER_PWD)
+    end
+  end
+end

data/test/shared/authentication/bulk_api_auth_shared.rb

@@ -0,0 +1,249 @@
+# 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.0x
+#
+# 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.
+
+module BulkAPIAuthTests
+
+  include Mongo
+
+  def init_auth_bulk
+    # Set up the test db
+    @collection = @db["bulk-api-auth-tests"]
+
+    # db user can insert but not remove
+    res = BSON::OrderedHash.new
+    res[:db] = @db.name
+    res[:collection] = ""
+
+    cmd = BSON::OrderedHash.new
+    cmd[:createRole] = "insertOnly"
+    cmd[:privileges] = [{:resource => res, :actions => [ "insert", "find" ]}]
+    cmd[:roles] = []
+    @db.command(cmd)
+    @db.add_user('insertOnly', 'password', nil, :roles => ['insertOnly'])
+
+    # db user can insert and remove
+    cmd = BSON::OrderedHash.new
+    cmd[:createRole] = "insertAndRemove"
+    cmd[:privileges] = [{:resource => res, :actions => [ "insert", "remove", "find" ]}]
+    cmd[:roles] = []
+    @db.command(cmd)
+    @db.add_user('insertAndRemove', 'password', nil, :roles => ['insertAndRemove'])
+
+    @admin.logout
+  end
+
+  def clear_collection(collection)
+    @admin.authenticate(TEST_USER, TEST_USER_PWD)
+    collection.remove
+    @admin.logout
+  end
+
+  def teardown_bulk
+    remove_all_users_and_roles(@db)
+    remove_all_users_and_roles(@admin)
+  end
+
+  def remove_all_users_and_roles(database)
+    @admin.authenticate(TEST_USER, TEST_USER_PWD)
+    if @version < '2.5.3'
+      database['system.users'].remove
+    else
+      database.command({:dropAllRolesFromDatabase => 1})
+      # Don't delete the TEST_USER from the TEST_DB, it is needed for future tests
+      database.command({:dropAllUsersFromDatabase => 1}) unless database.name == TEST_DB
+    end
+    @admin.logout
+  end
+
+  def test_auth_no_error
+    return unless @version >= '2.5.3'
+    init_auth_bulk
+    with_write_commands_and_operations(@db.connection) do |wire_version|
+      clear_collection(@collection)
+      @db.authenticate('insertAndRemove', 'password')
+      bulk = @collection.initialize_ordered_bulk_op
+      bulk.insert({:a => 1})
+      bulk.find({:a => 1}).remove_one
+
+      result = bulk.execute
+      assert_match_document(
+          {
+              "ok" => 1,
+              "nInserted" => 1,
+              "nRemoved" => 1
+          }, result, "wire_version:#{wire_version}")
+      assert_equal 0, @collection.count
+      @db.logout
+    end
+    teardown_bulk
+  end
+
+  def test_auth_error
+    return unless @version >= '2.5.3'
+    init_auth_bulk
+    with_write_commands_and_operations(@db.connection) do |wire_version|
+      clear_collection(@collection)
+      @db.authenticate('insertOnly', 'password')
+      bulk = @collection.initialize_ordered_bulk_op
+      bulk.insert({:a => 1})
+      bulk.find({:a => 1}).remove
+      bulk.insert({:a => 2})
+
+      ex = assert_raise Mongo::BulkWriteError do
+        bulk.execute
+      end
+      result = ex.result
+      assert_match_document(
+          {
+              "ok" => 1,
+              "n" => 1,
+              "writeErrors" =>
+                  [{
+                       "index" => 1,
+                       "code" => 13,
+                       "errmsg" => /not authorized/
+                  }],
+              "code" => 65,
+              "errmsg" => "batch item errors occurred",
+              "nInserted" => 1
+           }, result, "wire_version:#{wire_version}")
+      assert_equal 1, @collection.count
+      @db.logout
+    end
+    teardown_bulk
+  end
+
+  def test_auth_error_unordered
+    return unless @version >= '2.5.3'
+    init_auth_bulk
+    with_write_commands_and_operations(@db.connection) do |wire_version|
+      clear_collection(@collection)
+      @db.authenticate('insertOnly', 'password')
+      bulk = @collection.initialize_unordered_bulk_op
+      bulk.insert({:a => 1})
+      bulk.find({:a => 1}).remove_one
+      bulk.insert({:a => 2})
+
+      ex = assert_raise Mongo::BulkWriteError do
+        bulk.execute
+      end
+      result = ex.result
+      assert_equal 1, result["writeErrors"].length
+      assert_equal 2, result["n"]
+      assert_equal 2, result["nInserted"]
+      assert_equal 2, @collection.count
+      @db.logout
+    end
+    teardown_bulk
+  end
+
+  def test_duplicate_key_with_auth_error
+    return unless @version >= '2.5.3'
+    init_auth_bulk
+    with_write_commands_and_operations(@db.connection) do |wire_version|
+      clear_collection(@collection)
+      @db.authenticate('insertOnly', 'password')
+      bulk = @collection.initialize_ordered_bulk_op
+      bulk.insert({:_id => 1, :a => 1})
+      bulk.insert({:_id => 1, :a => 2})
+      bulk.find({:a => 1}).remove_one
+
+      ex = assert_raise Mongo::BulkWriteError do
+        bulk.execute
+      end
+      result = ex.result
+      assert_match_document(
+          {
+              "ok" => 1,
+              "n" => 1,
+              "writeErrors" =>
+                  [{
+                       "index" => 1,
+                       "code" => 11000,
+                       "errmsg" => /duplicate key error/
+                  }],
+              "code" => 65,
+              "errmsg" => "batch item errors occurred",
+              "nInserted" => 1
+           }, result, "wire_version:#{wire_version}")
+      assert_equal 1, @collection.count
+      @db.logout
+    end
+    teardown_bulk
+  end
+
+  def test_duplicate_key_with_auth_error_unordered
+    return unless @version >= '2.5.3'
+    init_auth_bulk
+    with_write_commands_and_operations(@db.connection) do |wire_version|
+      clear_collection(@collection)
+      @db.authenticate('insertOnly', 'password')
+      bulk = @collection.initialize_unordered_bulk_op
+      bulk.insert({:_id => 1, :a => 1})
+      bulk.insert({:_id => 1, :a => 1})
+      bulk.find({:a => 1}).remove_one
+
+      ex = assert_raise Mongo::BulkWriteError do
+        bulk.execute
+      end
+      result = ex.result
+      assert_equal 2, result["writeErrors"].length
+      assert_equal 1, result["n"]
+      assert_equal 1, result["nInserted"]
+      assert_equal 1, @collection.count
+      @db.logout
+    end
+    teardown_bulk
+  end
+
+  def test_write_concern_error_with_auth_error
+    with_no_replication(@db.connection) do
+      return unless @version >= '2.5.3'
+      init_auth_bulk
+      with_write_commands_and_operations(@db.connection) do |wire_version|
+        clear_collection(@collection)
+        @db.authenticate('insertOnly', 'password')
+        bulk = @collection.initialize_ordered_bulk_op
+        bulk.insert({:_id => 1, :a => 1})
+        bulk.insert({:_id => 2, :a => 1})
+        bulk.find({:a => 1}).remove_one
+        
+        ex = assert_raise Mongo::BulkWriteError do
+          bulk.execute({:w => 2})
+        end
+        result = ex.result
+        
+        assert_match_document(
+            {
+                "ok" => 0,
+                "n" => 0,
+                "nInserted" => 0,
+                "writeErrors" =>
+                    [{
+                         "index" => 0,
+                         "code" => 2,
+                         "errmsg" => /'w' > 1/
+                    }],
+                "code" => 65,
+                "errmsg" => "batch item errors occurred"
+             }, result, "wire_version#{wire_version}")
+# Re-visit this when RUBY-731 is resolved:
+        assert (@collection.count == batch_commands?(wire_version) ? 0 : 1)
+        @db.logout
+      end
+      teardown_bulk
+    end
+  end
+
+end