mongo 1.12.5 → 2.0.0

data/test/shared/authentication/sasl_plain_shared.rb

@@ -1,96 +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.
-
-module SASLPlainTests
-
-  # Tests for the PLAIN (LDAP) Authentication Mechanism.
-  #
-  # Note: These tests will be skipped automatically unless the test environment
-  # has been configured.
-  #
-  # In order to run these tests, set the following environment variables:
-  #
-  #   export MONGODB_SASL_HOST='server.domain.com'
-  #   export MONGODB_SASL_USER='application%2Fuser%40example.com'
-  #   export MONGODB_SASL_PASS='password'
-  #
-  #   # optional (defaults to '$external')
-  #   export MONGODB_SASL_SOURCE='source_database'
-  #
-  if ENV.key?('MONGODB_SASL_HOST') && ENV.key?('MONGODB_SASL_USER') && ENV.key?('MONGODB_SASL_PASS')
-
-    def test_plain_authenticate
-      replica_set = @client.class.name == 'Mongo::MongoReplicaSetClient'
-
-      # TODO: Remove this once we have a replica set configured for SASL in CI
-      return if ENV.key?('CI') && replica_set
-
-      host   = replica_set ? [ENV['MONGODB_SASL_HOST']] : ENV['MONGODB_SASL_HOST']
-      client = @client.class.new(host)
-      source = ENV['MONGODB_SASL_SOURCE'] || '$external'
-      db     = client['test']
-
-      # should successfully authenticate
-      assert db.authenticate(ENV['MONGODB_SASL_USER'], ENV['MONGODB_SASL_PASS'], true, source, 'PLAIN')
-      assert client[source].logout
-
-      # should raise on missing password
-      ex = assert_raise Mongo::MongoArgumentError do
-        db.authenticate(ENV['MONGODB_SASL_USER'], nil, true, source, 'PLAIN')
-      end
-      assert_match /username and password are required/, ex.message
-
-      # should raise on invalid password
-      assert_raise Mongo::AuthenticationError do
-        db.authenticate(ENV['MONGODB_SASL_USER'], 'foo', true, source, 'PLAIN')
-      end
-    end
-
-    def test_plain_authenticate_from_uri
-      source = ENV['MONGODB_SASL_SOURCE'] || '$external'
-
-      uri    = "mongodb://#{ENV['MONGODB_SASL_USER']}:#{ENV['MONGODB_SASL_PASS']}@" +
-               "#{ENV['MONGODB_SASL_HOST']}/some_db?authSource=#{source}" +
-               "&authMechanism=PLAIN"
-
-      client = @client.class.from_uri(uri)
-      db     = client['test']
-
-      # should be able to checkout a socket (authentication gets applied)
-      assert socket = client.checkout_reader(:mode => :primary)
-      client[source].logout(:socket => socket)
-      client.checkin(socket)
-
-      uri = "mongodb://#{ENV['MONGODB_SASL_USER']}@#{ENV['MONGODB_SASL_HOST']}/" +
-            "some_db?authSource=#{source}&authMechanism=PLAIN"
-
-      # should raise for missing password
-      ex = assert_raise Mongo::MongoArgumentError do
-        client = @client.class.from_uri(uri)
-      end
-      assert_match /username and password are required/, ex.message
-
-      uri = "mongodb://#{ENV['MONGODB_SASL_USER']}:foo@#{ENV['MONGODB_SASL_HOST']}/" +
-            "some_db?authSource=#{source}&authMechanism=PLAIN"
-
-      # should raise for invalid password
-      client = @client.class.from_uri(uri)
-      assert_raise Mongo::AuthenticationError do
-        client.checkout_reader(:mode => :primary)
-      end
-    end
-
-  end
-
-end

data/test/shared/authentication/scram_shared.rb

