mongo 2.0.6 → 2.1.0.beta

data/spec/mongo/uri_spec.rb

@@ -129,11 +129,11 @@ describe Mongo::URI do
   describe '#database' do
     let(:servers)  { 'localhost' }
     let(:string) { "#{scheme}#{servers}/#{db}" }
-    let(:db)     { TEST_DB }
+    let(:db)     { 'auth-db' }
 
     context 'database provided' do
       it 'returns the database name' do
-        expect(uri.database).to eq(TEST_DB)
+        expect(uri.database).to eq(db)
       end
     end
   end
@@ -171,7 +171,7 @@ describe Mongo::URI do
       end
 
       context 'journal' do
-        let(:options) { 'j=true' }
+        let(:options) { 'journal=true' }
         let(:concern) { { :j => true } }
 
         it 'sets the write concern options' do
@@ -248,7 +248,7 @@ describe Mongo::URI do
       end
     end
 
-    context 'read preferece tags provided' do
+    context 'read preference tags provided' do
 
       context 'single read preference tag set' do
         let(:options) do
@@ -505,12 +505,28 @@ describe Mongo::URI do
 
     context 'when an invalid option is provided' do
 
-      let(:options) { 'iDontKnow=10' }
+      let(:options) { 'invalidOption=10' }
 
-      it 'raises an exception' do
-        expect {
-          uri.options
-        }.to raise_error(Mongo::Error::InvalidURIOption)
+      let(:uri_options) do
+        uri.options
+      end
+
+      it 'does not raise an exception' do
+        expect(uri_options).to be_empty
+      end
+
+      context 'when an invalid option is combined with valid options' do
+
+        let(:options) { 'invalidOption=10&waitQueueTimeoutMS=500&ssl=true' }
+
+        it 'does not raise an exception' do
+          expect(uri_options).not_to be_empty
+        end
+
+        it 'sets the valid options' do
+          expect(uri_options[:wait_queue_timeout]).to eq(0.5)
+          expect(uri_options[:ssl]).to be true
+        end
       end
     end
   end

data/spec/spec_helper.rb

@@ -17,6 +17,20 @@ if RUBY_VERSION > '1.9' && RUBY_VERSION < '2.2'
   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")
+
+SSL_CERTS_DIR = "#{CURRENT_PATH}/support/certificates"
+CLIENT_PEM = "#{SSL_CERTS_DIR}/client.pem"
+CLIENT_PASSWORD_PEM = "#{SSL_CERTS_DIR}/password_protected.pem"
+CA_PEM = "#{SSL_CERTS_DIR}/ca.pem"
+CRL_PEM = "#{SSL_CERTS_DIR}/crl.pem"
+
 require 'mongo'
 
 require 'support/travis'
@@ -61,20 +75,6 @@ RSpec.configure do |config|
   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")
-
-SSL_CERTS_DIR = "#{CURRENT_PATH}/support/certificates"
-CLIENT_PEM = "#{SSL_CERTS_DIR}/client.pem"
-CLIENT_PASSWORD_PEM = "#{SSL_CERTS_DIR}/password_protected.pem"
-CA_PEM = "#{SSL_CERTS_DIR}/ca.pem"
-CRL_PEM = "#{SSL_CERTS_DIR}/crl.pem"
-
 # Determine whether the test clients are connecting to a standalone.
 #
 # @since 2.0.0
@@ -91,12 +91,13 @@ def replica_set?
   $replica_set ||= $mongo_client.cluster.replica_set?
 end
 
-# Determine whether the test clients are connecting to a sharded cluster.
+# Determine whether the test clients are connecting to a sharded cluster
+# or a single mongos.
 #
 # @since 2.0.0
 def sharded?
   $mongo_client ||= initialize_scanned_client!
-  $sharded ||= $mongo_client.cluster.sharded?
+  $sharded ||= ($mongo_client.cluster.sharded? || single_mongos?)
 end
 
 # Determine whether the single address provided is a replica set member.
@@ -107,7 +108,8 @@ end
 # @since 2.0.0
 def single_rs_member?
   $mongo_client ||= initialize_scanned_client!
-  single_seed? && $mongo_client.cluster.servers.first.replica_set_name
+  $single_rs_member ||= (single_seed? &&
+      $mongo_client.cluster.servers.first.replica_set_name)
 end
 
 # Determine whether the single address provided is a mongos.
@@ -118,7 +120,8 @@ end
 # @since 2.0.0
 def single_mongos?
   $mongo_client ||= initialize_scanned_client!
-  single_seed? && $mongo_client.cluster.servers.first.mongos?
+  $single_mongos ||= (single_seed? &&
+      $mongo_client.cluster.servers.first.mongos?)
 end
 
 # Determine whether a single address was provided.
@@ -146,10 +149,16 @@ def list_command_enabled?
   $list_command_enabled ||= $mongo_client.cluster.servers.first.features.list_indexes_enabled?
 end
 
