Merge pull request datastax#972 from datastax/python-fix-master-loop-tests

Python fix master loop tests

Author: mambocab

cassandra/io/asyncorereactor.py

@@ -237,7 +237,7 @@ def maybe_start(self):
                 self._loop_lock.release()
 
         if should_start:
-            self._thread = Thread(target=self._run_loop, name="cassandra_driver_event_loop")
+            self._thread = Thread(target=self._run_loop, name="asyncore_cassandra_driver_event_loop")
             self._thread.daemon = True
             self._thread.start()
 

cassandra/io/twistedreactor.py

@@ -128,7 +128,7 @@ def maybe_start(self):
         with self._lock:
             if not reactor.running:
                 self._thread = Thread(target=reactor.run,
-                                      name="cassandra_driver_event_loop",
+                                      name="cassandra_driver_twisted_event_loop",
                                       kwargs={'installSignalHandlers': False})
                 self._thread.daemon = True
                 self._thread.start()

tests/integration/standard/test_connection.py

@@ -18,11 +18,13 @@
     import unittest  # noqa
 
 from functools import partial
+import logging
 from six.moves import range
 import sys
 import threading
 from threading import Thread, Event
 import time
+from unittest import SkipTest
 
 from cassandra import ConsistencyLevel, OperationTimedOut
 from cassandra.cluster import NoHostAvailable, ConnectionShutdown, Cluster
@@ -43,6 +45,9 @@
     LibevConnection = None
 
 
+log = logging.getLogger(__name__)
+
+
 def setup_module():
     use_singledc()
 
@@ -394,10 +399,14 @@ def test_connect_timeout(self):
         self.assertTrue(exception_thrown)
 
     def test_subclasses_share_loop(self):
-        class C1(AsyncoreConnection):
+
+        if self.klass not in (AsyncoreConnection, LibevConnection):
+            raise SkipTest
+
+        class C1(self.klass):
             pass
 
-        class C2(AsyncoreConnection):
+        class C2(self.klass):
             pass
 
         clusterC1 = Cluster(connection_class=C1)
@@ -412,16 +421,18 @@ class C2(AsyncoreConnection):
 
 
 def get_eventloop_threads(name):
-    import threading
-    event_loops_threads = [thread for thread in threading.enumerate() if name == thread.name]
+    all_threads = list(threading.enumerate())
+    log.debug('all threads: {}'.format(all_threads))
+    log.debug('all names: {}'.format([thread.name for thread in all_threads]))
+    event_loops_threads = [thread for thread in all_threads if name == thread.name]
 
     return event_loops_threads
 
 
 class AsyncoreConnectionTests(ConnectionTests, unittest.TestCase):
 
     klass = AsyncoreConnection
-    event_loop_name = "cassandra_driver_event_loop"
+    event_loop_name = "asyncore_cassandra_driver_event_loop"
 
     def setUp(self):
         if is_monkey_patched():

tests/unit/io/test_asyncioreactor.py

@@ -1,33 +1,42 @@
-
 try:
     from cassandra.io.asyncioreactor import AsyncioConnection
     import asynctest
     ASYNCIO_AVAILABLE = True
 except (ImportError, SyntaxError):
+    AysncioConnection = None
     ASYNCIO_AVAILABLE = False
 
-from tests import is_monkey_patched
+from tests import is_monkey_patched, connection_class
 from tests.unit.io.utils import TimerCallback, TimerTestMixin
 
 from mock import patch
 
 import unittest
 import time
 
+skip_me = (is_monkey_patched() or
+           (not ASYNCIO_AVAILABLE) or
+           (connection_class is not AsyncioConnection))
+
 
+@unittest.skipIf(is_monkey_patched(), 'runtime is monkey patched for another reactor')
+@unittest.skipIf(connection_class is not AsyncioConnection,
+                 'not running asyncio tests; current connection_class is {}'.format(connection_class))
 @unittest.skipUnless(ASYNCIO_AVAILABLE, "asyncio is not available for this runtime")
 class AsyncioTimerTests(TimerTestMixin, unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        if is_monkey_patched() or not ASYNCIO_AVAILABLE:
+        if skip_me:
             return
         cls.connection_class = AsyncioConnection
         AsyncioConnection.initialize_reactor()
 
     @classmethod
     def tearDownClass(cls):
-        if ASYNCIO_AVAILABLE:
+        if skip_me:
+            return
+        if ASYNCIO_AVAILABLE and AsyncioConnection._loop:
             AsyncioConnection._loop.stop()
 
     @property
@@ -39,6 +48,8 @@ def _timers(self):
         raise RuntimeError('no TimerManager for AsyncioConnection')
 
     def setUp(self):
+        if skip_me:
+            return
         socket_patcher = patch('socket.socket')
         self.addCleanup(socket_patcher.stop)
         socket_patcher.start()