@@ -1,92 +0,0 @@
-# Copyright (C) 2014 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 SCRAMTests
-
-  def setup_conversation
-    SecureRandom.expects(:base64).returns('NDA2NzU3MDY3MDYwMTgy')
-    @password = Digest::MD5.hexdigest("user:mongo:pencil")
-    @scram = Mongo::Authentication::SCRAM.new({ :username => 'user' }, @password)
-  end
-
-  def test_scram_authenticate
-    if @version.to_s > '2.7'
-      @client.clear_auths
-      assert @db.authenticate(TEST_USER, TEST_USER_PWD, nil, 'admin', 'SCRAM-SHA-1')
-    end
-  end
-
-  def test_scram_conversation_start
-    setup_conversation
-    command = @scram.start
-    assert_equal 1, command['saslStart']
-    assert_equal 'SCRAM-SHA-1', command['mechanism']
-    assert_equal 'n,,n=user,r=NDA2NzU3MDY3MDYwMTgy', command['payload'].to_s
-  end
-
-  def test_scram_conversation_continue
-    setup_conversation
-    payload = BSON::Binary.new(
-      'r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
-    )
-    reply = { 'conversationId' => 1, 'done' => false, 'payload' => payload, 'ok' => 1.0 }
-    command = @scram.continue(reply)
-    assert_equal 1, command['saslContinue']
-    assert_equal 1, command['conversationId']
-    assert_equal(
-      'c=biws,r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,p=qYUYNy6SQ9Jucq9rFA9nVgXQdbM=',
-      command['payload'].to_s
-    )
-  end
-
-  def test_scram_conversation_continue_with_invalid_nonce
-    setup_conversation
-    payload = BSON::Binary.new(
-      'r=NDA2NzU4MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
-    )
-    reply = { 'conversationId' => 1, 'done' => false, 'payload' => payload, 'ok' => 1.0 }
-    assert_raise_error Mongo::InvalidNonce do
-      @scram.continue(reply)
-    end
-  end
-
-  def test_scram_conversation_finalize
-    setup_conversation
-    continue_payload = BSON::Binary.new(
-      'r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
-    )
-    continue_reply = { 'conversationId' => 1, 'done' => false, 'payload' => continue_payload, 'ok' => 1.0 }
-    @scram.continue(continue_reply)
-    payload = BSON::Binary.new('v=gwo9E8+uifshm7ixj441GvIfuUY=')
-    reply = { 'conversationId' => 1, 'done' => false, 'payload' => payload, 'ok' => 1.0 }
-    command = @scram.finalize(reply)
-    assert_equal 1, command['saslContinue']
-    assert_equal 1, command['conversationId']
-    assert_equal '', command['payload'].to_s
-  end
-
-  def test_scram_conversation_finalize_with_invalid_server_signature
-    setup_conversation
-    continue_payload = BSON::Binary.new(
-      'r=NDA2NzU3MDY3MDYwMTgyt7/+IWaw1HaZZ5NmPJUTWapLpH2Gg+d8,s=AVvQXzAbxweH2RYDICaplw==,i=10000'
-    )
-    continue_reply = { 'conversationId' => 1, 'done' => false, 'payload' => continue_payload, 'ok' => 1.0 }
-    @scram.continue(continue_reply)
-    payload = BSON::Binary.new('v=LQ+8yhQeVL2a3Dh+TDJ7xHz4Srk=')
-    reply = { 'conversationId' => 1, 'done' => false, 'payload' => payload, 'ok' => 1.0 }
-    assert_raise_error Mongo::InvalidSignature do
-      @scram.finalize(reply)
-    end
-  end
-end

data/test/shared/ssl_shared.rb

