cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aweisb...@apache.org
Subject [19/36] cassandra-dtest git commit: Migrate dtests to use pytest and python3
Date Mon, 29 Jan 2018 21:10:22 GMT
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/replication_test.py
----------------------------------------------------------------------
diff --git a/replication_test.py b/replication_test.py
index edc6fc0..8c29074 100644
--- a/replication_test.py
+++ b/replication_test.py
@@ -1,14 +1,18 @@
 import os
 import re
 import time
+import pytest
+import logging
+
 from collections import defaultdict
 
 from cassandra import ConsistencyLevel
 from cassandra.query import SimpleStatement
-from nose.plugins.attrib import attr
 
-from dtest import PRINT_DEBUG, DtestTimeoutError, Tester, debug, create_ks
-from tools.decorators import no_vnodes, since
+from dtest import DtestTimeoutError, Tester, create_ks
+
+since = pytest.mark.since
+logger = logging.getLogger(__name__)
 
 TRACE_DETERMINE_REPLICAS = re.compile('Determining replicas for mutation')
 TRACE_SEND_MESSAGE = re.compile('Sending (?:MUTATION|REQUEST_RESPONSE) message to /([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)')
@@ -73,8 +77,8 @@ def block_on_trace(session):
             raise DtestTimeoutError()
 
 
-@no_vnodes()
-class ReplicationTest(Tester):
+@pytest.mark.no_vnodes
+class TestReplication(Tester):
     """
     This test suite looks at how data is replicated across a cluster
     and who the coordinator, replicas and forwarders involved are.
@@ -176,7 +180,7 @@ class ReplicationTest(Tester):
         elif strategy == 'NetworkTopologyStrategy':
             # NetworkTopologyStrategy can be broken down into multiple
             # SimpleStrategies, just once per datacenter:
-            for dc, rf in replication_factor.items():
+            for dc, rf in list(replication_factor.items()):
                 dc_nodes = [n for n in nodes if n.data_center == dc]
                 replicas.extend(self.get_replicas_for_token(
                     token, rf, nodes=dc_nodes))
@@ -190,13 +194,13 @@ class ReplicationTest(Tester):
         """
         Pretty print a trace
         """
-        if PRINT_DEBUG:
-            print("-" * 40)
+        if logging.root.level == logging.DEBUG:
+            print(("-" * 40))
             for t in trace.events:
-                print("%s\t%s\t%s\t%s" % (t.source, t.source_elapsed, t.description, t.thread_name))
-            print("-" * 40)
+                print(("%s\t%s\t%s\t%s" % (t.source, t.source_elapsed, t.description, t.thread_name)))
+            print(("-" * 40))
 
-    def simple_test(self):
+    def test_simple(self):
         """
         Test the SimpleStrategy on a 3 node cluster
         """
@@ -209,8 +213,8 @@ class ReplicationTest(Tester):
         create_ks(session, 'test', replication_factor)
         session.execute('CREATE TABLE test.test (id int PRIMARY KEY, value text)', trace=False)
 
-        for key, token in murmur3_hashes.items():
-            debug('murmur3 hash key={key},token={token}'.format(key=key, token=token))
+        for key, token in list(murmur3_hashes.items()):
+            logger.debug('murmur3 hash key={key},token={token}'.format(key=key, token=token))
             query = SimpleStatement("INSERT INTO test (id, value) VALUES ({}, 'asdf')".format(key), consistency_level=ConsistencyLevel.ALL)
             future = session.execute_async(query, trace=True)
             future.result()
@@ -222,17 +226,17 @@ class ReplicationTest(Tester):
             stats = self.get_replicas_from_trace(trace)
             replicas_should_be = set(self.get_replicas_for_token(
                 token, replication_factor))
-            debug('\nreplicas should be: %s' % replicas_should_be)
-            debug('replicas were: %s' % stats['replicas'])
+            logger.debug('\nreplicas should be: %s' % replicas_should_be)
+            logger.debug('replicas were: %s' % stats['replicas'])
 
             # Make sure the correct nodes are replicas:
-            self.assertEqual(stats['replicas'], replicas_should_be)
+            assert stats['replicas'] == replicas_should_be
             # Make sure that each replica node was contacted and
             # acknowledged the write:
-            self.assertEqual(stats['nodes_sent_write'], stats['nodes_responded_write'])
+            assert stats['nodes_sent_write'] == stats['nodes_responded_write']
 
-    @attr("resource-intensive")
-    def network_topology_test(self):
+    @pytest.mark.resource_intensive
+    def test_network_topology(self):
         """
         Test the NetworkTopologyStrategy on a 2DC 3:3 node cluster
         """
@@ -248,7 +252,7 @@ class ReplicationTest(Tester):
 
         forwarders_used = set()
 
-        for key, token in murmur3_hashes.items():
+        for key, token in list(murmur3_hashes.items()):
             query = SimpleStatement("INSERT INTO test (id, value) VALUES ({}, 'asdf')".format(key), consistency_level=ConsistencyLevel.ALL)
             future = session.execute_async(query, trace=True)
             future.result()
@@ -260,9 +264,9 @@ class ReplicationTest(Tester):
             stats = self.get_replicas_from_trace(trace)
             replicas_should_be = set(self.get_replicas_for_token(
                 token, replication_factor, strategy='NetworkTopologyStrategy'))
-            debug('Current token is %s' % token)
-            debug('\nreplicas should be: %s' % replicas_should_be)
-            debug('replicas were: %s' % stats['replicas'])
+            logger.debug('Current token is %s' % token)
+            logger.debug('\nreplicas should be: %s' % replicas_should_be)
+            logger.debug('replicas were: %s' % stats['replicas'])
 
             # Make sure the coordinator only talked to a single node in
             # the second datacenter - CASSANDRA-5632:
@@ -270,27 +274,27 @@ class ReplicationTest(Tester):
             for node_contacted in stats['nodes_contacted'][node1.address()]:
                 if ip_nodes[node_contacted].data_center != node1.data_center:
                     num_in_other_dcs_contacted += 1
-            self.assertEqual(num_in_other_dcs_contacted, 1)
+            assert num_in_other_dcs_contacted == 1
 
             # Record the forwarder used for each INSERT:
             forwarders_used = forwarders_used.union(stats['forwarders'])
 
             try:
                 # Make sure the correct nodes are replicas:
-                self.assertEqual(stats['replicas'], replicas_should_be)
+                assert stats['replicas'] == replicas_should_be
                 # Make sure that each replica node was contacted and
                 # acknowledged the write:
-                self.assertEqual(stats['nodes_sent_write'], stats['nodes_responded_write'])
+                assert stats['nodes_sent_write'] == stats['nodes_responded_write']
             except AssertionError as e:
-                debug("Failed on key %s and token %s." % (key, token))
+                logger.debug("Failed on key %s and token %s." % (key, token))
                 raise e
 
         # Given a diverse enough keyset, each node in the second
         # datacenter should get a chance to be a forwarder:
-        self.assertEqual(len(forwarders_used), 3)
+        assert len(forwarders_used) == 3
 
 
-class SnitchConfigurationUpdateTest(Tester):
+class TestSnitchConfigurationUpdate(Tester):
     """
     Test to reproduce CASSANDRA-10238, wherein changing snitch properties to change racks without a restart
     could violate RF contract.
@@ -299,27 +303,31 @@ class SnitchConfigurationUpdateTest(Tester):
     which nodes should be shutdown in order to have the rack changed.
     """
 
-    ignore_log_patterns = ["Fatal exception during initialization",
-                           "Cannot start node if snitch's rack(.*) differs from previous rack(.*)",
-                           "Cannot update data center or rack"]
+    @pytest.fixture(autouse=True)
+    def fixture_add_additional_log_patterns(self, fixture_dtest_setup):
+        fixture_dtest_setup.ignore_log_patterns = (
+            "Fatal exception during initialization",
+            "Cannot start node if snitch's rack(.*) differs from previous rack(.*)",
+            "Cannot update data center or rack"
+        )
 
     def check_endpoint_count(self, ks, table, nodes, rf):
         """
         Check a dummy key expecting it to have replication factor as the sum of rf on all dcs.
         """
-        expected_count = sum([int(r) for d, r in rf.iteritems() if d != 'class'])
+        expected_count = sum([int(r) for d, r in rf.items() if d != 'class'])
         for node in nodes:
             cmd = "getendpoints {} {} dummy".format(ks, table)
             out, err, _ = node.nodetool(cmd)
 
             if len(err.strip()) > 0:
-                debug("Error running 'nodetool {}': {}".format(cmd, err))
+                logger.debug("Error running 'nodetool {}': {}".format(cmd, err))
 
-            debug("Endpoints for node {}, expected count is {}".format(node.address(), expected_count))
-            debug(out)
+            logger.debug("Endpoints for node {}, expected count is {}".format(node.address(), expected_count))
+            logger.debug(out)
             ips_found = re.findall('(\d+\.\d+\.\d+\.\d+)', out)
 
-            self.assertEqual(len(ips_found), expected_count, "wrong number of endpoints found ({}), should be: {}".format(len(ips_found), expected_count))
+            assert len(ips_found) == expected_count, "wrong number of endpoints found ({}), should be: {}".format(len(ips_found), expected_count)
 
     def wait_for_nodes_on_racks(self, nodes, expected_racks):
         """
@@ -331,9 +339,9 @@ class SnitchConfigurationUpdateTest(Tester):
             while time.time() < wait_expire:
                 out, err, _ = node.nodetool("status")
 
-                debug(out)
+                logger.debug(out)
                 if len(err.strip()) > 0:
-                    debug("Error trying to run nodetool status: {}".format(err))
+                    logger.debug("Error trying to run nodetool status: {}".format(err))
 
                 racks = []
                 for line in out.split(os.linesep):
@@ -343,10 +351,10 @@ class SnitchConfigurationUpdateTest(Tester):
 
                 if racks == expected_racks:
                     # great, the topology change is propagated
-                    debug("Topology change detected on node {}".format(i))
+                    logger.debug("Topology change detected on node {}".format(i))
                     break
                 else:
-                    debug("Waiting for topology change on node {}".format(i))
+                    logger.debug("Waiting for topology change on node {}".format(i))
                     time.sleep(5)
             else:
                 raise RuntimeError("Ran out of time waiting for topology to change on node {}".format(i))
