mongo 1.12.5 → 2.0.0

data/spec/mongo/uri_spec.rb

@@ -0,0 +1,517 @@
+require 'spec_helper'
+
+describe Mongo::URI do
+  let(:scheme) { 'mongodb://' }
+  let(:uri) { described_class.new(string) }
+
+  describe '#initialize' do
+    context 'string is not uri' do
+      let(:string) { 'tyler' }
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::URI::Invalid)
+      end
+    end
+  end
+
+  describe '#servers' do
+    let(:string) { "#{scheme}#{servers}" }
+
+    context 'single server' do
+      let(:servers) { 'localhost' }
+
+      it 'returns an array with the parsed server' do
+        expect(uri.servers).to eq([servers])
+      end
+    end
+
+    context 'single server with port' do
+      let(:servers) { 'localhost:27017' }
+
+      it 'returns an array with the parsed server' do
+        expect(uri.servers).to eq([servers])
+      end
+    end
+
+    context 'numerical ipv4 server' do
+      let(:servers) { '127.0.0.1' }
+
+      it 'returns an array with the parsed server' do
+        expect(uri.servers).to eq([servers])
+      end
+    end
+
+    context 'numerical ipv6 server' do
+      let(:servers) { '[::1]:27107' }
+
+      it 'returns an array with the parsed server' do
+        expect(uri.servers).to eq([servers])
+      end
+    end
+
+    context 'unix socket server' do
+      let(:servers) { '/tmp/mongodb-27017.sock' }
+
+      it 'returns an array with the parsed server' do
+        expect(uri.servers).to eq([servers])
+      end
+    end
+
+    context 'multiple servers' do
+      let(:servers) { 'localhost,127.0.0.1' }
+
+      it 'returns an array with the parsed servers' do
+        expect(uri.servers).to eq(servers.split(','))
+      end
+    end
+
+    context 'multiple servers with ports' do
+      let(:servers) { '127.0.0.1:27107,localhost:27018' }
+
+      it 'returns an array with the parsed servers' do
+        expect(uri.servers).to eq(servers.split(','))
+      end
+    end
+  end
+
+  describe '#client_options' do
+
+    let(:db)          { TEST_DB }
+    let(:servers)     { 'localhost' }
+    let(:string)      { "#{scheme}#{credentials}@#{servers}/#{db}" }
+    let(:user)        { 'tyler' }
+    let(:password)    { 's3kr4t' }
+    let(:credentials) { "#{user}:#{password}" }
+
+    let(:options) do
+      uri.client_options
+    end
+
+    it 'includes the database in the options' do
+      expect(options[:database]).to eq(TEST_DB)
+    end
+
+    it 'includes the credentials in the options' do
+      expect(options[:user]).to eq(user)
+    end
+
+    it 'includes the options in the options' do
+      expect(options[:password]).to eq(password)
+    end
+  end
+
+  describe '#credentials' do
+    let(:servers)    { 'localhost' }
+    let(:string)   { "#{scheme}#{credentials}@#{servers}" }
+    let(:user)     { 'tyler' }
+
+    context 'username provided' do
+      let(:credentials) { "#{user}:" }
+
+      it 'returns the username' do
+        expect(uri.credentials[:user]).to eq(user)
+      end
+    end
+
+    context 'username and password provided' do
+      let(:password)    { 's3kr4t' }
+      let(:credentials) { "#{user}:#{password}" }
+
+      it 'returns the username' do
+        expect(uri.credentials[:user]).to eq(user)
+      end
+
+      it 'returns the password' do
+        expect(uri.credentials[:password]).to eq(password)
+      end
+    end
+  end
+
+  describe '#database' do
+    let(:servers)  { 'localhost' }
+    let(:string) { "#{scheme}#{servers}/#{db}" }
+    let(:db)     { TEST_DB }
+
+    context 'database provided' do
+      it 'returns the database name' do
+        expect(uri.database).to eq(TEST_DB)
+      end
+    end
+  end
+
+  describe '#options' do
+    let(:servers)  { 'localhost' }
+    let(:string) { "#{scheme}#{servers}/?#{options}" }
+
+    context 'when no options were provided' do
+      let(:string) { "#{scheme}#{servers}" }
+
+      it 'returns an empty hash' do
+        expect(uri.options).to be_empty
+      end
+    end
+
+    context 'write concern options provided' do
+
+      context 'numerical w value' do
+        let(:options) { 'w=1' }
+        let(:concern) { { :w => 1 } }
+
+        it 'sets the write concern options' do
+          expect(uri.options[:write]).to eq(concern)
+        end
+      end
+
+      context 'w=majority' do
+        let(:options) { 'w=majority' }
+        let(:concern) { { :w => :majority } }
+
+        it 'sets the write concern options' do
+          expect(uri.options[:write]).to eq(concern)
+        end
+      end
+
+      context 'journal' do
+        let(:options) { 'j=true' }
+        let(:concern) { { :j => true } }
+
+        it 'sets the write concern options' do
+          expect(uri.options[:write]).to eq(concern)
+        end
+      end
+
+      context 'fsync' do
+        let(:options) { 'fsync=true' }
+        let(:concern) { { :fsync => true } }
+
+        it 'sets the write concern options' do
+          expect(uri.options[:write]).to eq(concern)
+        end
+      end
+
+      context 'wtimeoutMS' do
+        let(:timeout) { 1234 }
+        let(:options) { "w=2&wtimeoutMS=#{timeout}" }
+        let(:concern) { { :w => 2, :timeout => timeout } }
+
+        it 'sets the write concern options' do
+          expect(uri.options[:write]).to eq(concern)
+        end
+      end
+    end
+
+    context 'read preference option provided' do
+      let(:options) { "readPreference=#{mode}" }
+
+      context 'primary' do
+        let(:mode) { 'primary' }
+        let(:read) { { :mode => :primary } }
+
+        it 'sets the read preference' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+
+      context 'primaryPreferred' do
+        let(:mode) { 'primaryPreferred' }
+        let(:read) { { :mode => :primary_preferred } }
+
+        it 'sets the read preference' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+
+      context 'secondary' do
+        let(:mode) { 'secondary' }
+        let(:read) { { :mode => :secondary } }
+
+        it 'sets the read preference' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+
+      context 'secondaryPreferred' do
+        let(:mode) { 'secondaryPreferred' }
+        let(:read) { { :mode => :secondary_preferred } }
+
+        it 'sets the read preference' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+
+      context 'nearest' do
+        let(:mode) { 'nearest' }
+        let(:read) { { :mode => :nearest } }
+
+        it 'sets the read preference' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+    end
+
+    context 'read preferece tags provided' do
+
+      context 'single read preference tag set' do
+        let(:options) do
+          'readPreferenceTags=dc:ny,rack:1'
+        end
+
+        let(:read) do
+          { :tag_sets => [{ :dc => 'ny', :rack => '1' }] }
+        end
+
+        it 'sets the read preference tag set' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+
+      context 'multiple read preference tag sets' do
+        let(:options) do
+          'readPreferenceTags=dc:ny&readPreferenceTags=dc:bos'
+        end
+
+        let(:read) do
+          { :tag_sets => [{ :dc => 'ny' }, { :dc => 'bos' }] }
+        end
+
+        it 'sets the read preference tag sets' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+    end
+
+    context 'replica set option provided' do
+      let(:rs_name) { TEST_SET }
+      let(:options) { "replicaSet=#{rs_name}" }
+
+      it 'sets the replica set option' do
+        expect(uri.options[:replica_set]).to eq(rs_name)
+      end
+    end
+
+    context 'auth mechanism provided' do
+      let(:options) { "authMechanism=#{mechanism}" }
+
+      context 'plain' do
+        let(:mechanism) { 'PLAIN' }
+        let(:auth) { { :mechanism => :plain } }
+
+        it 'sets the auth mechanism to :plain' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context 'mongodb-cr' do
+        let(:mechanism) { 'MONGODB-CR' }
+        let(:auth) { { :mechanism => :mongodb_cr } }
+
+        it 'sets the auth mechanism to :mongodb_cr' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context 'gssapi' do
+        let(:mechanism) { 'GSSAPI' }
+        let(:auth) { { :mechanism => :gssapi } }
+
+        it 'sets the auth mechanism to :gssapi' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+    end
+
+    context 'auth source provided' do
+      let(:options) { "authSource=#{source}" }
+
+      context 'regular db' do
+        let(:source) { 'foo' }
+        let(:auth) { { :source => 'foo' } }
+
+        it 'sets the auth source to the database' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context '$external' do
+        let(:source) { '$external' }
+        let(:auth) { { :source => :external } }
+
+        it 'sets the auth source to :external' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+    end
+
+    context 'auth mechanism properties provided' do
+
+      context 'service_name' do
+        let(:options) do
+          "authMechanismProperties=SERVICE_NAME:#{service_name}"
+        end
+
+        let(:service_name) { 'foo' }
+        let(:auth) do
+          { auth_mech_properties: { service_name: service_name } }
+        end
+
+        it 'sets the auth mechanism properties' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context 'canonicalize_host_name' do
+        let(:options) do
+          "authMechanismProperties=CANONICALIZE_HOST_NAME:#{canonicalize_host_name}"
+        end
+
+        let(:canonicalize_host_name) { 'true' }
+        let(:auth) do
+          { auth_mech_properties: { canonicalize_host_name: true } }
+        end
+
+        it 'sets the auth mechanism properties' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context 'service_realm' do
+        let(:options) do
+          "authMechanismProperties=SERVICE_REALM:#{service_realm}"
+        end
+
+        let(:service_realm) { 'dumdum' }
+        let(:auth) do
+          { auth_mech_properties: { service_realm: service_realm } }
+        end
+
+        it 'sets the auth mechanism properties' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context 'multiple properties' do
+        let(:options) do
+          "authMechanismProperties=SERVICE_REALM:#{service_realm}," +
+            "CANONICALIZE_HOST_NAME:#{canonicalize_host_name}," +
+            "SERVICE_NAME:#{service_name}"
+        end
+
+        let(:service_name) { 'foo' }
+        let(:canonicalize_host_name) { 'true' }
+        let(:service_realm) { 'dumdum' }
+
+        let(:auth) do
+          { auth_mech_properties: { service_name: service_name,
+                                    canonicalize_host_name: true,
+                                    service_realm: service_realm } }
+        end
+
+        it 'sets the auth mechanism properties' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+    end
+
+    context 'connectTimeoutMS' do
+      let(:options) { "connectTimeoutMS=4567" }
+
+      it 'sets the the connect timeout' do
+        expect(uri.options[:connect_timeout]).to eq(4.567)
+      end
+    end
+
+    context 'socketTimeoutMS' do
+      let(:options) { "socketTimeoutMS=8910" }
+
+      it 'sets the socket timeout' do
+        expect(uri.options[:socket_timeout]).to eq(8.910)
+      end
+    end
+
+    context 'when providing serverSelectionTimeoutMS' do
+
+      let(:options) { "serverSelectionTimeoutMS=3561" }
+
+      it 'sets the the connect timeout' do
+        expect(uri.options[:server_selection_timeout]).to eq(3.561)
+      end
+    end
+
+    context 'when providing localThresholdMS' do
+
+      let(:options) { "localThresholdMS=3561" }
+
+      it 'sets the the connect timeout' do
+        expect(uri.options[:local_threshold]).to eq(3.561)
+      end
+    end
+
+    context 'when providing maxPoolSize' do
+
+      let(:max_pool_size) { 10 }
+      let(:options) { "maxPoolSize=#{max_pool_size}" }
+
+      it 'sets the max pool size option' do
+        expect(uri.options[:max_pool_size]).to eq(max_pool_size)
+      end
+    end
+
+    context 'when providing minPoolSize' do
+
+      let(:min_pool_size) { 5 }
+      let(:options) { "minPoolSize=#{min_pool_size}" }
+
+      it 'sets the min pool size option' do
+        expect(uri.options[:min_pool_size]).to eq(min_pool_size)
+      end
+    end
+
+    context 'when providing waitQueueTimeoutMS' do
+
+      let(:wait_queue_timeout) { 500 }
+      let(:options) { "waitQueueTimeoutMS=#{wait_queue_timeout}" }
+
+      it 'sets the wait queue timeout option' do
+        expect(uri.options[:wait_queue_timeout]).to eq(0.5)
+      end
+    end
+
+    context 'ssl' do
+      let(:options) { "ssl=#{ssl}" }
+
+      context 'true' do
+        let(:ssl) { true }
+
+        it 'sets the ssl option to true' do
+          expect(uri.options[:ssl]).to be true
+        end
+      end
+
+      context 'false' do
+        let(:ssl) { false }
+
+        it 'sets the ssl option to false' do
+          expect(uri.options[:ssl]).to be false
+        end
+      end
+    end
+
+    context 'grouped and non-grouped options provided' do
+      let(:options) { 'w=1&ssl=true' }
+
+      it 'do not overshadow top level options' do
+        expect(uri.options).not_to be_empty
+      end
+    end
+
+    context 'when an invalid option is provided' do
+
+      let(:options) { 'iDontKnow=10' }
+
+      it 'raises an exception' do
+        expect {
+          uri.options
+        }.to raise_error(Mongo::URI::InvalidOption)
+      end
+    end
+  end
+end

