You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by aw...@apache.org on 2018/01/29 21:10:27 UTC
[24/36] cassandra-dtest git commit: Migrate dtests to use pytest and
python3
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/meta_tests/assertion_test.py
----------------------------------------------------------------------
diff --git a/meta_tests/assertion_test.py b/meta_tests/assertion_test.py
index a056e47..2c3fe09 100644
--- a/meta_tests/assertion_test.py
+++ b/meta_tests/assertion_test.py
@@ -34,14 +34,14 @@ class TestAssertStderrClean(TestCase):
def test_invalid_error(self):
err = "This string is no good and should fail."
- with self.assertRaises(AssertionError):
+ with pytest.raises(AssertionError):
assert_stderr_clean(err)
def test_valid_and_invalid_errors_same_line(self):
err = ("This string is no good and should fail.objc[36358]: Class JavaLaunchHelper is implemented in both /Library/Java/JavaVirtualMachines/jdk1.8.0_91.jdk"
"/Contents/Home/bin/java and /Library/Java/JavaVirtualMachines/jdk1.8.0_91.jdk/Contents/Home/jre/lib/libinstrument.dylib."
"One of the two will be used. Which one is undefined.")
- with self.assertRaises(AssertionError):
+ with pytest.raises(AssertionError):
assert_stderr_clean(err)
def test_invalid_error_after_valid_error(self):
@@ -49,7 +49,7 @@ class TestAssertStderrClean(TestCase):
/Contents/Home/bin/java and /Library/Java/JavaVirtualMachines/jdk1.8.0_91.jdk/Contents/Home/jre/lib/libinstrument.dylib.
One of the two will be used. Which one is undefined.
This string is no good and should fail."""
- with self.assertRaises(AssertionError):
+ with pytest.raises(AssertionError):
assert_stderr_clean(err)
def test_invalid_error_before_valid_errors(self):
@@ -57,13 +57,13 @@ class TestAssertStderrClean(TestCase):
Class JavaLaunchHelper is implemented in both /Library/Java/JavaVirtualMachines/jdk1.8.0_91.jdk/Contents/Home/bin/java
and /Library/Java/JavaVirtualMachines/jdk1.8.0_91.jdk/Contents/Home/jre/lib/libinstrument.dylib. One of the two will be used. Which one is undefined.
"""
- with self.assertRaises(AssertionError):
+ with pytest.raises(AssertionError):
assert_stderr_clean(err)
class TestAssertionMethods(TestCase):
- def assertions_test(self):
+ def test_assertions(self):
# assert_exception_test
mock_session = Mock(**{'execute.side_effect': AlreadyExists("Dummy exception message.")})
assert_exception(mock_session, "DUMMY QUERY", expected=AlreadyExists)
@@ -111,5 +111,5 @@ class TestAssertionMethods(TestCase):
assert_almost_equal(1, 1.1, 1.3, error=.31)
def test_almost_equal_expect_failure(self):
- with self.assertRaises(AssertionError):
+ with pytest.raises(AssertionError):
assert_almost_equal(1, 1.3, error=.1)
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/meta_tests/utils_test/funcutils_test.py
----------------------------------------------------------------------
diff --git a/meta_tests/utils_test/funcutils_test.py b/meta_tests/utils_test/funcutils_test.py
index 3bbddd5..4d99c36 100644
--- a/meta_tests/utils_test/funcutils_test.py
+++ b/meta_tests/utils_test/funcutils_test.py
@@ -18,7 +18,7 @@ class Testget_rate_limited_function(TestCase):
"""
self.assertIs(rate_limited_func_arg.func, self.mock_func)
self.assertIs(rate_limited_func_arg.limit, self.mock_limit)
- self.assertEqual(rate_limited_func_arg.last_called, False)
+ assert rate_limited_func_arg.last_called == False
def test_init_with_positional_args(self):
"""
@@ -106,16 +106,16 @@ class Testget_rate_limited_function(TestCase):
If you call a rate-limited function, last_called is set to a new value.
"""
self.rate_limited_func.limit = 1
- self.assertEqual(self.rate_limited_func.last_called, False)
+ assert self.rate_limited_func.last_called == False
self.rate_limited_func()
- self.assertAlmostEqual(self.rate_limited_func.last_called, time(), places=2)
+ assert abs(round(self.rate_limited_func.last_called, 2) - round(time(), 2)) <= 0.0
def test_last_called_not_set_when_called_within_time_limit(self):
"""
If you call a rate-limited function during the time limit, last_called is not set to a new value.
"""
self.rate_limited_func.limit = 1
- self.assertEqual(self.rate_limited_func.last_called, False)
+ assert self.rate_limited_func.last_called == False
self.rate_limited_func()
last_called = self.rate_limited_func.last_called
self.rate_limited_func()
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/meta_tests/utils_test/metadata_wrapper_test.py
----------------------------------------------------------------------
diff --git a/meta_tests/utils_test/metadata_wrapper_test.py b/meta_tests/utils_test/metadata_wrapper_test.py
index 9009eac..4a8afc5 100644
--- a/meta_tests/utils_test/metadata_wrapper_test.py
+++ b/meta_tests/utils_test/metadata_wrapper_test.py
@@ -10,7 +10,7 @@ from tools.metadata_wrapper import (UpdatingClusterMetadataWrapper,
class UpdatingMetadataWrapperBaseTest(TestCase):
- def all_subclasses_known_test(self):
+ def test_all_subclasses_known(self):
"""
Test that all the subclasses of UpdatingMetadataWrapperBase are known
to this test suite. Basically, this will slap us on the wrist in the
@@ -40,7 +40,7 @@ class UpdatingMetadataWrapperBaseTest(TestCase):
init_args = [MagicMock() for _ in range(init_arg_len - 1)]
yield klaus(*init_args)
- def all_subclasses_defer_getattr_test(self):
+ def test_all_subclasses_defer_getattr(self):
"""
Each subclass should defer its attribute accesses to the wrapped
object.
@@ -48,7 +48,7 @@ class UpdatingMetadataWrapperBaseTest(TestCase):
for wrapper in self._each_subclass_instantiated_with_mock_args():
self.assertIs(wrapper.foo, wrapper._wrapped.foo)
- def all_subclasses_defer_getitem_test(self):
+ def test_all_subclasses_defer_getitem(self):
"""
Each subclass should defer its item accesses to the wrapped object.
"""
@@ -57,8 +57,8 @@ class UpdatingMetadataWrapperBaseTest(TestCase):
# from _wrapped[Y] for all Y
wrapper._wrapped.__getitem__.side_effect = hash
# check mocking correctness
- self.assertNotEqual(wrapper['foo'], wrapper._wrapped['bar'])
- self.assertEqual(wrapper['bar'], wrapper._wrapped['bar'])
+ assert wrapper['foo'] != wrapper._wrapped['bar']
+ assert wrapper['bar'] == wrapper._wrapped['bar']
class UpdatingTableMetadataWrapperTest(TestCase):
@@ -74,7 +74,7 @@ class UpdatingTableMetadataWrapperTest(TestCase):
max_schema_agreement_wait=self.max_schema_agreement_wait_sentinel
)
- def wrapped_access_calls_refresh_test(self):
+ def test_wrapped_access_calls_refresh(self):
"""
Accessing the wrapped object should call the table-refreshing method on
the cluster.
@@ -87,7 +87,7 @@ class UpdatingTableMetadataWrapperTest(TestCase):
max_schema_agreement_wait=self.max_schema_agreement_wait_sentinel
)
- def default_wrapper_max_schema_agreement_wait_is_None_test(self):
+ def test_default_wrapper_max_schema_agreement_wait_is_None(self):
wrapper = UpdatingTableMetadataWrapper(
cluster=self.cluster_mock,
ks_name=self.ks_name_sentinel,
@@ -100,7 +100,7 @@ class UpdatingTableMetadataWrapperTest(TestCase):
max_schema_agreement_wait=None
)
- def wrapped_returns_table_metadata_test(self):
+ def test_wrapped_returns_table_metadata(self):
"""
The wrapped object is accessed correctly from the internal cluster object.
"""
@@ -115,17 +115,12 @@ class UpdatingTableMetadataWrapperTest(TestCase):
keyspaces_defaultdict[self.ks_name_sentinel].tables.__getitem__.side_effect = hash
# check mocking correctness
- self.assertNotEqual(
- self.wrapper._wrapped,
- self.cluster_mock.metadata.keyspaces[self.ks_name_sentinel].tables['foo']
- )
+ assert self.wrapper._wrapped != self.cluster_mock.metadata.keyspaces[self.ks_name_sentinel].tables['foo']
+
# and this is the behavior we care about
- self.assertEqual(
- self.wrapper._wrapped,
- self.cluster_mock.metadata.keyspaces[self.ks_name_sentinel].tables[self.table_name_sentinel]
- )
+ assert self.wrapper._wrapped ==self.cluster_mock.metadata.keyspaces[self.ks_name_sentinel].tables[self.table_name_sentinel]
- def repr_test(self):
+ def test_repr(self):
self.assertEqual(
repr(self.wrapper),
'UpdatingTableMetadataWrapper(cluster={}, ks_name={}, table_name={}, max_schema_agreement_wait={})'.format(
@@ -145,7 +140,7 @@ class UpdatingKeyspaceMetadataWrapperTest(TestCase):
max_schema_agreement_wait=self.max_schema_agreement_wait_sentinel
)
- def wrapped_access_calls_refresh_test(self):
+ def test_wrapped_access_calls_refresh(self):
"""
Accessing the wrapped object should call the keyspace-refreshing method
on the cluster.
@@ -157,7 +152,7 @@ class UpdatingKeyspaceMetadataWrapperTest(TestCase):
max_schema_agreement_wait=self.max_schema_agreement_wait_sentinel
)
- def default_wrapper_max_schema_agreement_wait_is_None_test(self):
+ def test_default_wrapper_max_schema_agreement_wait_is_None(self):
wrapper = UpdatingKeyspaceMetadataWrapper(
cluster=self.cluster_mock,
ks_name=self.ks_name_sentinel
@@ -168,7 +163,7 @@ class UpdatingKeyspaceMetadataWrapperTest(TestCase):
max_schema_agreement_wait=None
)
- def wrapped_returns_keyspace_metadata_test(self):
+ def test_wrapped_returns_keyspace_metadata(self):
"""
The wrapped object is accessed correctly from the internal cluster object.
"""
@@ -176,10 +171,10 @@ class UpdatingKeyspaceMetadataWrapperTest(TestCase):
# from keyspaces[Y] for all Y
self.cluster_mock.metadata.keyspaces.__getitem__.side_effect = hash
# check mocking correctness
- self.assertNotEqual(self.wrapper._wrapped, self.cluster_mock.metadata.keyspaces['foo'])
- self.assertEqual(self.wrapper._wrapped, self.cluster_mock.metadata.keyspaces[self.ks_name_sentinel])
+ assert self.wrapper._wrapped != self.cluster_mock.metadata.keyspaces['foo']
+ assert self.wrapper._wrapped == self.cluster_mock.metadata.keyspaces[self.ks_name_sentinel]
- def repr_test(self):
+ def test_repr(self):
self.assertEqual(
repr(self.wrapper),
'UpdatingKeyspaceMetadataWrapper(cluster={}, ks_name={}, max_schema_agreement_wait={})'.format(
@@ -198,7 +193,7 @@ class UpdatingClusterMetadataWrapperTest(TestCase):
max_schema_agreement_wait=self.max_schema_agreement_wait_sentinel
)
- def wrapped_access_calls_refresh_test(self):
+ def test_wrapped_access_calls_refresh(self):
"""
Accessing the wrapped object should call the schema-refreshing method
on the cluster.
@@ -209,20 +204,20 @@ class UpdatingClusterMetadataWrapperTest(TestCase):
max_schema_agreement_wait=self.max_schema_agreement_wait_sentinel
)
- def default_wrapper_max_schema_agreement_wait_is_None_test(self):
+ def test_default_wrapper_max_schema_agreement_wait_is_None(self):
wrapper = UpdatingClusterMetadataWrapper(cluster=self.cluster_mock)
wrapper._wrapped
self.cluster_mock.refresh_schema_metadata.assert_called_once_with(
max_schema_agreement_wait=None
)
- def wrapped_returns_cluster_metadata_test(self):
+ def test_wrapped_returns_cluster_metadata(self):
"""
The wrapped object is accessed correctly from the internal cluster object.
"""
self.assertIs(self.wrapper._wrapped, self.cluster_mock.metadata)
- def repr_test(self):
+ def test_repr(self):
self.assertEqual(
repr(self.wrapper),
'UpdatingClusterMetadataWrapper(cluster={}, max_schema_agreement_wait={})'.format(
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/metadata_test.py
----------------------------------------------------------------------
diff --git a/metadata_test.py b/metadata_test.py
new file mode 100644
index 0000000..90141e7
--- /dev/null
+++ b/metadata_test.py
@@ -0,0 +1,68 @@
+import threading
+import time
+import logging
+import pytest
+
+from dtest import Tester
+
+logger = logging.getLogger(__name__)
+
+
+class TestMetadata(Tester):
+
+ def force_compact(self):
+ cluster = self.cluster
+ (node1, node2) = cluster.nodelist()
+ node1.nodetool("compact keyspace1 standard1")
+
+ def force_repair(self):
+ cluster = self.cluster
+ (node1, node2) = cluster.nodelist()
+ node1.nodetool('repair keyspace1 standard1')
+
+ def do_read(self):
+ cluster = self.cluster
+ (node1, node2) = cluster.nodelist()
+
+ node1.stress(['read', 'no-warmup', 'n=30000', '-schema', 'replication(factor=2)', 'compression=LZ4Compressor',
+ '-rate', 'threads=1'])
+
+ @pytest.mark.skip(reason='hangs CI')
+ def test_metadata_reset_while_compact(self):
+ """
+ Resets the schema while a compact, read and repair happens.
+ All kinds of glorious things can fail.
+ """
+ # while the schema is being reset, there will inevitably be some
+ # queries that will error with this message
+ self.fixture_dtest_setup.ignore_log_patterns = ['.*Unknown keyspace/cf pair.*']
+
+ cluster = self.cluster
+ cluster.populate(2).start(wait_other_notice=True)
+ (node1, node2) = cluster.nodelist()
+
+ node1.nodetool("disableautocompaction")
+ node1.nodetool("setcompactionthroughput 1")
+
+ for i in range(3):
+ node1.stress(['write', 'no-warmup', 'n=30000', '-schema', 'replication(factor=2)',
+ 'compression=LZ4Compressor', '-rate', 'threads=5', '-pop', 'seq=1..30000'])
+ node1.flush()
+
+ thread = threading.Thread(target=self.force_compact)
+ thread.start()
+ time.sleep(1)
+
+ thread2 = threading.Thread(target=self.force_repair)
+ thread2.start()
+ time.sleep(5)
+
+ thread3 = threading.Thread(target=self.do_read)
+ thread3.start()
+ time.sleep(5)
+
+ node1.nodetool("resetlocalschema")
+
+ thread.join()
+ thread2.join()
+ thread3.join()
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/metadata_tests.py
----------------------------------------------------------------------
diff --git a/metadata_tests.py b/metadata_tests.py
deleted file mode 100644
index 9c5ee2e..0000000
--- a/metadata_tests.py
+++ /dev/null
@@ -1,65 +0,0 @@
-import threading
-import time
-from unittest import skip
-
-from dtest import Tester
-
-
-class TestMetadata(Tester):
-
- def force_compact(self):
- cluster = self.cluster
- (node1, node2) = cluster.nodelist()
- node1.nodetool("compact keyspace1 standard1")
-
- def force_repair(self):
- cluster = self.cluster
- (node1, node2) = cluster.nodelist()
- node1.nodetool('repair keyspace1 standard1')
-
- def do_read(self):
- cluster = self.cluster
- (node1, node2) = cluster.nodelist()
-
- node1.stress(['read', 'no-warmup', 'n=30000', '-schema', 'replication(factor=2)', 'compression=LZ4Compressor',
- '-rate', 'threads=1'])
-
- @skip('hangs CI')
- def metadata_reset_while_compact_test(self):
- """
- Resets the schema while a compact, read and repair happens.
- All kinds of glorious things can fail.
- """
-
- # while the schema is being reset, there will inevitably be some
- # queries that will error with this message
- self.ignore_log_patterns = '.*Unknown keyspace/cf pair.*'
-
- cluster = self.cluster
- cluster.populate(2).start(wait_other_notice=True)
- (node1, node2) = cluster.nodelist()
-
- node1.nodetool("disableautocompaction")
- node1.nodetool("setcompactionthroughput 1")
-
- for i in range(3):
- node1.stress(['write', 'no-warmup', 'n=30000', '-schema', 'replication(factor=2)', 'compression=LZ4Compressor', '-rate', 'threads=5', '-pop', 'seq=1..30000'])
- node1.flush()
-
- thread = threading.Thread(target=self.force_compact)
- thread.start()
- time.sleep(1)
-
- thread2 = threading.Thread(target=self.force_repair)
- thread2.start()
- time.sleep(5)
-
- thread3 = threading.Thread(target=self.do_read)
- thread3.start()
- time.sleep(5)
-
- node1.nodetool("resetlocalschema")
-
- thread.join()
- thread2.join()
- thread3.join()
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/mixed_version_test.py
----------------------------------------------------------------------
diff --git a/mixed_version_test.py b/mixed_version_test.py
index 9da28b9..6fc656a 100644
--- a/mixed_version_test.py
+++ b/mixed_version_test.py
@@ -1,8 +1,13 @@
+import pytest
+import logging
+
from cassandra import ConsistencyLevel, OperationTimedOut, ReadTimeout
from cassandra.query import SimpleStatement
-from dtest import Tester, debug
-from tools.decorators import since
+from dtest import Tester
+
+since = pytest.mark.since
+logger = logging.getLogger(__name__)
class TestSchemaChanges(Tester):
@@ -20,19 +25,20 @@ class TestSchemaChanges(Tester):
node1, node2 = cluster.nodelist()
original_version = node1.get_cassandra_version()
+ upgraded_version = None
if original_version.vstring.startswith('2.0'):
upgraded_version = 'github:apache/cassandra-2.1'
elif original_version.vstring.startswith('2.1'):
upgraded_version = 'github:apache/cassandra-2.2'
else:
- self.skip("This test is only designed to work with 2.0 and 2.1 right now")
+ pytest.skip(msg="This test is only designed to work with 2.0 and 2.1 right now")
# start out with a major behind the previous version
# upgrade node1
node1.stop()
node1.set_install_dir(version=upgraded_version)
- debug("Set new cassandra dir for %s: %s" % (node1.name, node1.get_install_dir()))
+ logger.debug("Set new cassandra dir for %s: %s" % (node1.name, node1.get_install_dir()))
node1.set_log_level("INFO")
node1.start()
@@ -40,8 +46,9 @@ class TestSchemaChanges(Tester):
session = self.patient_exclusive_cql_connection(node1)
session.cluster.max_schema_agreement_wait = -1 # don't wait for schema agreement
- debug("Creating keyspace and table")
- session.execute("CREATE KEYSPACE test_upgrades WITH replication={'class': 'SimpleStrategy', 'replication_factor': '2'}")
+ logger.debug("Creating keyspace and table")
+ session.execute("CREATE KEYSPACE test_upgrades WITH replication={'class': 'SimpleStrategy', "
+ "'replication_factor': '2'}")
session.execute("CREATE TABLE test_upgrades.foo (a int primary key, b int)")
pattern = r".*Got .* command for nonexistent table test_upgrades.foo.*"
@@ -50,15 +57,16 @@ class TestSchemaChanges(Tester):
session.execute(SimpleStatement("SELECT * FROM test_upgrades.foo", consistency_level=ConsistencyLevel.ALL))
self.fail("expected failure")
except (ReadTimeout, OperationTimedOut):
- debug("Checking node2 for warning in log")
+ logger.debug("Checking node2 for warning in log")
node2.watch_log_for(pattern, timeout=10)
# non-paged range slice
try:
- session.execute(SimpleStatement("SELECT * FROM test_upgrades.foo", consistency_level=ConsistencyLevel.ALL, fetch_size=None))
+ session.execute(SimpleStatement("SELECT * FROM test_upgrades.foo", consistency_level=ConsistencyLevel.ALL,
+ fetch_size=None))
self.fail("expected failure")
except (ReadTimeout, OperationTimedOut):
- debug("Checking node2 for warning in log")
+ logger.debug("Checking node2 for warning in log")
pattern = r".*Got .* command for nonexistent table test_upgrades.foo.*"
node2.watch_log_for(pattern, timeout=10)
@@ -69,6 +77,6 @@ class TestSchemaChanges(Tester):
consistency_level=ConsistencyLevel.ALL, fetch_size=None))
self.fail("expected failure")
except (ReadTimeout, OperationTimedOut):
- debug("Checking node2 for warning in log")
+ logger.debug("Checking node2 for warning in log")
pattern = r".*Got .* command for nonexistent table test_upgrades.foo.*"
node2.watch_log_for(pattern, timeout=10)
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/multidc_putget_test.py
----------------------------------------------------------------------
diff --git a/multidc_putget_test.py b/multidc_putget_test.py
index bad3fad..3af0c9a 100644
--- a/multidc_putget_test.py
+++ b/multidc_putget_test.py
@@ -1,10 +1,14 @@
+import logging
+
from dtest import Tester, create_ks, create_cf
from tools.data import putget
+logger = logging.getLogger(__name__)
+
class TestMultiDCPutGet(Tester):
- def putget_2dc_rf1_test(self):
+ def test_putget_2dc_rf1(self):
""" Simple put-get test for 2 DC with one node each (RF=1) [catches #3539] """
cluster = self.cluster
cluster.populate([1, 1]).start()
@@ -15,7 +19,7 @@ class TestMultiDCPutGet(Tester):
putget(cluster, session)
- def putget_2dc_rf2_test(self):
+ def test_putget_2dc_rf2(self):
""" Simple put-get test for 2 DC with 2 node each (RF=2) -- tests cross-DC efficient writes """
cluster = self.cluster
cluster.populate([2, 2]).start()
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/native_transport_ssl_test.py
----------------------------------------------------------------------
diff --git a/native_transport_ssl_test.py b/native_transport_ssl_test.py
index 4716c80..284617d 100644
--- a/native_transport_ssl_test.py
+++ b/native_transport_ssl_test.py
@@ -1,20 +1,24 @@
import os
+import pytest
+import logging
from cassandra import ConsistencyLevel
from cassandra.cluster import NoHostAvailable
from dtest import Tester, create_ks, create_cf
from tools.data import putget
-from tools.decorators import since
from tools.misc import generate_ssl_stores
+since = pytest.mark.since
+logger = logging.getLogger(__name__)
-class NativeTransportSSL(Tester):
+
+class TestNativeTransportSSL(Tester):
"""
Native transport integration tests, specifically for ssl and port configurations.
"""
- def connect_to_ssl_test(self):
+ def test_connect_to_ssl(self):
"""
Connecting to SSL enabled native transport port should only be possible using SSL enabled client
"""
@@ -30,13 +34,13 @@ class NativeTransportSSL(Tester):
except NoHostAvailable:
pass
- self.assertGreater(len(node1.grep_log("io.netty.handler.ssl.NotSslRecordException.*")), 0, "Missing SSL handshake exception while connecting with non-SSL enabled client")
+ assert len(node1.grep_log("io.netty.handler.ssl.NotSslRecordException.*")), 0 > "Missing SSL handshake exception while connecting with non-SSL enabled client"
# enabled ssl on the client and try again (this should work)
- session = self.patient_cql_connection(node1, ssl_opts={'ca_certs': os.path.join(self.test_path, 'ccm_node.cer')})
+ session = self.patient_cql_connection(node1, ssl_opts={'ca_certs': os.path.join(self.fixture_dtest_setup.test_path, 'ccm_node.cer')})
self._putget(cluster, session)
- def connect_to_ssl_optional_test(self):
+ def test_connect_to_ssl_optional(self):
"""
Connecting to SSL optional native transport port must be possible with SSL and non-SSL native clients
@jira_ticket CASSANDRA-10559
@@ -50,14 +54,13 @@ class NativeTransportSSL(Tester):
self._putget(cluster, session)
# enabled ssl on the client and try again (this should work)
- session = self.patient_cql_connection(node1, ssl_opts={'ca_certs': os.path.join(self.test_path, 'ccm_node.cer')})
+ session = self.patient_cql_connection(node1, ssl_opts={'ca_certs': os.path.join(self.fixture_dtest_setup.test_path, 'ccm_node.cer')})
self._putget(cluster, session, ks='ks2')
- def use_custom_port_test(self):
+ def test_use_custom_port(self):
"""
Connect to non-default native transport port
"""
-
cluster = self._populateCluster(nativePort=9567)
node1 = cluster.nodelist()[0]
@@ -72,12 +75,11 @@ class NativeTransportSSL(Tester):
self._putget(cluster, session)
@since('3.0')
- def use_custom_ssl_port_test(self):
+ def test_use_custom_ssl_port(self):
"""
Connect to additional ssl enabled native transport port
@jira_ticket CASSANDRA-9590
"""
-
cluster = self._populateCluster(enableSSL=True, nativePortSSL=9666)
node1 = cluster.nodelist()[0]
cluster.start()
@@ -87,14 +89,14 @@ class NativeTransportSSL(Tester):
self._putget(cluster, session)
# connect to additional dedicated ssl port
- session = self.patient_cql_connection(node1, port=9666, ssl_opts={'ca_certs': os.path.join(self.test_path, 'ccm_node.cer')})
+ session = self.patient_cql_connection(node1, port=9666, ssl_opts={'ca_certs': os.path.join(self.fixture_dtest_setup.test_path, 'ccm_node.cer')})
self._putget(cluster, session, ks='ks2')
def _populateCluster(self, enableSSL=False, nativePort=None, nativePortSSL=None, sslOptional=False):
cluster = self.cluster
if enableSSL:
- generate_ssl_stores(self.test_path)
+ generate_ssl_stores(self.fixture_dtest_setup.test_path)
# C* versions before 3.0 (CASSANDRA-10559) do not know about
# 'client_encryption_options.optional' - so we must not add that parameter
if sslOptional:
@@ -102,7 +104,7 @@ class NativeTransportSSL(Tester):
'client_encryption_options': {
'enabled': True,
'optional': sslOptional,
- 'keystore': os.path.join(self.test_path, 'keystore.jks'),
+ 'keystore': os.path.join(self.fixture_dtest_setup.test_path, 'keystore.jks'),
'keystore_password': 'cassandra'
}
})
@@ -110,7 +112,7 @@ class NativeTransportSSL(Tester):
cluster.set_configuration_options({
'client_encryption_options': {
'enabled': True,
- 'keystore': os.path.join(self.test_path, 'keystore.jks'),
+ 'keystore': os.path.join(self.fixture_dtest_setup.test_path, 'keystore.jks'),
'keystore_password': 'cassandra'
}
})
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/nodetool_test.py
----------------------------------------------------------------------
diff --git a/nodetool_test.py b/nodetool_test.py
index b00e442..e913b30 100644
--- a/nodetool_test.py
+++ b/nodetool_test.py
@@ -1,12 +1,19 @@
import os
+import pytest
+import re
+import logging
+
from cassandra import ConsistencyLevel
from cassandra.query import SimpleStatement
from ccmlib.node import ToolError
-from dtest import Tester, debug, create_ks
+
+from dtest import Tester, create_ks
from tools.assertions import assert_all, assert_invalid, assert_none
-from tools.decorators import since
from tools.jmxutils import JolokiaAgent, make_mbean, remove_perf_disable_shared_mem
+since = pytest.mark.since
+logger = logging.getLogger(__name__)
+
class TestNodetool(Tester):
@@ -26,10 +33,10 @@ class TestNodetool(Tester):
try:
node.decommission()
- self.assertFalse("Expected nodetool error")
+ assert not "Expected nodetool error"
except ToolError as e:
- self.assertEqual('', e.stderr)
- self.assertTrue('Unsupported operation' in e.stdout)
+ assert '' == e.stderr
+ assert 'Unsupported operation' in e.stdout
def test_correct_dc_rack_in_nodetool_info(self):
"""
@@ -51,16 +58,19 @@ class TestNodetool(Tester):
for i, node in enumerate(cluster.nodelist()):
out, err, _ = node.nodetool('info')
- self.assertEqual(0, len(err), err)
- debug(out)
- for line in out.split(os.linesep):
+ assert 0 == len(err), err
+ out_str = out
+ if isinstance(out, (bytes, bytearray)):
+ out_str = out.decode("utf-8")
+ logger.debug(out_str)
+ for line in out_str.split(os.linesep):
if line.startswith('Data Center'):
- self.assertTrue(line.endswith(node.data_center),
- "Expected dc {} for {} but got {}".format(node.data_center, node.address(), line.rsplit(None, 1)[-1]))
+ assert line.endswith(node.data_center), \
+ "Expected dc {} for {} but got {}".format(node.data_center, node.address(), line.rsplit(None, 1)[-1])
elif line.startswith('Rack'):
rack = "rack{}".format(i % 2)
- self.assertTrue(line.endswith(rack),
- "Expected rack {} for {} but got {}".format(rack, node.address(), line.rsplit(None, 1)[-1]))
+ assert line.endswith(rack), \
+ "Expected rack {} for {} but got {}".format(rack, node.address(), line.rsplit(None, 1)[-1])
@since('3.4')
def test_nodetool_timeout_commands(self):
@@ -81,21 +91,21 @@ class TestNodetool(Tester):
# read all of the timeouts, make sure we get a sane response
for timeout_type in types:
out, err, _ = node.nodetool('gettimeout {}'.format(timeout_type))
- self.assertEqual(0, len(err), err)
- debug(out)
- self.assertRegexpMatches(out, r'.* \d+ ms')
+ assert 0 == len(err), err
+ logger.debug(out)
+ assert re.search(r'.* \d+ ms', out)
# set all of the timeouts to 123
for timeout_type in types:
_, err, _ = node.nodetool('settimeout {} 123'.format(timeout_type))
- self.assertEqual(0, len(err), err)
+ assert 0 == len(err), err
# verify that they're all reported as 123
for timeout_type in types:
out, err, _ = node.nodetool('gettimeout {}'.format(timeout_type))
- self.assertEqual(0, len(err), err)
- debug(out)
- self.assertRegexpMatches(out, r'.* 123 ms')
+ assert 0 == len(err), err
+ logger.debug(out)
+ assert re.search(r'.* 123 ms', out)
@since('3.0')
def test_cleanup_when_no_replica_with_index(self):
@@ -132,9 +142,9 @@ class TestNodetool(Tester):
self.cluster.flush()
for node in self.cluster.nodelist():
- self.assertNotEqual(0, len(node.get_sstables('ks', 'cf')))
+ assert 0 != len(node.get_sstables('ks', 'cf'))
if with_index:
- self.assertEqual(len(list(session_dc2.execute("SELECT * FROM ks.cf WHERE value = 'value'"))), 100)
+ assert 100 == len(list(session_dc2.execute("SELECT * FROM ks.cf WHERE value = 'value'"))), 100
# alter rf to only dc1
session.execute("ALTER KEYSPACE ks WITH REPLICATION = {'class' : 'NetworkTopologyStrategy', 'dc1' : 1, 'dc2' : 0};")
@@ -146,16 +156,16 @@ class TestNodetool(Tester):
# check local data on dc2
for node in self.cluster.nodelist():
if node.data_center == 'dc2':
- self.assertEqual(0, len(node.get_sstables('ks', 'cf')))
+ assert 0 == len(node.get_sstables('ks', 'cf'))
else:
- self.assertNotEqual(0, len(node.get_sstables('ks', 'cf')))
+ assert 0 != len(node.get_sstables('ks', 'cf'))
# dc1 data remains
statement = SimpleStatement("SELECT * FROM ks.cf", consistency_level=ConsistencyLevel.LOCAL_ONE)
- self.assertEqual(len(list(session.execute(statement))), 100)
+ assert 100 == len(list(session.execute(statement)))
if with_index:
statement = SimpleStatement("SELECT * FROM ks.cf WHERE value = 'value'", consistency_level=ConsistencyLevel.LOCAL_ONE)
- self.assertEqual(len(list(session.execute(statement))), 100)
+ assert len(list(session.execute(statement))) == 100
# alter rf back to query dc2, no data, no index
session.execute("ALTER KEYSPACE ks WITH REPLICATION = {'class' : 'NetworkTopologyStrategy', 'dc1' : 0, 'dc2' : 1};")
@@ -182,30 +192,30 @@ class TestNodetool(Tester):
# Do a first try without any keypace, we shouldn't have the notice
out, err, _ = node.nodetool('status')
- self.assertEqual(0, len(err), err)
- self.assertNotRegexpMatches(out, notice_message)
+ assert 0 == len(err), err
+ assert not re.search(notice_message, out)
session = self.patient_cql_connection(node)
session.execute("CREATE KEYSPACE ks1 WITH replication = { 'class':'SimpleStrategy', 'replication_factor':1}")
# With 1 keyspace, we should still not get the notice
out, err, _ = node.nodetool('status')
- self.assertEqual(0, len(err), err)
- self.assertNotRegexpMatches(out, notice_message)
+ assert 0 == len(err), err
+ assert not re.search(notice_message, out)
session.execute("CREATE KEYSPACE ks2 WITH replication = { 'class':'SimpleStrategy', 'replication_factor':1}")
# With 2 keyspaces with the same settings, we should not get the notice
out, err, _ = node.nodetool('status')
- self.assertEqual(0, len(err), err)
- self.assertNotRegexpMatches(out, notice_message)
+ assert 0 == len(err), err
+ assert not re.search(notice_message, out)
session.execute("CREATE KEYSPACE ks3 WITH replication = { 'class':'SimpleStrategy', 'replication_factor':3}")
# With a keyspace without the same replication factor, we should get the notice
out, err, _ = node.nodetool('status')
- self.assertEqual(0, len(err), err)
- self.assertRegexpMatches(out, notice_message)
+ assert 0 == len(err), err
+ assert re.search(notice_message, out)
@since('4.0')
def test_set_get_batchlog_replay_throttle(self):
@@ -220,14 +230,14 @@ class TestNodetool(Tester):
cluster.start()
# Test that nodetool help messages are displayed
- self.assertTrue('Set batchlog replay throttle' in node.nodetool('help setbatchlogreplaythrottle').stdout)
- self.assertTrue('Print batchlog replay throttle' in node.nodetool('help getbatchlogreplaythrottle').stdout)
+ assert 'Set batchlog replay throttle' in node.nodetool('help setbatchlogreplaythrottle').stdout
+ assert 'Print batchlog replay throttle' in node.nodetool('help getbatchlogreplaythrottle').stdout
# Set and get throttle with nodetool, ensuring that the rate change is logged
node.nodetool('setbatchlogreplaythrottle 2048')
- self.assertTrue(len(node.grep_log('Updating batchlog replay throttle to 2048 KB/s, 1024 KB/s per endpoint',
- filename='debug.log')) > 0)
- self.assertTrue('Batchlog replay throttle: 2048 KB/s' in node.nodetool('getbatchlogreplaythrottle').stdout)
+ assert len(node.grep_log('Updating batchlog replay throttle to 2048 KB/s, 1024 KB/s per endpoint',
+ filename='debug.log')) >= 0
+ assert 'Batchlog replay throttle: 2048 KB/s' in node.nodetool('getbatchlogreplaythrottle').stdout
@since('3.0')
def test_reloadlocalschema(self):
@@ -244,7 +254,8 @@ class TestNodetool(Tester):
session = self.patient_cql_connection(node)
- query = "CREATE KEYSPACE IF NOT EXISTS test WITH replication = {'class': 'NetworkTopologyStrategy', 'datacenter1': 2};"
+ query = "CREATE KEYSPACE IF NOT EXISTS test WITH replication " \
+ "= {'class': 'NetworkTopologyStrategy', 'datacenter1': 2};"
session.execute(query)
query = 'CREATE TABLE test.test (pk int, ck int, PRIMARY KEY (pk, ck));'
@@ -252,8 +263,6 @@ class TestNodetool(Tester):
ss = make_mbean('db', type='StorageService')
- schema_version = ''
-
# get initial schema version
with JolokiaAgent(node) as jmx:
schema_version = jmx.read_attribute(ss, 'SchemaVersion')
@@ -270,7 +279,7 @@ class TestNodetool(Tester):
# validate that schema version wasn't automatically updated
with JolokiaAgent(node) as jmx:
- self.assertEqual(schema_version, jmx.read_attribute(ss, 'SchemaVersion'))
+ assert schema_version == jmx.read_attribute(ss, 'SchemaVersion')
# make sure the new column wasn't automagically picked up
assert_invalid(session, 'INSERT INTO test.test (pk, ck, val) VALUES (0, 1, 2);')
@@ -280,7 +289,7 @@ class TestNodetool(Tester):
# validate that schema version changed
with JolokiaAgent(node) as jmx:
- self.assertNotEqual(schema_version, jmx.read_attribute(ss, 'SchemaVersion'))
+ assert schema_version != jmx.read_attribute(ss, 'SchemaVersion')
# try an insert with the new column again and validate it succeeds this time
session.execute('INSERT INTO test.test (pk, ck, val) VALUES (0, 1, 2);')
@@ -299,19 +308,19 @@ class TestNodetool(Tester):
cluster.start()
# Test that nodetool help messages are displayed
- self.assertTrue('Set the number of concurrent view' in node.nodetool('help setconcurrentviewbuilders').stdout)
- self.assertTrue('Get the number of concurrent view' in node.nodetool('help getconcurrentviewbuilders').stdout)
+ assert 'Set the number of concurrent view' in node.nodetool('help setconcurrentviewbuilders').stdout
+ assert 'Get the number of concurrent view' in node.nodetool('help getconcurrentviewbuilders').stdout
# Set and get throttle with nodetool, ensuring that the rate change is logged
node.nodetool('setconcurrentviewbuilders 4')
- self.assertTrue('Current number of concurrent view builders in the system is: \n4'
- in node.nodetool('getconcurrentviewbuilders').stdout)
+ assert 'Current number of concurrent view builders in the system is: \n4' \
+ in node.nodetool('getconcurrentviewbuilders').stdout
# Try to set an invalid zero value
try:
node.nodetool('setconcurrentviewbuilders 0')
except ToolError as e:
- self.assertTrue('concurrent_view_builders should be great than 0.' in e.stdout)
- self.assertTrue('Number of concurrent view builders should be greater than 0.', e.message)
+ assert 'concurrent_view_builders should be great than 0.' in e.stdout
+ assert 'Number of concurrent view builders should be greater than 0.', e.message
else:
self.fail("Expected error when setting and invalid value")
http://git-wip-us.apache.org/repos/asf/cassandra-dtest/blob/49b2dda4/offline_tools_test.py
----------------------------------------------------------------------
diff --git a/offline_tools_test.py b/offline_tools_test.py
index 028027d..7c7cc8f 100644
--- a/offline_tools_test.py
+++ b/offline_tools_test.py
@@ -3,21 +3,29 @@ import os
import random
import re
import subprocess
+import pytest
+import logging
from ccmlib import common
from ccmlib.node import ToolError
-from dtest import Tester, debug, create_ks
-from tools.decorators import since
+from dtest import Tester, create_ks
+
+since = pytest.mark.since
+logger = logging.getLogger(__name__)
class TestOfflineTools(Tester):
- # In 2.0, we will get this error log message due to jamm not being
- # in the classpath
- ignore_log_patterns = ["Unable to initialize MemoryMeter"]
+ @pytest.fixture(autouse=True)
+ def fixture_add_additional_log_patterns(self, fixture_dtest_setup):
+ fixture_dtest_setup.ignore_log_patterns = (
+ # In 2.0, we will get this error log message due to jamm not being
+ # in the classpath
+ "Unable to initialize MemoryMeter"
+ )
- def sstablelevelreset_test(self):
+ def test_sstablelevelreset(self):
"""
Insert data and call sstablelevelreset on a series of
tables. Confirm level is reset to 0 using its output.
@@ -34,9 +42,9 @@ class TestOfflineTools(Tester):
try:
node1.run_sstablelevelreset("keyspace1", "standard1")
except ToolError as e:
- self.assertIn("ColumnFamily not found: keyspace1/standard1", e.message)
+ assert re.search("ColumnFamily not found: keyspace1/standard1", str(e))
# this should return exit code 1
- self.assertEqual(e.exit_status, 1, "Expected sstablelevelreset to have a return code of 1, but instead return code was {}".format(e.exit_status))
+ assert e.exit_status == 1, "Expected sstablelevelreset to have a return code of 1 == but instead return code was {}".format(e.exit_status)
# now test by generating keyspace but not flushing sstables
cluster.start(wait_for_binary_proto=True)
@@ -46,8 +54,8 @@ class TestOfflineTools(Tester):
output, error, rc = node1.run_sstablelevelreset("keyspace1", "standard1")
self._check_stderr_error(error)
- self.assertIn("Found no sstables, did you give the correct keyspace", output)
- self.assertEqual(rc, 0, msg=str(rc))
+ assert re.search("Found no sstables, did you give the correct keyspace", output.decode("utf-8"))
+ assert rc == 0, str(rc)
# test by writing small amount of data and flushing (all sstables should be level 0)
cluster.start(wait_for_binary_proto=True)
@@ -59,9 +67,9 @@ class TestOfflineTools(Tester):
cluster.stop(gently=False)
output, error, rc = node1.run_sstablelevelreset("keyspace1", "standard1")
- self._check_stderr_error(error)
- self.assertIn("since it is already on level 0", output)
- self.assertEqual(rc, 0, msg=str(rc))
+ self._check_stderr_error(error.decode("utf-8"))
+ assert re.search("since it is already on level 0", output.decode("utf-8"))
+ assert rc == 0, str(rc)
# test by loading large amount data so we have multiple levels and checking all levels are 0 at end
cluster.start(wait_for_binary_proto=True)
@@ -74,21 +82,21 @@ class TestOfflineTools(Tester):
initial_levels = self.get_levels(node1.run_sstablemetadata(keyspace="keyspace1", column_families=["standard1"]))
_, error, rc = node1.run_sstablelevelreset("keyspace1", "standard1")
final_levels = self.get_levels(node1.run_sstablemetadata(keyspace="keyspace1", column_families=["standard1"]))
- self._check_stderr_error(error)
- self.assertEqual(rc, 0, msg=str(rc))
+ self._check_stderr_error(error.decode("utf-8"))
+ assert rc == 0, str(rc)
- debug(initial_levels)
- debug(final_levels)
+ logger.debug(initial_levels)
+ logger.debug(final_levels)
# let's make sure there was at least L1 beforing resetting levels
- self.assertTrue(max(initial_levels) > 0)
+ assert max(initial_levels) > 0
# let's check all sstables are on L0 after sstablelevelreset
- self.assertTrue(max(final_levels) == 0)
+ assert max(final_levels) == 0
def get_levels(self, data):
(out, err, rc) = data
- return map(int, re.findall("SSTable Level: ([0-9])", out))
+ return list(map(int, re.findall("SSTable Level: ([0-9])", out.decode("utf-8"))))
def wait_for_compactions(self, node):
pattern = re.compile("pending tasks: 0")
@@ -97,7 +105,7 @@ class TestOfflineTools(Tester):
if pattern.search(output):
break
- def sstableofflinerelevel_test(self):
+ def test_sstableofflinerelevel(self):
"""
Generate sstables of varying levels.
Reset sstables to L0 with sstablelevelreset
@@ -115,9 +123,9 @@ class TestOfflineTools(Tester):
# test by trying to run on nonexistent keyspace
# cluster.stop(gently=False)
# output, error, rc = node1.run_sstableofflinerelevel("keyspace1", "standard1", output=True)
- # self.assertTrue("java.lang.IllegalArgumentException: Unknown keyspace/columnFamily keyspace1.standard1" in error)
+ # assert "java.lang.IllegalArgumentException: Unknown keyspace/columnFamily keyspace1.standard1" in error
# # this should return exit code 1
- # self.assertEqual(rc, 1, msg=str(rc))
+ # assert rc, 1 == msg=str(rc)
# cluster.start()
# now test by generating keyspace but not flushing sstables
@@ -131,13 +139,13 @@ class TestOfflineTools(Tester):
try:
output, error, _ = node1.run_sstableofflinerelevel("keyspace1", "standard1")
except ToolError as e:
- self.assertIn("No sstables to relevel for keyspace1.standard1", e.stdout)
- self.assertEqual(e.exit_status, 1, msg=str(e.exit_status))
+ assert re.search("No sstables to relevel for keyspace1.standard1", e.stdout.decode("utf-8"))
+ assert e.exit_status == 1, str(e.exit_status)
# test by flushing (sstable should be level 0)
cluster.start(wait_for_binary_proto=True)
session = self.patient_cql_connection(node1)
- debug("Altering compaction strategy to LCS")
+ logger.debug("Altering compaction strategy to LCS")
session.execute("ALTER TABLE keyspace1.standard1 with compaction={'class': 'LeveledCompactionStrategy', 'sstable_size_in_mb':1};")
node1.stress(['write', 'n=1K', 'no-warmup',
@@ -149,8 +157,8 @@ class TestOfflineTools(Tester):
cluster.stop()
output, _, rc = node1.run_sstableofflinerelevel("keyspace1", "standard1")
- self.assertIn("L0=1", output)
- self.assertEqual(rc, 0, msg=str(rc))
+ assert re.search("L0=1", output.decode("utf-8"))
+ assert rc == 0, str(rc)
cluster.start(wait_for_binary_proto=True)
# test by loading large amount data so we have multiple sstables
@@ -162,56 +170,55 @@ class TestOfflineTools(Tester):
'-rate', 'threads=8'])
node1.flush()
- debug("Waiting for compactions to finish")
+ logger.debug("Waiting for compactions to finish")
self.wait_for_compactions(node1)
- debug("Stopping node")
+ logger.debug("Stopping node")
cluster.stop()
- debug("Done stopping node")
+ logger.debug("Done stopping node")
# Let's reset all sstables to L0
- debug("Getting initial levels")
+ logger.debug("Getting initial levels")
initial_levels = list(self.get_levels(node1.run_sstablemetadata(keyspace="keyspace1", column_families=["standard1"])))
- self.assertNotEqual([], initial_levels)
- debug('initial_levels:')
- debug(initial_levels)
- debug("Running sstablelevelreset")
+ assert [] != initial_levels
+ logger.debug('initial_levels:')
+ logger.debug(initial_levels)
+ logger.debug("Running sstablelevelreset")
node1.run_sstablelevelreset("keyspace1", "standard1")
- debug("Getting final levels")
+ logger.debug("Getting final levels")
final_levels = list(self.get_levels(node1.run_sstablemetadata(keyspace="keyspace1", column_families=["standard1"])))
- self.assertNotEqual([], final_levels)
- debug('final levels:')
- debug(final_levels)
+ assert [] != final_levels
+ logger.debug('final levels:')
+ logger.debug(final_levels)
# let's make sure there was at least 3 levels (L0, L1 and L2)
- self.assertGreater(max(initial_levels), 1)
+ assert max(initial_levels) > 1
# let's check all sstables are on L0 after sstablelevelreset
- self.assertEqual(max(final_levels), 0)
+ assert max(final_levels) == 0
# time to relevel sstables
- debug("Getting initial levels")
+ logger.debug("Getting initial levels")
initial_levels = self.get_levels(node1.run_sstablemetadata(keyspace="keyspace1", column_families=["standard1"]))
- debug("Running sstableofflinerelevel")
+ logger.debug("Running sstableofflinerelevel")
output, error, _ = node1.run_sstableofflinerelevel("keyspace1", "standard1")
- debug("Getting final levels")
+ logger.debug("Getting final levels")
final_levels = self.get_levels(node1.run_sstablemetadata(keyspace="keyspace1", column_families=["standard1"]))
- debug(output)
- debug(error)
+ logger.debug(output)
+ logger.debug(error)
- debug(initial_levels)
- debug(final_levels)
+ logger.debug(initial_levels)
+ logger.debug(final_levels)
# let's check sstables were promoted after releveling
- self.assertGreater(max(final_levels), 1)
+ assert max(final_levels) > 1
@since('2.2')
- def sstableverify_test(self):
+ def test_sstableverify(self):
"""
Generate sstables and test offline verification works correctly
Test on bad input: nonexistent keyspace and sstables
Test on potential situations: deleted sstables, corrupted sstables
"""
-
cluster = self.cluster
cluster.populate(3).start(wait_for_binary_proto=True)
node1, node2, node3 = cluster.nodelist()
@@ -220,14 +227,14 @@ class TestOfflineTools(Tester):
try:
(out, err, rc) = node1.run_sstableverify("keyspace1", "standard1")
except ToolError as e:
- self.assertIn("Unknown keyspace/table keyspace1.standard1", e.message)
- self.assertEqual(e.exit_status, 1, msg=str(e.exit_status))
+ assert "Unknown keyspace/table keyspace1.standard1" in repr(e)
+ assert e.exit_status == 1, str(e.exit_status)
# test on nonexistent sstables:
node1.stress(['write', 'n=100', 'no-warmup', '-schema', 'replication(factor=3)',
'-rate', 'threads=8'])
(out, err, rc) = node1.run_sstableverify("keyspace1", "standard1")
- self.assertEqual(rc, 0, msg=str(rc))
+ assert rc == 0, str(rc)
# Generate multiple sstables and test works properly in the simple case
node1.stress(['write', 'n=100K', 'no-warmup', '-schema', 'replication(factor=3)',
@@ -240,15 +247,14 @@ class TestOfflineTools(Tester):
(out, error, rc) = node1.run_sstableverify("keyspace1", "standard1")
- self.assertEqual(rc, 0, msg=str(rc))
+ assert rc == 0, str(rc)
# STDOUT of the sstableverify command consists of multiple lines which may contain
# Java-normalized paths. To later compare these with Python-normalized paths, we
# map over each line of out and replace Java-normalized paths with Python equivalents.
- outlines = map(lambda line: re.sub("(?<=path=').*(?=')",
+ outlines = [re.sub("(?<=path=').*(?=')",
lambda match: os.path.normcase(match.group(0)),
- line),
- out.splitlines())
+ line) for line in out.decode("utf-8").splitlines()]
# check output is correct for each sstable
sstables = self._get_final_sstables(node1, "keyspace1", "standard1")
@@ -263,18 +269,18 @@ class TestOfflineTools(Tester):
elif "Checking computed hash of BigTableReader" in line:
hashcomputed = True
else:
- debug(line)
+ logger.debug(line)
- debug(verified)
- debug(hashcomputed)
- debug(sstable)
- self.assertTrue(verified and hashcomputed)
+ logger.debug(verified)
+ logger.debug(hashcomputed)
+ logger.debug(sstable)
+ assert verified and hashcomputed
# now try intentionally corrupting an sstable to see if hash computed is different and error recognized
sstable1 = sstables[1]
- with open(sstable1, 'r') as f:
+ with open(sstable1, 'rb') as f:
sstabledata = bytearray(f.read())
- with open(sstable1, 'w') as out:
+ with open(sstable1, 'wb') as out:
position = random.randrange(0, len(sstabledata))
sstabledata[position] = (sstabledata[position] + 1) % 256
out.write(sstabledata)
@@ -284,12 +290,12 @@ class TestOfflineTools(Tester):
(out, error, rc) = node1.run_sstableverify("keyspace1", "standard1", options=['-v'])
except ToolError as e:
# Process sstableverify output to normalize paths in string to Python casing as above
- error = re.sub("(?<=Corrupted: ).*", lambda match: os.path.normcase(match.group(0)), e.message)
+ error = re.sub("(?<=Corrupted: ).*", lambda match: os.path.normcase(match.group(0)), str(e))
- self.assertIn("Corrupted: " + sstable1, error)
- self.assertEqual(e.exit_status, 1, msg=str(e.exit_status))
+ assert re.search("Corrupted: " + sstable1, error)
+ assert e.exit_status == 1, str(e.exit_status)
- def sstableexpiredblockers_test(self):
+ def test_sstableexpiredblockers(self):
cluster = self.cluster
cluster.populate(1).start(wait_for_binary_proto=True)
[node1] = cluster.nodelist()
@@ -304,14 +310,14 @@ class TestOfflineTools(Tester):
session.execute("delete from ks.cf where key = 3")
node1.flush()
out, error, _ = node1.run_sstableexpiredblockers(keyspace="ks", column_family="cf")
- self.assertIn("blocks 2 expired sstables from getting dropped", out)
+ assert "blocks 2 expired sstables from getting dropped" in out.decode("utf-8")
# 4.0 removes back compatibility with pre-3.0 versions, so testing upgradesstables for
# paths from those versions to 4.0 is invalid (and can only fail). There isn't currently
# any difference between the 3.0 and 4.0 sstable format though, but when the version is
# bumped for 4.0, remove the max_version & add a case for testing a 3.0 -> 4.0 upgrade
@since('2.2', max_version='3.X')
- def sstableupgrade_test(self):
+ def test_sstableupgrade(self):
"""
Test that sstableupgrade functions properly offline on a same-version Cassandra sstable, a
stdout message of "Found 0 sstables that need upgrading." should be returned.
@@ -320,7 +326,7 @@ class TestOfflineTools(Tester):
cluster = self.cluster
testversion = cluster.version()
original_install_dir = cluster.get_install_dir()
- debug('Original install dir: {}'.format(original_install_dir))
+ logger.debug('Original install dir: {}'.format(original_install_dir))
# Set up last major version to upgrade from, assuming 2.1 branch is the oldest tested version
if testversion < '2.2':
@@ -330,36 +336,36 @@ class TestOfflineTools(Tester):
# Error opening zip file or JAR manifest missing : /home/mshuler/git/cassandra/lib/jamm-0.2.5.jar
# The 2.1 installed jamm version is 0.3.0, but bin/cassandra.in.sh used by nodetool still has 0.2.5
# (when this is fixed in CCM issue #463, install version='github:apache/cassandra-2.0' as below)
- self.skipTest('Skipping 2.1 test due to jamm.jar version upgrade problem in CCM node configuration.')
+ pytest.skip('Skipping 2.1 test due to jamm.jar version upgrade problem in CCM node configuration.')
elif testversion < '3.0':
- debug('Test version: {} - installing github:apache/cassandra-2.1'.format(testversion))
+ logger.debug('Test version: {} - installing github:apache/cassandra-2.1'.format(testversion))
cluster.set_install_dir(version='github:apache/cassandra-2.1')
# As of 3.5, sstable format 'ma' from 3.0 is still the latest - install 2.2 to upgrade from
elif testversion < '4.0':
- debug('Test version: {} - installing github:apache/cassandra-2.2'.format(testversion))
+ logger.debug('Test version: {} - installing github:apache/cassandra-2.2'.format(testversion))
cluster.set_install_dir(version='github:apache/cassandra-2.2')
# From 4.0, one can only upgrade from 3.0
else:
- debug('Test version: {} - installing github:apache/cassandra-3.0'.format(testversion))
+ logger.debug('Test version: {} - installing github:apache/cassandra-3.0'.format(testversion))
cluster.set_install_dir(version='github:apache/cassandra-3.0')
# Start up last major version, write out an sstable to upgrade, and stop node
cluster.populate(1).start(wait_for_binary_proto=True)
[node1] = cluster.nodelist()
# Check that node1 is actually what we expect
- debug('Downgraded install dir: {}'.format(node1.get_install_dir()))
+ logger.debug('Downgraded install dir: {}'.format(node1.get_install_dir()))
session = self.patient_cql_connection(node1)
create_ks(session, 'ks', 1)
session.execute('create table ks.cf (key int PRIMARY KEY, val int) with gc_grace_seconds=0')
session.execute('insert into ks.cf (key, val) values (1,1)')
node1.flush()
cluster.stop()
- debug('Beginning ks.cf sstable: {}'.format(node1.get_sstables(keyspace='ks', column_family='cf')))
+ logger.debug('Beginning ks.cf sstable: {}'.format(node1.get_sstables(keyspace='ks', column_family='cf')))
# Upgrade Cassandra to original testversion and run sstableupgrade
cluster.set_install_dir(original_install_dir)
# Check that node1 is actually upgraded
- debug('Upgraded to original install dir: {}'.format(node1.get_install_dir()))
+ logger.debug('Upgraded to original install dir: {}'.format(node1.get_install_dir()))
# Perform a node start/stop so system tables get internally updated, otherwise we may get "Unknown keyspace/table ks.cf"
cluster.start(wait_for_binary_proto=True)
node1.flush()
@@ -372,19 +378,19 @@ class TestOfflineTools(Tester):
# change before it's release.
if testversion < '4.0':
(out, error, rc) = node1.run_sstableupgrade(keyspace='ks', column_family='cf')
- debug(out)
- debug(error)
- debug('Upgraded ks.cf sstable: {}'.format(node1.get_sstables(keyspace='ks', column_family='cf')))
- self.assertIn('Found 1 sstables that need upgrading.', out)
+ logger.debug(out)
+ logger.debug(error)
+ logger.debug('Upgraded ks.cf sstable: {}'.format(node1.get_sstables(keyspace='ks', column_family='cf')))
+ assert 'Found 1 sstables that need upgrading.' in out
# Check that sstableupgrade finds no upgrade needed on current version.
(out, error, rc) = node1.run_sstableupgrade(keyspace='ks', column_family='cf')
- debug(out)
- debug(error)
- self.assertIn('Found 0 sstables that need upgrading.', out)
+ logger.debug(out)
+ logger.debug(error)
+ assert 'Found 0 sstables that need upgrading.' in out
@since('3.0')
- def sstabledump_test(self):
+ def test_sstabledump(self):
"""
Test that sstabledump functions properly offline to output the contents of a table.
"""
@@ -405,41 +411,41 @@ class TestOfflineTools(Tester):
node1.flush()
cluster.stop()
[(out, error, rc)] = node1.run_sstabledump(keyspace='ks', column_families=['cf'])
- debug(out)
- debug(error)
+ logger.debug(out)
+ logger.debug(error)
# Load the json output and check that it contains the inserted key=1
s = json.loads(out)
- debug(s)
- self.assertEqual(len(s), 2)
+ logger.debug(s)
+ assert len(s) == 2
# order the rows so that we have key=1 first, then key=2
row0, row1 = s
(row0, row1) = (row0, row1) if row0['partition']['key'] == ['1'] else (row1, row0)
- self.assertEqual(row0['partition']['key'], ['1'])
+ assert row0['partition']['key'] == ['1']
- self.assertEqual(row1['partition']['key'], ['2'])
- self.assertIsNotNone(row1['partition'].get('deletion_info'))
- self.assertIsNotNone(row1.get('rows'))
+ assert row1['partition']['key'] == ['2']
+ assert row1['partition'].get('deletion_info') is not None
+ assert row1.get('rows') is not None
# Check that we only get the key back using the enumerate option
[(out, error, rc)] = node1.run_sstabledump(keyspace='ks', column_families=['cf'], enumerate_keys=True)
- debug(out)
- debug(error)
+ logger.debug(out)
+ logger.debug(error)
s = json.loads(out)
- debug(s)
- self.assertEqual(len(s), 2)
+ logger.debug(s)
+ assert len(s) == 2
dumped_keys = set(row[0] for row in s)
- self.assertEqual(set(['1', '2']), dumped_keys)
+ assert {'1', '2'} == dumped_keys
def _check_stderr_error(self, error):
acceptable = ["Max sstable size of", "Consider adding more capacity", "JNA link failure", "Class JavaLaunchHelper is implemented in both"]
if len(error) > 0:
for line in error.splitlines():
- self.assertTrue(any([msg in line for msg in acceptable]),
- 'Found line \n\n"{line}"\n\n in error\n\n{error}'.format(line=line, error=error))
+ assert any([msg in line for msg in acceptable]), \
+ 'Found line \n\n"{line}"\n\n in error\n\n{error}'.format(line=line, error=error)
def _get_final_sstables(self, node, ks, table):
"""
@@ -448,7 +454,7 @@ class TestOfflineTools(Tester):
file names no longer contain tmp in their names (CASSANDRA-7066).
"""
# Get all sstable data files
- allsstables = map(os.path.normcase, node.get_sstables(ks, table))
+ allsstables = list(map(os.path.normcase, node.get_sstables(ks, table)))
# Remove any temporary files
tool_bin = node.get_tool('sstableutil')
@@ -457,7 +463,7 @@ class TestOfflineTools(Tester):
env = common.make_cassandra_env(node.get_install_cassandra_root(), node.get_node_cassandra_root())
p = subprocess.Popen(args, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(stdout, stderr) = p.communicate()
- tmpsstables = map(os.path.normcase, stdout.splitlines())
+ tmpsstables = list(map(os.path.normcase, stdout.decode("utf-8").splitlines()))
ret = list(set(allsstables) - set(tmpsstables))
else:
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cassandra.apache.org
For additional commands, e-mail: commits-help@cassandra.apache.org