@@ -383,7 +391,7 @@ class SnitchConfigurationUpdateTest(Tester):
                                        final_racks=["rack0", "rack1", "rack2"],
                                        nodes_to_shutdown=[0, 2])
 
-    @attr("resource-intensive")
+    @pytest.mark.resource_intensive
     def test_rf_collapse_gossiping_property_file_snitch_multi_dc(self):
         """
         @jira_ticket CASSANDRA-10238
@@ -400,7 +408,7 @@ class SnitchConfigurationUpdateTest(Tester):
                                        final_racks=["rack1", "rack1", "rack1", "rack1", "rack1", "rack1"],
                                        nodes_to_shutdown=[0, 2, 3, 5])
 
-    @attr("resource-intensive")
+    @pytest.mark.resource_intensive
     def test_rf_expand_gossiping_property_file_snitch_multi_dc(self):
         """
         @jira_ticket CASSANDRA-10238
@@ -537,7 +545,7 @@ class SnitchConfigurationUpdateTest(Tester):
 
         session = self.patient_cql_connection(cluster.nodelist()[0])
 
-        options = (', ').join(['\'{}\': {}'.format(d, r) for d, r in rf.iteritems()])
+        options = (', ').join(['\'{}\': {}'.format(d, r) for d, r in rf.items()])
         session.execute("CREATE KEYSPACE testing WITH replication = {{{}}}".format(options))
         session.execute("CREATE TABLE testing.rf_test (key text PRIMARY KEY, value text)")
 
@@ -548,10 +556,10 @@ class SnitchConfigurationUpdateTest(Tester):
 
         for i in nodes_to_shutdown:
             node = cluster.nodelist()[i]
-            debug("Shutting down node {}".format(node.address()))
+            logger.debug("Shutting down node {}".format(node.address()))
             node.stop(wait_other_notice=True)
 
-        debug("Updating snitch file")
+        logger.debug("Updating snitch file")
         for i, node in enumerate(cluster.nodelist()):
             with open(os.path.join(node.get_conf_dir(), snitch_config_file), 'w') as topo_file:
                 for line in snitch_lines_after(i, node):
@@ -559,12 +567,12 @@ class SnitchConfigurationUpdateTest(Tester):
 
         # wait until the config is reloaded before we restart the nodes, the default check period is
         # 5 seconds so we wait for 10 seconds to be sure
-        debug("Waiting 10 seconds to make sure snitch file is reloaded...")
+        logger.debug("Waiting 10 seconds to make sure snitch file is reloaded...")
         time.sleep(10)
 
         for i in nodes_to_shutdown:
             node = cluster.nodelist()[i]
-            debug("Restarting node {}".format(node.address()))
+            logger.debug("Restarting node {}".format(node.address()))
             # Since CASSANDRA-10242 it is no longer
             # possible to start a node with a different rack unless we specify -Dcassandra.ignore_rack and since
             # CASSANDRA-9474 it is no longer possible to start a node with a different dc unless we specify
@@ -594,24 +602,24 @@ class SnitchConfigurationUpdateTest(Tester):
             for line in ["dc={}".format(node1.data_center), "rack=rack1"]:
                 topo_file.write(line + os.linesep)
 
-        debug("Starting node {} with rack1".format(node1.address()))
+        logger.debug("Starting node {} with rack1".format(node1.address()))
         node1.start(wait_for_binary_proto=True)
 
-        debug("Shutting down node {}".format(node1.address()))
+        logger.debug("Shutting down node {}".format(node1.address()))
         node1.stop(wait_other_notice=True)
 
-        debug("Updating snitch file with rack2")
+        logger.debug("Updating snitch file with rack2")
         for node in cluster.nodelist():
             with open(os.path.join(node.get_conf_dir(), 'cassandra-rackdc.properties'), 'w') as topo_file:
                 for line in ["dc={}".format(node.data_center), "rack=rack2"]:
                     topo_file.write(line + os.linesep)
 
-        debug("Restarting node {} with rack2".format(node1.address()))
+        logger.debug("Restarting node {} with rack2".format(node1.address()))
         mark = node1.mark_log()
         node1.start()
 
         # check node not running
