Fix wtimeout tests for MongoDB 2.8.

ajdavis · ajdavis · commit beaf1175b490 · 2014-11-13T15:48:45.000-05:00
diff --git a/test/test_bulk.py b/test/test_bulk.py
@@ -21,8 +21,14 @@
 from bson import InvalidDocument, SON
 from bson.py3compat import string_type
 from pymongo import MongoClient
+from pymongo.common import partition_node
 from pymongo.errors import BulkWriteError, InvalidOperation, OperationFailure
-from test import client_context, unittest, host, port, IntegrationTest
+from test import (client_context,
+                  unittest,
+                  host,
+                  port,
+                  IntegrationTest,
+                  SkipTest)
 from test.utils import oid_generated_on_client, remove_all_users
 
 
@@ -909,6 +915,36 @@ class TestBulkWriteConcern(BulkTestBase):
     def setUpClass(cls):
         super(TestBulkWriteConcern, cls).setUpClass()
         cls.w = client_context.w
+        cls.secondary = None
+        if cls.w > 1:
+            for member in client_context.ismaster['hosts']:
+                if member != client_context.ismaster['primary']:
+                    cls.secondary = MongoClient(*partition_node(member))
+                    break
+
+        # We tested wtimeout errors by specifying a write concern greater than
+        # the number of members, but in MongoDB 2.7.8+ this causes a different
+        # sort of error, "Not enough data-bearing nodes". In recent servers we
+        # use a failpoint to pause replication on a secondary.
+        cls.need_replication_stopped = client_context.version.at_least(2, 7, 8)
+
+    def cause_wtimeout(self, batch):
+        if self.need_replication_stopped:
+            if not client_context.test_commands_enabled:
+                raise SkipTest("Test commands must be enabled.")
+
+            self.secondary.admin.command('configureFailPoint',
+                                         'rsSyncApplyStop',
+                                         mode='alwaysOn')
+
+            try:
+                return batch.execute({'w': self.w, 'wtimeout': 1})
+            finally:
+                self.secondary.admin.command('configureFailPoint',
+                                             'rsSyncApplyStop',
+                                             mode='off')
+        else:
+            return batch.execute({'w': self.w + 1, 'wtimeout': 1})
 
     @client_context.require_version_min(1, 8, 2)
     def test_fsync_and_j(self):
@@ -932,7 +968,7 @@ def test_write_concern_failure_ordered(self):
         # Replication wtimeout is a 'soft' error.
         # It shouldn't stop batch processing.
         try:
-            batch.execute({'w': self.w + 1, 'wtimeout': 1})
+            self.cause_wtimeout(batch)
         except BulkWriteError as exc:
             result = exc.details
             self.assertEqual(exc.code, 65)
@@ -969,7 +1005,7 @@ def test_write_concern_failure_ordered(self):
             batch.insert({'a': 1})
             batch.insert({'a': 2})
             try:
-                batch.execute({'w': self.w + 1, 'wtimeout': 1})
+                self.cause_wtimeout(batch)
             except BulkWriteError as exc:
                 result = exc.details
                 self.assertEqual(exc.code, 65)
@@ -1011,7 +1047,7 @@ def test_write_concern_failure_unordered(self):
         # Replication wtimeout is a 'soft' error.
         # It shouldn't stop batch processing.
         try:
-            batch.execute({'w': self.w + 1, 'wtimeout': 1})
+            self.cause_wtimeout(batch)
         except BulkWriteError as exc:
             result = exc.details
             self.assertEqual(exc.code, 65)
@@ -1038,7 +1074,7 @@ def test_write_concern_failure_unordered(self):
             batch.insert({'a': 1})
             batch.insert({'a': 2})
             try:
-                batch.execute({'w': self.w + 1, 'wtimeout': 1})
+                self.cause_wtimeout(batch)
             except BulkWriteError as exc:
                 result = exc.details
                 self.assertEqual(exc.code, 65)
diff --git a/test/test_collection.py b/test/test_collection.py
@@ -1281,23 +1281,28 @@ def test_last_error_options(self):
         if client_context.setname:
             # client_context.w is the number of hosts in the replica set
             w = client_context.w + 1
-            self.assertRaises(WTimeoutError, self.db.test.save,
-                              {"x": 1}, w=w, wtimeout=1)
-            self.assertRaises(WTimeoutError, self.db.test.insert,
-                              {"x": 1}, w=w, wtimeout=1)
-            self.assertRaises(WTimeoutError, self.db.test.update,
-                              {"x": 1}, {"y": 2}, w=w, wtimeout=1)
-            self.assertRaises(WTimeoutError, self.db.test.remove,
-                              {"x": 1}, w=w, wtimeout=1)
 
-            try:
-                self.db.test.save({"x": 1}, w=w, wtimeout=1)
-            except WTimeoutError as exc:
-                # Just check that we set the error document. Fields
-                # vary by MongoDB version.
-                self.assertTrue(exc.details is not None)
-            else:
-                self.fail("WTimeoutError was not raised")
+            # MongoDB 2.8+ raises error code 100, CannotSatisfyWriteConcern,
+            # if w > number of members. Older versions just time out after 1 ms
+            # as if they had enough secondaries but some are lagging. They
+            # return an error with 'wtimeout': True and no code.
+            def wtimeout_err(f, *args, **kwargs):
+                try:
+                    f(*args, **kwargs)
+                except WTimeoutError as exc:
+                    self.assertIsNotNone(exc.details)
+                except OperationFailure as exc:
+                    self.assertIsNotNone(exc.details)
+                    self.assertEqual(100, exc.code,
+                                     "Unexpected error: %r" % exc)
+                else:
+                    self.fail("%s should have failed" % f)
+
+            coll = self.db.test
+            wtimeout_err(coll.save, {"x": 1}, w=w, wtimeout=1)
+            wtimeout_err(coll.insert, {"x": 1}, w=w, wtimeout=1)
+            wtimeout_err(coll.update, {"x": 1}, {"y": 2}, w=w, wtimeout=1)
+            wtimeout_err(coll.remove, {"x": 1}, w=w, wtimeout=1)
 
         # can't use fsync and j options together
         if client_context.version.at_least(1, 8, 2):