@@ -1,235 +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.
-
-module SSLTests
-  include Mongo
-
-  MONGODB_X509_USERNAME = 'CN=client,OU=kerneluser,O=10Gen,L=New York City,ST=New York,C=US'
-  CERT_PATH             = "#{Dir.pwd}/test/fixtures/certificates/"
-  CLIENT_CERT           = "#{CERT_PATH}client.pem"
-  CLIENT_CERT_PASS      = "#{CERT_PATH}password_protected.pem"
-  CA_CERT               = "#{CERT_PATH}ca.pem"
-  PASS_PHRASE           = ENV['SSL_KEY_PASS_PHRASE']
-
-  def create_client(*args)
-    if @client_class == MongoClient
-      @client_class.new(*args[0], args[1])
-    else
-      @client_class.new(args[0], args[1])
-    end
-  end
-
-  # Requires MongoDB not built with SSL
-  #
-  def test_ssl_not_configured
-    assert_raise Mongo::ConnectionTimeoutError do
-      create_client(['localhost', 27017], :connect_timeout => 2, :ssl => true)
-    end
-  end
-
-  # This test doesn't connect, no server config required
-  def test_ssl_configuration
-    # raises when ssl=false and ssl opts specified
-    assert_raise MongoArgumentError do
-      create_client(@connect_info, :connect  => false,
-                                   :ssl      => false,
-                                   :ssl_cert => CLIENT_CERT)
-    end
-
-    # raises when ssl=nil and ssl opts specified
-    assert_raise MongoArgumentError do
-      create_client(@connect_info, :connect => false,
-                                   :ssl_key => CLIENT_CERT)
-    end
-
-    # raises when verify=true and no ca_cert
-    assert_raise MongoArgumentError do
-      create_client(@connect_info, :connect    => false,
-                                   :ssl        => true,
-                                   :ssl_key    => CLIENT_CERT,
-                                   :ssl_cert   => CLIENT_CERT,
-                                   :ssl_verify => true)
-    end
-
-    # raises when key passphrase is given without key file
-    assert_raise MongoArgumentError do
-      create_client(@connect_info, :connect             => false,
-                                   :ssl                 => true,
-                                   :ssl_key_pass_phrase => PASS_PHRASE)
-    end
-  end
-
-  # Requires MongoDB built with SSL and the following options:
-  #
-  # mongod --dbpath /path/to/data/directory --sslOnNormalPorts \
-  # --sslPEMKeyFile /path/to/server.pem \
-  # --sslCAFile /path/to/ca.pem \
-  # --sslCRLFile /path/to/crl.pem \
-  # --sslWeakCertificateValidation
-  #
-  # Make sure you have 'server' as an alias for localhost in /etc/hosts
-  #
-  def test_ssl_basic
-    client = create_client(@connect_info, :connect => false, :ssl => true)
-    assert client.connect
-  end
-
-  # Requires MongoDB built with SSL and the following options:
-  #
-  # mongod --dbpath /path/to/data/directory --sslOnNormalPorts \
-  # --sslPEMKeyFile /path/to/server.pem \
-  # --sslCAFile /path/to/ca.pem \
-  # --sslCRLFile /path/to/crl.pem
-  #
-  # Make sure you have 'server' as an alias for localhost in /etc/hosts
-  #
-  def test_ssl_with_cert
-    client = create_client(@connect_info, :connect  => false,
-                                          :ssl      => true,
-                                          :ssl_cert => CLIENT_CERT,
-                                          :ssl_key  => CLIENT_CERT)
-    assert client.connect
-  end
-
-  def test_ssl_with_peer_cert_validation
-    client = create_client(@connect_info, :connect     => false,
-                                          :ssl         => true,
-                                          :ssl_key     => CLIENT_CERT,
-                                          :ssl_cert    => CLIENT_CERT,
-                                          :ssl_verify  => true,
-                                          :ssl_ca_cert => CA_CERT)
-    assert client.connect
-  end
-
-  def test_ssl_peer_cert_validation_hostname_fail
-    client = create_client(@bad_connect_info, :connect     => false,
-                                              :ssl         => true,
-                                              :ssl_key     => CLIENT_CERT,
-                                              :ssl_cert    => CLIENT_CERT,
-                                              :ssl_verify  => true,
-                                              :ssl_ca_cert => CA_CERT)
-    assert_raise ConnectionFailure do
-      client.connect
-    end
-  end
-
-  # Requires MongoDB built with SSL and the following options:
-  #
-  # mongod --dbpath /path/to/data/directory --sslOnNormalPorts \
-  # --sslPEMKeyFile /path/to/password_protected.pem \
-  # --sslCAFile /path/to/ca.pem \
-  # --sslCRLFile /path/to/crl.pem
-  #
-  # Make sure you have 'server' as an alias for localhost in /etc/hosts.
-  # If SSL_KEY_PASS_PHRASE is not set as an environment variable,
-  # you will be prompted to enter a passphrase at runtime.
-  #
-  def test_ssl_with_key_pass_phrase
-    client = create_client(@connect_info, :connect             => false,
-                                          :ssl                 => true,
-                                          :ssl_cert            => CLIENT_CERT_PASS,
-                                          :ssl_key             => CLIENT_CERT_PASS,
-                                          :ssl_key_pass_phrase => PASS_PHRASE)
-    assert client.connect
-  end
-
-  def test_ssl_with_key_pass_phrase_fail
-    client = create_client(@connect_info, :connect             => false,
-                                          :ssl                 => true,
-                                          :ssl_cert            => CLIENT_CERT_PASS,
-                                          :ssl_key             => CLIENT_CERT_PASS,
-                                          :ssl_key_pass_phrase => "secret")
-    assert_raise OpenSSL::PKey::RSAError do
-      client.connect
-    end
-  end
-
-  # Requires mongod built with SSL and the following options:
-  #
-  # mongod --dbpath /path/to/data/directory --sslOnNormalPorts \
-  # --sslPEMKeyFile /path/to/server.pem \
-  # --sslCAFile /path/to/ca.pem \
-  # --sslCRLFile /path/to/crl_client_revoked.pem
-  #
-  # Make sure you have 'server' as an alias for localhost in /etc/hosts
-  #
-  def test_ssl_with_invalid_cert
-    assert_raise ConnectionFailure do
-      create_client(@connect_info, :ssl         => true,
-                                   :ssl_key     => CLIENT_CERT,
-                                   :ssl_cert    => CLIENT_CERT,
-                                   :ssl_verify  => true,
-                                   :ssl_ca_cert => CA_CERT)
-    end
-  end
-
-  # X509 Authentication Tests
-  #
-  # Requires MongoDB built with SSL and the following options:
-  #
-  # mongod --auth --dbpath /path/to/data/directory --sslOnNormalPorts \
-  # --sslPEMKeyFile /path/to/server.pem \
-  # --sslCAFile /path/to/ca.pem \
-  # --sslCRLFile /path/to/crl.pem
-  #
-  # Note that the cert requires username:
-  #   'CN=client,OU=kerneluser,O=10Gen,L=New York City,ST=New York,C=US'
-  #
-  def test_x509_authentication
-    mechanism = 'MONGODB-X509'
-
-    client    = create_client(@connect_info, :ssl => true,
-                                             :ssl_cert => CLIENT_CERT,
-                                             :ssl_key  => CLIENT_CERT)
-
-    return unless client.server_version > '2.5.2'
-
-    db       = client.db('$external')
-
-    # add user for test (enable auth)
-    roles    = [{:role => 'readWriteAnyDatabase', :db => 'admin'},
-                {:role => 'userAdminAnyDatabase', :db => 'admin'}]
-    db.add_user(MONGODB_X509_USERNAME, nil, false, :roles => roles)
-
-    assert db.authenticate(MONGODB_X509_USERNAME, nil, nil, nil, mechanism)
-    assert db.collection_names
-
-    assert db.logout
-    assert_raise Mongo::OperationFailure do
-      db.collection_names
-    end
-
-    # username and valid certificate don't match
-    assert_raise Mongo::AuthenticationError do
-      db.authenticate('test', nil, nil, nil, mechanism)
-    end
-
-    # username required
-    assert_raise Mongo::AuthenticationError do
-      db.authenticate(nil, nil, nil, nil, mechanism)
-    end
-
-    assert MongoClient.from_uri(
-      "mongodb://#{MONGODB_X509_USERNAME}@#{@uri_info}/?ssl=true;authMechanism=#{mechanism}",
-          :ssl_cert => CLIENT_CERT,
-          :ssl_key  => CLIENT_CERT)
-    assert db.authenticate(MONGODB_X509_USERNAME, nil, nil, nil, mechanism)
-    assert db.collection_names
-
-    # clean up and remove all users
-    db.command(:dropAllUsersFromDatabase => 1)
-    db.logout
-  end
-
-end

