You are viewing a plain text version of this content. The canonical link for it is here.
Posted to builds@cassandra.apache.org by Apache Jenkins Server <je...@builds.apache.org> on 2021/01/15 15:43:51 UTC
Build complete: Cassandra-trunk #232 [UNSTABLE]
7e936e7f2c6ccc73d8e3acd31d7050889ec1efbe
-------------------------------------------------------------------------------
Build Cassandra-trunk #232 Still Unstable
URL: https://ci-cassandra.apache.org/job/Cassandra-trunk/232/
-------------------------------------------------------------------------------
Changes:
[Sam Tunnicliffe] Initial client handler correctly sets stream id on responses
-------------------------------------------------------------------------------
Failed Tests:
1 tests failed.
FAILED: dtest.consistency_test.TestConsistency.test_12872
-------------------------------------------------------------------------------
Cassandra CI Results
-------------------------------------------------------------------------------
Tests Failures Errors Skipped Success rate Time
3999 1 538 0 86.52% 137858.556
-------------------------------------------------------------------------------
Name Tests Errors Failures Skipped Time(s)
3831 538 1 0 137858.556
cqlshlib.python3.jdk8 168 0 0 0 0.000
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
Packages
-------------------------------------------------------------------------------
Name Tests Errors Failures Skipped Time(s)
Cassandra dtests 5 0 0 1067.335
Cassandra dtests 5 0 0 598.739
Cassandra dtests 6 0 0 820.773
Cassandra dtests 5 0 0 816.566
Cassandra dtests 5 0 0 910.315
Cassandra dtests 4 0 0 337.847
Cassandra dtests 2 0 0 375.916
Cassandra dtests 3 0 0 935.708
Cassandra dtests 24 5 0 467.749
Cassandra dtests 22 4 0 559.430
Cassandra dtests 22 4 0 516.390
Cassandra dtests 22 5 0 654.666
Cassandra dtests 22 5 0 410.442
Cassandra dtests 21 4 0 440.935
Cassandra dtests 22 4 0 829.225
Cassandra dtests 20 2 0 809.327
Cassandra dtests 20 2 0 921.292
Cassandra dtests 21 3 0 640.128
Cassandra dtests 19 1 0 868.219
Cassandra dtests 22 3 0 495.850
Cassandra dtests 20 2 0 956.682
Cassandra dtests 20 2 0 1113.722
Cassandra dtests 19 2 0 643.671
Cassandra dtests 19 3 0 480.663
Cassandra dtests 19 2 0 511.976
Cassandra dtests 17 1 0 453.282
Cassandra dtests 19 2 0 609.000
Cassandra dtests 19 2 0 649.987
Cassandra dtests 19 1 0 835.293
Cassandra dtests 20 2 0 580.222
Cassandra dtests 23 4 0 470.983
Cassandra dtests 23 2 0 1036.660
Cassandra dtests 21 4 0 843.097
Cassandra dtests 20 3 0 686.965
Cassandra dtests 18 2 0 710.628
Cassandra dtests 17 2 0 393.684
Cassandra dtests 19 3 0 566.598
Cassandra dtests 19 2 0 504.987
Cassandra dtests 20 3 0 465.601
Cassandra dtests 21 4 0 482.818
Cassandra dtests 20 4 0 374.179
Cassandra dtests 22 3 0 407.071
Cassandra dtests 19 2 0 637.224
Cassandra dtests 18 2 0 1025.410
Cassandra dtests 19 2 0 1062.124
Cassandra dtests 22 4 0 1072.660
Cassandra dtests 20 3 0 773.125
Cassandra dtests 20 3 0 959.560
Cassandra dtests 20 3 0 890.639
Cassandra dtests 20 3 0 923.757
Cassandra dtests 20 3 0 1003.324
Cassandra dtests 20 2 0 642.560
Cassandra dtests 22 3 0 614.633
Cassandra dtests 20 2 0 731.368
Cassandra dtests 20 2 0 865.956
Cassandra dtests 20 2 0 1626.312
Cassandra dtests 20 2 0 1117.292
Cassandra dtests 21 3 0 886.340
Cassandra dtests 22 4 0 700.422
Cassandra dtests 20 2 0 891.156
Cassandra dtests 21 3 0 526.176
Cassandra dtests 21 3 0 918.664
Cassandra dtests 21 4 0 893.280
Cassandra dtests 22 4 0 540.504
Cassandra dtests 22 4 0 583.960
Cassandra dtests 21 3 0 391.045
Cassandra dtests 21 3 0 922.133
Cassandra dtests 21 3 0 511.404
Cassandra dtests 22 4 0 540.164
Cassandra dtests 23 5 0 498.075
Cassandra dtests 21 3 0 548.536
Cassandra dtests 21 3 0 582.957
Cassandra dtests 19 1 0 987.262
Cassandra dtests 19 3 0 567.331
Cassandra dtests 18 2 0 703.138
Cassandra dtests 20 4 0 569.327
Cassandra dtests 20 4 0 470.929
Cassandra dtests 17 1 0 653.033
Cassandra dtests 20 3 0 408.145
Cassandra dtests 19 2 0 486.606
Cassandra dtests 21 4 0 657.453
Cassandra dtests 21 4 0 809.696
Cassandra dtests 19 3 0 607.508
Cassandra dtests 20 2 0 965.379
Cassandra dtests 19 4 0 343.465
Cassandra dtests 18 3 0 324.888
Cassandra dtests 20 3 0 595.240
Cassandra dtests 20 3 0 562.411
Cassandra dtests 22 5 0 448.569
Cassandra dtests 24 4 0 589.812
Cassandra dtests 21 4 0 477.916
Cassandra dtests 20 3 0 618.768
Cassandra dtests 20 3 0 635.828
Cassandra dtests 20 4 0 577.796
Cassandra dtests 21 3 0 1003.559
Cassandra dtests 18 2 0 578.036
Cassandra dtests 18 2 0 526.614
Cassandra dtests 18 2 0 613.951
Cassandra dtests 18 2 0 573.206
Cassandra dtests 16 2 0 416.835
Cassandra dtests 17 2 0 675.052
Cassandra dtests 18 2 0 565.694
Cassandra dtests 17 2 0 798.824
Cassandra dtests 18 2 0 742.780
Cassandra dtests 19 2 0 820.342
Cassandra dtests 20 2 0 681.929
Cassandra dtests 20 4 0 422.921
Cassandra dtests 19 3 0 992.464
Cassandra dtests 18 2 0 964.679
Cassandra dtests 20 3 0 594.911
Cassandra dtests 20 3 0 718.110
Cassandra dtests 20 3 0 480.763
Cassandra dtests 19 2 0 527.308
Cassandra dtests 20 3 0 586.387
Cassandra dtests 20 3 0 869.983
Cassandra dtests 20 3 0 604.544
Cassandra dtests 20 2 0 999.466
Cassandra dtests 20 3 0 509.753
Cassandra dtests 19 2 0 932.371
Cassandra dtests 19 2 0 792.833
Cassandra dtests 19 2 0 634.013
Cassandra dtests 19 2 0 729.329
Cassandra dtests 21 4 0 471.538
Cassandra dtests 19 2 0 716.816
Cassandra dtests 21 4 0 730.220
Cassandra dtests 21 4 0 498.217
Cassandra dtests 20 3 0 704.252
Cassandra dtests 19 1 0 1159.048
Cassandra dtests 20 3 0 609.959
Cassandra dtests 21 4 0 888.128
Cassandra dtests 20 3 0 1010.225
Cassandra dtests 21 4 0 888.245
Cassandra dtests 20 3 0 700.300
Cassandra dtests 19 2 0 738.782
Cassandra dtests 18 2 0 880.952
Cassandra dtests 16 1 0 583.432
Cassandra dtests 20 2 0 794.330
Cassandra dtests 19 3 0 642.916
Cassandra dtests 18 2 0 712.159
Cassandra dtests 19 3 0 639.887
Cassandra dtests 20 4 0 531.202
Cassandra dtests 18 2 0 662.525
Cassandra dtests 19 2 0 533.356
Cassandra dtests 19 2 0 431.742
Cassandra dtests 21 4 0 562.126
Cassandra dtests 21 4 0 769.315
Cassandra dtests 19 3 0 589.552
Cassandra dtests 20 2 0 786.382
Cassandra dtests 17 2 0 421.870
Cassandra dtests 19 4 0 209.309
Cassandra dtests 20 3 0 732.420
Cassandra dtests 20 3 0 553.674
Cassandra dtests 21 4 0 506.919
Cassandra dtests 23 5 0 702.369
Cassandra dtests 21 4 0 447.418
Cassandra dtests 21 4 0 545.096
Cassandra dtests 20 3 0 693.173
Cassandra dtests 19 3 0 623.855
Cassandra dtests 21 3 0 1016.316
Cassandra dtests 19 3 0 472.493
Cassandra dtests 18 2 0 605.647
Cassandra dtests 18 2 0 544.892
Cassandra dtests 18 2 0 598.427
Cassandra dtests 17 2 0 605.744
Cassandra dtests 16 2 0 414.754
Cassandra dtests 18 2 0 662.386
Cassandra dtests 18 2 0 982.685
Cassandra dtests 17 2 0 582.629
Cassandra dtests 19 2 0 834.179
Cassandra dtests 19 1 0 995.315
Cassandra dtests 20 4 0 526.857
Cassandra dtests 19 3 0 953.272
Cassandra dtests 19 3 0 888.273
Cassandra dtests 19 2 0 779.701
Cassandra dtests 20 3 0 707.332
Cassandra dtests 19 2 0 561.102
Cassandra dtests 20 3 0 513.911
Cassandra dtests 19 2 0 612.935
Cassandra dtests 20 3 1 1000.963
Cassandra dtests 20 3 0 670.282
Cassandra dtests 20 2 0 819.314
Cassandra dtests 21 4 0 397.683
Cassandra dtests 19 2 0 646.566
Cassandra dtests 19 2 0 758.360
Cassandra dtests 19 2 0 750.263
Cassandra dtests 19 2 0 737.130
Cassandra dtests 21 4 0 586.644
Cassandra dtests 19 2 0 667.939
Cassandra dtests 20 3 0 596.314
Cassandra dtests 21 4 0 718.725
Cassandra dtests 21 4 0 630.563
Cassandra dtests 20 2 0 1244.594
Cassandra dtests 20 3 0 474.308
Cassandra dtests 21 4 0 521.485
Cassandra dtests 20 3 0 887.364
Cassandra dtests 21 4 0 990.842
Cassandra dtests 20 3 0 1226.503
Cassandra dtests 18 1 0 970.798
Cassandra dtests 20 3 0 889.005
Cassandra dtests 16 1 0 589.814
-------------------------------------------------------------------------------
cqlshlib.python3.jdk8
Name Tests Errors Failures Skipped Time(s)
no_cython 84 0 0 NaN
cython 84 0 0 NaN
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
Failures
-------------------------------------------------------------------------------
Cassandra dtests // test_validate_empty_column_name // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_validate_empty_column_name'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f423356fd00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4233ca0400>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4233ea69d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4233c928b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_validate_empty_column_name'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_read_repair_chance // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_read_repair_chance'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f423356fd00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f423274ffa0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4233ea69d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4230dd1e20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_read_repair_chance'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_cf_remove_and_range_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cf_remove_and_range_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f423356fd00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4230265730>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4233ea69d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4231cff220>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cf_remove_and_range_slice'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_index_scan // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_index_scan'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f423356fd00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f423377a070>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4233ea69d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4233aed6a0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_index_scan'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_dead_coordinator // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dead_coordinator'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f423356fd00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4231b499d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4233ea69d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4233d333d0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dead_coordinator'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_range_collation // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_collation'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f28bfd5b190>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f28bca8ddf0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f28c0468a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f28bf05da60>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_collation'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compact_storage_get // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_storage_get'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f28bfd5b190>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f28be3411f0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f28c0468a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f28c03d6490>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_storage_get'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_datetimeformat_round_trip // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_datetimeformat_round_trip'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f28bfd5b190>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f28bfda2640>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f28c0468a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f28bfda2f40>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_datetimeformat_round_trip'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_range_async_2 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_2'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f28bfd5b190>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f28bf0b7400>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f28c0468a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f28bf0b71f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_2'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_monotonic_reads[blocking] // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_monotonic_reads[blocking]'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fbd214c7be0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fbd21795550>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fbd21a06b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fbd217f61f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_monotonic_reads[blocking]'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_range_partial // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_partial'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fbd214c7be0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fbd2084d700>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fbd21a06b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fbd212ed490>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_partial'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_range_tombstone_eoc_0 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_tombstone_eoc_0'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fbd214c7be0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fbd207a4cd0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fbd21a06b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fbd207a4760>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_tombstone_eoc_0'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_range_async_3 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_3'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fbd214c7be0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fbd2055fa90>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fbd21a06b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fbd217a8e80>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_3'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_only_superuser_can_create_users // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_only_superuser_can_create_users'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8fd8b78460>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8fd8b783d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8fd94659d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8fd8b78280>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_only_superuser_can_create_users'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_monotonic_reads[none] // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_monotonic_reads[none]'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8fd8b78460>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8fd8235490>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8fd94659d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8fd91cb850>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_monotonic_reads[none]'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_get_slice_range // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_slice_range'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8fd8b78460>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8fd80db250>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8fd94659d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8fd25eb250>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_slice_range'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_multi_dc_tokens_default // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multi_dc_tokens_default'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8fd8b78460>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8fd8c5be80>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8fd94659d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8fd8c5bca0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multi_dc_tokens_default'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_deprecated_repair_error_notification // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_deprecated_repair_error_notification'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8fd8b78460>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8fd0a12bb0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8fd94659d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8fd0a127f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_deprecated_repair_error_notification'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_password_authenticator_create_user_requires_password
// Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_password_authenticator_create_user_requires_password'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f91e8f80400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f91e8f80370>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f91e98b0b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f91e8f800a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_password_authenticator_create_user_requires_password'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests /
/ test_paging_with_filtering_on_partition_key_on_counter_columns_compact /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_partition_key_on_counter_columns_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f91e8f80400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f91e9091d00>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f91e98b0b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f91e8f79550>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_partition_key_on_counter_columns_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_atomic_writes[blocking] // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_atomic_writes
[blocking]'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f91e8f80400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f91e92a6b50>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f91e98b0b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f91e919fc10>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_atomic_writes
[blocking]'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_get_slice_super_range // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_slice_super_range'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f91e8f80400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f91e818dcd0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f91e98b0b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f91e818d820>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_slice_super_range'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_multi_dc_tokens_murmur3 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multi_dc_tokens_murmur3'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f91e8f80400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f91e82ec430>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f91e98b0b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f91e82ec1f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multi_dc_tokens_murmur3'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_large_collection_errors // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_large_collection_errors'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7edc0c6760>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7ed85f5130>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7edc9f6a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7edb892490>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_large_collection_errors'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_atomic_writes[none] // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_atomic_writes
[none]'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7edc0c6760>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7ed9804580>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7edc9f6a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7ed966ce20>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_atomic_writes
[none]'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_get_range_slices_tokens // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slices_tokens'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7edc0c6760>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7edb5cc190>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7edc9f6a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7edb5ccc10>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slices_tokens'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_multi_dc_tokens_random // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multi_dc_tokens_random'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7edc0c6760>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7edb639c40>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7edc9f6a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7edb697ac0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multi_dc_tokens_random'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_cql3_insert_thrift // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_cql3_insert_thrift'>>
dtest_config = <dtest_config.DTestConfig object at 0x7faf6721a910>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7faf66845c70>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7faf67b4faf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7faf66845910>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_cql3_insert_thrift'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests /
/ test_paging_with_filtering_on_partition_key_on_clustering_columns_compact /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_partition_key_on_clustering_columns_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7faf6721a910>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7faf66943220>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7faf67b4faf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7faf6685cb20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_partition_key_on_clustering_columns_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_get_range_slice_super // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slice_super'>>
dtest_config = <dtest_config.DTestConfig object at 0x7faf6721a910>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7faf668f7eb0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7faf67b4faf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7faf664d6850>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slice_super'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_datetime_values // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_datetime_values'>>
dtest_config = <dtest_config.DTestConfig object at 0x7faf6721a910>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7faf668cab80>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7faf67b4faf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7faf668663a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_datetime_values'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_rename // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_rename'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fcbb8caed60>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fcbb82a98e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fcbb95ddaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fcbb93d31c0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_rename'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_get_range_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fcbb8caed60>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fcbb9082c70>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fcbb95ddaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fcbb0293be0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slice'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_8280_validate_indexed_values_compact // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_8280_validate_indexed_values_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f16a3353d90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f16a08fd970>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f16a3c24a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f168968ec40>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_8280_validate_indexed_values_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_wrapped_range_slices // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_wrapped_range_slices'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f16a3353d90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f16a39b8cd0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f16a3c24a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f16a33f8640>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_wrapped_range_slices'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_only_superusers_can_drop_users // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_only_superusers_can_drop_users'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fabd836b820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fabd8367dc0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fabd8bfa9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fabd83676a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_only_superusers_can_drop_users'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests /
/ test_paging_on_compact_table_with_tombstone_on_first_column // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_on_compact_table_with_tombstone_on_first_column'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fabd836b820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fabd718da90>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fabd8bfa9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fabd71ad2b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_on_compact_table_with_tombstone_on_first_column'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_get_slice_by_names // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_slice_by_names'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fabd836b820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fabd7121be0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fabd8bfa9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fabd7018790>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_slice_by_names'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_multiget_slice_with_compact_table // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multiget_slice_with_compact_table'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa4a5d76100>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa4a5bd9190>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa4a5dd6af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa471395340>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multiget_slice_with_compact_table'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_range_slice_query_with_tombstones // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_slice_query_with_tombstones'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa1e2062070>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa1e035b9d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa1e2996a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa1e25fa250>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_slice_query_with_tombstones'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_cf_remove_column // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cf_remove_column'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa1e2062070>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa1d177ec40>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa1e2996a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa1d163f760>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cf_remove_column'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_index_scan_uuid_names // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_index_scan_uuid_names'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa1e2062070>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa1d18441f0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa1e2996a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa1d18444f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_index_scan_uuid_names'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_paging_with_no_clustering_columns_compact // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_no_clustering_columns_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f794283b5e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7940624160>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f79430c5b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7942eaabe0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_no_clustering_columns_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_multiget_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multiget_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f794283b5e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f79405daac0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f79430c5b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7942ea8cd0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multiget_slice'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_drop_compact_storage_flag // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_drop_compact_storage_flag'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1648835970>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f1645e30340>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1648fbcaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f1645e31790>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_drop_compact_storage_flag'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_multi_count // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multi_count'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1648835970>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f16466096d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1648fbcaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f16466a2fa0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multi_count'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_json_tools // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_json_tools'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7db89418e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7db7de2d90>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7db8fa0ca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7db7d8b100>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_json_tools'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_super_deletion // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_super_deletion'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7db89418e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7db7d1cb20>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7db8fa0ca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7db7cef9a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_super_deletion'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_bootstrap_binary_disabled // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_bootstrap_binary_disabled'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f24a28ed7c0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f24a05348e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f24a2e3fb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f24a055c220>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_bootstrap_binary_disabled'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_paging_for_range_name_queries_compact // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_for_range_name_queries_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f24a28ed7c0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f24a032d700>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f24a2e3fb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f24a032d910>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_for_range_name_queries_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_reinsert // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_reinsert'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f24a28ed7c0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f24a28b24c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f24a2e3fb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f24a26ae700>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_reinsert'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_14766 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_14766'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f813a4a7730>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8139a926a0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f813ac6cca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8139a925b0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_14766'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_keyspace // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_keyspace'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f813a4a7730>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f813986a160>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f813ac6cca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f813986a7c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_keyspace'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_describe'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd84fbba130>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd84cd0ddc0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd8503c3c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd84cd0d8e0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_describe'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_sc_with_row_cache // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_sc_with_row_cache'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fe4f4f836d0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fe4cfe32520>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fe4f5788b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fe4cfe32d30>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_sc_with_row_cache'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_ring // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_ring'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fe4f4f836d0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fe4f5277550>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fe4f5788b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fe4f51c1d90>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_ring'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_functional // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_functional'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f3c77563d60>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f3c77862250>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f3c77d80af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f3c76abc190>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_functional'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_token_map // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_token_map'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f3c77563d60>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f3c76af39d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f3c77d80af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f3c76af3eb0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_token_map'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_partitioner // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_partitioner'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fe5fc27bbe0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fe5f856ea00>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fe5fca98b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fe5fc655be0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_partitioner'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_read_old_sstables_after_upgrade // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_read_old_sstables_after_upgrade'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fdaf5a06970>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fdaf605d8b0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fdaf6266c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fdaf605de20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_read_old_sstables_after_upgrade'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_snitch // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_snitch'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fdaf5a06970>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fdaf4190d60>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fdaf6266c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fdaf508b190>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_snitch'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compact_counter_cluster // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_counter_cluster'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fdda3ac6340>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fdda20d9040>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fdda4386af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fdda2045880>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_counter_cluster'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_gcable_tombstone_resurrection_on_range_slice_query /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_gcable_tombstone_resurrection_on_range_slice_query'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fdda3ac6340>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fdda3cdcca0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fdda4386af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fdda3ca2cd0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_gcable_tombstone_resurrection_on_range_slice_query'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_cf_remove_supercolumn // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cf_remove_supercolumn'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fdda3ac6340>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fdda209b2e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fdda4386af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fdda3c4f820>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cf_remove_supercolumn'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_index_scan_expiring // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_index_scan_expiring'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fdda3ac6340>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fdda2045910>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fdda4386af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fdda3ae75e0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_index_scan_expiring'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_closing_connections // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_closing_connections'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f2fee29ef10>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f2fc0765910>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f2feeae9af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f2fc0765bb0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_closing_connections'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_invalid_ks_names // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_ks_names'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f2fee29ef10>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f2fc06428e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f2feeae9af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f2fbbd2abb0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_ks_names'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_hsha_defaults // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_hsha_defaults'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4ec489f7c0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4ec48a88e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4ec5152ca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4ec4068f10>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_hsha_defaults'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_populate_mv_after_insert_wide_rows // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_populate_mv_after_insert_wide_rows'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4ec489f7c0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4ec406d310>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4ec5152ca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4ec50ba280>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_populate_mv_after_insert_wide_rows'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_6285 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_6285'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4ec489f7c0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4ebfcf2130>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4ec5152ca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4ec4b17070>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_6285'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_invalid_strategy_class // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_strategy_class'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4ec489f7c0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4ebfc56880>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4ec5152ca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4ebfc563d0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_strategy_class'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_hsha_with_ssl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_hsha_with_ssl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f5cbc8efac0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f5cbd0c9e80>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f5cbd145a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f5cbc8ef4c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_hsha_with_ssl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_insert // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_insert'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f5cbc8efac0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f5cb6db6040>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f5cbd145a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f5cbc8f2880>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_insert'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_invalid_cf_names // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_cf_names'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f5cbc8efac0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f5cb6fd54c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f5cbd145a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f5cb6fd5b20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_cf_names'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_empty_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_empty_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fe70b167700>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fe70a7bbe20>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fe70b9a69d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fe70b358970>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_empty_slice'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_system_cf_recreate // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_cf_recreate'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fe70b167700>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fe70b79f550>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fe70b9a69d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fe70b79f580>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_cf_recreate'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_cas // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_cas'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fab52a886a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fab529f06d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fab5312eaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fab52f0f250>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_cas'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_system_keyspace_operations // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_keyspace_operations'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fab52a886a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fab51eaf910>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fab5312eaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fab51eafcd0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_keyspace_operations'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_missing_super // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_missing_super'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f6424480f10>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f6422c089d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f6424d3baf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f6424b19d00>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_missing_super'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_create_then_drop_ks // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_create_then_drop_ks'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f6424480f10>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f64239048e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f6424d3baf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f6423904100>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_create_then_drop_ks'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_no_anticompaction_after_dclocal_repair // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_after_dclocal_repair'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f6424480f10>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f64201a49d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f6424d3baf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f6421b3e070>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_after_dclocal_repair'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_count // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_count'>>
dtest_config = <dtest_config.DTestConfig object at 0x7faebed5ba90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7faebe346fd0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7faebf5bdb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7faebe2acf10>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_count'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_column_validators // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_column_validators'>>
dtest_config = <dtest_config.DTestConfig object at 0x7faebed5ba90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7faebe2a34f0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7faebf5bdb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7faebe2841c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_column_validators'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_count_paging // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_count_paging'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd0f6a5f1f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd0f582c2e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd0f6ab8b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd0f56d6370>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_count_paging'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_system_column_family_operations // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_column_family_operations'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd0f6a5f1f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd0f55f0970>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd0f6ab8b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd0f55f0d30>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_column_family_operations'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_no_anticompaction_after_hostspecific_repair // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_after_hostspecific_repair'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd0f6a5f1f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd0f5696e50>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd0f6ab8b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd0f417ef10>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_after_hostspecific_repair'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_rf_collapse_yaml_file_snitch // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_rf_collapse_yaml_file_snitch'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fac63f04760>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fac63407d00>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fac6479eaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fac6368a070>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_rf_collapse_yaml_file_snitch'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_count_around_page_size // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_count_around_page_size'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fac63f04760>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fac6352d700>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fac6479eaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fac626ac220>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_count_around_page_size'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_dynamic_indexes_creation_deletion // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dynamic_indexes_creation_deletion'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fac63f04760>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fac635855b0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fac6479eaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fac64120b80>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dynamic_indexes_creation_deletion'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_no_anticompaction_after_subrange_repair // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_after_subrange_repair'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fac63f04760>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fac631a3df0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fac6479eaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fac630e99a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_after_subrange_repair'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_rf_expand_yaml_file_snitch // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_rf_expand_yaml_file_snitch'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fcc5cc4a910>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fcc5c1ae1c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fcc5d4bbc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fcc5cc4f910>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_rf_expand_yaml_file_snitch'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_insert // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_insert'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fcc5cc4a910>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fcc547cf3d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fcc5d4bbc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fcc547d06a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_insert'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_dynamic_indexes_with_system_update_cf // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dynamic_indexes_with_system_update_cf'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fcc5cc4a910>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fcc5c1a78e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fcc5d4bbc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fcc5c1a71c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dynamic_indexes_with_system_update_cf'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_no_anticompaction_of_already_repaired // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_of_already_repaired'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fcc5cc4a910>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fcc57c4e3d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fcc5d4bbc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fcc57dca910>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_of_already_repaired'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_cf_resurrect_subcolumn // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cf_resurrect_subcolumn'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f94ade69d90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f94ae4c2c40>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f94ae761b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f94ae562970>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cf_resurrect_subcolumn'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_index_scan_indexed_column_outside_slice_predicate /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_index_scan_indexed_column_outside_slice_predicate'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f94ade69d90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f94ae0b9070>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f94ae761b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f94ac3678e0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_index_scan_indexed_column_outside_slice_predicate'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_failure_during_anticompaction // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_failure_during_anticompaction'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f94ade69d90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f94ad5afb20>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f94ae761b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f94ac360e20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_failure_during_anticompaction'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_get // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_super_get'>>
dtest_config = <dtest_config.DTestConfig object at 0x7efdabfdc310>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7efdac1ed8e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7efdac806af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7efdab494370>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_super_get'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_system_super_column_family_operations // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_super_column_family_operations'>>
dtest_config = <dtest_config.DTestConfig object at 0x7efdabfdc310>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7efdac188a60>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7efdac806af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7efdac188490>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_super_column_family_operations'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_subcolumn_limit // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_subcolumn_limit'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fbca7d68130>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fbca8382400>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fbca8581a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fbca7284670>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_subcolumn_limit'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_insert_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_insert_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fbca7d68130>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fbca4cf0af0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fbca8581a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fbca4cf0580>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_insert_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_long_order // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_long_order'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f57a07b1fd0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f579fb8b640>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f57a0f77af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f579fea0e80>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_long_order'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_insert_max_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_insert_max_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f57a07b1fd0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f579fbea4c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f57a0f77af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f579fbeabb0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_insert_max_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_failed_snitch_update_yaml_file_snitch // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_failed_snitch_update_yaml_file_snitch'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f91b7a02e20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f919e442370>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f91b82359d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f919f599ca0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_failed_snitch_update_yaml_file_snitch'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_integer_order // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_integer_order'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f91b7a02e20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f919f523100>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f91b82359d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f919f770a30>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_integer_order'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_insert_max_default_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_insert_max_default_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f91b7a02e20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f91b80234c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f91b82359d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f91b8023a60>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_insert_max_default_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_alter_table // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_alter_table'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f91b7a02e20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f91b6cfd340>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f91b82359d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f919f7618e0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_alter_table'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_time_uuid // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_time_uuid'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f5b16f10820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f5b164f8400>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f5b176cea60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f5b17069670>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_time_uuid'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_simple_expiration // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_simple_expiration'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f5b16f10820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f5b16664640>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f5b176cea60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f5b16664c10>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_simple_expiration'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_mutation_v2 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_mutation_v2'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f5b16f10820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f5b1703f370>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f5b176cea60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f5b156348b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_mutation_v2'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_sstableupgrade // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_sstableupgrade'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fde71a93820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fde72051be0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fde72265b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fde7205aa90>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_sstableupgrade'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_long_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_long_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fde71a93820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fde710a3d30>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fde72265b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fde70f320d0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_long_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_expiration_with_default_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_expiration_with_default_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fde71a93820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fde71fe72b0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fde72265b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fde710d1e20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_expiration_with_default_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compaction_delete[LeveledCompactionStrategy] /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[LeveledCompactionStrategy]'>>
dtest_config = <dtest_config.DTestConfig object at 0x7efc876dcaf0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7efc85d4e880>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7efc87f1bc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7efc85cb0520>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[LeveledCompactionStrategy]'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_integer_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_integer_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7efc876dcaf0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7efc86b33880>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7efc87f1bc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7efc86ba8190>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_integer_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_expiration_with_default_ttl_and_zero_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_expiration_with_default_ttl_and_zero_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7efc876dcaf0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7efc87b2fd90>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7efc87f1bc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7efc87b8bc10>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_expiration_with_default_ttl_and_zero_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compaction_delete[SizeTieredCompactionStrategy] /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[SizeTieredCompactionStrategy]'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f46a955bc10>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f46a8479460>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f46a9db9d30>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f46a81fc100>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[SizeTieredCompactionStrategy]'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_insert // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_insert'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f46a955bc10>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f46a2a8b430>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f46a9db9d30>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f46a2a8b190>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_insert'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_simple_expiration_batch_mutate // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_simple_expiration_batch_mutate'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f46a955bc10>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f46a27d2700>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f46a9db9d30>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f46a27d2340>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_simple_expiration_batch_mutate'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compaction_delete[DateTieredCompactionStrategy] /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[DateTieredCompactionStrategy]'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f930caa24f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f930c037790>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f930d2eeb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f930c038b50>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[DateTieredCompactionStrategy]'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_standard_columns // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_standard_columns'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f930caa24f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f930cc04ac0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f930d2eeb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f930cc52190>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_standard_columns'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_update_expiring // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_update_expiring'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f930caa24f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f9307f3c0a0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f930d2eeb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f930d0a4490>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_update_expiring'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_remove_standard_columns // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_standard_columns'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f78e0d6e820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f78e01af100>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f78e160da60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f78e139d4c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_standard_columns'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_remove_expiring // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_remove_expiring'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f78e0d6e820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f78e04c1a00>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f78e160da60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f78e04c1c40>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_remove_expiring'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_paging_with_filtering_on_counter_columns_compact /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_counter_columns_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7ff5b839d130>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7ff5b5006f70>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7ff5b8c74b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7ff5b4de0fa0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_counter_columns_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_empty_range // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_empty_range'>>
dtest_config = <dtest_config.DTestConfig object at 0x7ff5b839d130>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7ff5b78307f0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7ff5b8c74b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7ff5b7a904c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_empty_range'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_column_not_found_quorum // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_column_not_found_quorum'>>
dtest_config = <dtest_config.DTestConfig object at 0x7ff5b839d130>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7ff5b795af70>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7ff5b8c74b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7ff5b5809160>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_column_not_found_quorum'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_remove_standard_row // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_standard_row'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7ead35b2e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7eacab5340>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7eadbccb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7eaca4bbe0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_standard_row'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_ring_on_invalid_keyspace // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_ring_on_invalid_keyspace'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7ead35b2e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7ea6e2c0a0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7eadbccb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7ead52de50>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_ring_on_invalid_keyspace'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests /
/ test_batch_mutate_remove_super_columns_with_standard_under // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_with_standard_under'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8b2ee1ca30>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8b2de89eb0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8b2f6bfca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8b2de84580>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_with_standard_under'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_add // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_add'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8b2ee1ca30>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8b2ce63400>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8b2f6bfca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8b2ce5e460>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_add'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests /
/ test_batch_mutate_remove_super_columns_with_none_given_underneath // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_with_none_given_underneath'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1a49a5f2e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f1a38279460>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1a4a2bdb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f1a48d01ca0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_with_none_given_underneath'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_super_add // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_super_add'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1a49a5f2e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f1a381a4c40>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1a4a2bdb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f1a381a4df0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_super_add'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_remove_super_columns_entire_row /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_entire_row'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f3c0f53fbe0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f3bf47cb040>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f3c0fd9baf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f3c0f6386a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_entire_row'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_standard_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_standard_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f3c0f53fbe0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f3c0ca9b100>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f3c0fd9baf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f3c0ca9bd00>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_standard_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compact_storage // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_storage'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f71ece21580>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f71ec255e50>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f71ed6a2a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f71ec2201f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_storage'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_remove_slice_standard // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_slice_standard'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f71ece21580>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f71ed0080d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f71ed6a2a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f71ec2246d0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_slice_standard'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_super_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_super_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f71ece21580>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f71ed0161c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f71ed6a2a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f71ed016b20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_super_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compact_storage_composite // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_storage_composite'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f10e8206550>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f10e520e940>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f10e8a5eaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f10e553c8e0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_storage_composite'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_remove_slice_of_entire_supercolumns /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_slice_of_entire_supercolumns'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f10e8206550>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f10e5141eb0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f10e8a5eaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f10e5128040>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_slice_of_entire_supercolumns'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f10e8206550>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f10e52172b0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f10e8a5eaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f10e5217f40>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_thrift // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_thrift'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f10e8206550>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f10e521e0d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f10e8a5eaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f10e5229310>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_thrift'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_readrepair // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_readrepair'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd6559a8e50>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd654f83b20>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd6560c8b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd655ec32e0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_readrepair'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_super_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_super_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd6559a8e50>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd654424130>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd6560c8b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd64ed50b20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_super_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_logged_batch_compatibility_1 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_logged_batch_compatibility_1'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fb2daca7340>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fb2dadadac0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fb2db582940>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fb2d94017f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_logged_batch_compatibility_1'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_insertions_and_deletions // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_insertions_and_deletions'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fb2daca7340>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fb2c2cc43d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fb2db582940>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fb2d8cb6550>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_insertions_and_deletions'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_batch_add // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_batch_add'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fb2daca7340>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fb2db38f160>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fb2db582940>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fb2db379e80>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_batch_add'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batchlog_replay_compatibility_1 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batchlog_replay_compatibility_1'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f3846300700>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f3844a95f10>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f3846b169d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f3844a21100>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batchlog_replay_compatibility_1'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_bad_system_calls // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_bad_system_calls'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f3846300700>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f384564d2b0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f3846b169d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f384589dc40>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_bad_system_calls'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_batch_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_batch_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f3846300700>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f3844946190>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f3846b169d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f38449469a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_batch_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_logged_batch_compatibility_2 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_logged_batch_compatibility_2'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4bdcc30e80>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4bdcdcaa00>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4bdd475b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4bdcca6a00>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_logged_batch_compatibility_2'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_wide_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_wide_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4bdcc30e80>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4bdd232dc0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4bdd475b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4bdc24f730>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_wide_slice'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_bad_batch_calls // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_bad_batch_calls'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4bdcc30e80>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4bd67b8730>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4bdd475b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4bd47f1fa0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_bad_batch_calls'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_range_deletion // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_deletion'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4bdcc30e80>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4bd55c24f0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4bdd475b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4bd564d1c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_deletion'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_cql_read_compatibility // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cql_read_compatibility'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa8cce7e5b0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa8c5eb1c10>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa8cd445b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa8cc0776a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cql_read_compatibility'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_get_range_slice_after_deletion // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slice_after_deletion'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa8cce7e5b0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa8c54782e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa8cd445b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa8ccf33e20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slice_after_deletion'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_remove_column_ttl_with_default_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_remove_column_ttl_with_default_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa8cce7e5b0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa8c548d520>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa8cd445b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa8c548d100>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_remove_column_ttl_with_default_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_async_1 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_1'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa8cce7e5b0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa8c5ebb310>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa8cd445b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa8c5f27580>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_1'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_logged_batch_compatibility_3 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_logged_batch_compatibility_3'>>
dtest_config = <dtest_config.DTestConfig object at 0x7ff90ef7d310>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7ff90f1391c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7ff90f80da60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7ff90f181fd0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_logged_batch_compatibility_3'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_13691 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_13691'>>
dtest_config = <dtest_config.DTestConfig object at 0x7ff90ef7d310>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7ff90d61e520>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7ff90f80da60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7ff90d582490>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_13691'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_column_name_lengths // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_column_name_lengths'>>
dtest_config = <dtest_config.DTestConfig object at 0x7ff90ef7d310>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7ff90c2f7fd0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7ff90f80da60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7ff8f41a4c40>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_column_name_lengths'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_range_deletion_eoc_0 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_deletion_eoc_0'>>
dtest_config = <dtest_config.DTestConfig object at 0x7ff90ef7d310>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7ff90e0a4730>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7ff90f80da60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7ff90e0a4ac0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_deletion_eoc_0'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_logged_batch_compatibility_4 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_logged_batch_compatibility_4'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fb33e8bed60>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fb33e9442b0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fb33f150c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fb33eac7130>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_logged_batch_compatibility_4'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_bad_calls // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_bad_calls'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fb33e8bed60>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fb33c2010d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fb33f150c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fb32c448340>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_bad_calls'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fb33e8bed60>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fb33c380cd0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fb33f150c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fb33c380070>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_slice'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batchlog_replay_compatibility_4 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batchlog_replay_compatibility_4'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f35b4abd4f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f35b4ad12b0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f35b534c9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f35b4c78a30>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batchlog_replay_compatibility_4'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_insert_super // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_insert_super'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f35b4abd4f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f35b51365e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f35b534c9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f35b4ff3700>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_insert_super'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_multiget_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_multiget_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f35b4abd4f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f35ac673940>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f35b534c9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f35ac673ca0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_multiget_slice'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_logged_batch_compatibility_5 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_logged_batch_compatibility_5'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f612974a850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f6129760e80>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f6129fdb9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f61298e3820>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_logged_batch_compatibility_5'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_cf_remove_column // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_cf_remove_column'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f612974a850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f6129d92040>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f6129fdb9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f61297ce2b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_cf_remove_column'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_counter_get_slice_range // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_counter_get_slice_range'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f612974a850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f6129d90220>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f6129fdb9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f6128449bb0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_counter_get_slice_range'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_alter_rf_and_run_read_repair // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_alter_rf_and_run_read_repair'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8d535b7400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8d51b86280>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8d53eaba60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8d51b86b50>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_alter_rf_and_run_read_repair'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_drop_column_compact // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_drop_column_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8d535b7400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8d51b11af0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8d53eaba60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8d504f0ee0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_drop_column_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_cf_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_cf_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8d535b7400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8d51a84be0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8d53eaba60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8d52644fd0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_cf_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_counter_get_slice_super_range // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_counter_get_slice_super_range'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8d535b7400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8d51255280>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8d53eaba60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8d51255130>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_counter_get_slice_super_range'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_table_compact_storage // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_table_compact_storage'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1300b2fe50>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f12f9fbbfa0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1301298af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f12f9320e20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_table_compact_storage'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_paging_with_filtering_on_clustering_columns_compact
// Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_clustering_columns_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1300b2fe50>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f12f97d30a0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1301298af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f12f95cac10>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_clustering_columns_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_cql_write_compatibility // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cql_write_compatibility'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1300b2fe50>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f12f92f59d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1301298af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f12f96c46a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_cql_write_compatibility'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_multi_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multi_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1300b2fe50>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f12f9eb0e80>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1301298af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f12f9eb08b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_multi_slice'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_async_2 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_2'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1300b2fe50>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f12fa6b2ee0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1301298af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f12f9fb5b20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_2'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_range_with_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_with_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f71ddc90d90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f71dd0aa400>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f71de2bcaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f71dcd23df0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_with_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_truncate // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_truncate'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f71ddc90d90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f71dd04d040>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f71de2bcaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f71dd04da00>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_truncate'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_async_3 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_3'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f71ddc90d90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f71dd130280>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f71de2bcaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f71dd130490>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_3'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_range_with_remove_cf // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_with_remove_cf'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f46e08ced00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f46dc2c1df0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f46e0e23940>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f46e06ef130>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_with_remove_cf'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_cql_range_tombstone_and_static // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_cql_range_tombstone_and_static'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f46e08ced00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f46dc4187c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f46e0e23940>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f46dc418ca0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_cql_range_tombstone_and_static'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_range_async_1 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_1'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f46e08ced00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f46dfbc6e20>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f46e0e23940>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f46dc2cb9d0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_1'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_get_range_slice_super // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slice_super'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f298ce80be0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f2987ee1d60>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f298d760b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f2987cbbb80>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slice_super'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_large_collection_errors // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_large_collection_errors'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fc46860eeb0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fc468951d00>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fc468b63b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fc46894c100>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_large_collection_errors'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests /
/ test_paging_with_filtering_on_partition_key_on_clustering_columns_compact /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_partition_key_on_clustering_columns_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fc46860eeb0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fc468616340>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fc468b63b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fc468625b50>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_partition_key_on_clustering_columns_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_keyspace // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_keyspace'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fc46860eeb0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fc46779b4f0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fc468b63b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fc4677cd1f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_keyspace'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_cql3_insert_thrift // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_cql3_insert_thrift'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f608e236460>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f608e065880>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f608e782c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f608de8cb80>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_cql3_insert_thrift'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_describe'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f608e236460>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f608d1addc0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f608e782c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f608d1ad880>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_describe'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_only_superuser_can_create_users // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_only_superuser_can_create_users'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f221a695dc0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f221a695e50>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f221af14af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f221a619430>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_only_superuser_can_create_users'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_rename // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_rename'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f221a695dc0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f220a63d190>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f221af14af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f22183d1d30>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_rename'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_sc_with_row_cache // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_sc_with_row_cache'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f221a695dc0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f220a567250>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f221af14af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f220a2aa1c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_sc_with_row_cache'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_ring // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_ring'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f221a695dc0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f22183cc820>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f221af14af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f22183cc4f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_ring'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_password_authenticator_create_user_requires_password
// Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_password_authenticator_create_user_requires_password'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1550f575b0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f1550f49520>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f15517d8c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f1550f49e80>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_password_authenticator_create_user_requires_password'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests /
/ test_paging_on_compact_table_with_tombstone_on_first_column // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_on_compact_table_with_tombstone_on_first_column'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1550f575b0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f15504a1700>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f15517d8c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f155060b2b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_on_compact_table_with_tombstone_on_first_column'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_functional // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_functional'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1550f575b0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f15485a30d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f15517d8c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f152a5b31c0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_functional'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_token_map // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_token_map'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1550f575b0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f1548a7b0d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f15517d8c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f1548a7b940>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_token_map'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_partitioner // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_partitioner'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fcd2a51b640>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fcd2806db20>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fcd2ad9da60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fccffcbfa60>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_partitioner'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_paging_with_no_clustering_columns_compact // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_no_clustering_columns_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f09d1b031f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f09d1aaca30>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f09d21e3a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f09d1aac9a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_no_clustering_columns_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_read_old_sstables_after_upgrade // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_read_old_sstables_after_upgrade'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f09d1b031f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f09d10a4580>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f09d21e3a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f09c2148970>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_read_old_sstables_after_upgrade'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_snitch // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_snitch'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f09d1b031f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f09d1f844f0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f09d21e3a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f09d2169100>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_snitch'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_closing_connections // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_closing_connections'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa73c160190>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa73ada8eb0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa73c1ca9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa73adb7250>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_closing_connections'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_invalid_ks_names // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_ks_names'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa73c160190>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa73bf547f0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa73c1ca9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa73bf54190>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_ks_names'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_drop_compact_storage_flag // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_drop_compact_storage_flag'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f9de6ddb850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f9de75248e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f9de7611b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f9de43b9880>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_drop_compact_storage_flag'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_json_tools // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_json_tools'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f9de6ddb850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f9de73faa90>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f9de7611b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f9de73ff6a0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_json_tools'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_6285 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_6285'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f9de6ddb850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f9de73a5520>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f9de7611b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f9de739f9a0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_6285'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_invalid_strategy_class // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_strategy_class'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f9de6ddb850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f9de73f6f40>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f9de7611b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f9de73f68b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_strategy_class'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_only_superusers_can_drop_users // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_only_superusers_can_drop_users'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4ca4340a90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4ca4340b20>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4ca4b4ba60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4ca438c970>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_only_superusers_can_drop_users'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_paging_for_range_name_queries_compact // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_for_range_name_queries_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4ca4340a90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4ca21a7970>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4ca4b4ba60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4ca4942d90>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_for_range_name_queries_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_insert // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_insert'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4ca4340a90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4ca0eb2c10>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4ca4b4ba60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4ca0eb2f10>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_insert'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_invalid_cf_names // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_cf_names'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4ca4340a90>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4c816a6400>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4ca4b4ba60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4c816a6ca0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_invalid_cf_names'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_14766 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_14766'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f65e4350cd0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f65e4782130>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f65e498cb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f65e17bbfa0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_14766'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_empty_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_empty_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f65e4350cd0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f65e1679cd0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f65e498cb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f65e16cb9d0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_empty_slice'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_system_cf_recreate // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_cf_recreate'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f65e4350cd0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f65e478d7f0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f65e498cb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f65e478dd30>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_cf_recreate'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_paging_with_filtering_on_clustering_columns_compact
// Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_clustering_columns_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f41482a6640>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4144457a60>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4148b7baf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f414422bd60>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_paging_with_filtering_on_clustering_columns_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_get_range_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f41482a6640>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4147748e20>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4148b7baf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f41477b2ee0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_range_slice'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_cas // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_cas'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd76fbf7580>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd74c353880>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd7703fcb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd76f1c9550>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_cas'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_system_keyspace_operations // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_keyspace_operations'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd76fbf7580>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd76d06e280>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd7703fcb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd76d06ea90>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_keyspace_operations'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_remove_column_ttl_with_default_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_remove_column_ttl_with_default_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd76fbf7580>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd76d113ee0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd7703fcb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd76d113af0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_remove_column_ttl_with_default_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_async_1 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_1'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd76fbf7580>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd74c6bb730>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd7703fcb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd74c43cbb0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_1'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_missing_super // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_missing_super'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fba5e2e49a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fba4f6f8190>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fba5eaefaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fba4f6f0c70>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_missing_super'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_create_then_drop_ks // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_create_then_drop_ks'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fba5e2e49a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fba5d936190>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fba5eaefaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fba5d936cd0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_create_then_drop_ks'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_async_2 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_2'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fba5e2e49a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fba5d992700>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fba5eaefaf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fba5d9a2d60>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_2'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_count // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_count'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fb9230d46a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fb922416280>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fb92376fca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fb9236d6400>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_count'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_column_validators // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_column_validators'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fb9230d46a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fb9223bab20>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fb92376fca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fb9223baee0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_column_validators'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_async_3 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_3'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fb9230d46a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fb9226d6a90>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fb92376fca0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fb92239d4c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_async_3'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_count_paging // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_count_paging'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f99e650a400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f99e43830d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f99e6d6caf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f99e427a8b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_count_paging'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_system_column_family_operations // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_column_family_operations'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f99e650a400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f99e6b62f10>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f99e6d6caf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f99e6b624f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_column_family_operations'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_range_async_1 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_1'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f99e650a400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f99e6af4730>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f99e6d6caf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f99e64f5220>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_1'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_rf_collapse_yaml_file_snitch // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_rf_collapse_yaml_file_snitch'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f0c473f7550>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f0c2dc96df0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f0c47ae5b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f0c2e9fdcd0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_rf_collapse_yaml_file_snitch'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_count_around_page_size // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_count_around_page_size'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f0c473f7550>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f0c469f22b0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f0c47ae5b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f0c4695e7c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_count_around_page_size'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_dynamic_indexes_creation_deletion // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dynamic_indexes_creation_deletion'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f0c473f7550>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f0c475bf880>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f0c47ae5b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f0c475bf280>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dynamic_indexes_creation_deletion'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_datetimeformat_round_trip // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_datetimeformat_round_trip'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f0c473f7550>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f0c47a051c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f0c47ae5b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f0c473ec7f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_datetimeformat_round_trip'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_range_async_2 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_2'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f0c473f7550>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f0c478e0c40>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f0c47ae5b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f0c469caf10>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_2'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_rf_expand_yaml_file_snitch // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_rf_expand_yaml_file_snitch'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa6fe442e50>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa6fe52e880>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa6fe9c2af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa6fe52e940>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_rf_expand_yaml_file_snitch'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_insert // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_insert'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa6fe442e50>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa6fc92cb80>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa6fe9c2af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa6eff0ef40>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_insert'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_dynamic_indexes_with_system_update_cf // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dynamic_indexes_with_system_update_cf'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa6fe442e50>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa6eefb5e80>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa6fe9c2af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa6eefb58b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dynamic_indexes_with_system_update_cf'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_force_repair_range_async_3 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_3'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fa6fe442e50>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fa6efb73940>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fa6fe9c2af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fa6efb231f0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_force_repair_range_async_3'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_populate_mv_after_insert_wide_rows // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_populate_mv_after_insert_wide_rows'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f922268a3a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f9222be8eb0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f9222d2eb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f9222ab7520>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_populate_mv_after_insert_wide_rows'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_get // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_super_get'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f922268a3a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f91f5381df0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f9222d2eb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f92226ea340>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_super_get'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_system_super_column_family_operations // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_super_column_family_operations'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f922268a3a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f9222584640>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f9222d2eb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f92226a7ca0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_system_super_column_family_operations'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_deprecated_repair_error_notification // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_deprecated_repair_error_notification'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f922268a3a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f92214dba00>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f9222d2eb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f9221bff2b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_deprecated_repair_error_notification'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_hsha_defaults // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_hsha_defaults'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f6c8fef55e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f6c906fbb80>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f6c9077dc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f6c906fb4c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_hsha_defaults'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_super_subcolumn_limit // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_subcolumn_limit'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f6c8fef55e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f6c900bf7c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f6c9077dc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f6c8ff8b5b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_super_subcolumn_limit'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_insert_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_insert_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f6c8fef55e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f6c8f664b80>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f6c9077dc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f6c90575670>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_insert_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_hsha_with_ssl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_hsha_with_ssl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1f6ef46850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f1f6d705310>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1f6f796a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f1f6d706340>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_hsha_with_ssl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_long_order // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_long_order'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1f6ef46850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f1f6f185280>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1f6f796a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f1f6ef836d0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_long_order'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_insert_max_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_insert_max_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1f6ef46850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f1f6f120550>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1f6f796a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f1f6f109280>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_insert_max_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_failed_snitch_update_yaml_file_snitch // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_failed_snitch_update_yaml_file_snitch'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f45f473f3a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f45f494f310>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f45f4ff4af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f45f4f47580>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_failed_snitch_update_yaml_file_snitch'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_integer_order // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_integer_order'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f45f473f3a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f45d165f4c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f45f4ff4af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f45f1692250>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_integer_order'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_insert_max_default_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_insert_max_default_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f45f473f3a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f45f493ad00>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f45f4ff4af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f45f493a910>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_insert_max_default_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_datetime_values // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_datetime_values'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f45f473f3a0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f45f4988fa0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f45f4ff4af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f45f4f01d30>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_datetime_values'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_table_compact_storage // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_table_compact_storage'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f6149772e20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f6149e377f0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f614a041a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f6149e37b50>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_table_compact_storage'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_8280_validate_indexed_values_compact // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_8280_validate_indexed_values_compact'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f6149772e20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f6149e48880>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f614a041a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f6148d8dd30>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_8280_validate_indexed_values_compact'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_wrapped_range_slices // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_wrapped_range_slices'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f6149772e20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f6149f23550>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f614a041a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f6149afc580>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_wrapped_range_slices'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_time_uuid // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_time_uuid'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f19543ead00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f19545acc10>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1954c2ac10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f1953804fa0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_time_uuid'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_simple_expiration // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_simple_expiration'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f19543ead00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f19547b8190>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1954c2ac10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f19547b8640>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_simple_expiration'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_long_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_long_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8d91a955b0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8d90c3bc70>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8d9234ea60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8d90ca6400>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_long_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_expiration_with_default_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_expiration_with_default_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f8d91a955b0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f8d90f82bb0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8d9234ea60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8d90f82e80>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_expiration_with_default_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_integer_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_integer_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f21bdfa81f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f21bd39ffa0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f21be820a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f21bd37d4c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_integer_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_expiration_with_default_ttl_and_zero_ttl // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_expiration_with_default_ttl_and_zero_ttl'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f21bdfa81f0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f21be19fe20>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f21be820a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f21be19f430>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_expiration_with_default_ttl_and_zero_ttl'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_insert // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_insert'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f50b7b6d400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f50b6ce6340>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f50b821baf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f50b6e28760>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_insert'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_simple_expiration_batch_mutate // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_simple_expiration_batch_mutate'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f50b7b6d400>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f50b7b61a60>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f50b821baf0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f50b7b94400>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_simple_expiration_batch_mutate'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_standard_columns // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_standard_columns'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4d1c51b160>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4d1b920c70>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4d1cd91b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4d1c74acd0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_standard_columns'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_update_expiring // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_update_expiring'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f4d1c51b160>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f4d1b7c6640>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f4d1cd91b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f4d1b80f730>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_update_expiring'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_remove_standard_columns // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_standard_columns'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f689b5b0670>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f689a7480a0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f689bbbf9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f689a6968b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_standard_columns'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_remove_expiring // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_remove_expiring'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f689b5b0670>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f689a7fc640>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f689bbbf9d0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f689a85cb20>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_remove_expiring'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_remove_standard_row // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_standard_row'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f45d1157070>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f45d00c4d00>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f45d1781af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f45d02222e0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_standard_row'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_describe_ring_on_invalid_keyspace // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_ring_on_invalid_keyspace'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f45d1157070>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f45d005f4c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f45d1781af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f45d024e310>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_describe_ring_on_invalid_keyspace'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests /
/ test_batch_mutate_remove_super_columns_with_standard_under // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_with_standard_under'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fac51ed3760>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fac40c5c610>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fac52496c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fac40e15d60>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_with_standard_under'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_add // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_add'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fac51ed3760>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fac52297070>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fac52496c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fac52297a60>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_add'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests /
/ test_batch_mutate_remove_super_columns_with_none_given_underneath // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_with_none_given_underneath'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fbfc8605a30>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fbfc78d5e50>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fbfc8d9fb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fbfc7d26520>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_with_none_given_underneath'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_super_add // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_super_add'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fbfc8605a30>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fbfc78bad60>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fbfc8d9fb80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fbfc7944640>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_super_add'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_remove_super_columns_entire_row /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_entire_row'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd428307a00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd42787cb20>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd428b01b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd42527a2b0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_super_columns_entire_row'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_standard_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_standard_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fd428307a00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fd42693caf0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fd428b01b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fd42693c160>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_standard_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_get_slice_by_names // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_slice_by_names'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7dcb855e20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7dcb016700>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7dcc126940>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7dcbbb7250>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_get_slice_by_names'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_dead_coordinator // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dead_coordinator'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7dcb855e20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7dcadc2610>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7dcc126940>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7dcadcb9d0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_dead_coordinator'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_sstableupgrade // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_sstableupgrade'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f933c4baa00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f933ca99490>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f933ccb3a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f933ca99cd0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_sstableupgrade'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compact_storage // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_storage'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f933c4baa00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f933ca63550>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f933ccb3a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f933ca45460>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_storage'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_remove_slice_standard // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_slice_standard'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f933c4baa00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f9338c54700>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f933ccb3a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f933bca1490>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_slice_standard'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_super_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_super_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f933c4baa00>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f933ba90d90>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f933ccb3a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f933ba2c2e0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_super_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compact_storage_composite // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_storage_composite'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7d2cbbd2e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7d2c2adca0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7d2d3b6af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7d2d2f76a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compact_storage_composite'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_remove_slice_of_entire_supercolumns /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_slice_of_entire_supercolumns'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7d2cbbd2e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7d2cdb8550>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7d2d3b6af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7d2c16b070>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_remove_slice_of_entire_supercolumns'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f7d2cbbd2e0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f7d24682af0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f7d2d3b6af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f7d24682c40>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compaction_delete[LeveledCompactionStrategy] /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[LeveledCompactionStrategy]'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f268663dfa0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f268663d9a0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f2686e4fc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f2684450a90>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[LeveledCompactionStrategy]'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_super_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_super_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f268663dfa0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f2685b17f10>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f2686e4fc10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f2685b6b430>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_super_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compaction_delete[SizeTieredCompactionStrategy] /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[SizeTieredCompactionStrategy]'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fab25c13b20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fab263677c0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fab26456b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fab26365b80>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[SizeTieredCompactionStrategy]'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_mutate_insertions_and_deletions // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_insertions_and_deletions'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fab25c13b20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fab25d8b190>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fab26456b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fab251c7340>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_mutate_insertions_and_deletions'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_batch_add // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_batch_add'>>
dtest_config = <dtest_config.DTestConfig object at 0x7fab25c13b20>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7fab241d0760>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7fab26456b80>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7fab241d0070>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_batch_add'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_compaction_delete[DateTieredCompactionStrategy] /
/ Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[DateTieredCompactionStrategy]'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f3d4b232820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f3d498aaf10>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f3d4ba87a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f3d498a3970>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_compaction_delete[DateTieredCompactionStrategy]'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_bad_system_calls // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_bad_system_calls'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f3d4b232820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f3d4a7b52e0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f3d4ba87a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f3d4b333bb0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_bad_system_calls'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_batch_remove // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_batch_remove'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f3d4b232820>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f3d4a87bca0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f3d4ba87a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f3d4a87b610>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_batch_remove'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_bad_batch_calls // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_bad_batch_calls'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f5f725eca30>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f5f70159700>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f5f72df6af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f5f702381c0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_bad_batch_calls'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_range_deletion // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_deletion'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f5f725eca30>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f5f71bac970>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f5f72df6af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f5f71bac610>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_deletion'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_no_anticompaction_after_dclocal_repair // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_after_dclocal_repair'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f5f725eca30>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f5f72bf9400>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f5f72df6af0>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f5f7023b670>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_after_dclocal_repair'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_column_name_lengths // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_column_name_lengths'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f0ae8451ac0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f0ae570af10>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f0ae8c5ba60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f0ae83ad130>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_column_name_lengths'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_range_deletion_eoc_0 // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_deletion_eoc_0'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f0ae8451ac0>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f0ae573deb0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f0ae8c5ba60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f0ae57380a0>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_range_deletion_eoc_0'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_bad_calls // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_bad_calls'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f819323c850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f81917539d0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8193a46a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f81918f37f0>
request = <SubRequest 'fixture_dtest_setup' for <Function 'test_bad_calls'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f819323c850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f819174fa60>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8193a46a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f819150d370>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_slice'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_no_anticompaction_after_hostspecific_repair // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_after_hostspecific_repair'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f819323c850>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f81918607f0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f8193a46a60>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f8191795100>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_no_anticompaction_after_hostspecific_repair'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_batch_insert_super // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_insert_super'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1958af2c70>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f1953c59a60>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1959368c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if not dtest_setup.allow_log_errors:
errors = check_logs_for_errors(dtest_setup)
if len(errors) > 0:
failed = True
pytest.fail(msg='Unexpected error found in node logs (see stdout for full
details). Errors: [{errors}]'
.format(errors=str.join(", ", errors)), pytrace=False)
finally:
try:
# save the logs for inspection
if failed or not dtest_config.delete_logs:
copy_logs(request, dtest_setup.cluster)
except Exception as e:
logger.error("Error saving log:", str(e))
finally:
> dtest_setup.cleanup_cluster(request)
conftest.py:352:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
_
self = <dtest_setup.DTestSetup object at 0x7f1953ed1d60>
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_batch_insert_super'>>
def cleanup_cluster(self, request=None):
with log_filter('cassandra'): # quiet noise from driver when nodes start
going down
> if self.dtest_config.keep_test_dir or
(self.dtest_config.keep_failed_test_dir and request and
request.node.rep_call.failed):
E AttributeError: 'Function' object has no attribute 'rep_call'
dtest_setup.py:351: AttributeError
-----------------------------------------------------------------------------
Cassandra dtests // test_incr_decr_standard_multiget_slice // Error
test teardown failure
request = <SubRequest 'fixture_dtest_setup' for <Function
'test_incr_decr_standard_multiget_slice'>>
dtest_config = <dtest_config.DTestConfig object at 0x7f1958af2c70>
fixture_dtest_setup_overrides = <dtest_setup_overrides.DTestSetupOverrides
object at 0x7f19580b53a0>
fixture_logging_setup = None, fixture_dtest_cluster_name = 'test'
fixture_dtest_create_cluster_func = <function DTestSetup.create_ccm_cluster
at 0x7f1959368c10>
@pytest.fixture(scope='function', autouse=False)
def fixture_dtest_setup(request,
dtest_config,
fixture_dtest_setup_overrides,
fixture_logging_setup,
fixture_dtest_cluster_name,
fixture_dtest_create_cluster_func):
if running_in_docker():
cleanup_docker_environment_before_test_execution()
# do all of our setup operations to get the enviornment ready for the actual
test
# to run (e.g. bring up a cluster with the necessary config, populate
variables, etc)
initial_environment = copy.deepcopy(os.environ)
dtest_setup = DTestSetup(dtest_config=dtest_config,
setup_overrides=fixture_dtest_setup_overrides,
cluster_name=fixture_dtest_cluster_name)
dtest_setup.initialize_cluster(fixture_dtest_create_cluster_func)
if not dtest_config.disable_active_log_watching:
dtest_setup.begin_active_log_watch()
# at this point we're done with our setup operations in this fixture
# yield to allow the actual test to run
yield dtest_setup
# phew! we're back after executing the test, now we need to do
# all of our teardown and cleanup operations
reset_environment_vars(initial_environment)
dtest_setup.jvm_args = []
for con in dtest_setup.connections:
con.cluster.shutdown()
dtest_setup.connections = []
failed = False
try:
if no