-def testing_locally?
-  !(ENV['CI'] || ENV['JENKINS_HOME'])
+# Is the test suite running locally (not on Travis or Jenkins).
+#
+# @since 2.1.0
+def testing_ssl_locally?
+  running_ssl? && !(ENV['CI'] || ENV['JENKINS_CI'])
 end
 
+# Is the test suite running on SSL.
+#
+# @since 2.0.2
 def running_ssl?
   SSL
 end

data/spec/support/authorization.rb

@@ -50,13 +50,28 @@ WRITE_CONCERN = CONNECT[:connect] == :replica_set ? { w: ADDRESSES.size } : { w:
 # @since 2.0.3
 SSL = ENV['SSL_ENABLED'] == 'true'
 
+# SSL options.
+#
+# @since 2.1.0
+SSL_OPTIONS = {
+                  ssl: SSL,
+                  ssl_verify: false,
+                  ssl_cert:  CLIENT_PEM,
+                  ssl_key:  CLIENT_PEM
+                }
+
+# Base test options.
+#
+# @since 2.1.0
+BASE_OPTIONS = {
+                  max_pool_size: 1,
+                  write: WRITE_CONCERN
+               }
+
 # Options for test suite clients.
 #
 # @since 2.0.3
-TEST_OPTIONS = CONNECT.merge(max_pool_size: 1,
-                             write: WRITE_CONCERN,
-                             ssl: SSL,
-                             server_selection_timeout: 3)
+TEST_OPTIONS = BASE_OPTIONS.merge(CONNECT).merge(SSL_OPTIONS)
 
 # The root user name.
 #

data/spec/support/certificates/client.pem

@@ -32,13 +32,13 @@ Certificate:
                     6e:a7
                 Exponent: 65537 (0x10001)
         X509v3 extensions:
-            X509v3 Basic Constraints: 
+            X509v3 Basic Constraints:
                 CA:FALSE
-            Netscape Comment: 
+            Netscape Comment:
                 OpenSSL Generated Certificate
-            X509v3 Subject Key Identifier: 
+            X509v3 Subject Key Identifier:
                 4A:8B:EE:22:42:E6:F8:62:4C:86:38:8D:C5:78:95:98:C1:10:05:7C
-            X509v3 Authority Key Identifier: 
+            X509v3 Authority Key Identifier:
                 keyid:07:41:19:3A:9F:7E:C5:B7:22:4E:B7:BC:D5:DF:E4:FC:09:B8:64:16
 
     Signature Algorithm: sha1WithRSAEncryption

data/spec/support/crud/read.rb

@@ -93,30 +93,29 @@ module Mongo
         private
   
         def count(collection)
-          view = collection.find(filter)
           options = ARGUMENT_MAP.reduce({}) do |opts, (key, value)|
             opts.merge!(key => arguments[value]) if arguments[value]
             opts
           end
-          view.count(options)
+          collection.count(filter, options)
         end
   
         def aggregate(collection)
-          collection.find.tap do |view|
-            view = view.batch_size(batch_size) if batch_size
-          end.aggregate(pipeline).to_a
+          collection.aggregate(pipeline, options).to_a
         end
   
         def distinct(collection)
-          collection.find(filter).distinct(field_name)
+          collection.distinct(field_name, filter, options)
         end
   
         def find(collection)
-          view = collection.find(filter)
-          ARGUMENT_MAP.each do |key, value|
-            view = view.send(key, arguments[value]) if arguments[value]
+          collection.find(filter, options).to_a
+        end
+
+        def options
+          ARGUMENT_MAP.reduce({}) do |opts, (key, value)|
+            arguments[value] ? opts.merge!(key => arguments[value]) : opts
           end
-          view.to_a
         end
   
         def batch_size

data/spec/support/crud/write.rb

@@ -42,7 +42,9 @@ module Mongo
         # @since 2.0.0
         ARGUMENT_MAP = {
                         :sort => 'sort',
-                        :projection => 'projection'
+                        :projection => 'projection',
+                        :return_document => 'returnDocument',
+                        :upsert => 'upsert'
                        }
 
         # Operations that need a check if results on < 2.6 will match.
@@ -111,12 +113,12 @@ module Mongo
         private
   
         def delete_many(collection)
-          result = collection.find(filter).delete_many
+          result = collection.delete_many(filter)
           { 'deletedCount' => result.deleted_count }
         end
 
         def delete_one(collection)
-          result = collection.find(filter).delete_one
+          result = collection.delete_one(filter)
           { 'deletedCount' => result.deleted_count }
         end
 
@@ -137,48 +139,50 @@ module Mongo
         end
 
         def replace_one(collection)
-          result = collection.find(filter).replace_one(replacement, upsert: upsert)
+          result = collection.replace_one(filter, replacement, options)
           update_return_doc(result)
         end
 
         def update_many(collection)
-          result = collection.find(filter).update_many(update, upsert: upsert)
+          result = collection.update_many(filter, update, options)
           update_return_doc(result)
         end
 
         def update_one(collection)
-          result = collection.find(filter).update_one(update, upsert: upsert)
+          result = collection.update_one(filter, update, options)
           update_return_doc(result)
         end
 
         def find_one_and_delete(collection)
-          view = collection.find(filter)
-          ARGUMENT_MAP.each do |key, value|
-            view = view.send(key, arguments[value]) if arguments[value]
-          end
-          view.find_one_and_delete
+          collection.find_one_and_delete(filter, options)
         end
 
         def find_one_and_replace(collection)
-          view = collection.find(filter)
-          ARGUMENT_MAP.each do |key, value|
-            view = view.send(key, arguments[value]) if arguments[value]
-          end
-          view.find_one_and_replace(replacement, upsert: upsert, return_document: return_document)
+          collection.find_one_and_replace(filter, replacement, options)
         end
 
         def find_one_and_update(collection)
-          view = collection.find(filter)
-          ARGUMENT_MAP.each do |key, value|
-            view = view.send(key, arguments[value]) if arguments[value]
+          collection.find_one_and_update(filter, update, options)
+        end
+
+        def options
+          ARGUMENT_MAP.reduce({}) do |opts, (key, value)|
+            arguments[value] ? opts.merge!(key => send(key)) : opts
           end
-          view.find_one_and_update(update, upsert: upsert, return_document: return_document)
         end
 
         def replacement
           arguments['replacement']
         end
 
+        def sort
+          arguments['sort']
+        end
+
+        def projection
+          arguments['projection']
+        end
+
         def documents
           arguments['documents']
         end

data/spec/support/sdam/rs/equal_electionids.yml

@@ -0,0 +1,45 @@
+description: "New primary with equal electionId"
+
+uri: "mongodb://a/?replicaSet=rs"
+
+phases: [
+
+    # A and B claim to be primaries, with equal electionIds.
+    {
+        responses: [
+            ["a:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017"],
+                setName: "rs",
+                electionId: {"$oid": "000000000000000000000001"}
+            }],
+            ["b:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017"],
+                setName: "rs",
+                electionId: {"$oid": "000000000000000000000001"}
+            }]
+        ],
+
+        # No choice but to believe the latter response.
+        outcome: {
+            servers: {
+                "a:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId: ,
+                },
+                "b:27017": {
+                    type: "RSPrimary",
+                    setName: "rs",
+                    electionId: {"$oid": "000000000000000000000001"}
+                }
+            },
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs",
+            maxElectionId: {"$oid": "000000000000000000000001"}
+        }
+    }
+]