-        debug("Waiting for error message in log file")
+        logger.debug("Waiting for error message in log file")
 
         if cluster.version() >= '2.2':
             node1.watch_log_for("Cannot start node if snitch's rack(.*) differs from previous rack(.*)",
@@ -696,7 +704,7 @@ class SnitchConfigurationUpdateTest(Tester):
 
         marks = [node.mark_log() for node in cluster.nodelist()]
 
-        debug("Updating snitch file")
+        logger.debug("Updating snitch file")
         for node in cluster.nodelist():
             with open(os.path.join(node.get_conf_dir(), snitch_config_file), 'w') as topo_file:
                 for line in snitch_lines_after:
@@ -704,7 +712,7 @@ class SnitchConfigurationUpdateTest(Tester):
 
         # wait until the config is reloaded, the default check period is
         # 5 seconds so we wait for 10 seconds to be sure
-        debug("Waiting 10 seconds to make sure snitch file is reloaded...")
+        logger.debug("Waiting 10 seconds to make sure snitch file is reloaded...")
         time.sleep(10)
 
         # check racks have not changed
@@ -723,7 +731,7 @@ class SnitchConfigurationUpdateTest(Tester):
         """
         expected_error = (r"Cannot start node if snitch's data center (.*) differs from previous data center (.*)\. "
                           "Please fix the snitch configuration, decommission and rebootstrap this node or use the flag -Dcassandra.ignore_dc=true.")
-        self.ignore_log_patterns = [expected_error]
+        self.fixture_dtest_setup.ignore_log_patterns = [expected_error]
 
         cluster = self.cluster
         cluster.populate(1)
@@ -744,4 +752,4 @@ class SnitchConfigurationUpdateTest(Tester):
 
         mark = node.mark_log()
         node.start()
-        node.watch_log_for(expected_error, from_mark=mark, timeout=10)
+        node.watch_log_for(expected_error, from_mark=mark, timeout=120)

http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/requirements.txt
----------------------------------------------------------------------
diff --git a/requirements.txt b/requirements.txt
index bf46e38..388a8a9 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,21 +1,18 @@
-# See python driver docs: futures and six have to be installed before
-# cythonizing the driver, perhaps only on old pips.
-# http://datastax.github.io/python-driver/installation.html#cython-based-extensions
-futures
-six
 -e git+https://github.com/datastax/python-driver.git@cassandra-test#egg=cassandra-driver
 # Used ccm version is tracked by cassandra-test branch in ccm repo. Please create a PR there for fixes or upgrades to new releases.
--e git+https://github.com/pcmanus/ccm.git@cassandra-test#egg=ccm
-cql
+-e git+https://github.com/riptano/ccm.git@cassandra-test#egg=ccm
+cqlsh
 decorator
 docopt
 enum34
 flaky
 mock
-nose
-nose-test-select
+pytest
+pytest-timeout
 parse
 pycodestyle
 psutil
-pycassa
-thrift==0.9.3
+thrift==0.10.0
+netifaces
+beautifulsoup4
+lxml

http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/run_dtests.py
----------------------------------------------------------------------
diff --git a/run_dtests.py b/run_dtests.py
index e7165af..198cde2 100755
--- a/run_dtests.py
+++ b/run_dtests.py
@@ -1,264 +1,280 @@
 #!/usr/bin/env python
 """
-Usage: run_dtests.py [--nose-options NOSE_OPTIONS] [TESTS...] [--vnodes VNODES_OPTIONS...]
-                 [--runner-debug | --runner-quiet] [--dry-run]
-
-nosetests options:
-    --nose-options NOSE_OPTIONS  specify options to pass to `nosetests`.
-    TESTS                        space-separated list of tests to pass to `nosetests`
-
-script configuration options:
-    --runner-debug -d            print debug statements in this script
-    --runner-quiet -q            quiet all output from this script
-
-cluster configuration options:
-    --vnodes VNODES_OPTIONS...   specify whether to run with or without vnodes.
-                                 valid values: 'true' and 'false'
-
-example:
-    The following command will execute nosetests with the '-v' (verbose) option, vnodes disabled, and run a single test:
-    ./run_dtests.py --nose-options -v --vnodes false repair_tests/repair_test.py:TestRepair.token_range_repair_test_with_cf
-
+usage: run_dtests.py [-h] [--use-vnodes] [--use-off-heap-memtables] [--num-tokens NUM_TOKENS] [--data-dir-count-per-instance DATA_DIR_COUNT_PER_INSTANCE] [--force-resource-intensive-tests]
+                     [--skip-resource-intensive-tests] [--cassandra-dir CASSANDRA_DIR] [--cassandra-version CASSANDRA_VERSION] [--delete-logs] [--execute-upgrade-tests] [--disable-active-log-watching]
+                     [--keep-test-dir] [--enable-jacoco-code-coverage] [--dtest-enable-debug-logging] [--dtest-print-tests-only] [--dtest-print-tests-output DTEST_PRINT_TESTS_OUTPUT]
+                     [--pytest-options PYTEST_OPTIONS] [--dtest-tests DTEST_TESTS]
+
+optional arguments:
+  -h, --help                                                 show this help message and exit
+  --use-vnodes                                               Determines wither or not to setup clusters using vnodes for tests (default: False)
+  --use-off-heap-memtables                                   Enable Off Heap Memtables when creating test clusters for tests (default: False)
+  --num-tokens NUM_TOKENS                                    Number of tokens to set num_tokens yaml setting to when creating instances with vnodes enabled (default: 256)
+  --data-dir-count-per-instance DATA_DIR_COUNT_PER_INSTANCE  Control the number of data directories to create per instance (default: 3)
+  --force-resource-intensive-tests                           Forces the execution of tests marked as resource_intensive (default: False)
+  --skip-resource-intensive-tests                            Skip all tests marked as resource_intensive (default: False)
+  --cassandra-dir CASSANDRA_DIR
+  --cassandra-version CASSANDRA_VERSION
+  --delete-logs
+  --execute-upgrade-tests                                    Execute Cassandra Upgrade Tests (e.g. tests annotated with the upgrade_test mark) (default: False)
+  --disable-active-log-watching                              Disable ccm active log watching, which will cause dtests to check for errors in the logs in a single operation instead of semi-realtime
+                                                             processing by consuming ccm _log_error_handler callbacks (default: False)
+  --keep-test-dir                                            Do not remove/cleanup the test ccm cluster directory and it's artifacts after the test completes (default: False)
+  --enable-jacoco-code-coverage                              Enable JaCoCo Code Coverage Support (default: False)
+  --dtest-enable-debug-logging                               Enable debug logging (for this script, pytest, and during execution of test functions) (default: False)
+  --dtest-print-tests-only                                   Print list of all tests found eligible for execution given the provided options. (default: False)
+  --dtest-print-tests-output DTEST_PRINT_TESTS_OUTPUT        Path to file where the output of --dtest-print-tests-only should be written to (default: False)
+  --pytest-options PYTEST_OPTIONS                            Additional command line arguments to proxy directly thru when invoking pytest. (default: None)
+  --dtest-tests DTEST_TESTS                                  Comma separated list of test files, test classes, or test methods to execute. (default: None)
 """
-from __future__ import print_function
-
 import subprocess
 import sys
 import os
-from collections import namedtuple
-from itertools import product
-from os import getcwd, environ
-from tempfile import NamedTemporaryFile
-
-from docopt import docopt
-
-from plugins.dtestconfig import GlobalConfigObject
-
-
-# Generate values in a matrix from these lists of values for each attribute
-# not defined in arguments to the runner script.
-default_config_matrix = GlobalConfigObject(
-    vnodes=(True, False),
-)
-
+import re
+import logging
 
-def _noop(*args, **kwargs):
-    pass
-
-
-class ValidationResult(namedtuple('_ValidationResult', ['serialized', 'error_messages'])):
-    """
-    A value to be returned from validation functions. If serialization works,
-    return one with 'serialized' set, otherwise return a list of string on the
-    'error_messages' attribute.
-    """
-    __slots__ = ()
+from os import getcwd
+from tempfile import NamedTemporaryFile
+from bs4 import BeautifulSoup
 
-    def __new__(cls, serialized=None, error_messages=None):
-        if error_messages is None:
-            error_messages = []
+from _pytest.config import Parser
+import argparse
 
-        success_result = serialized is not None
-        failure_result = bool(error_messages)
+from conftest import pytest_addoption
 
-        if success_result + failure_result != 1:
-            msg = ('attempted to instantiate a {cls_name} with serialized='
-                   '{serialized} and error_messages={error_messages}. {cls_name} '
-                   'objects must be instantiated with either a serialized or '
-                   'error_messages argument, but not both.')
-            msg = msg.format(cls_name=cls.__name__,
-                             serialized=serialized,
-                             error_messages=error_messages)
-            raise ValueError(msg)
+logger = logging.getLogger(__name__)
 
-        return super(ValidationResult, cls).__new__(cls, serialized=serialized, error_messages=error_messages)
 
+class RunDTests():
+    def run(self, argv):
+        parser = argparse.ArgumentParser(formatter_class=lambda prog: argparse.ArgumentDefaultsHelpFormatter(prog,
+                                                                                                             max_help_position=100,
+                                                                                                             width=200))
 
-def _validate_and_serialize_vnodes(vnodes_value):
-    """
-    Validate the values received for vnodes configuration. Returns a
-    ValidationResult.
+        # this is a bit ugly: all of our command line arguments are added and configured as part
+        # of pytest. however, we also have this wrapper script to make it easier for those who
+        # aren't comfortable calling pytest directly. To avoid duplicating code (e.g. have the options
+        # in two separate places) we directly use the pytest_addoption fixture from conftest.py. Unfortunately,
+        # pytest wraps ArgumentParser, so, first we add the options to a pytest Parser, and then we pull
+        # all of those custom options out and add them to the unwrapped ArgumentParser we want to use
+        # here inside of run_dtests.py.
+        #
+        # So NOTE: to add a command line argument, if you're trying to do so by adding it here, you're doing it wrong!
+        # add it to conftest.py:pytest_addoption
+        pytest_parser = Parser()
+        pytest_addoption(pytest_parser)
+
+        # add all of the options from the pytest Parser we created, and add them into our ArgumentParser instance
+        pytest_custom_opts = pytest_parser._anonymous
+        for opt in pytest_custom_opts.options:
+            parser.add_argument(opt._long_opts[0], action=opt._attrs['action'],
+                                default=opt._attrs.get('default', None),
+                                help=opt._attrs.get('help', None))
+
+        parser.add_argument("--dtest-enable-debug-logging", action="store_true", default=False,
+                            help="Enable debug logging (for this script, pytest, and during execution "
+                                 "of test functions)")
+        parser.add_argument("--dtest-print-tests-only", action="store_true", default=False,
+                            help="Print list of all tests found eligible for execution given the provided options.")
+        parser.add_argument("--dtest-print-tests-output", action="store", default=False,
+                            help="Path to file where the output of --dtest-print-tests-only should be written to")
+        parser.add_argument("--pytest-options", action="store", default=None,
+                            help="Additional command line arguments to proxy directly thru when invoking pytest.")
+        parser.add_argument("--dtest-tests", action="store", default=None,
+                            help="Comma separated list of test files, test classes, or test methods to execute.")
+
+        args = parser.parse_args()
+
+        if not args.dtest_print_tests_only and args.cassandra_dir is None:
+            if args.cassandra_version is None:
+                raise Exception("Required dtest arguments were missing! You must provide either --cassandra-dir "
+                                "or --cassandra-version. Refer to the documentation or invoke the help with --help.")
+
+        if args.dtest_enable_debug_logging:
+            logging.root.setLevel(logging.DEBUG)
+            logger.setLevel(logging.DEBUG)
+
+        # Get dictionaries corresponding to each point in the configuration matrix
+        # we want to run, then generate a config object for each of them.
+        logger.debug('Generating configurations from the following matrix:\n\t{}'.format(args))
+
+        args_to_invoke_pytest = []
+        if args.pytest_options:
+            for arg in args.pytest_options.split(" "):
+                args_to_invoke_pytest.append("'{the_arg}'".format(the_arg=arg))
+
+        for arg in argv:
+            if arg.startswith("--pytest-options") or arg.startswith("--dtest-"):
+                continue
+            args_to_invoke_pytest.append("'{the_arg}'".format(the_arg=arg))
+
+        if args.dtest_print_tests_only:
+            args_to_invoke_pytest.append("'--collect-only'")
+
+        if args.dtest_tests:
+            for test in args.dtest_tests.split(","):
+                args_to_invoke_pytest.append("'{test_name}'".format(test_name=test))
+
+        original_raw_cmd_args = ", ".join(args_to_invoke_pytest)
+
+        logger.debug("args to call with: [%s]" % original_raw_cmd_args)
+
+        # the original run_dtests.py script did it like this to hack around nosetest
+        # limitations -- i'm not sure if they still apply or not in a pytest world
+        # but for now just leaving it as is, because it does the job (although
+        # certainly is still pretty complicated code and has a hacky feeling)
+        to_execute = (
+                "import pytest\n" +
+                (
+                "pytest.main([{options}])\n").format(options=original_raw_cmd_args)
+        )
+        temp = NamedTemporaryFile(dir=getcwd())
+        logger.debug('Writing the following to {}:'.format(temp.name))
 
-    If the values validate, return a ValidationResult with 'serialized' set to
-    the equivalent of:
+        logger.debug('```\n{to_execute}```\n'.format(to_execute=to_execute))
+        temp.write(to_execute.encode("utf-8"))
+        temp.flush()
 
-        tuple(set({'true': True, 'false':False}[v.lower()] for v in vnodes_value))
+        # We pass nose_argv as options to the python call to maintain
+        # compatibility with the nosetests command. Arguments passed in via the
+        # command line are treated one way, args passed in as
+        # nose.main(argv=...) are treated another. Compare with the options
+        # -xsv for an example.
+        cmd_list = [sys.executable, temp.name]
+        logger.debug('subprocess.call-ing {cmd_list}'.format(cmd_list=cmd_list))
 
-    If the values don't validate, return a ValidationResult with 'messages' set
-    to a list of strings, each of which points out an invalid value.
-    """
-    messages = []
-    vnodes_value = set(v.lower() for v in vnodes_value)
-    value_map = {'true': True, 'false': False}
+        sp = subprocess.Popen(cmd_list, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=os.environ.copy())
 
-    for v in vnodes_value:
-        if v not in value_map:
-            messages.append('{} not a valid value for --vnodes option. '
-                            'valid values are {} (case-insensitive)'.format(v, ', '.join(list(value_map))))
+        if args.dtest_print_tests_only:
+            stdout, stderr = sp.communicate()
 
-    if messages:
-        return ValidationResult(error_messages=messages)
+            if stderr:
+                print(stderr.decode("utf-8"))
+                result = sp.returncode
+                exit(result)
 
-    serialized = tuple({value_map[v] for v in vnodes_value})
-    return ValidationResult(serialized=serialized)
+            all_collected_test_modules = collect_test_modules(stdout)
+            joined_test_modules = "\n".join(all_collected_test_modules)
+            #print("Collected %d Test Modules" % len(all_collected_test_modules))
+            if args.dtest_print_tests_output is not None:
+                collected_tests_output_file = open(args.dtest_print_tests_output, "w")
+                collected_tests_output_file.write(joined_test_modules)
+                collected_tests_output_file.close()
 
+            print(joined_test_modules)
+        else:
+            while True:
+                stdout_output = sp.stdout.readline()
+                stdout_output_str = stdout_output.decode("utf-8")
+                if stdout_output_str == '' and sp.poll() is not None:
+                    break
+                if stdout_output_str:
+                    print(stdout_output_str.strip())
 
-def validate_and_serialize_options(docopt_options):
-    """
-    For each value that should be configured for a config object, attempt to
-    serialize the passed-in strings into objects that can be used for
-    configuration. If no values were passed in, use the list of options from
-    the defaults above.
+                stderr_output = sp.stderr.readline()
+                stderr_output_str = stderr_output.decode("utf-8")
+                if stderr_output_str == '' and sp.poll() is not None:
+                    break
+                if stderr_output_str:
+                    print(stderr_output_str.strip())
 
-    Raises a ValueError and prints an error message if any values are invalid
-    or didn't serialize correctly.
-    """
-    vnodes = _validate_and_serialize_vnodes(docopt_options['--vnodes'])
-    if vnodes.error_messages:
-        raise ValueError('Validation error:\n{}'.format('\t\n'.join(list(vnodes.error_messages))))
-    return GlobalConfigObject(
-        vnodes=vnodes.serialized or default_config_matrix.vnodes
-    )
+        exit(sp.returncode)
 
 
-def product_of_values(d):
+def collect_test_modules(stdout):
     """
-    Transforms a dictionary of {key: list(configuration_options} into a tuple
-    of dictionaries, each corresponding to a point in the product, with the
-    values preserved at the keys where they were found in the argument.
-
-    This is difficult to explain and is probably best demonstrated with an
-    example:
-
-        >>> from pprint import pprint
-        >>> from runner import product_of_values
-        >>> pprint(product_of_values(
-        ...     {'a': [1, 2, 3],
-        ...      'b': [4, 5, 6]}
-        ... ))
-        ({'a': 1, 'b': 4},
-         {'a': 1, 'b': 5},
-         {'a': 1, 'b': 6},
-         {'a': 2, 'b': 4},
-         {'a': 2, 'b': 5},
-         {'a': 2, 'b': 6},
-         {'a': 3, 'b': 4},
-         {'a': 3, 'b': 5},
-         {'a': 3, 'b': 6})
-
-    So, in this case, we get something like
-
-        for a_value in d['a']:
-            for b_value in d['b']:
-                yield {'a': a_value, 'b': b_value}
-
-    This method does that, but for dictionaries with arbitrary iterables at
-    arbitrary numbers of keys.
+    Takes the xml-ish (no, it's not actually xml so we need to format it a bit) --collect-only output as printed
+    by pytest to stdout and normalizes it to get a list of all collected tests in a human friendly format
+    :param stdout: the stdout from pytest (should have been invoked with the --collect-only cmdline argument)
+    :return: a formatted list of collected test modules in format test_file.py::TestClass::test_function
     """
-
-    # transform, e.g., {'a': [1, 2, 3], 'b': [4, 5, 6]} into
-    # [[('a', 1), ('a', 2), ('a', 3)],
-    #  [('b', 4), ('b', 5), ('b', 6)]]
-    tuple_list = [[(k, v) for v in v_list] for k, v_list in d.items()]
-
-    # return the cartesian product of the flattened dict
-    return tuple(dict(result) for result in product(*tuple_list))
+    # unfortunately, pytest emits xml like output -- but it's not actually xml, so we'll fail to parse
+    # if we try. first step is to fix up the pytest output to create well formatted xml
+    xml_line_regex_pattern = re.compile("^([\s])*<(Module|Class|Function|Instance) '(.*)'>")
+    is_first_module = True
+    is_first_class = True
+    has_closed_class = False
+    section_has_instance = False
+    section_has_class = False
+    test_collect_xml_lines = []
+
+    test_collect_xml_lines.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")
+    test_collect_xml_lines.append("<Modules>")
+    for line in stdout.decode("utf-8").split('\n'):
+        re_ret = re.search(xml_line_regex_pattern, line)
+        if re_ret:
+            if not is_first_module and re_ret.group(2) == "Module":
+                if section_has_instance:
+                    test_collect_xml_lines.append("      </Instance>")
+                if section_has_class:
+                    test_collect_xml_lines.append("    </Class>")
+
+                test_collect_xml_lines.append("  </Module>")
+                is_first_class = True
+                has_closed_class= False
+                section_has_instance = False
+                section_has_class = False
+                is_first_module = False
+            elif is_first_module and re_ret.group(2) == "Module":
+                if not has_closed_class and section_has_instance:
+                    test_collect_xml_lines.append("      </Instance>")
+                if not has_closed_class and section_has_class:
+                    test_collect_xml_lines.append("    </Class>")
+
+                is_first_class = True
+                is_first_module = False
+                has_closed_class = False
+                section_has_instance = False
+                section_has_class = False
+            elif re_ret.group(2) == "Instance":
+                section_has_instance = True
+            elif not is_first_class and re_ret.group(2) == "Class":
+                if section_has_instance:
+                    test_collect_xml_lines.append("      </Instance>")
+                if section_has_class:
+                    test_collect_xml_lines.append("    </Class>")
+                has_closed_class = True
+                section_has_class = True
+            elif re_ret.group(2) == "Class":
+                is_first_class = False
+                section_has_class = True
+                has_closed_class = False
+
+            if re_ret.group(2) == "Function":
+                test_collect_xml_lines.append("          <Function name=\"{name}\"></Function>"
+                                              .format(name=re_ret.group(3)))
+            elif re_ret.group(2) == "Class":
+                test_collect_xml_lines.append("    <Class name=\"{name}\">".format(name=re_ret.group(3)))
+            elif re_ret.group(2) == "Module":
+                test_collect_xml_lines.append("  <Module name=\"{name}\">".format(name=re_ret.group(3)))
+            elif re_ret.group(2) == "Instance":
+                test_collect_xml_lines.append("      <Instance name=\"\">".format(name=re_ret.group(3)))
+            else:
+                test_collect_xml_lines.append(line)
+
+    test_collect_xml_lines.append("      </Instance>")
+    test_collect_xml_lines.append("    </Class>")
+    test_collect_xml_lines.append("  </Module>")
+    test_collect_xml_lines.append("</Modules>")
+
+    all_collected_test_modules = []
+
+    # parse the now valid xml
+    print("\n".join(test_collect_xml_lines))
+    test_collect_xml = BeautifulSoup("\n".join(test_collect_xml_lines), "lxml-xml")
+
+    # find all Modules (followed by classes in those modules, and then finally functions)
+    for pytest_module in test_collect_xml.findAll("Module"):
+        for test_class_name in pytest_module.findAll("Class"):
+            for function_name in test_class_name.findAll("Function"):
+                # adds to test list in format like test_file.py::TestClass::test_function for every test function found
+                all_collected_test_modules.append("{module_name}::{class_name}::{function_name}"
+                                                  .format(module_name=pytest_module.attrs['name'],
+                                                          class_name=test_class_name.attrs['name'],
+                                                          function_name=function_name.attrs['name']))
+
+    return all_collected_test_modules
 
 
 if __name__ == '__main__':
-    options = docopt(__doc__)
-    validated_options = validate_and_serialize_options(options)
-
-    nose_options = options['--nose-options'] or ''
-    nose_option_list = nose_options.split()
-    test_list = options['TESTS']
-    nose_argv = nose_option_list + test_list
-
-    verbosity = 1  # default verbosity level
-    if options['--runner-debug']:
-        verbosity = 2
-    if options['--runner-quiet']:  # --debug and --quiet are mutually exclusive, enforced by docopt
-        verbosity = 0
-
-    debug = print if verbosity >= 2 else _noop
-    output = print if verbosity >= 1 else _noop
-
-    # Get dictionaries corresponding to each point in the configuration matrix
-    # we want to run, then generate a config object for each of them.
-    debug('Generating configurations from the following matrix:\n\t{}'.format(validated_options))
-    all_configs = tuple(GlobalConfigObject(**d) for d in
-                        product_of_values(validated_options._asdict()))
-    output('About to run nosetests with config objects:\n'
-           '\t{configs}\n'.format(configs='\n\t'.join(map(repr, all_configs))))
-
-    results = []
-    for config in all_configs:
-        # These properties have to hold if we want to evaluate their reprs
-        # below in the generated file.
-        assert eval(repr(config), {'GlobalConfigObject': GlobalConfigObject}, {}) == config
-        assert eval(repr(nose_argv), {}, {}) == nose_argv
-
-        output('Running dtests with config object {}'.format(config))
-
-        # Generate a file that runs nose, passing in config as the
-        # configuration object.
-        #
-        # Yes, this is icky. The reason we do it is because we're dealing with
-        # global configuration. We've decided global, nosetests-run-level
-        # configuration is the way to go. This means we don't want to call
-        # nose.main() multiple times in the same Python interpreter -- I have
-        # not yet found a way to re-execute modules (thus getting new
-        # module-level configuration) for each call. This didn't even work for
-        # me with exec(script, {}, {}). So, here we are.
-        #
-        # How do we execute code in a new interpreter each time? Generate the
-        # code as text, then shell out to a new interpreter.
-        to_execute = (
-            "import nose\n" +
-            "from plugins.dtestconfig import DtestConfigPlugin, GlobalConfigObject\n" +
-            "from plugins.dtestxunit import DTestXunit\n" +
-            "from plugins.dtesttag import DTestTag\n" +
-            "from plugins.dtestcollect import DTestCollect\n" +
-            "import sys\n" +
-            "print sys.getrecursionlimit()\n" +
-            "print sys.setrecursionlimit(8000)\n" +
-            ("nose.main(addplugins=[DtestConfigPlugin({config}), DTestXunit(), DTestCollect(), DTestTag()])\n" if "TEST_TAG" in environ else "nose.main(addplugins=[DtestConfigPlugin({config}), DTestCollect(), DTestXunit()])\n")
-        ).format(config=repr(config))
-        temp = NamedTemporaryFile(dir=getcwd())
-        debug('Writing the following to {}:'.format(temp.name))
-
-        debug('```\n{to_execute}```\n'.format(to_execute=to_execute))
-        temp.write(to_execute)
-        temp.flush()
-
-        # We pass nose_argv as options to the python call to maintain
-        # compatibility with the nosetests command. Arguments passed in via the
-        # command line are treated one way, args passed in as
-        # nose.main(argv=...) are treated another. Compare with the options
-        # -xsv for an example.
-        cmd_list = [sys.executable, temp.name] + nose_argv
-        debug('subprocess.call-ing {cmd_list}'.format(cmd_list=cmd_list))
-
-        if options['--dry-run']:
-            print('Would run the following command:\n\t{}'.format(cmd_list))
-            with open(temp.name, 'r') as f:
-                contents = f.read()
-            print('{temp_name} contains:\n```\n{contents}```\n'.format(
-                temp_name=temp.name,
-                contents=contents
-            ))
-        else:
-            results.append(subprocess.call(cmd_list, env=os.environ.copy()))
-        # separate the end of the last subprocess.call output from the
-        # beginning of the next by printing a newline.
-        print()
-
-    # If this answer:
-    # http://stackoverflow.com/a/21788998/3408454
-    # is to be believed, nosetests will exit with 0 on success, 1 on test or
-    # other failure, and 2 on printing usage. We'll just grab the max of the
-    # runs we saw -- if one printed usage, the whole run "printed usage", if
-    # none printed usage, and one or more failed, we failed, else success.
-    if not results:
-        results = [0]
-    exit(max(results))
+    RunDTests().run(sys.argv[1:])

http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/schema_metadata_test.py
----------------------------------------------------------------------
diff --git a/schema_metadata_test.py b/schema_metadata_test.py
index baf8b5a..fdfcf56 100644
--- a/schema_metadata_test.py
+++ b/schema_metadata_test.py
@@ -1,10 +1,13 @@
+import pytest
+import logging
+
 from collections import defaultdict
 from uuid import uuid4
 
-from nose.tools import assert_equal, assert_in
+from dtest import Tester, create_ks
 
-from dtest import Tester, debug, create_ks
-from tools.decorators import since
+since = pytest.mark.since
+logger = logging.getLogger(__name__)
 
 
 def establish_durable_writes_keyspace(version, session, table_name_prefix=""):
@@ -32,11 +35,10 @@ def verify_durable_writes_keyspace(created_on_version, current_version, keyspace
         "durable_writes_true": True,
         "durable_writes_false": False
     }
-    for keyspace, is_durable in expected.iteritems():
+    for keyspace, is_durable in expected.items():
         keyspace_name = _cql_name_builder(table_name_prefix, keyspace)
         meta = session.cluster.metadata.keyspaces[keyspace_name]
-        assert_equal(is_durable, meta.durable_writes,
-                     "keyspace [{}] had durable_writes of [{}] should be [{}]".format(keyspace_name, meta.durable_writes, is_durable))
+        assert is_durable == meta.durable_writes, "keyspace [{}] had durable_writes of [{}] should be [{}]".format(keyspace_name, meta.durable_writes, is_durable)
 
 
 def establish_indexes_table(version, session, table_name_prefix=""):
@@ -53,29 +55,29 @@ def establish_indexes_table(version, session, table_name_prefix=""):
 
     session.execute(cql.format(table_name))
     index_name = _cql_name_builder("idx_" + table_name_prefix, table_name)
-    debug("table name: [{}], index name: [{}], prefix: [{}]".format(table_name, index_name, table_name_prefix))
+    logger.debug("table name: [{}], index name: [{}], prefix: [{}]".format(table_name, index_name, table_name_prefix))
     session.execute("CREATE INDEX {0} ON {1}( d )".format(index_name, table_name))
 
 
 def verify_indexes_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
     table_name = _cql_name_builder(table_name_prefix, "test_indexes")
     index_name = _cql_name_builder("idx_" + table_name_prefix, table_name)
-    debug("table name: [{}], index name: [{}], prefix: [{}]".format(table_name, index_name, table_name_prefix))
+    logger.debug("table name: [{}], index name: [{}], prefix: [{}]".format(table_name, index_name, table_name_prefix))
     meta = session.cluster.metadata.keyspaces[keyspace].indexes[index_name]
 
-    assert_equal('d', meta.index_options['target'])
+    assert 'd' == meta.index_options['target']
 
     meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
-    assert_equal(1, len(meta.clustering_key))
-    assert_equal('c', meta.clustering_key[0].name)
+    assert 1 == len(meta.clustering_key)
+    assert 'c' == meta.clustering_key[0].name
 
-    assert_equal(1, len(meta.indexes))
+    assert 1 == len(meta.indexes)
 
-    assert_equal({'target': 'd'}, meta.indexes[index_name].index_options)
-    assert_equal(3, len(meta.primary_key))
-    assert_equal('a', meta.primary_key[0].name)
-    assert_equal('b', meta.primary_key[1].name)
-    assert_equal('c', meta.primary_key[2].name)
+    assert {'target': 'd'} == meta.indexes[index_name].index_options
+    assert 3 == len(meta.primary_key)
+    assert 'a' == meta.primary_key[0].name
+    assert 'b' == meta.primary_key[1].name
+    assert 'c' == meta.primary_key[2].name
 
 
 def establish_clustering_order_table(version, session, table_name_prefix=""):
@@ -96,13 +98,13 @@ def establish_clustering_order_table(version, session, table_name_prefix=""):
 def verify_clustering_order_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
     table_name = _cql_name_builder(table_name_prefix, "test_clustering_order")
     meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
-    assert_equal(0, len(meta.indexes))
-    assert_equal(2, len(meta.primary_key))
-    assert_equal('event_type', meta.primary_key[0].name)
-    assert_equal('insertion_time', meta.primary_key[1].name)
-    assert_equal(1, len(meta.clustering_key))
-    assert_equal('insertion_time', meta.clustering_key[0].name)
-    assert_in('insertion_time DESC', meta.as_cql_query())
+    assert 0 == len(meta.indexes)
+    assert 2 == len(meta.primary_key)
+    assert 'event_type' == meta.primary_key[0].name
+    assert 'insertion_time' == meta.primary_key[1].name
+    assert 1 == len(meta.clustering_key)
+    assert 'insertion_time' == meta.clustering_key[0].name
+    assert 'insertion_time DESC' in meta.as_cql_query()
 
 
 def establish_compact_storage_table(version, session, table_name_prefix=""):
@@ -123,16 +125,16 @@ def establish_compact_storage_table(version, session, table_name_prefix=""):
 def verify_compact_storage_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
     table_name = _cql_name_builder(table_name_prefix, "test_compact_storage")
     meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
-    assert_equal(3, len(meta.columns))
-    assert_equal(2, len(meta.primary_key))
-    assert_equal(1, len(meta.clustering_key))
-    assert_equal('sub_block_id', meta.clustering_key[0].name)
-    assert_equal('block_id', meta.primary_key[0].name)
-    assert_equal('uuid', meta.primary_key[0].cql_type)
-    assert_equal('sub_block_id', meta.primary_key[1].name)
-    assert_equal('int', meta.primary_key[1].cql_type)
-    assert_equal(1, len(meta.clustering_key))
-    assert_equal('sub_block_id', meta.clustering_key[0].name)
+    assert 3 == len(meta.columns)
+    assert 2 == len(meta.primary_key)
+    assert 1 == len(meta.clustering_key)
+    assert 'sub_block_id' == meta.clustering_key[0].name
+    assert 'block_id' == meta.primary_key[0].name
+    assert 'uuid' == meta.primary_key[0].cql_type
+    assert 'sub_block_id' == meta.primary_key[1].name
+    assert 'int' == meta.primary_key[1].cql_type
+    assert 1 == len(meta.clustering_key)
+    assert 'sub_block_id' == meta.clustering_key[0].name
 
 
 def establish_compact_storage_composite_table(version, session, table_name_prefix=""):
@@ -153,19 +155,19 @@ def establish_compact_storage_composite_table(version, session, table_name_prefi
 def verify_compact_storage_composite_table(created_on_version, current_version, keyspace, session, table_name_prefix=""):
     table_name = _cql_name_builder(table_name_prefix, "test_compact_storage_composite")
     meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
-    assert_equal(4, len(meta.columns))
-    assert_equal(3, len(meta.primary_key))
-    assert_equal('key', meta.primary_key[0].name)
-    assert_equal('text', meta.primary_key[0].cql_type)
-    assert_equal('column1', meta.primary_key[1].name)
-    assert_equal('int', meta.primary_key[1].cql_type)
-    assert_equal('column2', meta.primary_key[2].name)
-    assert_equal('int', meta.primary_key[2].cql_type)
-    assert_equal(2, len(meta.clustering_key))
-    assert_equal('column1', meta.clustering_key[0].name)
-    assert_equal('int', meta.clustering_key[0].cql_type)
-    assert_equal('column2', meta.clustering_key[1].name)
-    assert_equal('int', meta.clustering_key[1].cql_type)
+    assert 4 == len(meta.columns)
+    assert 3 == len(meta.primary_key)
+    assert 'key' == meta.primary_key[0].name
+    assert 'text' == meta.primary_key[0].cql_type
+    assert 'column1' == meta.primary_key[1].name
+    assert 'int' == meta.primary_key[1].cql_type
+    assert 'column2' == meta.primary_key[2].name
+    assert 'int' == meta.primary_key[2].cql_type
+    assert 2 == len(meta.clustering_key)
+    assert 'column1' == meta.clustering_key[0].name
+    assert 'int' == meta.clustering_key[0].cql_type
+    assert 'column2' == meta.clustering_key[1].name
+    assert 'int' == meta.clustering_key[1].cql_type
 
 
 def establish_nondefault_table_settings(version, session, table_name_prefix=""):
@@ -213,45 +215,45 @@ def verify_nondefault_table_settings(created_on_version, current_version, keyspa
     table_name = _cql_name_builder(table_name_prefix, "test_nondefault_settings")
     meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
 
-    assert_equal('insightful information', meta.options['comment'])
-    assert_equal(0.88, meta.options['dclocal_read_repair_chance'])
-    assert_equal(9999, meta.options['gc_grace_seconds'])
-    assert_equal(0.99, meta.options['read_repair_chance'])
-    assert_equal(0.5, meta.options['bloom_filter_fp_chance'])
+    assert 'insightful information' == meta.options['comment']
+    assert 0.88 == meta.options['dclocal_read_repair_chance']
+    assert 9999 == meta.options['gc_grace_seconds']
+    assert 0.99 == meta.options['read_repair_chance']
+    assert 0.5 == meta.options['bloom_filter_fp_chance']
 
     if created_on_version >= '2.1':
-        assert_equal(86400, meta.options['default_time_to_live'])
-        assert_equal(1, meta.options['min_index_interval'])
-        assert_equal(20, meta.options['max_index_interval'])
+        assert 86400 == meta.options['default_time_to_live']
+        assert 1 == meta.options['min_index_interval']
+        assert 20 == meta.options['max_index_interval']
 
     if created_on_version >= '3.0':
-        assert_equal('55PERCENTILE', meta.options['speculative_retry'])
-        assert_equal(2121, meta.options['memtable_flush_period_in_ms'])
+        assert '55PERCENTILE' == meta.options['speculative_retry']
+        assert 2121 == meta.options['memtable_flush_period_in_ms']
 
     if current_version >= '3.0':
-        assert_equal('org.apache.cassandra.io.compress.DeflateCompressor', meta.options['compression']['class'])
-        assert_equal('128', meta.options['compression']['chunk_length_in_kb'])
-        assert_equal('org.apache.cassandra.db.compaction.LeveledCompactionStrategy', meta.options['compaction']['class'])
+        assert 'org.apache.cassandra.io.compress.DeflateCompressor' == meta.options['compression']['class']
+        assert '128' == meta.options['compression']['chunk_length_in_kb']
+        assert 'org.apache.cassandra.db.compaction.LeveledCompactionStrategy' == meta.options['compaction']['class']
 
     if '2.1' <= current_version < '3.0':
-        assert_equal('{"keys":"NONE", "rows_per_partition":"ALL"}', meta.options['caching'])
-        assert_in('"chunk_length_kb":"128"', meta.options['compression_parameters'])
-        assert_in('"sstable_compression":"org.apache.cassandra.io.compress.DeflateCompressor"', meta.options['compression_parameters'])
+        assert '{"keys":"NONE", "rows_per_partition":"ALL"}' == meta.options['caching']
+        assert '"chunk_length_kb":"128"' in meta.options['compression_parameters']
+        assert '"sstable_compression":"org.apache.cassandra.io.compress.DeflateCompressor"' in meta.options['compression_parameters']
     elif current_version >= '3.0':
-        assert_equal('NONE', meta.options['caching']['keys'])
-        assert_equal('ALL', meta.options['caching']['rows_per_partition'])
-        assert_equal('org.apache.cassandra.io.compress.DeflateCompressor', meta.options['compression']['class'])
-        assert_equal('128', meta.options['compression']['chunk_length_in_kb'])
-        assert_equal('org.apache.cassandra.db.compaction.LeveledCompactionStrategy', meta.options['compaction']['class'])
+        assert 'NONE' == meta.options['caching']['keys']
+        assert 'ALL' == meta.options['caching']['rows_per_partition']
+        assert 'org.apache.cassandra.io.compress.DeflateCompressor' == meta.options['compression']['class']
+        assert '128' == meta.options['compression']['chunk_length_in_kb']
+        assert 'org.apache.cassandra.db.compaction.LeveledCompactionStrategy' == meta.options['compaction']['class']
     else:
-        assert_equal('ROWS_ONLY', meta.options['caching'])
+        assert 'ROWS_ONLY' == meta.options['caching']
 
-    assert_equal(2, len(meta.partition_key))
-    assert_equal(meta.partition_key[0].name, 'a')
-    assert_equal(meta.partition_key[1].name, 'b')
+    assert 2 == len(meta.partition_key)
+    assert meta.partition_key[0].name == 'a'
+    assert meta.partition_key[1].name == 'b'
 
-    assert_equal(1, len(meta.clustering_key))
-    assert_equal(meta.clustering_key[0].name, 'c')
+    assert 1 == len(meta.clustering_key)
+    assert meta.clustering_key[0].name == 'c'
 
 
 def establish_uda(version, session, table_name_prefix=""):
@@ -281,13 +283,13 @@ def verify_uda(created_on_version, current_version, keyspace, session, table_nam
     function_name = _cql_name_builder(table_name_prefix, "test_uda_function")
     aggregate_name = _cql_name_builder(table_name_prefix, "test_uda_aggregate")
 
-    assert_in(function_name + "(int,int)", session.cluster.metadata.keyspaces[keyspace].functions.keys())
-    assert_in(aggregate_name + "(int)", session.cluster.metadata.keyspaces[keyspace].aggregates.keys())
+    assert function_name + "(int,int)" in list(session.cluster.metadata.keyspaces[keyspace].functions.keys())
+    assert aggregate_name + "(int)" in list(session.cluster.metadata.keyspaces[keyspace].aggregates.keys())
 
     aggr_meta = session.cluster.metadata.keyspaces[keyspace].aggregates[aggregate_name + "(int)"]
-    assert_equal(function_name, aggr_meta.state_func)
-    assert_equal('int', aggr_meta.state_type)
-    assert_equal('int', aggr_meta.return_type)
+    assert function_name == aggr_meta.state_func
+    assert 'int' == aggr_meta.state_type
+    assert 'int' == aggr_meta.return_type
 
 
 def establish_udf(version, session, table_name_prefix=""):
@@ -303,13 +305,13 @@ def verify_udf(created_on_version, current_version, keyspace, session, table_nam
     if created_on_version < '2.2':
         return
     function_name = _cql_name_builder(table_name_prefix, "test_udf")
-    assert_in(function_name + "(double)", session.cluster.metadata.keyspaces[keyspace].functions.keys())
+    assert function_name + "(double)" in list(session.cluster.metadata.keyspaces[keyspace].functions.keys())
     meta = session.cluster.metadata.keyspaces[keyspace].functions[function_name + "(double)"]
-    assert_equal('java', meta.language)
-    assert_equal('double', meta.return_type)
-    assert_equal(['double'], meta.argument_types)
-    assert_equal(['input'], meta.argument_names)
-    assert_equal('return Double.valueOf(Math.log(input.doubleValue()));', meta.body)
+    assert 'java' == meta.language
+    assert 'double' == meta.return_type
+    assert ['double'] == meta.argument_types
+    assert ['input'] == meta.argument_names
+    assert 'return Double.valueOf(Math.log(input.doubleValue()));' == meta.body
 
 
 def establish_udt_table(version, session, table_name_prefix=""):
@@ -330,13 +332,13 @@ def verify_udt_table(created_on_version, current_version, keyspace, session, tab
     table_name = _cql_name_builder(table_name_prefix, "test_udt")
     meta = session.cluster.metadata.keyspaces[keyspace].user_types[table_name]
 
-    assert_equal(meta.field_names, ['street', 'city', 'zip'])
-    assert_equal('street', meta.field_names[0])
-    assert_equal('text', meta.field_types[0])
-    assert_equal('city', meta.field_names[1])
-    assert_equal('text', meta.field_types[1])
-    assert_equal('zip', meta.field_names[2])
-    assert_equal('int', meta.field_types[2])
+    assert meta.field_names == ['street', 'city', 'zip']
+    assert 'street' == meta.field_names[0]
+    assert 'text' == meta.field_types[0]
+    assert 'city' == meta.field_names[1]
+    assert 'text' == meta.field_types[1]
+    assert 'zip' == meta.field_names[2]
+    assert 'int' == meta.field_types[2]
 
 
 def establish_static_column_table(version, session, table_name_prefix=""):
@@ -358,15 +360,15 @@ def verify_static_column_table(created_on_version, current_version, keyspace, se
         return
     table_name = _cql_name_builder(table_name_prefix, "test_static_column")
     meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
-    assert_equal(4, len(meta.columns))
-    assert_equal('text', meta.columns['user'].cql_type)
-    assert_equal(False, meta.columns['user'].is_static)
-    assert_equal('int', meta.columns['balance'].cql_type)
-    assert_equal(True, meta.columns['balance'].is_static)
-    assert_equal('int', meta.columns['expense_id'].cql_type)
-    assert_equal(False, meta.columns['expense_id'].is_static)
-    assert_equal('int', meta.columns['amount'].cql_type)
-    assert_equal(False, meta.columns['amount'].is_static)
+    assert 4 == len(meta.columns)
+    assert 'text' == meta.columns['user'].cql_type
+    assert False == meta.columns['user'].is_static
+    assert 'int' == meta.columns['balance'].cql_type
+    assert True == meta.columns['balance'].is_static
+    assert 'int' == meta.columns['expense_id'].cql_type
+    assert False == meta.columns['expense_id'].is_static
+    assert 'int' == meta.columns['amount'].cql_type
+    assert False == meta.columns['amount'].is_static
 
 
 def establish_collection_datatype_table(version, session, table_name_prefix=""):
@@ -399,24 +401,24 @@ def verify_collection_datatype_table(created_on_version, current_version, keyspa
     table_name = _cql_name_builder(table_name_prefix, "test_collection_datatypes")
     meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
     if created_on_version > '2.1':
-        assert_equal(13, len(meta.columns))
+        assert 13 == len(meta.columns)
     else:
-        assert_equal(7, len(meta.columns))
+        assert 7 == len(meta.columns)
 
-    assert_equal('list<int>', meta.columns['a'].cql_type)
-    assert_equal('list<text>', meta.columns['b'].cql_type)
-    assert_equal('set<int>', meta.columns['c'].cql_type)
-    assert_equal('set<text>', meta.columns['d'].cql_type)
-    assert_equal('map<text, text>', meta.columns['e'].cql_type)
-    assert_equal('map<text, int>', meta.columns['f'].cql_type)
+    assert 'list<int>' == meta.columns['a'].cql_type
+    assert 'list<text>' == meta.columns['b'].cql_type
+    assert 'set<int>' == meta.columns['c'].cql_type
+    assert 'set<text>' == meta.columns['d'].cql_type
+    assert 'map<text, text>' == meta.columns['e'].cql_type
+    assert 'map<text, int>' == meta.columns['f'].cql_type
 
     if created_on_version > '2.1':
-        assert_equal('frozen<list<int>>', meta.columns['g'].cql_type)
-        assert_equal('frozen<list<text>>', meta.columns['h'].cql_type)
-        assert_equal('frozen<set<int>>', meta.columns['i'].cql_type)
-        assert_equal('frozen<set<text>>', meta.columns['j'].cql_type)
-        assert_equal('frozen<map<text, text>>', meta.columns['k'].cql_type)
-        assert_equal('frozen<map<text, int>>', meta.columns['l'].cql_type)
+        assert 'frozen<list<int>>' == meta.columns['g'].cql_type
+        assert 'frozen<list<text>>' == meta.columns['h'].cql_type
+        assert 'frozen<set<int>>' == meta.columns['i'].cql_type
+        assert 'frozen<set<text>>' == meta.columns['j'].cql_type
+        assert 'frozen<map<text, text>>' == meta.columns['k'].cql_type
+        assert 'frozen<map<text, int>>' == meta.columns['l'].cql_type
 
 
 def establish_basic_datatype_table(version, session, table_name_prefix=""):
@@ -453,33 +455,33 @@ def verify_basic_datatype_table(created_on_version, current_version, keyspace, s
     table_name = _cql_name_builder(table_name_prefix, "test_basic_datatypes")
     meta = session.cluster.metadata.keyspaces[keyspace].tables[table_name]
     if created_on_version > '2.2':
-        assert_equal(19, len(meta.columns))
+        assert 19 == len(meta.columns)
     else:
-        assert_equal(15, len(meta.columns))
-
-    assert_equal(1, len(meta.primary_key))
-    assert_equal('b', meta.primary_key[0].name)
-
-    assert_equal('ascii', meta.columns['a'].cql_type)
-    assert_equal('bigint', meta.columns['b'].cql_type)
-    assert_equal('blob', meta.columns['c'].cql_type)
-    assert_equal('boolean', meta.columns['d'].cql_type)
-    assert_equal('decimal', meta.columns['e'].cql_type)
-    assert_equal('double', meta.columns['f'].cql_type)
-    assert_equal('float', meta.columns['g'].cql_type)
-    assert_equal('inet', meta.columns['h'].cql_type)
-    assert_equal('int', meta.columns['i'].cql_type)
-    assert_equal('text', meta.columns['j'].cql_type)
-    assert_equal('timestamp', meta.columns['k'].cql_type)
-    assert_equal('timeuuid', meta.columns['l'].cql_type)
-    assert_equal('uuid', meta.columns['m'].cql_type)
-    assert_equal('text', meta.columns['n'].cql_type)
-    assert_equal('varint', meta.columns['o'].cql_type)
+        assert 15 == len(meta.columns)
+
+    assert 1 == len(meta.primary_key)
+    assert 'b' == meta.primary_key[0].name
+
+    assert 'ascii' == meta.columns['a'].cql_type
+    assert 'bigint' == meta.columns['b'].cql_type
+    assert 'blob' == meta.columns['c'].cql_type
+    assert 'boolean' == meta.columns['d'].cql_type
+    assert 'decimal' == meta.columns['e'].cql_type
+    assert 'double' == meta.columns['f'].cql_type
+    assert 'float' == meta.columns['g'].cql_type
+    assert 'inet' == meta.columns['h'].cql_type
+    assert 'int' == meta.columns['i'].cql_type
+    assert 'text' == meta.columns['j'].cql_type
+    assert 'timestamp' == meta.columns['k'].cql_type
+    assert 'timeuuid' == meta.columns['l'].cql_type
+    assert 'uuid' == meta.columns['m'].cql_type
+    assert 'text' == meta.columns['n'].cql_type
+    assert 'varint' == meta.columns['o'].cql_type
     if created_on_version > '2.2':
-        assert_equal('date', meta.columns['p'].cql_type)
-        assert_equal('smallint', meta.columns['q'].cql_type)
-        assert_equal('time', meta.columns['r'].cql_type)
-        assert_equal('tinyint', meta.columns['s'].cql_type)
+        assert 'date' == meta.columns['p'].cql_type
+        assert 'smallint' == meta.columns['q'].cql_type
+        assert 'time' == meta.columns['r'].cql_type
+        assert 'tinyint' == meta.columns['s'].cql_type
 
 
 def _cql_name_builder(prefix, table_name):
@@ -495,10 +497,9 @@ def _cql_name_builder(prefix, table_name):
 
 
 class TestSchemaMetadata(Tester):
-
-    def setUp(self):
-        Tester.setUp(self)
-        cluster = self.cluster
+    @pytest.fixture(scope='function', autouse=True)
+    def fixture_set_cluster_settings(self, fixture_dtest_setup):
+        cluster = fixture_dtest_setup.cluster
         cluster.schema_event_refresh_window = 0
 
         if cluster.version() >= '3.0':
@@ -508,101 +509,101 @@ class TestSchemaMetadata(Tester):
             cluster.set_configuration_options({'enable_user_defined_functions': 'true'})
         cluster.populate(1).start()
 
-        self.session = self.patient_cql_connection(cluster.nodelist()[0])
+        self.session = fixture_dtest_setup.patient_cql_connection(cluster.nodelist()[0])
         create_ks(self.session, 'ks', 1)
 
     def _keyspace_meta(self, keyspace_name="ks"):
         self.session.cluster.refresh_schema_metadata()
         return self.session.cluster.metadata.keyspaces[keyspace_name]
 
-    def creating_and_dropping_keyspace_test(self):
+    def test_creating_and_dropping_keyspace(self):
         starting_keyspace_count = len(self.session.cluster.metadata.keyspaces)
-        self.assertEqual(True, self._keyspace_meta().durable_writes)
+        assert True == self._keyspace_meta().durable_writes
         self.session.execute("""
                 CREATE KEYSPACE so_long
                     WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}
                     AND durable_writes = false
             """)
-        self.assertEqual(False, self._keyspace_meta('so_long').durable_writes)
+        assert False == self._keyspace_meta('so_long').durable_writes
         self.session.execute("DROP KEYSPACE so_long")
-        self.assertEqual(starting_keyspace_count, len(self.session.cluster.metadata.keyspaces))
+        assert starting_keyspace_count == len(self.session.cluster.metadata.keyspaces)
 
-    def creating_and_dropping_table_test(self):
+    def test_creating_and_dropping_table(self):
         self.session.execute("create table born_to_die (id uuid primary key, name varchar)")
         meta = self._keyspace_meta().tables['born_to_die']
-        self.assertEqual('ks', meta.keyspace_name)
-        self.assertEqual('born_to_die', meta.name)
-        self.assertEqual(1, len(meta.partition_key))
-        self.assertEqual('id', meta.partition_key[0].name)
-        self.assertEqual(2, len(meta.columns))
-        self.assertIsNotNone(meta.columns.get('id'))
-        self.assertEqual('uuid', meta.columns['id'].cql_type)
-        self.assertIsNotNone(meta.columns.get('name'))
-        self.assertEqual('text', meta.columns['name'].cql_type)
-        self.assertEqual(0, len(meta.clustering_key))
-        self.assertEqual(0, len(meta.triggers))
-        self.assertEqual(0, len(meta.indexes))
+        assert 'ks' == meta.keyspace_name
+        assert 'born_to_die' == meta.name
+        assert 1 == len(meta.partition_key)
+        assert 'id' == meta.partition_key[0].name
+        assert 2 == len(meta.columns)
+        assert meta.columns.get('id') is not None
+        assert 'uuid' == meta.columns['id'].cql_type
+        assert meta.columns.get('name') is not None
+        assert 'text' == meta.columns['name'].cql_type
+        assert 0 == len(meta.clustering_key)
+        assert 0 == len(meta.triggers)
+        assert 0 == len(meta.indexes)
         self.session.execute("drop table born_to_die")
-        self.assertIsNone(self._keyspace_meta().tables.get('born_to_die'))
+        assert self._keyspace_meta().tables.get('born_to_die') is None
 
-    def creating_and_dropping_table_with_2ary_indexes_test(self):
-        self.assertEqual(0, len(self._keyspace_meta().indexes))
+    def test_creating_and_dropping_table_with_2ary_indexes(self):
+        assert 0 == len(self._keyspace_meta().indexes)
         self.session.execute("create table born_to_die (id uuid primary key, name varchar)")
         self.session.execute("create index ix_born_to_die_name on born_to_die(name)")
 
-        self.assertEqual(1, len(self._keyspace_meta().indexes))
+        assert 1 == len(self._keyspace_meta().indexes)
         ix_meta = self._keyspace_meta().indexes['ix_born_to_die_name']
-        self.assertEqual('ix_born_to_die_name', ix_meta.name)
+        assert 'ix_born_to_die_name' == ix_meta.name
 
-        self.assertEqual({'target': 'name'}, ix_meta.index_options)
-        self.assertEqual('COMPOSITES', ix_meta.kind)
+        assert {'target': 'name'} == ix_meta.index_options
+        assert 'COMPOSITES' == ix_meta.kind
 
         self.session.execute("drop table born_to_die")
-        self.assertIsNone(self._keyspace_meta().tables.get('born_to_die'))
-        self.assertIsNone(self._keyspace_meta().indexes.get('ix_born_to_die_name'))
-        self.assertEqual(0, len(self._keyspace_meta().indexes))
+        assert self._keyspace_meta().tables.get('born_to_die') is None
+        assert self._keyspace_meta().indexes.get('ix_born_to_die_name') is None
+        assert 0 == len(self._keyspace_meta().indexes)
 
     @since('2.1')
-    def creating_and_dropping_user_types_test(self):
-        self.assertEqual(0, len(self._keyspace_meta().user_types))
+    def test_creating_and_dropping_user_types(self):
+        assert 0 == len(self._keyspace_meta().user_types)
         self.session.execute("CREATE TYPE soon_to_die (foo text, bar int)")
-        self.assertEqual(1, len(self._keyspace_meta().user_types))
+        assert 1 == len(self._keyspace_meta().user_types)
 
         ut_meta = self._keyspace_meta().user_types['soon_to_die']
-        self.assertEqual('ks', ut_meta.keyspace)
-        self.assertEqual('soon_to_die', ut_meta.name)
-        self.assertEqual(['foo', 'bar'], ut_meta.field_names)
-        self.assertEqual(['text', 'int'], ut_meta.field_types)
+        assert 'ks' == ut_meta.keyspace
+        assert 'soon_to_die' == ut_meta.name
+        assert ['foo', 'bar'] == ut_meta.field_names
+        assert ['text', 'int'] == ut_meta.field_types
 
         self.session.execute("DROP TYPE soon_to_die")
-        self.assertEqual(0, len(self._keyspace_meta().user_types))
+        assert 0 == len(self._keyspace_meta().user_types)
 
     @since('2.2')
-    def creating_and_dropping_udf_test(self):
-        self.assertEqual(0, len(self._keyspace_meta().functions), "expected to start with no indexes")
+    def test_creating_and_dropping_udf(self):
+        assert 0 == len(self._keyspace_meta().functions), "expected to start with no indexes"
         self.session.execute("""
                 CREATE OR REPLACE FUNCTION ks.wasteful_function (input double)
                     CALLED ON NULL INPUT
                     RETURNS double
                     LANGUAGE java AS 'return Double.valueOf(Math.log(input.doubleValue()));';
             """)
-        self.assertEqual(1, len(self._keyspace_meta().functions), "udf count should be 1")
+        assert 1 == len(self._keyspace_meta().functions), "udf count should be 1"
         udf_meta = self._keyspace_meta().functions['wasteful_function(double)']
-        self.assertEqual('ks', udf_meta.keyspace)
-        self.assertEqual('wasteful_function', udf_meta.name)
-        self.assertEqual(['double'], udf_meta.argument_types)
-        self.assertEqual(['input'], udf_meta.argument_names)
-        self.assertEqual('double', udf_meta.return_type)
-        self.assertEqual('java', udf_meta.language)
-        self.assertEqual('return Double.valueOf(Math.log(input.doubleValue()));', udf_meta.body)
-        self.assertTrue(udf_meta.called_on_null_input)
+        assert 'ks' == udf_meta.keyspace
+        assert 'wasteful_function' == udf_meta.name
+        assert ['double'] == udf_meta.argument_types
+        assert ['input'] == udf_meta.argument_names
+        assert 'double' == udf_meta.return_type
+        assert 'java' == udf_meta.language
+        assert 'return Double.valueOf(Math.log(input.doubleValue()));' == udf_meta.body
+        assert udf_meta.called_on_null_input
         self.session.execute("DROP FUNCTION ks.wasteful_function")
-        self.assertEqual(0, len(self._keyspace_meta().functions), "expected udf list to be back to zero")
+        assert 0 == len(self._keyspace_meta().functions), "expected udf list to be back to zero"
 
     @since('2.2')
-    def creating_and_dropping_uda_test(self):
-        self.assertEqual(0, len(self._keyspace_meta().functions), "expected to start with no indexes")
-        self.assertEqual(0, len(self._keyspace_meta().aggregates), "expected to start with no aggregates")
+    def test_creating_and_dropping_uda(self):
+        assert 0 == len(self._keyspace_meta().functions), "expected to start with no indexes"
+        assert 0 == len(self._keyspace_meta().aggregates), "expected to start with no aggregates"
         self.session.execute('''
                 CREATE FUNCTION ks.max_val(current int, candidate int)
                 CALLED ON NULL INPUT
@@ -615,86 +616,86 @@ class TestSchemaMetadata(Tester):
                 STYPE int
                 INITCOND -1
             ''')
-        self.assertEqual(1, len(self._keyspace_meta().functions), "udf count should be 1")
-        self.assertEqual(1, len(self._keyspace_meta().aggregates), "uda count should be 1")
+        assert 1 == len(self._keyspace_meta().functions), "udf count should be 1"
+        assert 1 == len(self._keyspace_meta().aggregates), "uda count should be 1"
         udf_meta = self._keyspace_meta().functions['max_val(int,int)']
         uda_meta = self._keyspace_meta().aggregates['kind_of_max_agg(int)']
 
-        self.assertEqual('ks', udf_meta.keyspace)
-        self.assertEqual('max_val', udf_meta.name)
-        self.assertEqual(['int', 'int'], udf_meta.argument_types)
-        self.assertEqual(['current', 'candidate'], udf_meta.argument_names)
-        self.assertEqual('int', udf_meta.return_type)
-        self.assertEqual('java', udf_meta.language)
-        self.assertEqual('if (current == null) return candidate; else return Math.max(current, candidate);', udf_meta.body)
-        self.assertTrue(udf_meta.called_on_null_input)
-
-        self.assertEqual('ks', uda_meta.keyspace)
-        self.assertEqual('kind_of_max_agg', uda_meta.name)
-        self.assertEqual(['int'], uda_meta.argument_types)
-        self.assertEqual('max_val', uda_meta.state_func)
-        self.assertEqual('int', uda_meta.state_type)
-        self.assertEqual(None, uda_meta.final_func)
-        self.assertEqual('-1', uda_meta.initial_condition)
-        self.assertEqual('int', uda_meta.return_type)
+        assert 'ks' == udf_meta.keyspace
+        assert 'max_val' == udf_meta.name
+        assert ['int', 'int'] == udf_meta.argument_types
+        assert ['current', 'candidate'] == udf_meta.argument_names
+        assert 'int' == udf_meta.return_type
+        assert 'java' == udf_meta.language
+        assert 'if (current == null) return candidate; else return Math.max(current, candidate);' == udf_meta.body
+        assert udf_meta.called_on_null_input
+
+        assert 'ks' == uda_meta.keyspace
+        assert 'kind_of_max_agg' == uda_meta.name
+        assert ['int'] == uda_meta.argument_types
+        assert 'max_val' == uda_meta.state_func
+        assert 'int' == uda_meta.state_type
+        assert None == uda_meta.final_func
+        assert '-1' == uda_meta.initial_condition
+        assert 'int' == uda_meta.return_type
 
         self.session.execute("DROP AGGREGATE ks.kind_of_max_agg")
-        self.assertEqual(0, len(self._keyspace_meta().aggregates), "expected uda list to be back to zero")
+        assert 0 == len(self._keyspace_meta().aggregates), "expected uda list to be back to zero"
         self.session.execute("DROP FUNCTION ks.max_val")
-        self.assertEqual(0, len(self._keyspace_meta().functions), "expected udf list to be back to zero")
+        assert 0 == len(self._keyspace_meta().functions), "expected udf list to be back to zero"
 
-    def basic_table_datatype_test(self):
+    def test_basic_table_datatype(self):
         establish_basic_datatype_table(self.cluster.version(), self.session)
         verify_basic_datatype_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)
 
-    def collection_table_datatype_test(self):
+    def test_collection_table_datatype(self):
         establish_collection_datatype_table(self.cluster.version(), self.session)
         verify_collection_datatype_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)
 
-    def clustering_order_test(self):
+    def test_clustering_order(self):
         establish_clustering_order_table(self.cluster.version(), self.session)
         verify_clustering_order_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)
 
     @since("2.0", max_version="3.X")  # Compact Storage
-    def compact_storage_test(self):
+    def test_compact_storage(self):
         establish_compact_storage_table(self.cluster.version(), self.session)
         verify_compact_storage_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)
 
     @since("2.0", max_version="3.X")  # Compact Storage
-    def compact_storage_composite_test(self):
+    def test_compact_storage_composite(self):
         establish_compact_storage_composite_table(self.cluster.version(), self.session)
         verify_compact_storage_composite_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)
 
-    def nondefault_table_settings_test(self):
+    def test_nondefault_table_settings(self):
         establish_nondefault_table_settings(self.cluster.version(), self.session)
         verify_nondefault_table_settings(self.cluster.version(), self.cluster.version(), 'ks', self.session)
 
-    def indexes_test(self):
+    def test_indexes(self):
         establish_indexes_table(self.cluster.version(), self.session)
         verify_indexes_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)
 
-    def durable_writes_test(self):
+    def test_durable_writes(self):
         establish_durable_writes_keyspace(self.cluster.version(), self.session)
         verify_durable_writes_keyspace(self.cluster.version(), self.cluster.version(), 'ks', self.session)
 
     @since('2.0')
-    def static_column_test(self):
+    def test_static_column(self):
         establish_static_column_table(self.cluster.version(), self.session)
         verify_static_column_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)
 
     @since('2.1')
-    def udt_table_test(self):
+    def test_udt_table(self):
         establish_udt_table(self.cluster.version(), self.session)
         verify_udt_table(self.cluster.version(), self.cluster.version(), 'ks', self.session)
 
     @since('2.2')
-    def udf_test(self):
+    def test_udf(self):
         establish_udf(self.cluster.version(), self.session)
         self.session.cluster.refresh_schema_metadata()
         verify_udf(self.cluster.version(), self.cluster.version(), 'ks', self.session)
 
     @since('2.2')
-    def uda_test(self):
+    def test_uda(self):
         establish_uda(self.cluster.version(), self.session)
         self.session.cluster.refresh_schema_metadata()
         verify_uda(self.cluster.version(), self.cluster.version(), 'ks', self.session)

http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/schema_test.py
----------------------------------------------------------------------
diff --git a/schema_test.py b/schema_test.py
index 1553adc..8aaea3d 100644
--- a/schema_test.py
+++ b/schema_test.py
@@ -1,15 +1,19 @@
 import time
+import pytest
+import logging
 
 from cassandra.concurrent import execute_concurrent_with_args
 
 from tools.assertions import assert_invalid, assert_all, assert_one
-from tools.decorators import since
 from dtest import Tester, create_ks
 
+since = pytest.mark.since
+logger = logging.getLogger(__name__)
+
 
 class TestSchema(Tester):
 
-    def table_alteration_test(self):
+    def test_table_alteration(self):
         """
         Tests that table alters return as expected with many sstables at different schema points
         """
@@ -42,16 +46,16 @@ class TestSchema(Tester):
         rows = session.execute("select * from tbl_o_churn")
         for row in rows:
             if row.id < rows_to_insert * 5:
-                self.assertEqual(row.c1, 'bbb')
-                self.assertIsNone(row.c2)
-                self.assertFalse(hasattr(row, 'c0'))
+                assert row.c1 == 'bbb'
+                assert row.c2 is None
+                assert not hasattr(row, 'c0')
             else:
-                self.assertEqual(row.c1, 'ccc')
-                self.assertEqual(row.c2, 'ddd')
-                self.assertFalse(hasattr(row, 'c0'))
+                assert row.c1 == 'ccc'
+                assert row.c2 == 'ddd'
+                assert not hasattr(row, 'c0')
 
     @since("2.0", max_version="3.X")  # Compact Storage
-    def drop_column_compact_test(self):
+    def test_drop_column_compact(self):
         session = self.prepare()
 
         session.execute("USE ks")
@@ -59,7 +63,7 @@ class TestSchema(Tester):
 
         assert_invalid(session, "ALTER TABLE cf DROP c1", "Cannot drop columns from a")
 
-    def drop_column_compaction_test(self):
+    def test_drop_column_compaction(self):
         session = self.prepare()
         session.execute("USE ks")
         session.execute("CREATE TABLE cf (key int PRIMARY KEY, c1 int, c2 int)")
@@ -84,7 +88,7 @@ class TestSchema(Tester):
         session = self.patient_cql_connection(node)
         assert_all(session, "SELECT c1 FROM ks.cf", [[None], [None], [None], [4]], ignore_order=True)
 
-    def drop_column_queries_test(self):
+    def test_drop_column_queries(self):
         session = self.prepare()
 
         session.execute("USE ks")
@@ -116,7 +120,7 @@ class TestSchema(Tester):
 
         assert_one(session, "SELECT * FROM cf WHERE c2 = 5", [3, 4, 5])
 
-    def drop_column_and_restart_test(self):
+    def test_drop_column_and_restart(self):
         """
         Simply insert data in a table, drop a column involved in the insert and restart the node afterwards.
         This ensures that the dropped_columns system table is properly flushed on the alter or the restart
@@ -142,7 +146,7 @@ class TestSchema(Tester):
         session.execute("USE ks")
         assert_one(session, "SELECT * FROM t", [0, 0])
 
-    def drop_static_column_and_restart_test(self):
+    def test_drop_static_column_and_restart(self):
         """
         Dropping a static column caused an sstable corrupt exception after restarting, here
         we test that we can drop a static column and restart safely.


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cassandra.apache.org
For additional commands, e-mail: commits-help@cassandra.apache.org


Mime
View raw message