qa: new expectedFailure testcase method

The idea is to write:

  with self.expectedFailure(...): \

just before the statement that is expected to fail. Contrary to the existing
decorator, we want to:
- be sure that the test fails at the expected line;
- be able to remove an expectedFailure without touching the code around.

neo/tests/__init__.py

@@ -28,6 +28,7 @@ import weakref
 import MySQLdb
 import transaction
 
+from contextlib import contextmanager
 from ConfigParser import SafeConfigParser
 from cStringIO import StringIO
 try:
@@ -215,6 +216,14 @@ class NeoTestBase(unittest.TestCase):
             expected if isinstance(expected, str) else '|'.join(expected),
             '|'.join(pt._formatRows(sorted(pt.count_dict, key=key))))
 
+    @contextmanager
+    def expectedFailure(self, exception=AssertionError, regex=None):
+        with self.assertRaisesRegexp(exception, regex) as cm:
+            yield
+            raise _UnexpectedSuccess
+        # XXX: passing sys.exc_info() causes deadlocks
+        raise _ExpectedFailure((type(cm.exception), None, None))
+
 class NeoUnitTestBase(NeoTestBase):
     """ Base class for neo tests, implements common checks """
 

neo/tests/threaded/test.py

@@ -35,7 +35,7 @@ from neo.lib.handler import DelayEvent, EventHandler
 from neo.lib import logging
 from neo.lib.protocol import (CellStates, ClusterStates, NodeStates, NodeTypes,
     Packets, Packet, uuid_str, ZERO_OID, ZERO_TID, MAX_TID)
-from .. import expectedFailure, unpickle_state, Patch, TransactionalResource
+from .. import unpickle_state, Patch, TransactionalResource
 from . import ClientApplication, ConnectionFilter, LockLock, NEOCluster, \
     NEOThreadedTest, RandomConflictDict, ThreadId, with_cluster
 from neo.lib.util import add64, makeChecksum, p64, u64
@@ -175,9 +175,9 @@ class Test(NEOThreadedTest):
         with Patch(PCounterWithResolution, _p_resolveConflict=resolve):
             self.assertEqual(self._testUndoConflict(cluster, 1, 3).x, big)
 
-    @expectedFailure(POSException.ConflictError)
     @with_cluster()
     def testUndoConflictDuringStore(self, cluster):
+        with self.expectedFailure(POSException.ConflictError): \
         self._testUndoConflict(cluster, 1)
 
     def testStorageDataLock(self, dedup=False):
@@ -247,7 +247,8 @@ class Test(NEOThreadedTest):
         s.resetNode()
         storage.app.max_reconnection_to_master = 0
         self.assertRaises(NEOPrimaryMasterLost, storage.tpc_vote, t1)
-        expectedFailure(self.assertFalse)(s.dm.getOrphanList())
+        with self.expectedFailure(): \
+        self.assertFalse(s.dm.getOrphanList())
 
     @with_cluster(storage_count=1)
     def testDelayedUnlockInformation(self, cluster):
@@ -2636,8 +2637,8 @@ class Test(NEOThreadedTest):
             self.assertEqual(1, len(getStorageList()))
         with Patch(EventHandler, protocolError=lambda *_: sys.exit()):
             self.tic()
-        expectedFailure(self.assertEqual)(neoctl.getClusterState(),
-                                          ClusterStates.RUNNING)
+        with self.expectedFailure(): \
+        self.assertEqual(neoctl.getClusterState(), ClusterStates.RUNNING)
         self.assertEqual({1: NodeStates.RUNNING, 2: NodeStates.RUNNING},
             {x[2]: x[3] for x in neoctl.getNodeList(NodeTypes.STORAGE)})
 

neo/tests/threaded/testReplication.py

@@ -32,7 +32,7 @@ from neo.lib.connection import ClientConnection
 from neo.lib.protocol import CellStates, ClusterStates, Packets, \
     ZERO_OID, ZERO_TID, MAX_TID, uuid_str
 from neo.lib.util import add64, p64, u64
-from .. import expectedFailure, Patch, TransactionalResource
+from .. import Patch, TransactionalResource
 from . import ConnectionFilter, NEOCluster, NEOThreadedTest, \
     predictable_random, with_cluster
 from .test import PCounter, PCounterWithResolution # XXX
@@ -682,7 +682,8 @@ class ReplicationTests(NEOThreadedTest):
         s0.start()
         self.tic()
         self.assertEqual(2, s0.sqlCount('obj'))
-        expectedFailure(self.assertEqual)(2, count)
+        with self.expectedFailure(): \
+        self.assertEqual(2, count)
 
     @with_cluster(replicas=1)
     def testResumingReplication(self, cluster):