data/spec/support/sdam/rs/new_primary_new_electionid.yml

@@ -0,0 +1,98 @@
+description: "New primary with greater electionId"
+
+uri: "mongodb://a/?replicaSet=rs"
+
+phases: [
+
+    # Primary A is discovered and tells us about B.
+    {
+        responses: [
+            ["a:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017"],
+                setName: "rs",
+                electionId: {"$oid": "000000000000000000000001"}
+            }]
+        ],
+
+        outcome: {
+            servers: {
+                "a:27017": {
+                    type: "RSPrimary",
+                    setName: "rs",
+                    electionId: {"$oid": "000000000000000000000001"}
+                },
+                "b:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                }
+            },
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs",
+            maxElectionId: {"$oid": "000000000000000000000001"}
+        }
+    },
+
+    # B is elected.
+    {
+        responses: [
+            ["b:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017"],
+                setName: "rs",
+                electionId: {"$oid": "000000000000000000000002"}
+            }]
+        ],
+
+        outcome: {
+            servers: {
+                "a:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                },
+                "b:27017": {
+                    type: "RSPrimary",
+                    setName: "rs",
+                    electionId: {"$oid": "000000000000000000000002"}
+                }
+            },
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs",
+            maxElectionId: {"$oid": "000000000000000000000002"}
+        }
+    },
+
+    # A still claims to be primary but it's ignored.
+    {
+        responses: [
+            ["a:27017", {
+                ok: 1,
+                ismaster: true,
+                hosts: ["a:27017", "b:27017"],
+                setName: "rs",
+                electionId: {"$oid": "000000000000000000000001"}
+            }]
+        ],
+        outcome: {
+            servers: {
+                "a:27017": {
+                    type: "Unknown",
+                    setName: ,
+                    electionId:
+                },
+                "b:27017": {
+                    type: "RSPrimary",
+                    setName: "rs",
+                    electionId: {"$oid": "000000000000000000000002"}
+                }
+            },
+            topologyType: "ReplicaSetWithPrimary",
+            setName: "rs",
+            maxElectionId: {"$oid": "000000000000000000000002"}
+        }
+    }
+]