data/spec/mongo/write_concern/acknowledged_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Mongo::WriteConcern::Acknowledged do
+
+  describe '#get_last_error' do
+
+    let(:get_last_error) do
+      concern.get_last_error
+    end
+
+    context 'when the options are symbols' do
+
+      let(:concern) do
+        described_class.new(:w => :majority)
+      end
+
+      it 'converts the values to strings' do
+        expect(get_last_error).to eq(:getlasterror => 1, :w => 'majority')
+      end
+    end
+
+    context 'when the options are strings' do
+
+      let(:concern) do
+        described_class.new(:w => 'majority')
+      end
+
+      it 'keeps the values as strings' do
+        expect(get_last_error).to eq(:getlasterror => 1, :w => 'majority')
+      end
+    end
+
+    context 'when the options are numbers' do
+
+      let(:concern) do
+        described_class.new(:w => 3)
+      end
+
+      it 'keeps the values as numbers' do
+        expect(get_last_error).to eq(:getlasterror => 1, :w => 3)
+      end
+    end
+  end
+end

data/spec/mongo/write_concern/unacknowledged_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Mongo::WriteConcern::Unacknowledged do
+
+  let(:concern) do
+    described_class.new(:w => 0)
+  end
+
+  describe '#get_last_error' do
+
+    it 'returns nil' do
+      expect(concern.get_last_error).to be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,133 @@
+if RUBY_VERSION > '1.9' && RUBY_VERSION < '2.2'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    # report groups
+    add_group 'Wire Protocol', 'lib/mongo/protocol'
+    # filters
+    add_filter 'tasks'
+    add_filter 'spec'
+    add_filter 'bin'
+  end
+end
+
+require 'mongo'
+
+require 'support/travis'
+require 'support/matchers'
+require 'support/authorization'
+require 'support/server_discovery_and_monitoring'
+require 'support/server_selection_rtt'
+require 'support/server_selection'
+require 'support/crud'
+
+Mongo::Logger.logger = Logger.new($stdout)
+Mongo::Logger.logger.level = Logger::INFO
+
+RSpec.configure do |config|
+  config.color     = true
+  config.fail_fast = true unless ENV['CI'] || ENV['JENKINS_HOME']
+  config.formatter = 'documentation'
+  config.include(Authorization)
+
+  config.before(:suite) do
+
+    begin
+      # Create the root user administrator as the first user to be added to the
+      # database. This user will need to be authenticated in order to add any
+      # more users to any other databases.
+      ADMIN_UNAUTHORIZED_CLIENT.database.users.create(ROOT_USER)
+    rescue Exception => e
+    end
+    begin
+      # Adds the test user to the test database with permissions on all
+      # databases that will be used in the test suite.
+      ADMIN_AUTHORIZED_CLIENT.database.users.create(TEST_USER)
+    rescue Exception => e
+      unless write_command_enabled?
+        # If we are on versions less than 2.6, we need to create a user for
+        # each database, since the users are not stored in the admin database
+        # but in the system.users collection on the datbases themselves. Also,
+        # roles in versions lower than 2.6 can only be strings, not hashes.
+        begin ROOT_AUTHORIZED_CLIENT.database.users.create(TEST_READ_WRITE_USER); rescue; end
+      end
+    end
+  end
+end
+
+TEST_SET = 'ruby-driver-rs'
+COVERAGE_MIN = 90
+CURRENT_PATH = File.expand_path(File.dirname(__FILE__))
+SERVER_DISCOVERY_TESTS = Dir.glob("#{CURRENT_PATH}/support/sdam/**/*.yml")
+SERVER_SELECTION_RTT_TESTS = Dir.glob("#{CURRENT_PATH}/support/server_selection/rtt/*.yml")
+SERVER_SELECTION_TESTS = Dir.glob("#{CURRENT_PATH}/support/server_selection/selection/**/*.yml")
+CRUD_TESTS = Dir.glob("#{CURRENT_PATH}/support/crud_tests/**/*.yml")
+
+# Determine whether the test clients are connecting to a standlone.
+#
+# @since 2.0.0
+def standalone?
+  $mongo_client ||= initialize_scanned_client!
+  $standalone ||= $mongo_client.cluster.standalone?
+end
+
+# Determine whether the test clients are connecting to a replica set.
+#
+# @since 2.0.0
+def replica_set?
+  $mongo_client ||= initialize_scanned_client!
+  $replica_set ||= $mongo_client.cluster.replica_set?
+end
+
+# Determine whether the test clients are connecting to a sharded cluster.
+#
+# @since 2.0.0
+def sharded?
+  $mongo_client ||= initialize_scanned_client!
+  $sharded ||= $mongo_client.cluster.sharded?
+end
+
+# For instances where behaviour is different on different versions, we need to
+# determine in the specs if we are 2.6 or higher.
+#
+# @since 2.0.0
+def write_command_enabled?
+  $mongo_client ||= initialize_scanned_client!
+  $write_command_enabled ||= $mongo_client.cluster.servers.first.features.write_command_enabled?
+end
+
+# For instances where behaviour is different on different versions, we need to
+# determine in the specs if we are 2.7 or higher.
+#
+# @since 2.0.0
+def list_command_enabled?
+  $mongo_client ||= initialize_scanned_client!
+  $list_command_enabled ||= $mongo_client.cluster.servers.first.features.list_indexes_enabled?
+end
+
+alias :scram_sha_1_enabled? :list_command_enabled?
+
+# Depending on whether write commands are enabled, there are different documents that
+# are guaranteed to cause a delete failure.
+#
+# @since 2.0.0
+def failing_delete_doc
+  write_command_enabled? ? { q: { '$set' => { a: 1 } }, limit: 0 } :
+                           { que: { field: 'test' } }
+end
+
+# Initializes a basic scanned client to do an ismaster check.
+#
+# @since 2.0.0
+def initialize_scanned_client!
+  Mongo::Client.new(ADDRESSES, database: TEST_DB, connect: CONNECT)
+end
+
+# require all shared examples
+Dir['./spec/support/shared/*.rb'].sort.each { |file| require file }