data/test/test_helper.rb

@@ -1,61 +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.
-
-# NOTE: on ruby <1.9 you need to run individual tests with 'bundle exec'
-
-unless RUBY_VERSION < '1.9' || ENV.key?('JENKINS_CI')
-  require 'simplecov'
-  require 'coveralls'
-
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-
-  SimpleCov.start do
-    add_group 'Driver', 'lib/mongo'
-    add_group 'BSON', 'lib/bson'
-
-    add_filter 'tasks'
-    add_filter 'test'
-    add_filter 'bin'
-  end
-end
-
-# required for at_exit, at_start hooks
-require 'test-unit'
-
-require 'test/unit'
-require 'shoulda'
-require 'mocha/setup'
-
-# cluster manager
-require 'tools/mongo_config'
-
-# For kerberos testing.
-begin
-  require 'mongo_kerberos'
-rescue LoadError; end
-
-# test helpers
-require 'helpers/general'
-require 'helpers/test_unit'
-
-# optional development and debug utilities
-begin
-  require 'pry-rescue'
-  require 'pry-nav'
-rescue LoadError
-  # failed to load, skipping pry
-end

data/test/threading/basic_test.rb

@@ -1,120 +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 ThreadingTest < Test::Unit::TestCase
-
-  include Mongo
-
-  def setup
-    @client = standard_connection(:pool_size => 10, :pool_timeout => 30)
-    @db = @client.db(TEST_DB)
-    @coll = @db.collection('thread-test-collection')
-    @coll.drop
-
-    collections = ['duplicate', 'unique']
-
-    collections.each do |coll_name|
-      coll = @db.collection(coll_name)
-      coll.drop
-      coll.insert("test" => "insert")
-      coll.insert("test" => "update")
-      instance_variable_set("@#{coll_name}", coll)
-    end
-
-    @unique.create_index("test", :unique => true)
-  end
-
-  def test_safe_update
-    threads = []
-    300.times do |i|
-      threads << Thread.new do
-        if i % 2 == 0
-          assert_raise Mongo::OperationFailure do
-            @unique.update({"test" => "insert"}, {"$set" => {"test" => "update"}})
-          end
-        else
-          @duplicate.update({"test" => "insert"}, {"$set" => {"test" => "update"}})
-          @duplicate.update({"test" => "update"}, {"$set" => {"test" => "insert"}})
-        end
-      end
-    end
-
-    threads.each {|thread| thread.join}
-  end
-
-  def test_safe_insert
-    threads = []
-    300.times do |i|
-      threads << Thread.new do
-        if i % 2 == 0
-          assert_raise Mongo::OperationFailure do
-            @unique.insert({"test" => "insert"})
-          end
-        else
-          @duplicate.insert({"test" => "insert"})
-        end
-      end
-    end
-
-    threads.each {|thread| thread.join}
-  end
-
-  def test_concurrent_find
-    n_threads = 50
-
-    1000.times do |i|
-      @coll.insert({ "x" => "a" })
-    end
-
-    threads = []
-    n_threads.times do |i|
-      threads << Thread.new do
-        sum = 0
-        @coll.find.to_a.size
-      end
-    end
-
-    thread_values = threads.map(&:value)
-    assert thread_values.all?{|v| v == 1000}
-    assert_equal thread_values.size, n_threads
-  end
-
-  def test_threading
-    @coll.drop
-    @coll = @db.collection('thread-test-collection')
-
-    docs = []
-    1000.times {|i| docs << {:x => i}}
-    @coll.insert(docs)
-
-    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