58 CI automation of test suite

.github/workflows/adelphi-python.yaml

@@ -0,0 +1,29 @@
+name: adelphi Python
+
+on:
+  push:
+    branches: [ 115-breadth-first-testing ]
+  pull_request:
+    branches: [ 115-breadth-first-testing ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.x
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        cd python
+        pip install ./adelphi
+        cd adelphi
+        pip install -r ./test-requirements.txt
+    - name: Execute tests
+      run: |
+        cd python/adelphi
+        test-adelphi

.gitignore

@@ -56,6 +56,7 @@ coverage.xml
 *.py,cover
 .hypothesis/
 .pytest_cache/
+python/adelphi/tox.ini
 
 # Translations
 *.mo

python/adelphi/adelphi/anonymize.py

@@ -15,7 +15,6 @@
 
 # Functions and constants related to the anonymization process
 from adelphi.store import get_standard_columns_from_table_metadata
-import re
 
 # default prefixes for the anonymized names
 KEYSPACE_PREFIX = "ks"

python/adelphi/adelphi/gh.py

@@ -22,7 +22,6 @@
 
 from github import Github
 
-logging.basicConfig(level=logging.INFO)
 log = logging.getLogger('adelphi')
 
 # We're assuming any storage repo will be created after the conversion to "main"

python/adelphi/adelphi/store.py

@@ -27,7 +27,8 @@
 from cassandra.cluster import Cluster, ExecutionProfile, EXEC_PROFILE_DEFAULT, default_lbp_factory
 from cassandra.auth import PlainTextAuthProvider
 
-logging.basicConfig(level=logging.INFO)
+from tenacity import retry
+
 log = logging.getLogger('adelphi')
 
 system_keyspaces = set(["system",
@@ -39,20 +40,26 @@
                     "system_views"])
 
 def build_auth_provider(username = None,password = None):
-    # instantiate auth provider if credentials have been provided
-    auth_provider = None
-    if username is not None and password is not None:
-        auth_provider = PlainTextAuthProvider(username=username, password=password)
-    return auth_provider
+    """Instantiate auth provider if credentials have been provided"""
+    if username is None or password is None:
+        return None
+    return PlainTextAuthProvider(username=username, password=password)
 
 
+@retry
 def with_cluster(cluster_fn, hosts, port, username = None, password = None):
     ep = ExecutionProfile(load_balancing_policy=default_lbp_factory())
     cluster = Cluster(hosts, port=port, auth_provider=build_auth_provider(username,password), execution_profiles={EXEC_PROFILE_DEFAULT: ep})
-    cluster.connect()
-    rv = cluster_fn(cluster)
-    cluster.shutdown()
-    return rv
+    try:
+        cluster.connect()
+        return cluster_fn(cluster)
+    finally:
+        cluster.shutdown()
+
+
+@retry
+def with_local_cluster(cluster_fn):
+    return with_cluster(cluster_fn, ["127.0.0.1"], port=9042)
 
 
 def build_keyspace_objects(keyspaces, metadata):
@@ -71,9 +78,7 @@ def partition(pred, iterable):
 
 
 def get_standard_columns_from_table_metadata(table_metadata):
-    """
-    Return the standard columns and ensure to exclude pk and ck ones.
-    """
+    """Return the standard columns and ensure to exclude pk and ck ones"""
     partition_column_names = [c.name for c in table_metadata.partition_key]
     clustering_column_names = [c.name for c in table_metadata.clustering_key]
     standard_columns = []
@@ -96,3 +101,28 @@ def set_replication_factor(selected_keyspaces, factor):
             log.debug("Replication for keyspace " + ks.name+ ": " + str(ks.replication_strategy))
             strategy = ks.replication_strategy
             strategy.replication_factor_info = factor
+
+
+def create_schema(session, schemaPath):
+    """Read schema CQL document and apply CQL commands to cluster"""
+    log.info("Creating schema on Cassandra cluster from file {}".format(schemaPath))
+    with open(schemaPath) as schema:
+        buff = ""
+        for line in schema:
+            realLine = line.strip()
+            if len(realLine) == 0:
+                log.debug("Skipping empty statement")
+                continue
+            if realLine.startswith("//") or realLine.startswith("--"):
+                log.debug("Skipping commented statement")
+                continue
+            buff += (" " if len(buff) > 0 else "")
+            buff += realLine
+            if buff.endswith(';'):
+                log.debug("Executing statement {}".format(buff))
+                try:
+                    session.execute(buff)
+                except Exception as exc:
+                    log.error("Exception executing statement: {}".format(buff), exc_info=exc)
+                finally:
+                    buff = ""

python/adelphi/bin/test-adelphi

@@ -0,0 +1,121 @@
+#!python
+
+# Run test suite for some set of Cassandra versions.
+#
+# We implement this as a front-end script because the tox/pytest/unittest chain
+# isn't great about iterating over a suite of test fixtures and re-running the
+# collected tests for each of them.  Rather than fight with the frameworks we
+# manage the fixture iteration manually in this script.  This also has the
+# nice side effect of moving a lot of C* checking/session code out of the test
+# suite, which in turn should allow us to write simpler tests.
+import configparser
+import os
+import re
+import sys
+
+from adelphi.store import with_local_cluster
+
+import click
+import docker
+from tenacity import retry, stop_after_attempt, wait_fixed
+import tox
+
+
+# Default C* versions to include in all integration tests
+DEFAULT_CASSANDRA_VERSIONS = ["2.1.22", "2.2.19", "3.0.23", "3.11.10", "4.0-rc1"]
+
+TOX_DEPENDENCIES = """pytest
+    subprocess32 ~= 3.5
+    tenacity ~= 7.0"""
+TOX_CONFIG = "tox.ini"
+
+
+@retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
+def runCassandraContainer(client, version):
+    return client.containers.run(name="adelphi", remove=True, detach=True, ports={9042: 9042}, image="cassandra:{}".format(version))
+
+
+def writeToxIni(version):
+    config = configparser.ConfigParser()
+    config["tox"] = { "envlist": "py2, py3" }
+    config["testenv"] = {"deps": TOX_DEPENDENCIES, \
+        "commands": "pytest {posargs}", \
+        "setenv": "CASSANDRA_VERSION = {}".format(version)}
+    with open(TOX_CONFIG, 'w') as configfile:
+        config.write(configfile)
+
+
+def buildVersionMap():
+    assert sorted(DEFAULT_CASSANDRA_VERSIONS)
+    rv = {v:v for v in DEFAULT_CASSANDRA_VERSIONS}
+    majorMinorPattern = re.compile(r"(\d\.\d).*")
+    for v in DEFAULT_CASSANDRA_VERSIONS:
+        majorMinorMatch = majorMinorPattern.match(v)
+        if majorMinorMatch:
+            majorMinor = majorMinorMatch.group(1)
+            rv[majorMinor] = v
+            # The reason we needed to asset that our input was sorted; we want the last
+            # major version entry we discover in the list to map to the major version.
+            # So "2" => "2.2.whatever" rather than "2.1.whatever"
+            rv[majorMinor.split('.')[0]] = v
+    return rv
+
+
+def resolveCassandraVersions(cassandra_versions):
+    if not cassandra_versions:
+        return DEFAULT_CASSANDRA_VERSIONS
+    versionMap = buildVersionMap()
+    computedVersions = [x for x in [versionMap.get(v) for v in cassandra_versions] if x is not None]
+    if not computedVersions:
+        print("Could not compute valid Cassandra versions based on args, using defaults")
+        return DEFAULT_CASSANDRA_VERSIONS
+    return computedVersions
+
+
+@click.command()
+@click.option('--cassandra', '-c', multiple=True, type=str)
+@click.option('--python', '-p', multiple=True, type=click.Choice(["py2","py3"], case_sensitive = False))
+@click.option("--pytest", "-t", type=str, help="Arguments to be passed to pytest")
+def runtests(cassandra, python, pytest):
+    client = docker.from_env()
+    tox_args = ["-e {}".format(py) for py in python] if python else []
+    if pytest:
+        tox_args.append("--")
+        tox_args.append(pytest)
+    print("Full tox args: {}".format(tox_args))
+
+    cassandra_versions = resolveCassandraVersions(cassandra)
+    print("Cassandra versions to test: {}".format(','.join(cassandra_versions)))
+    exitCodes = []
+    for version in resolveCassandraVersions(cassandra_versions):
+
+        print("Running test suite for Cassandra version {}".format(version))
+        container = runCassandraContainer(client, version)
+
+        print("Validating connection to local Cassandra")
+        def validationFn(cluster):
+            session = cluster.connect()
+            rs = session.execute("select * from system.local")
+            print("Connected to Cassandra cluster, first row of system.local: {}".format(rs.one()))
+            return (cluster, session)
+        with_local_cluster.retry_with(stop=stop_after_attempt(5), wait=wait_fixed(3))(validationFn)
+
+        try:
+            if os.path.exists(TOX_CONFIG):
+                os.remove(TOX_CONFIG)
+            writeToxIni(version)
+
+            # cmdline() will raise SystemExit when it's done so trap that here to avoid
+            # exiting all the things
+            try:
+                tox.cmdline(tox_args)
+            except SystemExit as exc:
+                exitCodes.append(exc.code)
+        except Exception as exc:
+            print("Exception running tests for Cassandra version {}".format(version), exc)
+        finally:
+            container.stop()
+    sys.exit(sum(1 for x in exitCodes if x != 0))
+
+if __name__ == '__main__':
+    runtests(obj={})

python/adelphi/setup.py

@@ -8,7 +8,8 @@
     'cassandra-driver ~= 3.24',
     'click ~= 7.1',
     'PyGithub ~= 1.45',
-    'PyYAML ~= 5.4'
+    'PyYAML ~= 5.4',
+    'tenacity ~= 7.0'
     ]
 
 if not PY3:
@@ -48,6 +49,6 @@
         'Topic :: Software Development :: Libraries :: Python Modules'
    ],
    packages=['adelphi'],
-   scripts=['bin/adelphi'],
+   scripts=['bin/adelphi','bin/test-adelphi'],
    install_requires=dependencies,
 )

python/adelphi/test-requirements.txt

@@ -0,0 +1,2 @@
+docker ~= 4.4
+tox ~= 3.22