Moved some utils module to fix import errors in unit tests

Author: aboudreault

tests/integration/__init__.py

@@ -166,6 +166,8 @@ def _get_dse_version_from_cass(cass_version):
     cv_string = os.getenv('CASSANDRA_VERSION', None)
     mcv_string = os.getenv('MAPPED_CASSANDRA_VERSION', None)
     try:
+        print(cv_string)
+        sasa
         cassandra_version = Version(cv_string)  # env var is set to test-dse for DDAC
     except:
         # fallback to MAPPED_CASSANDRA_VERSION

tests/integration/cloud/test_cloud.py

@@ -31,7 +31,7 @@
 from mock import patch
 
 from tests.integration import requirescloudproxy
-from tests.integration.util import wait_until_not_raised
+from tests.util import wait_until_not_raised
 from tests.integration.cloud import CloudProxyCluster, CLOUD_PROXY_SERVER
 
 DISALLOWED_CONSISTENCIES = [

tests/integration/long/test_topology_change.py

@@ -4,7 +4,7 @@
 from cassandra.policies import HostStateListener
 from tests.integration import PROTOCOL_VERSION, get_node, use_cluster, local
 from tests.integration.long.utils import decommission
-from tests.integration.util import wait_until
+from tests.util import wait_until
 
 
 class StateListener(HostStateListener):

tests/integration/simulacron/test_connection.py

@@ -27,8 +27,9 @@
 from cassandra.policies import HostStateListener, RoundRobinPolicy
 
 from tests import connection_class, thread_pool_executor_class
+from tests.util late
 from tests.integration import requiressimulacron, libevtest
-from tests.integration.util import assert_quiescent_pool_state, late
+from tests.integration.util import assert_quiescent_pool_state
 # important to import the patch PROTOCOL_VERSION from the simulacron module
 from tests.integration.simulacron import SimulacronBase, PROTOCOL_VERSION
 from cassandra.connection import DEFAULT_CQL_VERSION

tests/integration/standard/test_custom_cluster.py

@@ -14,7 +14,7 @@
 
 from cassandra.cluster import Cluster, NoHostAvailable
 from tests.integration import use_singledc, get_cluster, remove_cluster,  local
-from tests.integration.util import wait_until, wait_until_not_raised
+from tests.util import wait_until, wait_until_not_raised
 
 try:
     import unittest2 as unittest

tests/integration/util.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 from tests.integration import PROTOCOL_VERSION
-from functools import wraps
 import time
 
 
@@ -50,60 +49,3 @@ def assert_quiescent_pool_state(test_case, cluster, wait=None):
             test_case.assertEqual(connection.highest_request_id, max(req_ids))
             if PROTOCOL_VERSION < 3:
                 test_case.assertEqual(connection.highest_request_id, connection.max_request_id)
-
-
-def wait_until(condition, delay, max_attempts):
-    """
-    Executes a function at regular intervals while the condition
-    is false and the amount of attempts < maxAttempts.
-    :param condition: a function
-    :param delay: the delay in second
-    :param max_attempts: the maximum number of attempts. So the timeout
-                         of this function is delay*max_attempts
-    """
-    attempt = 0
-    while not condition() and attempt < max_attempts:
-        attempt += 1
-        time.sleep(delay)
-
-    if attempt >= max_attempts:
-        raise Exception("Condition is still False after {} attempts.".format(max_attempts))
-
-
-def wait_until_not_raised(condition, delay, max_attempts):
-    """
-    Executes a function at regular intervals while the condition
-    doesn't raise an exception and the amount of attempts < maxAttempts.
-    :param condition: a function
-    :param delay: the delay in second
-    :param max_attempts: the maximum number of attemps. So the timeout
-                         of this function will be delay*max_attempts
-    """
-    def wrapped_condition():
-        try:
-            condition()
-        except:
-            return False
-
-        return True
-
-    attempt = 0
-    while attempt < (max_attempts-1):
-        attempt += 1
-        if wrapped_condition():
-            return
-
-        time.sleep(delay)
-
-    # last attempt, let the exception raise
-    condition()
-
-
-def late(seconds=1):
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            time.sleep(seconds)
-            func(*args, **kwargs)
-        return wrapper
-    return decorator

tests/unit/advanced/test_auth.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
 from puresasl import QOP
 
 try:
@@ -21,10 +22,10 @@
 
 from cassandra.auth import DSEGSSAPIAuthProvider
 
-from tests.integration import requiredse
-
+# Cannot import requiredse from tests.integration
 # This auth provider requires kerberos and puresals
-@requiredse
+DSE_VERSION = os.getenv('DSE_VERSION', None)
+@unittest.skipUnless(DSE_VERSION, "DSE required")
 class TestGSSAPI(unittest.TestCase):
 
     def test_host_resolution(self):

tests/unit/test_connection.py

@@ -31,7 +31,7 @@
 from cassandra.protocol import (write_stringmultimap, write_int, write_string,
                                 SupportedMessage, ProtocolHandler)
 
-from tests.integration.util import wait_until
+from tests.util import wait_until
 
 
 class ConnectionTest(unittest.TestCase):

tests/util.py

@@ -0,0 +1,72 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+ 
+import time
+from functools import wraps
+
+def wait_until(condition, delay, max_attempts):
+    """
+    Executes a function at regular intervals while the condition
+    is false and the amount of attempts < maxAttempts.
+    :param condition: a function
+    :param delay: the delay in second
+    :param max_attempts: the maximum number of attempts. So the timeout
+                         of this function is delay*max_attempts
+    """
+    attempt = 0
+    while not condition() and attempt < max_attempts:
+        attempt += 1
+        time.sleep(delay)
+
+    if attempt >= max_attempts:
+        raise Exception("Condition is still False after {} attempts.".format(max_attempts))
+
+
+def wait_until_not_raised(condition, delay, max_attempts):
+    """
+    Executes a function at regular intervals while the condition
+    doesn't raise an exception and the amount of attempts < maxAttempts.
+    :param condition: a function
+    :param delay: the delay in second
+    :param max_attempts: the maximum number of attemps. So the timeout
+                         of this function will be delay*max_attempts
+    """
+    def wrapped_condition():
+        try:
+            condition()
+        except:
+            return False
+
+        return True
+
+    attempt = 0
+    while attempt < (max_attempts-1):
+        attempt += 1
+        if wrapped_condition():
+            return
+
+        time.sleep(delay)
+
+    # last attempt, let the exception raise
+    condition()
+
+
+def late(seconds=1):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            time.sleep(seconds)
+            func(*args, **kwargs)
+        return wrapper
+    return decorator