diff --git a/tests/CVE_2018_1058.py b/tests/CVE_2018_1058.py
index 3da41f116..cfd55cc60 100644
--- a/tests/CVE_2018_1058.py
+++ b/tests/CVE_2018_1058.py
@@ -2,17 +2,14 @@
import unittest
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
-module_name = 'CVE-2018-1058'
-
class CVE_2018_1058(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
def test_basic_default_search_path(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True)
self.init_pb(backup_dir)
@@ -31,16 +28,12 @@ def test_basic_default_search_path(self):
self.backup_node(backup_dir, 'node', node, backup_type='full', options=['--stream'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_backup_modified_search_path(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True)
self.set_auto_conf(node, options={'search_path': 'public,pg_catalog'})
@@ -77,15 +70,11 @@ def test_basic_backup_modified_search_path(self):
self.assertFalse(
'pg_probackup vulnerable!' in log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_checkdb_modified_search_path(self):
""""""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.set_auto_conf(node, options={'search_path': 'public,pg_catalog'})
node.slow_start()
@@ -138,6 +127,3 @@ def test_basic_checkdb_modified_search_path(self):
e.message,
"\n Unexpected Error Message: {0}\n CMD: {1}".format(
repr(e.message), self.cmd))
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/__init__.py b/tests/__init__.py
index 79537ad78..40d5faf65 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -27,7 +27,7 @@ def load_tests(loader, tests, pattern):
if os.environ['PG_PROBACKUP_LONG'] == 'ON':
suite.addTests(loader.loadTestsFromModule(time_consuming))
-# suite.addTests(loader.loadTestsFromModule(auth_test))
+ suite.addTests(loader.loadTestsFromModule(auth_test))
suite.addTests(loader.loadTestsFromModule(archive))
suite.addTests(loader.loadTestsFromModule(backup))
suite.addTests(loader.loadTestsFromModule(catchup))
@@ -35,9 +35,9 @@ def load_tests(loader, tests, pattern):
suite.addTests(loader.loadTestsFromModule(compatibility))
suite.addTests(loader.loadTestsFromModule(checkdb))
suite.addTests(loader.loadTestsFromModule(config))
-# suite.addTests(loader.loadTestsFromModule(cfs_backup))
-# suite.addTests(loader.loadTestsFromModule(cfs_restore))
-# suite.addTests(loader.loadTestsFromModule(cfs_validate_backup))
+ suite.addTests(loader.loadTestsFromModule(cfs_backup))
+ suite.addTests(loader.loadTestsFromModule(cfs_restore))
+ suite.addTests(loader.loadTestsFromModule(cfs_validate_backup))
suite.addTests(loader.loadTestsFromModule(compression))
suite.addTests(loader.loadTestsFromModule(delete))
suite.addTests(loader.loadTestsFromModule(delta))
diff --git a/tests/archive.py b/tests/archive.py
index a65b85dba..5e59dd268 100644
--- a/tests/archive.py
+++ b/tests/archive.py
@@ -10,19 +10,15 @@
from distutils.dir_util import copy_tree
-module_name = 'archive'
-
-
class ArchiveTest(ProbackupTest, unittest.TestCase):
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_pgpro434_1(self):
"""Description in jira issue PGPRO-434"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -64,8 +60,6 @@ def test_pgpro434_1(self):
self.assertEqual(
result, node.safe_psql("postgres", "SELECT * FROM t_heap"),
'data after restore not equal to original data')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
# @unittest.skip("skip")
# @unittest.expectedFailure
@@ -74,10 +68,9 @@ def test_pgpro434_2(self):
Check that timelines are correct.
WAITING PGPRO-1053 for --immediate
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -85,7 +78,6 @@ def test_pgpro434_2(self):
)
if self.get_version(node) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because pg_control_checkpoint() is not supported in PG 9.5')
@@ -219,9 +211,6 @@ def test_pgpro434_2(self):
"SELECT * FROM t_heap"),
'data after restore not equal to original data')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_pgpro434_3(self):
"""
@@ -230,10 +219,9 @@ def test_pgpro434_3(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -284,9 +272,6 @@ def test_pgpro434_3(self):
log_content,
'PostgreSQL crashed because of a failed assert')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_pgpro434_4(self):
"""
@@ -295,10 +280,9 @@ def test_pgpro434_4(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -361,16 +345,12 @@ def test_pgpro434_4(self):
log_content,
'PostgreSQL crashed because of a failed assert')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_archive_push_file_exists(self):
"""Archive-push if file exists"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -454,16 +434,12 @@ def test_archive_push_file_exists(self):
print(log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_archive_push_file_exists_overwrite(self):
"""Archive-push if file exists"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={'checkpoint_timeout': '30s'})
@@ -530,16 +506,12 @@ def test_archive_push_file_exists_overwrite(self):
'WAL file already exists in archive with '
'different checksum, overwriting', log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_archive_push_partial_file_exists(self):
"""Archive-push if stale '.part' file exists"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -613,16 +585,12 @@ def test_archive_push_partial_file_exists(self):
'Reusing stale temp WAL file',
log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_archive_push_part_file_exists_not_stale(self):
"""Archive-push if .part file exists and it is not stale"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -693,9 +661,6 @@ def test_archive_push_part_file_exists_not_stale(self):
# 'is not stale',
# log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_replica_archive(self):
@@ -704,10 +669,9 @@ def test_replica_archive(self):
turn it into replica, set replica with archiving,
make archive backup from replica
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -716,7 +680,6 @@ def test_replica_archive(self):
'max_wal_size': '32MB'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -726,7 +689,7 @@ def test_replica_archive(self):
master.slow_start()
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
master.psql(
@@ -775,7 +738,7 @@ def test_replica_archive(self):
# RESTORE FULL BACKUP TAKEN FROM replica
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node'))
node.cleanup()
self.restore_node(backup_dir, 'replica', data_dir=node.data_dir)
@@ -824,9 +787,6 @@ def test_replica_archive(self):
after = node.safe_psql("postgres", "SELECT * FROM t_heap")
self.assertEqual(before, after)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_master_and_replica_parallel_archiving(self):
@@ -836,10 +796,9 @@ def test_master_and_replica_parallel_archiving(self):
set replica with archiving, make archive backup from replica,
make archive backup from master
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -847,12 +806,11 @@ def test_master_and_replica_parallel_archiving(self):
)
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.init_pb(backup_dir)
@@ -916,9 +874,6 @@ def test_master_and_replica_parallel_archiving(self):
self.assertEqual(
'OK', self.show_pb(backup_dir, 'master', backup_id)['status'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_basic_master_and_replica_concurrent_archiving(self):
@@ -931,10 +886,9 @@ def test_basic_master_and_replica_concurrent_archiving(self):
if self.pg_config_version < self.version_to_num('9.6.0'):
self.skipTest('You need PostgreSQL >= 9.6 for this test')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -942,12 +896,11 @@ def test_basic_master_and_replica_concurrent_archiving(self):
'archive_timeout': '10s'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.init_pb(backup_dir)
@@ -1020,10 +973,6 @@ def test_basic_master_and_replica_concurrent_archiving(self):
self.backup_node(backup_dir, 'master', master)
self.backup_node(backup_dir, 'master', replica)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_concurrent_archiving(self):
@@ -1037,10 +986,9 @@ def test_concurrent_archiving(self):
if self.pg_config_version < self.version_to_num('11.0'):
self.skipTest('You need PostgreSQL >= 11 for this test')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1056,7 +1004,7 @@ def test_concurrent_archiving(self):
# Settings for Replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'node', replica)
@@ -1067,7 +1015,7 @@ def test_concurrent_archiving(self):
# create cascade replicas
replica1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica1'))
replica1.cleanup()
# Settings for casaced replica
@@ -1103,17 +1051,13 @@ def test_concurrent_archiving(self):
log_content = f.read()
self.assertNotIn('different checksum', log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_archive_pg_receivexlog(self):
"""Test backup with pg_receivexlog wal delivary method"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1177,16 +1121,14 @@ def test_archive_pg_receivexlog(self):
# Clean after yourself
pg_receivexlog.kill()
- self.del_test_dir(module_name, fname)
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_archive_pg_receivexlog_compression_pg10(self):
"""Test backup with pg_receivewal compressed wal delivary method"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1245,7 +1187,6 @@ def test_archive_pg_receivexlog_compression_pg10(self):
# Clean after yourself
pg_receivexlog.kill()
- self.del_test_dir(module_name, fname)
# @unittest.expectedFailure
# @unittest.skip("skip")
@@ -1266,10 +1207,9 @@ def test_archive_catalog(self):
ARCHIVE master:
t1 -Z1--Z2---
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1277,7 +1217,6 @@ def test_archive_catalog(self):
'checkpoint_timeout': '30s'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -1307,7 +1246,7 @@ def test_archive_catalog(self):
backup_dir, 'master', master, backup_type='page')
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
self.set_replica(master, replica)
@@ -1576,8 +1515,6 @@ def test_archive_catalog(self):
self.assertEqual(timeline_2['parent-tli'], 1)
self.assertEqual(timeline_1['parent-tli'], 0)
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_archive_catalog_1(self):
@@ -1588,10 +1525,9 @@ def test_archive_catalog_1(self):
self.skipTest('You need to enable ARCHIVE_COMPRESSION '
'for this test to run')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1631,8 +1567,6 @@ def test_archive_catalog_1(self):
'000000010000000000000001')
self.assertEqual(timeline['status'], 'OK')
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_archive_catalog_2(self):
@@ -1643,10 +1577,9 @@ def test_archive_catalog_2(self):
self.skipTest('You need to enable ARCHIVE_COMPRESSION '
'for this test to run')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1688,8 +1621,6 @@ def test_archive_catalog_2(self):
'000000010000000000000002')
self.assertEqual(timeline['status'], 'OK')
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_archive_options(self):
@@ -1700,10 +1631,9 @@ def test_archive_options(self):
if not self.remote:
self.skipTest("You must enable PGPROBACKUP_SSH_REMOTE"
" for run this test")
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1766,8 +1696,6 @@ def test_archive_options(self):
'postgres',
'select 1')
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_archive_options_1(self):
@@ -1775,10 +1703,9 @@ def test_archive_options_1(self):
check that '--archive-host', '--archive-user', '--archiver-port'
and '--restore-command' are working as expected with set-config
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1837,8 +1764,6 @@ def test_archive_options_1(self):
self.probackup_path, backup_dir, 'node', self.user),
recovery_content)
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_undefined_wal_file_path(self):
@@ -1846,10 +1771,9 @@ def test_undefined_wal_file_path(self):
check that archive-push works correct with undefined
--wal-file-path
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1879,19 +1803,16 @@ def test_undefined_wal_file_path(self):
# check
self.assertEqual(self.show_archive(backup_dir, instance='node', tli=1)['min-segno'], '000000010000000000000001')
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_intermediate_archiving(self):
"""
check that archive-push works correct with --wal-file-path setting by user
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
node_pg_options = {}
@@ -1904,7 +1825,7 @@ def test_intermediate_archiving(self):
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
- wal_dir = os.path.join(self.tmp_path, module_name, fname, 'intermediate_dir')
+ wal_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'intermediate_dir')
shutil.rmtree(wal_dir, ignore_errors=True)
os.makedirs(wal_dir)
if os.name == 'posix':
@@ -1929,8 +1850,6 @@ def test_intermediate_archiving(self):
self.assertEqual(self.show_archive(backup_dir, instance='node', tli=1)['min-segno'], wal_segment)
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_waldir_outside_pgdata_archiving(self):
@@ -1941,13 +1860,12 @@ def test_waldir_outside_pgdata_archiving(self):
self.skipTest(
'Skipped because waldir outside pgdata is supported since PG 10')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- external_wal_dir = os.path.join(self.tmp_path, module_name, fname, 'ext_wal_dir')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ external_wal_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'ext_wal_dir')
shutil.rmtree(external_wal_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums', '--waldir={0}'.format(external_wal_dir)])
self.init_pb(backup_dir)
@@ -1964,18 +1882,15 @@ def test_waldir_outside_pgdata_archiving(self):
# check
self.assertEqual(self.show_archive(backup_dir, instance='node', tli=1)['min-segno'], '000000010000000000000001')
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_hexadecimal_timeline(self):
"""
Check that timelines are correct.
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2023,9 +1938,6 @@ def test_hexadecimal_timeline(self):
'0000000D000000000000001C',
tli13['max-segno'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
# @unittest.expectedFailure
def test_archiving_and_slots(self):
@@ -2033,10 +1945,9 @@ def test_archiving_and_slots(self):
Check that archiving don`t break slot
guarantee.
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -2087,15 +1998,11 @@ def test_archiving_and_slots(self):
exit(1)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_archive_push_sanity(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -2125,14 +2032,14 @@ def test_archive_push_sanity(self):
self.assertNotIn('WARNING', postgres_log_content)
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(
backup_dir, 'node', replica,
data_dir=replica.data_dir, options=['-R'])
- #self.set_archiving(backup_dir, 'replica', replica, replica=True)
+ # self.set_archiving(backup_dir, 'replica', replica, replica=True)
self.set_auto_conf(replica, {'port': replica.port})
self.set_auto_conf(replica, {'archive_mode': 'always'})
self.set_auto_conf(replica, {'hot_standby': 'on'})
@@ -2160,22 +2067,17 @@ def test_archive_push_sanity(self):
self.assertNotIn('WARNING', output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_archive_pg_receivexlog_partial_handling(self):
"""check that archive-get delivers .partial and .gz.partial files"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
if self.get_version(node) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -2234,7 +2136,7 @@ def test_archive_pg_receivexlog_partial_handling(self):
pg_receivexlog.kill()
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -2255,16 +2157,12 @@ def test_archive_pg_receivexlog_partial_handling(self):
self.assertEqual(result, result_new)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
def test_multi_timeline_recovery_prefetching(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2367,24 +2265,19 @@ def test_multi_timeline_recovery_prefetching(self):
'WAL segment 000000010000000000000006, prefetch state: 5/10',
postgres_log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_archive_get_batching_sanity(self):
"""
Make sure that batching works.
.gz file is corrupted and uncompressed is not, check that both
corruption detected and uncompressed file is used.
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
if self.get_version(node) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -2399,7 +2292,7 @@ def test_archive_get_batching_sanity(self):
node.pgbench_init(scale=50)
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(
@@ -2440,18 +2333,14 @@ def test_archive_get_batching_sanity(self):
self.assertIn('prefetch state: 9/10', postgres_log_content)
self.assertIn('prefetch state: 8/10', postgres_log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_archive_get_prefetch_corruption(self):
"""
Make sure that WAL corruption is detected.
And --prefetch-dir is honored.
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2466,7 +2355,7 @@ def test_archive_get_prefetch_corruption(self):
node.pgbench_init(scale=50)
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(
@@ -2576,19 +2465,15 @@ def test_archive_get_prefetch_corruption(self):
'LOG: restored log file "{0}" from archive'.format(filename),
postgres_log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_archive_show_partial_files_handling(self):
"""
check that files with '.part', '.part.gz', '.partial' and '.partial.gz'
siffixes are handled correctly
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2707,19 +2592,15 @@ def test_archive_show_partial_files_handling(self):
'WARNING',
log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_archive_empty_history_file(self):
"""
https://github.com/postgrespro/pg_probackup/issues/326
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2800,8 +2681,6 @@ def test_archive_empty_history_file(self):
'WARNING: History file is corrupted or missing: "{0}"'.format(os.path.join(wal_dir, '00000004.history')),
log_content)
- self.del_test_dir(module_name, fname)
-
# TODO test with multiple not archived segments.
# TODO corrupted file in archive.
diff --git a/tests/auth_test.py b/tests/auth_test.py
index 39786d7a9..7e0b6fcfb 100644
--- a/tests/auth_test.py
+++ b/tests/auth_test.py
@@ -30,13 +30,12 @@ def test_backup_via_unprivileged_user(self):
run a backups without EXECUTE rights on
certain functions
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -127,25 +126,16 @@ def test_backup_via_unprivileged_user(self):
node.safe_psql(
"postgres",
"GRANT EXECUTE ON FUNCTION pg_stop_backup(boolean) TO backup")
- elif self.get_vestion(node) < self.version_to_num('15.0'):
+ elif self.get_version(node) < self.version_to_num('15.0'):
node.safe_psql(
"postgres",
- "GRANT EXECUTE ON FUNCTION "
- "pg_stop_backup(boolean, boolean) TO backup")
- # Do this for ptrack backups
- node.safe_psql(
- "postgres",
- "GRANT EXECUTE ON FUNCTION pg_stop_backup() TO backup")
+ "GRANT EXECUTE ON FUNCTION pg_stop_backup() TO backup; "
+ "GRANT EXECUTE ON FUNCTION pg_stop_backup(boolean, boolean) TO backup;")
else:
node.safe_psql(
"postgres",
- "GRANT EXECUTE ON FUNCTION "
- "pg_backup_stop(boolean) TO backup")
- # Do this for ptrack backups
- node.safe_psql(
- "postgres",
- "GRANT EXECUTE ON FUNCTION pg_backup_stop() TO backup")
-
+ "GRANT EXECUTE ON FUNCTION pg_backup_stop() TO backup; "
+ "GRANT EXECUTE ON FUNCTION pg_backup_stop(boolean) TO backup;")
self.backup_node(
backup_dir, 'node', node, options=['-U', 'backup'])
@@ -176,14 +166,12 @@ def test_backup_via_unprivileged_user(self):
# backup_dir, 'node', node,
# backup_type='ptrack', options=['-U', 'backup'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
class AuthTest(unittest.TestCase):
pb = None
node = None
+ # TODO move to object scope, replace module_name
@classmethod
def setUpClass(cls):
@@ -197,7 +185,10 @@ def setUpClass(cls):
set_replication=True,
initdb_params=['--data-checksums', '--auth-host=md5']
)
- modify_pg_hba(cls.node)
+
+ cls.username = cls.pb.get_username()
+
+ cls.modify_pg_hba(cls.node)
cls.pb.init_pb(cls.backup_dir)
cls.pb.add_instance(cls.backup_dir, cls.node.name, cls.node)
@@ -207,7 +198,7 @@ def setUpClass(cls):
except StartNodeException:
raise unittest.skip("Node hasn't started")
- if cls.pb.get_version(cls.node) < 150000:
+ if cls.pb.get_version(cls.node) < 100000:
cls.node.safe_psql(
"postgres",
"CREATE ROLE backup WITH LOGIN PASSWORD 'password'; "
@@ -222,6 +213,21 @@ def setUpClass(cls):
"GRANT EXECUTE ON FUNCTION txid_current() TO backup; "
"GRANT EXECUTE ON FUNCTION txid_current_snapshot() TO backup; "
"GRANT EXECUTE ON FUNCTION txid_snapshot_xmax(txid_snapshot) TO backup;")
+ elif cls.pb.get_version(cls.node) < 150000:
+ cls.node.safe_psql(
+ "postgres",
+ "CREATE ROLE backup WITH LOGIN PASSWORD 'password'; "
+ "GRANT USAGE ON SCHEMA pg_catalog TO backup; "
+ "GRANT EXECUTE ON FUNCTION current_setting(text) TO backup; "
+ "GRANT EXECUTE ON FUNCTION pg_is_in_recovery() TO backup; "
+ "GRANT EXECUTE ON FUNCTION pg_start_backup(text, boolean, boolean) TO backup; "
+ "GRANT EXECUTE ON FUNCTION pg_stop_backup() TO backup; "
+ "GRANT EXECUTE ON FUNCTION pg_stop_backup(boolean, boolean) TO backup; "
+ "GRANT EXECUTE ON FUNCTION pg_create_restore_point(text) TO backup; "
+ "GRANT EXECUTE ON FUNCTION pg_switch_wal() TO backup; "
+ "GRANT EXECUTE ON FUNCTION txid_current() TO backup; "
+ "GRANT EXECUTE ON FUNCTION txid_current_snapshot() TO backup; "
+ "GRANT EXECUTE ON FUNCTION txid_snapshot_xmax(txid_snapshot) TO backup;")
else:
cls.node.safe_psql(
"postgres",
@@ -233,13 +239,14 @@ def setUpClass(cls):
"GRANT EXECUTE ON FUNCTION pg_backup_stop() TO backup; "
"GRANT EXECUTE ON FUNCTION pg_backup_stop(boolean) TO backup; "
"GRANT EXECUTE ON FUNCTION pg_create_restore_point(text) TO backup; "
- "GRANT EXECUTE ON FUNCTION pg_switch_xlog() TO backup; "
+ "GRANT EXECUTE ON FUNCTION pg_switch_wal() TO backup; "
"GRANT EXECUTE ON FUNCTION txid_current() TO backup; "
"GRANT EXECUTE ON FUNCTION txid_current_snapshot() TO backup; "
"GRANT EXECUTE ON FUNCTION txid_snapshot_xmax(txid_snapshot) TO backup;")
cls.pgpass_file = os.path.join(os.path.expanduser('~'), '.pgpass')
+ # TODO move to object scope, replace module_name
@classmethod
def tearDownClass(cls):
cls.node.cleanup()
@@ -247,12 +254,13 @@ def tearDownClass(cls):
@unittest.skipIf(skip_test, "Module pexpect isn't installed. You need to install it.")
def setUp(self):
- self.cmd = ['backup',
+ self.pb_cmd = ['backup',
'-B', self.backup_dir,
'--instance', self.node.name,
'-h', '127.0.0.1',
'-p', str(self.node.port),
'-U', 'backup',
+ '-d', 'postgres',
'-b', 'FULL'
]
@@ -272,44 +280,31 @@ def test_empty_password(self):
""" Test case: PGPB_AUTH03 - zero password length """
try:
self.assertIn("ERROR: no password supplied",
- str(run_pb_with_auth([self.pb.probackup_path] + self.cmd, '\0\r\n'))
- )
+ self.run_pb_with_auth('\0\r\n'))
except (TIMEOUT, ExceptionPexpect) as e:
self.fail(e.value)
def test_wrong_password(self):
""" Test case: PGPB_AUTH04 - incorrect password """
- try:
- self.assertIn("password authentication failed",
- str(run_pb_with_auth([self.pb.probackup_path] + self.cmd, 'wrong_password\r\n'))
- )
- except (TIMEOUT, ExceptionPexpect) as e:
- self.fail(e.value)
+ self.assertIn("password authentication failed",
+ self.run_pb_with_auth('wrong_password\r\n'))
def test_right_password(self):
""" Test case: PGPB_AUTH01 - correct password """
- try:
- self.assertIn("completed",
- str(run_pb_with_auth([self.pb.probackup_path] + self.cmd, 'password\r\n'))
- )
- except (TIMEOUT, ExceptionPexpect) as e:
- self.fail(e.value)
+ self.assertIn("completed",
+ self.run_pb_with_auth('password\r\n'))
def test_right_password_and_wrong_pgpass(self):
""" Test case: PGPB_AUTH05 - correct password and incorrect .pgpass (-W)"""
line = ":".join(['127.0.0.1', str(self.node.port), 'postgres', 'backup', 'wrong_password'])
- create_pgpass(self.pgpass_file, line)
- try:
- self.assertIn("completed",
- str(run_pb_with_auth([self.pb.probackup_path] + self.cmd + ['-W'], 'password\r\n'))
- )
- except (TIMEOUT, ExceptionPexpect) as e:
- self.fail(e.value)
+ self.create_pgpass(self.pgpass_file, line)
+ self.assertIn("completed",
+ self.run_pb_with_auth('password\r\n', add_args=["-W"]))
def test_ctrl_c_event(self):
""" Test case: PGPB_AUTH02 - send interrupt signal """
try:
- run_pb_with_auth([self.pb.probackup_path] + self.cmd, kill=True)
+ self.run_pb_with_auth(kill=True)
except TIMEOUT:
self.fail("Error: CTRL+C event ignored")
@@ -317,91 +312,74 @@ def test_pgpassfile_env(self):
""" Test case: PGPB_AUTH06 - set environment var PGPASSFILE """
path = os.path.join(self.pb.tmp_path, module_name, 'pgpass.conf')
line = ":".join(['127.0.0.1', str(self.node.port), 'postgres', 'backup', 'password'])
- create_pgpass(path, line)
+ self.create_pgpass(path, line)
self.pb.test_env["PGPASSFILE"] = path
- try:
- self.assertEqual(
- "OK",
- self.pb.show_pb(self.backup_dir, self.node.name, self.pb.run_pb(self.cmd + ['-w']))["status"],
- "ERROR: Full backup status is not valid."
- )
- except ProbackupException as e:
- self.fail(e)
+ self.assertEqual(
+ "OK",
+ self.pb.show_pb(self.backup_dir, self.node.name, self.pb.run_pb(self.pb_cmd + ['-w']))["status"],
+ "ERROR: Full backup status is not valid."
+ )
def test_pgpass(self):
""" Test case: PGPB_AUTH07 - Create file .pgpass in home dir. """
line = ":".join(['127.0.0.1', str(self.node.port), 'postgres', 'backup', 'password'])
- create_pgpass(self.pgpass_file, line)
- try:
- self.assertEqual(
- "OK",
- self.pb.show_pb(self.backup_dir, self.node.name, self.pb.run_pb(self.cmd + ['-w']))["status"],
- "ERROR: Full backup status is not valid."
- )
- except ProbackupException as e:
- self.fail(e)
+ self.create_pgpass(self.pgpass_file, line)
+ self.assertEqual(
+ "OK",
+ self.pb.show_pb(self.backup_dir, self.node.name, self.pb.run_pb(self.pb_cmd + ['-w']))["status"],
+ "ERROR: Full backup status is not valid."
+ )
def test_pgpassword(self):
""" Test case: PGPB_AUTH08 - set environment var PGPASSWORD """
self.pb.test_env["PGPASSWORD"] = "password"
- try:
- self.assertEqual(
- "OK",
- self.pb.show_pb(self.backup_dir, self.node.name, self.pb.run_pb(self.cmd + ['-w']))["status"],
- "ERROR: Full backup status is not valid."
- )
- except ProbackupException as e:
- self.fail(e)
+ self.assertEqual(
+ "OK",
+ self.pb.show_pb(self.backup_dir, self.node.name, self.pb.run_pb(self.pb_cmd + ['-w']))["status"],
+ "ERROR: Full backup status is not valid."
+ )
def test_pgpassword_and_wrong_pgpass(self):
""" Test case: PGPB_AUTH09 - Check priority between PGPASSWORD and .pgpass file"""
line = ":".join(['127.0.0.1', str(self.node.port), 'postgres', 'backup', 'wrong_password'])
- create_pgpass(self.pgpass_file, line)
+ self.create_pgpass(self.pgpass_file, line)
self.pb.test_env["PGPASSWORD"] = "password"
- try:
- self.assertEqual(
- "OK",
- self.pb.show_pb(self.backup_dir, self.node.name, self.pb.run_pb(self.cmd + ['-w']))["status"],
- "ERROR: Full backup status is not valid."
- )
- except ProbackupException as e:
- self.fail(e)
-
+ self.assertEqual(
+ "OK",
+ self.pb.show_pb(self.backup_dir, self.node.name, self.pb.run_pb(self.pb_cmd + ['-w']))["status"],
+ "ERROR: Full backup status is not valid."
+ )
-def run_pb_with_auth(cmd, password=None, kill=False):
- try:
- with spawn(" ".join(cmd), encoding='utf-8', timeout=10) as probackup:
+ def run_pb_with_auth(self, password=None, add_args = [], kill=False):
+ with spawn(self.pb.probackup_path, self.pb_cmd + add_args, encoding='utf-8', timeout=10) as probackup:
result = probackup.expect(u"Password for user .*:", 5)
if kill:
probackup.kill(signal.SIGINT)
elif result == 0:
probackup.sendline(password)
probackup.expect(EOF)
- return probackup.before
+ return str(probackup.before)
else:
raise ExceptionPexpect("Other pexpect errors.")
- except TIMEOUT:
- raise TIMEOUT("Timeout error.")
- except ExceptionPexpect:
- raise ExceptionPexpect("Pexpect error.")
-
-
-def modify_pg_hba(node):
- """
- Description:
- Add trust authentication for user postgres. Need for add new role and set grant.
- :param node:
- :return None:
- """
- hba_conf = os.path.join(node.data_dir, "pg_hba.conf")
- with open(hba_conf, 'r+') as fio:
- data = fio.read()
- fio.seek(0)
- fio.write('host\tall\tpostgres\t127.0.0.1/0\ttrust\n' + data)
-
-
-def create_pgpass(path, line):
- with open(path, 'w') as passfile:
- # host:port:db:username:password
- passfile.write(line)
- os.chmod(path, 0o600)
+
+
+ @classmethod
+ def modify_pg_hba(cls, node):
+ """
+ Description:
+ Add trust authentication for user postgres. Need for add new role and set grant.
+ :param node:
+ :return None:
+ """
+ hba_conf = os.path.join(node.data_dir, "pg_hba.conf")
+ with open(hba_conf, 'r+') as fio:
+ data = fio.read()
+ fio.seek(0)
+ fio.write('host\tall\t%s\t127.0.0.1/0\ttrust\n%s' % (cls.username, data))
+
+
+ def create_pgpass(self, path, line):
+ with open(path, 'w') as passfile:
+ # host:port:db:username:password
+ passfile.write(line)
+ os.chmod(path, 0o600)
diff --git a/tests/backup.py b/tests/backup.py
index 85c76243c..db7ccf5a0 100644
--- a/tests/backup.py
+++ b/tests/backup.py
@@ -8,23 +8,19 @@
import subprocess
-module_name = 'backup'
-
-
class BackupTest(ProbackupTest, unittest.TestCase):
def test_full_backup(self):
"""
Just test full backup with at least two segments
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
# we need to write a lot. Lets speedup a bit.
pg_options={"fsync": "off", "synchronous_commit": "off"})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -42,21 +38,17 @@ def test_full_backup(self):
"INFO: Backup {0} is valid".format(backup_id),
out)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_full_backup_stream(self):
"""
Just test full backup with at least two segments in stream mode
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
# we need to write a lot. Lets speedup a bit.
pg_options={"fsync": "off", "synchronous_commit": "off"})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -74,20 +66,16 @@ def test_full_backup_stream(self):
"INFO: Backup {0} is valid".format(backup_id),
out)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
# PGPRO-707
def test_backup_modes_archive(self):
"""standart backup modes with ARCHIVE WAL method"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -144,18 +132,14 @@ def test_backup_modes_archive(self):
backup_dir, 'node',
backup_id=show_backup_2['id'])["parent-backup-id"])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_smooth_checkpoint(self):
"""full backup with smooth checkpoint"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -167,18 +151,14 @@ def test_smooth_checkpoint(self):
self.assertEqual(self.show_pb(backup_dir, 'node')[0]['status'], "OK")
node.stop()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incremental_backup_without_full(self):
"""page backup without validated full backup"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -203,18 +183,14 @@ def test_incremental_backup_without_full(self):
self.show_pb(backup_dir, 'node')[0]['status'],
"ERROR")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incremental_backup_corrupt_full(self):
"""page-level backup with corrupted full backup"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -264,19 +240,15 @@ def test_incremental_backup_corrupt_full(self):
self.assertEqual(
self.show_pb(backup_dir, 'node')[1]['status'], "ERROR")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delta_threads_stream(self):
"""delta multi thread backup mode and stream"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -291,21 +263,17 @@ def test_delta_threads_stream(self):
backup_type="delta", options=["-j", "4", "--stream"])
self.assertEqual(self.show_pb(backup_dir, 'node')[1]['status'], "OK")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_detect_corruption(self):
"""make node, corrupt some page, check that backup failed"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -356,21 +324,16 @@ def test_page_detect_corruption(self):
'ERROR',
"Backup Status should be ERROR")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
-
# @unittest.skip("skip")
def test_backup_detect_corruption(self):
"""make node, corrupt some page, check that backup failed"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -503,20 +466,16 @@ def test_backup_detect_corruption(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_backup_detect_invalid_block_header(self):
"""make node, corrupt some page, check that backup failed"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -644,20 +603,16 @@ def test_backup_detect_invalid_block_header(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_backup_detect_missing_permissions(self):
"""make node, corrupt some page, check that backup failed"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -785,22 +740,18 @@ def test_backup_detect_missing_permissions(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_backup_truncate_misaligned(self):
"""
make node, truncate file to size not even to BLCKSIZE,
take backup
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -836,19 +787,15 @@ def test_backup_truncate_misaligned(self):
self.assertIn("WARNING: File", output)
self.assertIn("invalid file size", output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_tablespace_in_pgdata_pgpro_1376(self):
"""PGPRO-1376 """
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -930,9 +877,6 @@ def test_tablespace_in_pgdata_pgpro_1376(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_tablespace_handling(self):
"""
@@ -941,13 +885,12 @@ def test_basic_tablespace_handling(self):
check that restore with tablespace mapping will end with
success
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -989,7 +932,7 @@ def test_basic_tablespace_handling(self):
tblspace2_new_path = self.get_tblspace_path(node, 'tblspace2_new')
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
try:
@@ -1043,22 +986,18 @@ def test_basic_tablespace_handling(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_tablespace_handling_1(self):
"""
make node with tablespace A, take full backup, check that restore with
tablespace mapping of tablespace B will end with error
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -1078,7 +1017,7 @@ def test_tablespace_handling_1(self):
options=["-j", "4", "--stream"])
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
try:
@@ -1101,22 +1040,18 @@ def test_tablespace_handling_1(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_tablespace_handling_2(self):
"""
make node without tablespaces, take full backup, check that restore with
tablespace mapping will end with error
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -1130,7 +1065,7 @@ def test_tablespace_handling_2(self):
options=["-j", "4", "--stream"])
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
try:
@@ -1153,18 +1088,14 @@ def test_tablespace_handling_2(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_drop_rel_during_full_backup(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1236,16 +1167,12 @@ def test_drop_rel_during_full_backup(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
def test_drop_db_during_full_backup(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1304,18 +1231,14 @@ def test_drop_db_during_full_backup(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_drop_rel_during_backup_delta(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1375,18 +1298,14 @@ def test_drop_rel_during_backup_delta(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_drop_rel_during_backup_page(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1443,16 +1362,12 @@ def test_drop_rel_during_backup_page(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_persistent_slot_for_stream_backup(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1477,16 +1392,12 @@ def test_persistent_slot_for_stream_backup(self):
backup_dir, 'node', node,
options=['--stream', '--slot=slot_1'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_temp_slot_for_stream_backup(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={'max_wal_size': '40MB'})
@@ -1509,18 +1420,14 @@ def test_basic_temp_slot_for_stream_backup(self):
backup_dir, 'node', node,
options=['--stream', '--slot=slot_1', '--temp-slot'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_backup_concurrent_drop_table(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1557,19 +1464,15 @@ def test_backup_concurrent_drop_table(self):
self.assertEqual(show_backup['status'], "OK")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_pg_11_adjusted_wal_segment_size(self):
""""""
if self.pg_config_version < self.version_to_num('11.0'):
self.skipTest('You need PostgreSQL >= 11 for this test')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=[
'--data-checksums',
@@ -1645,18 +1548,14 @@ def test_pg_11_adjusted_wal_segment_size(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_sigint_handling(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1686,18 +1585,14 @@ def test_sigint_handling(self):
self.show_pb(backup_dir, 'node', backup_id)['status'],
'Backup STATUS should be "ERROR"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_sigterm_handling(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1726,18 +1621,14 @@ def test_sigterm_handling(self):
self.show_pb(backup_dir, 'node', backup_id)['status'],
'Backup STATUS should be "ERROR"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_sigquit_handling(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1765,16 +1656,12 @@ def test_sigquit_handling(self):
self.show_pb(backup_dir, 'node', backup_id)['status'],
'Backup STATUS should be "ERROR"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_drop_table(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1800,19 +1687,15 @@ def test_drop_table(self):
self.backup_node(
backup_dir, 'node', node, options=['--stream'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_missing_file_permissions(self):
""""""
if os.name == 'nt':
self.skipTest('Skipped because it is POSIX only test')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1847,19 +1730,15 @@ def test_basic_missing_file_permissions(self):
os.chmod(full_path, 700)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_missing_dir_permissions(self):
""""""
if os.name == 'nt':
self.skipTest('Skipped because it is POSIX only test')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1890,16 +1769,12 @@ def test_basic_missing_dir_permissions(self):
os.rmdir(full_path)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_backup_with_least_privileges_role(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'],
@@ -2119,9 +1994,6 @@ def test_backup_with_least_privileges_role(self):
backup_dir, 'node', node, backup_type='ptrack',
datname='backupdb', options=['--stream', '-U', 'backup'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_parent_choosing(self):
"""
@@ -2130,10 +2002,9 @@ def test_parent_choosing(self):
PAGE1 <- CORRUPT
FULL
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2183,9 +2054,6 @@ def test_parent_choosing(self):
backup_dir, 'node', backup_id=page3_id)['parent-backup-id'],
full_id)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_parent_choosing_1(self):
"""
@@ -2194,10 +2062,9 @@ def test_parent_choosing_1(self):
PAGE1 <- (missing)
FULL
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2243,9 +2110,6 @@ def test_parent_choosing_1(self):
backup_dir, 'node', backup_id=page3_id)['parent-backup-id'],
full_id)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_parent_choosing_2(self):
"""
@@ -2254,10 +2118,9 @@ def test_parent_choosing_2(self):
PAGE1 <- OK
FULL <- (missing)
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2303,19 +2166,15 @@ def test_parent_choosing_2(self):
backup_dir, 'node')[2]['status'],
'ERROR')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_backup_with_less_privileges_role(self):
"""
check permissions correctness from documentation:
https://github.com/postgrespro/pg_probackup/blob/master/Documentation.md#configuring-the-database-cluster
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'],
@@ -2450,12 +2309,11 @@ def test_backup_with_less_privileges_role(self):
datname='backupdb', options=['--stream', '-U', 'backup'])
if self.get_version(node) < 90600:
- self.del_test_dir(module_name, fname)
return
# Restore as replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'node', replica)
@@ -2520,18 +2378,14 @@ def test_backup_with_less_privileges_role(self):
backup_dir, 'replica', replica, backup_type='ptrack',
datname='backupdb', options=['--stream', '-U', 'backup'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
def test_issue_132(self):
"""
https://github.com/postgrespro/pg_probackup/issues/132
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2558,18 +2412,14 @@ def test_issue_132(self):
exit(1)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
def test_issue_132_1(self):
"""
https://github.com/postgrespro/pg_probackup/issues/132
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2718,17 +2568,13 @@ def test_issue_132_1(self):
'INFO: Restore of backup {0} completed.'.format(delta_id),
output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_note_sanity(self):
"""
test that adding note to backup works as expected
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2756,18 +2602,14 @@ def test_note_sanity(self):
'note',
backup_meta)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_parent_backup_made_by_newer_version(self):
"""incremental backup with parent made by newer version"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2809,20 +2651,16 @@ def test_parent_backup_made_by_newer_version(self):
self.assertEqual(
self.show_pb(backup_dir, 'node')[1]['status'], "ERROR")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_issue_289(self):
"""
https://github.com/postgrespro/pg_probackup/issues/289
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -2854,20 +2692,16 @@ def test_issue_289(self):
self.assertEqual(
self.show_pb(backup_dir, 'node')[0]['status'], "ERROR")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_issue_290(self):
"""
https://github.com/postgrespro/pg_probackup/issues/290
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2903,18 +2737,14 @@ def test_issue_290(self):
self.assertEqual(
self.show_pb(backup_dir, 'node')[0]['status'], "ERROR")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
def test_issue_203(self):
"""
https://github.com/postgrespro/pg_probackup/issues/203
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2934,7 +2764,7 @@ def test_issue_203(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'node',
@@ -2943,18 +2773,14 @@ def test_issue_203(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_issue_231(self):
"""
https://github.com/postgrespro/pg_probackup/issues/231
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2975,17 +2801,13 @@ def test_issue_231(self):
# it is a bit racy
self.assertIn("WARNING: Cannot create directory", out)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_incr_backup_filenode_map(self):
"""
https://github.com/postgrespro/pg_probackup/issues/320
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -2994,7 +2816,7 @@ def test_incr_backup_filenode_map(self):
node.slow_start()
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'),
initdb_params=['--data-checksums'])
node1.cleanup()
@@ -3026,18 +2848,14 @@ def test_incr_backup_filenode_map(self):
'postgres',
'select 1')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_missing_wal_segment(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'],
@@ -3103,16 +2921,12 @@ def test_missing_wal_segment(self):
# TODO: check the same for PAGE backup
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_missing_replication_permission(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
@@ -3127,7 +2941,7 @@ def test_missing_replication_permission(self):
# Create replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'node', replica)
@@ -3257,16 +3071,12 @@ def test_missing_replication_permission(self):
"\n Unexpected Error Message: {0}\n CMD: {1}".format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_missing_replication_permission_1(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
@@ -3281,7 +3091,7 @@ def test_missing_replication_permission_1(self):
# Create replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'node', replica)
@@ -3411,16 +3221,12 @@ def test_missing_replication_permission_1(self):
r'WARNING: could not connect to database backupdb: (connection to server (on socket "/tmp/.s.PGSQL.\d+"|at "localhost" \(127.0.0.1\), port \d+) failed: ){0,1}'
'FATAL: must be superuser or replication role to start walsender')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_backup_default_transaction_read_only(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={'default_transaction_read_only': 'on'})
@@ -3459,18 +3265,14 @@ def test_basic_backup_default_transaction_read_only(self):
# PAGE backup
self.backup_node(backup_dir, 'node', node, backup_type='page')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_backup_atexit(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
@@ -3519,16 +3321,12 @@ def test_backup_atexit(self):
'setting its status to ERROR',
log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_pg_stop_backup_missing_permissions(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
@@ -3598,20 +3396,16 @@ def test_pg_stop_backup_missing_permissions(self):
"\n Unexpected Error Message: {0}\n CMD: {1}".format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_start_time(self):
"""Test, that option --start-time allows to set backup_id and restore"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -3625,7 +3419,7 @@ def test_start_time(self):
# restore FULL backup by backup_id calculated from start-time
self.restore_node(
backup_dir, 'node',
- data_dir=os.path.join(self.tmp_path, module_name, fname, 'node_restored_full'),
+ data_dir=os.path.join(self.tmp_path, self.module_name, self.fname, 'node_restored_full'),
backup_id=base36enc(startTime))
#FULL backup with incorrect start time
@@ -3655,7 +3449,7 @@ def test_start_time(self):
# restore DELTA backup by backup_id calculated from start-time
self.restore_node(
backup_dir, 'node',
- data_dir=os.path.join(self.tmp_path, module_name, fname, 'node_restored_delta'),
+ data_dir=os.path.join(self.tmp_path, self.module_name, self.fname, 'node_restored_delta'),
backup_id=base36enc(startTime))
# PAGE backup
@@ -3666,7 +3460,7 @@ def test_start_time(self):
# restore PAGE backup by backup_id calculated from start-time
self.restore_node(
backup_dir, 'node',
- data_dir=os.path.join(self.tmp_path, module_name, fname, 'node_restored_page'),
+ data_dir=os.path.join(self.tmp_path, self.module_name, self.fname, 'node_restored_page'),
backup_id=base36enc(startTime))
# PTRACK backup
@@ -3682,35 +3476,31 @@ def test_start_time(self):
# restore PTRACK backup by backup_id calculated from start-time
self.restore_node(
backup_dir, 'node',
- data_dir=os.path.join(self.tmp_path, module_name, fname, 'node_restored_ptrack'),
+ data_dir=os.path.join(self.tmp_path, self.module_name, self.fname, 'node_restored_ptrack'),
backup_id=base36enc(startTime))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_start_time_few_nodes(self):
"""Test, that we can synchronize backup_id's for different DBs"""
- fname = self.id().split('.')[3]
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
- backup_dir1 = os.path.join(self.tmp_path, module_name, fname, 'backup1')
+ backup_dir1 = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup1')
self.init_pb(backup_dir1)
self.add_instance(backup_dir1, 'node1', node1)
self.set_archiving(backup_dir1, 'node1', node1)
node1.slow_start()
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
- backup_dir2 = os.path.join(self.tmp_path, module_name, fname, 'backup2')
+ backup_dir2 = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup2')
self.init_pb(backup_dir2)
self.add_instance(backup_dir2, 'node2', node2)
self.set_archiving(backup_dir2, 'node2', node2)
@@ -3772,6 +3562,3 @@ def test_start_time_few_nodes(self):
show_backup2 = self.show_pb(backup_dir2, 'node2')[3]
self.assertEqual(show_backup1['id'], show_backup2['id'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
diff --git a/tests/catchup.py b/tests/catchup.py
index baef9d29f..88170c807 100644
--- a/tests/catchup.py
+++ b/tests/catchup.py
@@ -4,11 +4,7 @@
import unittest
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
-module_name = 'catchup'
-
class CatchupTest(ProbackupTest, unittest.TestCase):
- def setUp(self):
- self.fname = self.id().split('.')[3]
#########################################
# Basic tests
@@ -19,7 +15,7 @@ def test_basic_full_catchup(self):
"""
# preparation
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True
)
src_pg.slow_start()
@@ -29,7 +25,7 @@ def test_basic_full_catchup(self):
src_query_result = src_pg.safe_psql("postgres", "SELECT * FROM ultimate_question")
# do full catchup
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -57,7 +53,6 @@ def test_basic_full_catchup(self):
# Cleanup
dst_pg.stop()
#self.assertEqual(1, 0, 'Stop test')
- self.del_test_dir(module_name, self.fname)
def test_full_catchup_with_tablespace(self):
"""
@@ -65,7 +60,7 @@ def test_full_catchup_with_tablespace(self):
"""
# preparation
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True
)
src_pg.slow_start()
@@ -77,7 +72,7 @@ def test_full_catchup_with_tablespace(self):
src_query_result = src_pg.safe_psql("postgres", "SELECT * FROM ultimate_question")
# do full catchup with tablespace mapping
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
tblspace1_new_path = self.get_tblspace_path(dst_pg, 'tblspace1_new')
self.catchup_node(
backup_mode = 'FULL',
@@ -115,7 +110,6 @@ def test_full_catchup_with_tablespace(self):
# Cleanup
dst_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_basic_delta_catchup(self):
"""
@@ -123,7 +117,7 @@ def test_basic_delta_catchup(self):
"""
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
pg_options = { 'wal_log_hints': 'on' }
)
@@ -133,7 +127,7 @@ def test_basic_delta_catchup(self):
"CREATE TABLE ultimate_question(answer int)")
# preparation 2: make clean shutdowned lagging behind replica
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -183,7 +177,6 @@ def test_basic_delta_catchup(self):
# Cleanup
dst_pg.stop()
#self.assertEqual(1, 0, 'Stop test')
- self.del_test_dir(module_name, self.fname)
def test_basic_ptrack_catchup(self):
"""
@@ -194,7 +187,7 @@ def test_basic_ptrack_catchup(self):
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
ptrack_enable = True,
initdb_params = ['--data-checksums']
@@ -206,7 +199,7 @@ def test_basic_ptrack_catchup(self):
"CREATE TABLE ultimate_question(answer int)")
# preparation 2: make clean shutdowned lagging behind replica
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -256,7 +249,6 @@ def test_basic_ptrack_catchup(self):
# Cleanup
dst_pg.stop()
#self.assertEqual(1, 0, 'Stop test')
- self.del_test_dir(module_name, self.fname)
def test_tli_delta_catchup(self):
"""
@@ -264,14 +256,14 @@ def test_tli_delta_catchup(self):
"""
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
pg_options = { 'wal_log_hints': 'on' }
)
src_pg.slow_start()
# preparation 2: destination
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -329,7 +321,6 @@ def test_tli_delta_catchup(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_tli_ptrack_catchup(self):
"""
@@ -340,7 +331,7 @@ def test_tli_ptrack_catchup(self):
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
ptrack_enable = True,
initdb_params = ['--data-checksums']
@@ -349,7 +340,7 @@ def test_tli_ptrack_catchup(self):
src_pg.safe_psql("postgres", "CREATE EXTENSION ptrack")
# preparation 2: destination
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -412,7 +403,6 @@ def test_tli_ptrack_catchup(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
#########################################
# Test various corner conditions
@@ -423,7 +413,7 @@ def test_table_drop_with_delta(self):
"""
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
pg_options = { 'wal_log_hints': 'on' }
)
@@ -433,7 +423,7 @@ def test_table_drop_with_delta(self):
"CREATE TABLE ultimate_question AS SELECT 42 AS answer")
# preparation 2: make clean shutdowned lagging behind replica
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -468,7 +458,6 @@ def test_table_drop_with_delta(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_table_drop_with_ptrack(self):
"""
@@ -479,7 +468,7 @@ def test_table_drop_with_ptrack(self):
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
ptrack_enable = True,
initdb_params = ['--data-checksums']
@@ -491,7 +480,7 @@ def test_table_drop_with_ptrack(self):
"CREATE TABLE ultimate_question AS SELECT 42 AS answer")
# preparation 2: make clean shutdowned lagging behind replica
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -526,7 +515,6 @@ def test_table_drop_with_ptrack(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_tablefile_truncation_with_delta(self):
"""
@@ -534,7 +522,7 @@ def test_tablefile_truncation_with_delta(self):
"""
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
pg_options = { 'wal_log_hints': 'on' }
)
@@ -549,7 +537,7 @@ def test_tablefile_truncation_with_delta(self):
src_pg.safe_psql("postgres", "VACUUM t_heap")
# preparation 2: make clean shutdowned lagging behind replica
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -583,7 +571,6 @@ def test_tablefile_truncation_with_delta(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_tablefile_truncation_with_ptrack(self):
"""
@@ -594,7 +581,7 @@ def test_tablefile_truncation_with_ptrack(self):
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
ptrack_enable = True,
initdb_params = ['--data-checksums']
@@ -611,7 +598,7 @@ def test_tablefile_truncation_with_ptrack(self):
src_pg.safe_psql("postgres", "VACUUM t_heap")
# preparation 2: make clean shutdowned lagging behind replica
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -645,7 +632,6 @@ def test_tablefile_truncation_with_ptrack(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
#########################################
# Test reaction on user errors
@@ -657,7 +643,7 @@ def test_local_tablespace_without_mapping(self):
if self.remote:
self.skipTest('Skipped because this test tests local catchup error handling')
- src_pg = self.make_simple_node(base_dir = os.path.join(module_name, self.fname, 'src'))
+ src_pg = self.make_simple_node(base_dir = os.path.join(self.module_name, self.fname, 'src'))
src_pg.slow_start()
tblspace_path = self.get_tblspace_path(src_pg, 'tblspace')
@@ -669,7 +655,7 @@ def test_local_tablespace_without_mapping(self):
"postgres",
"CREATE TABLE ultimate_question TABLESPACE tblspace AS SELECT 42 AS answer")
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
try:
self.catchup_node(
backup_mode = 'FULL',
@@ -691,7 +677,6 @@ def test_local_tablespace_without_mapping(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_running_dest_postmaster(self):
"""
@@ -699,14 +684,14 @@ def test_running_dest_postmaster(self):
"""
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
pg_options = { 'wal_log_hints': 'on' }
)
src_pg.slow_start()
# preparation 2: destination
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -738,7 +723,6 @@ def test_running_dest_postmaster(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_same_db_id(self):
"""
@@ -747,12 +731,12 @@ def test_same_db_id(self):
# preparation:
# source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True
)
src_pg.slow_start()
# destination
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -765,9 +749,9 @@ def test_same_db_id(self):
dst_pg.slow_start()
dst_pg.stop()
# fake destination
- fake_dst_pg = self.make_simple_node(base_dir = os.path.join(module_name, self.fname, 'fake_dst'))
+ fake_dst_pg = self.make_simple_node(base_dir = os.path.join(self.module_name, self.fname, 'fake_dst'))
# fake source
- fake_src_pg = self.make_simple_node(base_dir = os.path.join(module_name, self.fname, 'fake_src'))
+ fake_src_pg = self.make_simple_node(base_dir = os.path.join(self.module_name, self.fname, 'fake_src'))
# try delta catchup (src (with correct src conn), fake_dst)
try:
@@ -803,7 +787,6 @@ def test_same_db_id(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_tli_destination_mismatch(self):
"""
@@ -811,14 +794,14 @@ def test_tli_destination_mismatch(self):
"""
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
pg_options = { 'wal_log_hints': 'on' }
)
src_pg.slow_start()
# preparation 2: destination
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -860,7 +843,6 @@ def test_tli_destination_mismatch(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_tli_source_mismatch(self):
"""
@@ -868,14 +850,14 @@ def test_tli_source_mismatch(self):
"""
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
pg_options = { 'wal_log_hints': 'on' }
)
src_pg.slow_start()
# preparation 2: fake source (promouted copy)
- fake_src_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'fake_src'))
+ fake_src_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'fake_src'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -899,7 +881,7 @@ def test_tli_source_mismatch(self):
fake_src_pg.safe_psql("postgres", "CREATE TABLE ultimate_question AS SELECT 'trash' AS garbage")
# preparation 3: destination
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -940,7 +922,6 @@ def test_tli_source_mismatch(self):
# Cleanup
src_pg.stop()
fake_src_pg.stop()
- self.del_test_dir(module_name, self.fname)
#########################################
# Test unclean destination
@@ -951,7 +932,7 @@ def test_unclean_delta_catchup(self):
"""
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
pg_options = { 'wal_log_hints': 'on' }
)
@@ -961,7 +942,7 @@ def test_unclean_delta_catchup(self):
"CREATE TABLE ultimate_question(answer int)")
# preparation 2: destination
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -1028,7 +1009,6 @@ def test_unclean_delta_catchup(self):
# Cleanup
dst_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_unclean_ptrack_catchup(self):
"""
@@ -1039,7 +1019,7 @@ def test_unclean_ptrack_catchup(self):
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
ptrack_enable = True,
pg_options = { 'wal_log_hints': 'on' }
@@ -1051,7 +1031,7 @@ def test_unclean_ptrack_catchup(self):
"CREATE TABLE ultimate_question(answer int)")
# preparation 2: destination
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -1118,7 +1098,6 @@ def test_unclean_ptrack_catchup(self):
# Cleanup
dst_pg.stop()
- self.del_test_dir(module_name, self.fname)
#########################################
# Test replication slot logic
@@ -1139,13 +1118,13 @@ def test_catchup_with_replication_slot(self):
"""
# preparation
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True
)
src_pg.slow_start()
# 1a. --slot option
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst_1a'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst_1a'))
try:
self.catchup_node(
backup_mode = 'FULL',
@@ -1165,7 +1144,7 @@ def test_catchup_with_replication_slot(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(e.message), self.cmd))
# 1b. --slot option
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst_1b'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst_1b'))
src_pg.safe_psql("postgres", "SELECT pg_catalog.pg_create_physical_replication_slot('existentslot_1b')")
self.catchup_node(
backup_mode = 'FULL',
@@ -1178,7 +1157,7 @@ def test_catchup_with_replication_slot(self):
)
# 2a. --slot --perm-slot
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst_2a'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst_2a'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -1191,7 +1170,7 @@ def test_catchup_with_replication_slot(self):
)
# 2b. and 4. --slot --perm-slot
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst_2b'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst_2b'))
src_pg.safe_psql("postgres", "SELECT pg_catalog.pg_create_physical_replication_slot('existentslot_2b')")
try:
self.catchup_node(
@@ -1213,7 +1192,7 @@ def test_catchup_with_replication_slot(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(e.message), self.cmd))
# 3. --perm-slot --slot
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst_3'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst_3'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -1233,7 +1212,7 @@ def test_catchup_with_replication_slot(self):
# 5. --perm-slot --temp-slot (PG>=10)
if self.get_version(src_pg) >= self.version_to_num('10.0'):
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst_5'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst_5'))
try:
self.catchup_node(
backup_mode = 'FULL',
@@ -1254,7 +1233,6 @@ def test_catchup_with_replication_slot(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(e.message), self.cmd))
#self.assertEqual(1, 0, 'Stop test')
- self.del_test_dir(module_name, self.fname)
#########################################
# --exclude-path
@@ -1265,7 +1243,7 @@ def test_catchup_with_exclude_path(self):
"""
# preparation
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True
)
src_pg.slow_start()
@@ -1282,7 +1260,7 @@ def test_catchup_with_exclude_path(self):
f.flush()
f.close
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -1333,7 +1311,6 @@ def test_catchup_with_exclude_path(self):
#self.assertEqual(1, 0, 'Stop test')
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_config_exclusion(self):
"""
@@ -1341,7 +1318,7 @@ def test_config_exclusion(self):
"""
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
pg_options = { 'wal_log_hints': 'on' }
)
@@ -1351,7 +1328,7 @@ def test_config_exclusion(self):
"CREATE TABLE ultimate_question(answer int)")
# preparation 2: make lagging behind replica
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -1458,7 +1435,6 @@ def test_config_exclusion(self):
src_pg.stop()
dst_pg.stop()
#self.assertEqual(1, 0, 'Stop test')
- self.del_test_dir(module_name, self.fname)
#########################################
# --dry-run
@@ -1469,13 +1445,13 @@ def test_dry_run_catchup_full(self):
"""
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True
)
src_pg.slow_start()
# preparation 2: make clean shutdowned lagging behind replica
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
src_pg.pgbench_init(scale = 10)
pgbench = src_pg.pgbench(options=['-T', '10', '--no-vacuum'])
@@ -1500,7 +1476,6 @@ def test_dry_run_catchup_full(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_dry_run_catchup_ptrack(self):
"""
@@ -1511,7 +1486,7 @@ def test_dry_run_catchup_ptrack(self):
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
ptrack_enable = True,
initdb_params = ['--data-checksums']
@@ -1524,7 +1499,7 @@ def test_dry_run_catchup_ptrack(self):
pgbench.wait()
# preparation 2: make clean shutdowned lagging behind replica
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -1557,7 +1532,6 @@ def test_dry_run_catchup_ptrack(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
def test_dry_run_catchup_delta(self):
"""
@@ -1566,7 +1540,7 @@ def test_dry_run_catchup_delta(self):
# preparation 1: source
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True,
initdb_params = ['--data-checksums'],
pg_options = { 'wal_log_hints': 'on' }
@@ -1578,7 +1552,7 @@ def test_dry_run_catchup_delta(self):
pgbench.wait()
# preparation 2: make clean shutdowned lagging behind replica
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode = 'FULL',
source_pgdata = src_pg.data_dir,
@@ -1611,5 +1585,3 @@ def test_dry_run_catchup_delta(self):
# Cleanup
src_pg.stop()
- self.del_test_dir(module_name, self.fname)
-
diff --git a/tests/cfs_backup.py b/tests/cfs_backup.py
index fe2af20e3..28ef275df 100644
--- a/tests/cfs_backup.py
+++ b/tests/cfs_backup.py
@@ -6,7 +6,6 @@
from .helpers.cfs_helpers import find_by_extensions, find_by_name, find_by_pattern, corrupt_file
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
-module_name = 'cfs_backup'
tblspace_name = 'cfs_tblspace'
@@ -14,11 +13,10 @@ class CfsBackupNoEncTest(ProbackupTest, unittest.TestCase):
# --- Begin --- #
@unittest.skipUnless(ProbackupTest.enterprise, 'skip')
def setUp(self):
- self.fname = self.id().split('.')[3]
self.backup_dir = os.path.join(
- self.tmp_path, module_name, self.fname, 'backup')
+ self.tmp_path, self.module_name, self.fname, 'backup')
self.node = self.make_simple_node(
- base_dir="{0}/{1}/node".format(module_name, self.fname),
+ base_dir="{0}/{1}/node".format(self.module_name, self.fname),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -1228,10 +1226,6 @@ def test_broken_file_pg_compression_into_tablespace_dir(self):
)
# # --- End ---#
-# @unittest.skipUnless(ProbackupTest.enterprise, 'skip')
-# def tearDown(self):
-# self.node.cleanup()
-# self.del_test_dir(module_name, self.fname)
#class CfsBackupEncTest(CfsBackupNoEncTest):
diff --git a/tests/cfs_catchup.py b/tests/cfs_catchup.py
index 2cbb46729..43c3f18f1 100644
--- a/tests/cfs_catchup.py
+++ b/tests/cfs_catchup.py
@@ -6,13 +6,8 @@
from .helpers.cfs_helpers import find_by_extensions, find_by_name, find_by_pattern, corrupt_file
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
-module_name = 'cfs_catchup'
-tblspace_name = 'cfs_tblspace'
-
class CfsCatchupNoEncTest(ProbackupTest, unittest.TestCase):
- def setUp(self):
- self.fname = self.id().split('.')[3]
@unittest.skipUnless(ProbackupTest.enterprise, 'skip')
def test_full_catchup_with_tablespace(self):
@@ -21,7 +16,7 @@ def test_full_catchup_with_tablespace(self):
"""
# preparation
src_pg = self.make_simple_node(
- base_dir = os.path.join(module_name, self.fname, 'src'),
+ base_dir = os.path.join(self.module_name, self.fname, 'src'),
set_replication = True
)
src_pg.slow_start()
@@ -36,7 +31,7 @@ def test_full_catchup_with_tablespace(self):
"CHECKPOINT")
# do full catchup with tablespace mapping
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
tblspace1_new_path = self.get_tblspace_path(dst_pg, 'tblspace1_new')
self.catchup_node(
backup_mode = 'FULL',
@@ -120,8 +115,3 @@ def test_full_catchup_with_tablespace(self):
src_query_result = src_pg.safe_psql("postgres", "SELECT * FROM ultimate_question")
dst_query_result = dst_pg.safe_psql("postgres", "SELECT * FROM ultimate_question")
self.assertEqual(src_query_result, dst_query_result, 'Different answer from copy')
-
- # Cleanup
- src_pg.stop()
- dst_pg.stop()
- self.del_test_dir(module_name, self.fname)
diff --git a/tests/cfs_restore.py b/tests/cfs_restore.py
index 611afc49e..660cef9c6 100644
--- a/tests/cfs_restore.py
+++ b/tests/cfs_restore.py
@@ -15,20 +15,16 @@
from .helpers.cfs_helpers import find_by_name
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
-
-module_name = 'cfs_restore'
-
tblspace_name = 'cfs_tblspace'
tblspace_name_new = 'cfs_tblspace_new'
class CfsRestoreBase(ProbackupTest, unittest.TestCase):
def setUp(self):
- self.fname = self.id().split('.')[3]
- self.backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ self.backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.node = self.make_simple_node(
- base_dir="{0}/{1}/node".format(module_name, self.fname),
+ base_dir="{0}/{1}/node".format(self.module_name, self.fname),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -60,10 +56,6 @@ def setUp(self):
def add_data_in_cluster(self):
pass
- def tearDown(self):
- self.node.cleanup()
- self.del_test_dir(module_name, self.fname)
-
class CfsRestoreNoencEmptyTablespaceTest(CfsRestoreBase):
# @unittest.expectedFailure
@@ -102,8 +94,7 @@ def test_restore_empty_tablespace_from_fullbackup(self):
tblspace = self.node.safe_psql(
"postgres",
"SELECT * FROM pg_tablespace WHERE spcname='{0}'".format(tblspace_name)
- )
- tblspace = str(tblspace)
+ ).decode("UTF-8")
self.assertTrue(
tblspace_name in tblspace and "compression=true" in tblspace,
"ERROR: The tablespace not restored or it restored without compressions"
@@ -212,7 +203,7 @@ def test_restore_from_fullbackup_to_new_location(self):
self.node.cleanup()
shutil.rmtree(self.get_tblspace_path(self.node, tblspace_name))
- node_new = self.make_simple_node(base_dir="{0}/{1}/node_new_location".format(module_name, self.fname))
+ node_new = self.make_simple_node(base_dir="{0}/{1}/node_new_location".format(self.module_name, self.fname))
node_new.cleanup()
try:
@@ -255,7 +246,7 @@ def test_restore_from_fullbackup_to_new_location_5_jobs(self):
self.node.cleanup()
shutil.rmtree(self.get_tblspace_path(self.node, tblspace_name))
- node_new = self.make_simple_node(base_dir="{0}/{1}/node_new_location".format(module_name, self.fname))
+ node_new = self.make_simple_node(base_dir="{0}/{1}/node_new_location".format(self.module_name, self.fname))
node_new.cleanup()
try:
diff --git a/tests/cfs_validate_backup.py b/tests/cfs_validate_backup.py
index eea6f0e21..343020dfc 100644
--- a/tests/cfs_validate_backup.py
+++ b/tests/cfs_validate_backup.py
@@ -5,7 +5,6 @@
from .helpers.cfs_helpers import find_by_extensions, find_by_name, find_by_pattern, corrupt_file
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
-module_name = 'cfs_validate_backup'
tblspace_name = 'cfs_tblspace'
diff --git a/tests/checkdb.py b/tests/checkdb.py
index 07b55c6db..2caf4fcb2 100644
--- a/tests/checkdb.py
+++ b/tests/checkdb.py
@@ -9,9 +9,6 @@
import time
-module_name = 'checkdb'
-
-
class CheckdbTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
@@ -19,10 +16,9 @@ def test_checkdb_amcheck_only_sanity(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir="{0}/{1}/node".format(module_name, fname),
+ base_dir="{0}/{1}/node".format(self.module_name, self.fname),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -223,15 +219,13 @@ def test_checkdb_amcheck_only_sanity(self):
# Clean after yourself
gdb.kill()
node.stop()
- self.del_test_dir(module_name, fname)
# @unittest.skip("skip")
def test_basic_checkdb_amcheck_only_sanity(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir="{0}/{1}/node".format(module_name, fname),
+ base_dir="{0}/{1}/node".format(self.module_name, self.fname),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -362,18 +356,16 @@ def test_basic_checkdb_amcheck_only_sanity(self):
# Clean after yourself
node.stop()
- self.del_test_dir(module_name, fname)
# @unittest.skip("skip")
def test_checkdb_block_validation_sanity(self):
"""make node, corrupt some pages, check that checkdb failed"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -459,14 +451,12 @@ def test_checkdb_block_validation_sanity(self):
# Clean after yourself
node.stop()
- self.del_test_dir(module_name, fname)
def test_checkdb_checkunique(self):
"""Test checkunique parameter of amcheck.bt_index_check function"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
node.slow_start()
@@ -550,17 +540,15 @@ def test_checkdb_checkunique(self):
# Clean after yourself
node.stop()
- self.del_test_dir(module_name, fname)
# @unittest.skip("skip")
def test_checkdb_sigint_handling(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -605,15 +593,13 @@ def test_checkdb_sigint_handling(self):
# Clean after yourself
gdb.kill()
node.stop()
- self.del_test_dir(module_name, fname)
# @unittest.skip("skip")
def test_checkdb_with_least_privileges(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -861,4 +847,3 @@ def test_checkdb_with_least_privileges(self):
# Clean after yourself
node.stop()
- self.del_test_dir(module_name, fname)
diff --git a/tests/compatibility.py b/tests/compatibility.py
index 3b913aba5..591afb069 100644
--- a/tests/compatibility.py
+++ b/tests/compatibility.py
@@ -5,8 +5,6 @@
from sys import exit
import shutil
-module_name = 'compatibility'
-
def check_manual_tests_enabled():
return 'PGPROBACKUP_MANUAL' in os.environ and os.environ['PGPROBACKUP_MANUAL'] == 'ON'
@@ -52,7 +50,7 @@ def test_catchup_with_different_remote_major_pg(self):
pgprobackup_ssh_agent_path = os.environ['PGPROBACKUP_SSH_AGENT_PATH']
src_pg = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'src'),
+ base_dir=os.path.join(self.module_name, self.fname, 'src'),
set_replication=True,
)
src_pg.slow_start()
@@ -61,7 +59,7 @@ def test_catchup_with_different_remote_major_pg(self):
"CREATE TABLE ultimate_question AS SELECT 42 AS answer")
# do full catchup
- dst_pg = self.make_empty_node(os.path.join(module_name, self.fname, 'dst'))
+ dst_pg = self.make_empty_node(os.path.join(self.module_name, self.fname, 'dst'))
self.catchup_node(
backup_mode='FULL',
source_pgdata=src_pg.data_dir,
@@ -88,17 +86,13 @@ def test_catchup_with_different_remote_major_pg(self):
options=['-d', 'postgres', '-p', str(src_pg.port), '--stream', '--remote-path=' + pgprobackup_ssh_agent_path]
)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_backward_compatibility_page(self):
"""Description in jira issue PGPRO-434"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -126,7 +120,7 @@ def test_backward_compatibility_page(self):
# RESTORE old FULL with new binary
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
@@ -223,17 +217,13 @@ def test_backward_compatibility_page(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_backward_compatibility_delta(self):
"""Description in jira issue PGPRO-434"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -261,7 +251,7 @@ def test_backward_compatibility_delta(self):
# RESTORE old FULL with new binary
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
@@ -357,9 +347,6 @@ def test_backward_compatibility_delta(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_backward_compatibility_ptrack(self):
@@ -368,10 +355,9 @@ def test_backward_compatibility_ptrack(self):
if not self.ptrack:
self.skipTest('Skipped because ptrack support is disabled')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -404,7 +390,7 @@ def test_backward_compatibility_ptrack(self):
# RESTORE old FULL with new binary
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
@@ -471,17 +457,13 @@ def test_backward_compatibility_ptrack(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_backward_compatibility_compression(self):
"""Description in jira issue PGPRO-434"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -504,7 +486,7 @@ def test_backward_compatibility_compression(self):
# restore OLD FULL with new binary
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
@@ -630,9 +612,6 @@ def test_backward_compatibility_compression(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_backward_compatibility_merge(self):
@@ -640,10 +619,9 @@ def test_backward_compatibility_merge(self):
Create node, take FULL and PAGE backups with old binary,
merge them with new binary
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -674,7 +652,7 @@ def test_backward_compatibility_merge(self):
# restore OLD FULL with new binary
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
@@ -685,9 +663,6 @@ def test_backward_compatibility_merge(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_backward_compatibility_merge_1(self):
@@ -696,10 +671,9 @@ def test_backward_compatibility_merge_1(self):
merge them with new binary.
old binary version =< 2.2.7
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -749,7 +723,7 @@ def test_backward_compatibility_merge_1(self):
# restore merged backup
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'node', node_restored)
@@ -757,9 +731,6 @@ def test_backward_compatibility_merge_1(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_backward_compatibility_merge_2(self):
@@ -768,10 +739,9 @@ def test_backward_compatibility_merge_2(self):
merge them with new binary.
old binary version =< 2.2.7
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -788,7 +758,7 @@ def test_backward_compatibility_merge_2(self):
'VACUUM pgbench_accounts')
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
# FULL backup with OLD binary
self.backup_node(backup_dir, 'node', node, old_binary=True)
@@ -879,9 +849,6 @@ def test_backward_compatibility_merge_2(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata4, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_backward_compatibility_merge_3(self):
@@ -890,10 +857,9 @@ def test_backward_compatibility_merge_3(self):
merge them with new binary.
old binary version =< 2.2.7
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -910,7 +876,7 @@ def test_backward_compatibility_merge_3(self):
'VACUUM pgbench_accounts')
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
# FULL backup with OLD binary
self.backup_node(
@@ -1002,9 +968,6 @@ def test_backward_compatibility_merge_3(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata4, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_backward_compatibility_merge_4(self):
@@ -1016,10 +979,9 @@ def test_backward_compatibility_merge_4(self):
self.assertTrue(
False, 'You need pg_probackup old_binary =< 2.4.0 for this test')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1036,7 +998,7 @@ def test_backward_compatibility_merge_4(self):
'VACUUM pgbench_accounts')
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
# FULL backup with OLD binary
self.backup_node(
@@ -1079,9 +1041,6 @@ def test_backward_compatibility_merge_4(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_backward_compatibility_merge_5(self):
@@ -1098,10 +1057,9 @@ def test_backward_compatibility_merge_5(self):
self.version_to_num(self.old_probackup_version),
self.version_to_num(self.probackup_version))
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1151,7 +1109,7 @@ def test_backward_compatibility_merge_5(self):
# restore merged backup
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'node', node_restored)
@@ -1159,9 +1117,6 @@ def test_backward_compatibility_merge_5(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_vacuum_truncate(self):
"""
@@ -1173,10 +1128,9 @@ def test_page_vacuum_truncate(self):
and check data correctness
old binary should be 2.2.x version
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1224,7 +1178,7 @@ def test_page_vacuum_truncate(self):
pgdata3 = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -1263,9 +1217,6 @@ def test_page_vacuum_truncate(self):
node_restored.slow_start()
node_restored.cleanup()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_vacuum_truncate_compression(self):
"""
@@ -1277,10 +1228,9 @@ def test_page_vacuum_truncate_compression(self):
and check data correctness
old binary should be 2.2.x version
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1330,7 +1280,7 @@ def test_page_vacuum_truncate_compression(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'node', node_restored)
@@ -1342,9 +1292,6 @@ def test_page_vacuum_truncate_compression(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_vacuum_truncate_compressed_1(self):
"""
@@ -1356,10 +1303,9 @@ def test_page_vacuum_truncate_compressed_1(self):
and check data correctness
old binary should be 2.2.x version
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1411,7 +1357,7 @@ def test_page_vacuum_truncate_compressed_1(self):
pgdata3 = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -1450,9 +1396,6 @@ def test_page_vacuum_truncate_compressed_1(self):
node_restored.slow_start()
node_restored.cleanup()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_hidden_files(self):
"""
@@ -1461,10 +1404,9 @@ def test_hidden_files(self):
with old binary, then try to delete backup
with new binary
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1479,21 +1421,17 @@ def test_hidden_files(self):
self.delete_pb(backup_dir, 'node', backup_id)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
- # @unittest.skip("skip")
+ # @unittest.skip("skip")
def test_compatibility_tablespace(self):
"""
https://github.com/postgrespro/pg_probackup/issues/348
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node, old_binary=True)
@@ -1519,7 +1457,7 @@ def test_compatibility_tablespace(self):
tblspace_new_path = self.get_tblspace_path(node, 'tblspace_new')
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
try:
@@ -1560,6 +1498,3 @@ def test_compatibility_tablespace(self):
if self.paranoia:
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/compression.py b/tests/compression.py
index c10a59489..94f2dffff 100644
--- a/tests/compression.py
+++ b/tests/compression.py
@@ -5,9 +5,6 @@
import subprocess
-module_name = 'compression'
-
-
class CompressionTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
@@ -18,10 +15,9 @@ def test_basic_compression_stream_zlib(self):
check data correctness in restored instance
"""
self.maxDiff = None
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -116,19 +112,15 @@ def test_basic_compression_stream_zlib(self):
delta_result_new = node.execute("postgres", "SELECT * FROM t_heap")
self.assertEqual(delta_result, delta_result_new)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_compression_archive_zlib(self):
"""
make archive node, make full and page backups,
check data correctness in restored instance
"""
self.maxDiff = None
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -219,19 +211,15 @@ def test_compression_archive_zlib(self):
self.assertEqual(delta_result, delta_result_new)
node.cleanup()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_compression_stream_pglz(self):
"""
make archive node, make full and page stream backups,
check data correctness in restored instance
"""
self.maxDiff = None
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -324,19 +312,15 @@ def test_compression_stream_pglz(self):
self.assertEqual(delta_result, delta_result_new)
node.cleanup()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_compression_archive_pglz(self):
"""
make archive node, make full and page backups,
check data correctness in restored instance
"""
self.maxDiff = None
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -429,19 +413,15 @@ def test_compression_archive_pglz(self):
self.assertEqual(delta_result, delta_result_new)
node.cleanup()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_compression_wrong_algorithm(self):
"""
make archive node, make full and page backups,
check data correctness in restored instance
"""
self.maxDiff = None
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -467,9 +447,6 @@ def test_compression_wrong_algorithm(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incompressible_pages(self):
"""
@@ -477,10 +454,9 @@ def test_incompressible_pages(self):
take backup with compression, make sure that page was not compressed,
restore backup and check data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -517,6 +493,3 @@ def test_incompressible_pages(self):
self.compare_pgdata(pgdata, pgdata_restored)
node.slow_start()
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/config.py b/tests/config.py
index b41382204..b1a0f9295 100644
--- a/tests/config.py
+++ b/tests/config.py
@@ -5,19 +5,16 @@
from sys import exit
from shutil import copyfile
-module_name = 'config'
-
class ConfigTest(ProbackupTest, unittest.TestCase):
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_remove_instance_config(self):
- """remove pg_probackup.conf"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ """remove pg_probackup.conself.f"""
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -57,10 +54,9 @@ def test_remove_instance_config(self):
# @unittest.skip("skip")
def test_corrupt_backup_content(self):
"""corrupt backup_content.control"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
diff --git a/tests/delete.py b/tests/delete.py
index 55d08f23b..10100887d 100644
--- a/tests/delete.py
+++ b/tests/delete.py
@@ -2,10 +2,6 @@
import os
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
import subprocess
-from sys import exit
-
-
-module_name = 'delete'
class DeleteTest(ProbackupTest, unittest.TestCase):
@@ -14,12 +10,11 @@ class DeleteTest(ProbackupTest, unittest.TestCase):
# @unittest.expectedFailure
def test_delete_full_backups(self):
"""delete full backups"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -51,19 +46,15 @@ def test_delete_full_backups(self):
self.assertEqual(show_backups[0]['id'], id_1)
self.assertEqual(show_backups[1]['id'], id_3)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_del_instance_archive(self):
"""delete full backups"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -83,19 +74,15 @@ def test_del_instance_archive(self):
# Delete instance
self.del_instance(backup_dir, 'node')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_delete_archive_mix_compress_and_non_compressed_segments(self):
"""delete full backups"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir="{0}/{1}/node".format(module_name, fname),
+ base_dir="{0}/{1}/node".format(self.module_name, self.fname),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(
@@ -142,18 +129,14 @@ def test_delete_archive_mix_compress_and_non_compressed_segments(self):
'--retention-redundancy=3',
'--delete-expired'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delete_increment_page(self):
"""delete increment and all after him"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -182,22 +165,18 @@ def test_delete_increment_page(self):
self.assertEqual(show_backups[1]['backup-mode'], "FULL")
self.assertEqual(show_backups[1]['status'], "OK")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delete_increment_ptrack(self):
"""delete increment and all after him"""
if not self.ptrack:
self.skipTest('Skipped because ptrack support is disabled')
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -230,9 +209,6 @@ def test_delete_increment_ptrack(self):
self.assertEqual(show_backups[1]['backup-mode'], "FULL")
self.assertEqual(show_backups[1]['status'], "OK")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delete_orphaned_wal_segments(self):
"""
@@ -240,12 +216,11 @@ def test_delete_orphaned_wal_segments(self):
delete second backup without --wal option,
then delete orphaned wals via --wal option
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -302,9 +277,6 @@ def test_delete_orphaned_wal_segments(self):
wals = [f for f in os.listdir(wals_dir) if os.path.isfile(os.path.join(wals_dir, f))]
self.assertEqual (0, len(wals), "Number of wals should be equal to 0")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delete_wal_between_multiple_timelines(self):
"""
@@ -315,12 +287,11 @@ def test_delete_wal_between_multiple_timelines(self):
[A1, B1) are deleted and backups B1 and A2 keep
their WAL
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -332,7 +303,7 @@ def test_delete_wal_between_multiple_timelines(self):
node.pgbench_init(scale=3)
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'))
node2.cleanup()
self.restore_node(backup_dir, 'node', node2)
@@ -356,22 +327,18 @@ def test_delete_wal_between_multiple_timelines(self):
self.validate_pb(backup_dir)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delete_backup_with_empty_control_file(self):
"""
take backup, truncate its control file,
try to delete it via 'delete' command
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
set_replication=True)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -397,18 +364,14 @@ def test_delete_backup_with_empty_control_file(self):
self.delete_pb(backup_dir, 'node', backup_id=backup_id)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delete_interleaved_incremental_chains(self):
"""complicated case of interleaved backup chains"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -521,9 +484,6 @@ def test_delete_interleaved_incremental_chains(self):
print(self.show_pb(
backup_dir, 'node', as_json=False, as_text=True))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delete_multiple_descendants(self):
"""
@@ -536,12 +496,11 @@ def test_delete_multiple_descendants(self):
FULLb |
FULLa should be deleted
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -693,9 +652,6 @@ def test_delete_multiple_descendants(self):
self.assertEqual(len(self.show_pb(backup_dir, 'node')), 4)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delete_multiple_descendants_dry_run(self):
"""
@@ -706,12 +662,11 @@ def test_delete_multiple_descendants_dry_run(self):
|
FULLa
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -798,17 +753,13 @@ def test_delete_multiple_descendants_dry_run(self):
self.validate_pb(backup_dir, 'node')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_delete_error_backups(self):
"""delete increment and all after him"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -869,6 +820,3 @@ def test_delete_error_backups(self):
self.assertEqual(show_backups[1]['status'], "OK")
self.assertEqual(show_backups[2]['status'], "OK")
self.assertEqual(show_backups[3]['status'], "OK")
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/delta.py b/tests/delta.py
index 82fb714f7..23583fd93 100644
--- a/tests/delta.py
+++ b/tests/delta.py
@@ -8,9 +8,6 @@
from threading import Thread
-module_name = 'delta'
-
-
class DeltaTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
@@ -21,15 +18,14 @@ def test_basic_delta_vacuum_truncate(self):
take delta backup, take second delta backup,
restore latest delta backup and check data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -77,9 +73,6 @@ def test_basic_delta_vacuum_truncate(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delta_vacuum_truncate_1(self):
"""
@@ -88,15 +81,14 @@ def test_delta_vacuum_truncate_1(self):
take delta backup, take second delta backup,
restore latest delta backup and check data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'),
)
self.init_pb(backup_dir)
@@ -161,9 +153,6 @@ def test_delta_vacuum_truncate_1(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delta_vacuum_truncate_2(self):
"""
@@ -172,15 +161,14 @@ def test_delta_vacuum_truncate_2(self):
take delta backup, take second delta backup,
restore latest delta backup and check data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'),
)
self.init_pb(backup_dir)
@@ -223,19 +211,15 @@ def test_delta_vacuum_truncate_2(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delta_stream(self):
"""
make archive node, take full and delta stream backups,
restore them and check data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -306,9 +290,6 @@ def test_delta_stream(self):
self.assertEqual(delta_result, delta_result_new)
node.cleanup()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delta_archive(self):
"""
@@ -316,10 +297,9 @@ def test_delta_archive(self):
restore them and check data correctness
"""
self.maxDiff = None
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -381,19 +361,15 @@ def test_delta_archive(self):
self.assertEqual(delta_result, delta_result_new)
node.cleanup()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delta_multiple_segments(self):
"""
Make node, create table with multiple segments,
write some data to it, check delta and data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -434,7 +410,7 @@ def test_delta_multiple_segments(self):
# RESTORE NODE
restored_node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'restored_node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'restored_node'))
restored_node.cleanup()
tblspc_path = self.get_tblspace_path(node, 'somedata')
tblspc_path_new = self.get_tblspace_path(
@@ -463,9 +439,6 @@ def test_delta_multiple_segments(self):
if self.paranoia:
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delta_vacuum_full(self):
"""
@@ -474,15 +447,14 @@ def test_delta_vacuum_full(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.init_pb(backup_dir)
@@ -542,19 +514,15 @@ def test_delta_vacuum_full(self):
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_create_db(self):
"""
Make node, take full backup, create database db1, take delta backup,
restore database and check it presense
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -596,7 +564,7 @@ def test_create_db(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored')
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored')
)
node_restored.cleanup()
@@ -667,19 +635,15 @@ def test_create_db(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_exists_in_previous_backup(self):
"""
Make node, take full backup, create table, take page backup,
take delta backup, check that file is no fully copied to delta backup
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -750,7 +714,7 @@ def test_exists_in_previous_backup(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored')
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored')
)
node_restored.cleanup()
@@ -773,19 +737,15 @@ def test_exists_in_previous_backup(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_alter_table_set_tablespace_delta(self):
"""
Make node, create tablespace with table, take full backup,
alter tablespace location, take delta backup, restore database.
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=['--data-checksums'],
pg_options={
'checkpoint_timeout': '30s',
@@ -826,7 +786,7 @@ def test_alter_table_set_tablespace_delta(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -858,9 +818,6 @@ def test_alter_table_set_tablespace_delta(self):
self.assertEqual(result, result_new, 'lost some data after restore')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_alter_database_set_tablespace_delta(self):
"""
@@ -868,10 +825,9 @@ def test_alter_database_set_tablespace_delta(self):
take delta backup, alter database tablespace location,
take delta backup restore last delta backup.
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
)
@@ -919,7 +875,7 @@ def test_alter_database_set_tablespace_delta(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored')
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored')
)
node_restored.cleanup()
@@ -947,19 +903,15 @@ def test_alter_database_set_tablespace_delta(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_delta_delete(self):
"""
Make node, create tablespace with table, take full backup,
alter tablespace location, take delta backup, restore database.
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=['--data-checksums'],
pg_options={
'checkpoint_timeout': '30s',
@@ -1005,7 +957,7 @@ def test_delta_delete(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored')
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored')
)
node_restored.cleanup()
@@ -1029,20 +981,16 @@ def test_delta_delete(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_delta_nullified_heap_page_backup(self):
"""
make node, take full backup, nullify some heap block,
take delta backup, restore, physically compare pgdata`s
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1093,7 +1041,7 @@ def test_delta_nullified_heap_page_backup(self):
# Restore DELTA backup
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -1103,21 +1051,17 @@ def test_delta_nullified_heap_page_backup(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_delta_backup_from_past(self):
"""
make node, take FULL stream backup, take DELTA stream backup,
restore FULL backup, try to take second DELTA stream backup
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -1158,22 +1102,18 @@ def test_delta_backup_from_past(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
# @unittest.expectedFailure
def test_delta_pg_resetxlog(self):
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
'shared_buffers': '512MB',
'max_wal_size': '3GB'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -1251,7 +1191,7 @@ def test_delta_pg_resetxlog(self):
# pgdata = self.pgdata_content(node.data_dir)
#
# node_restored = self.make_simple_node(
-# base_dir=os.path.join(module_name, fname, 'node_restored'))
+# base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
# node_restored.cleanup()
#
# self.restore_node(
@@ -1259,6 +1199,3 @@ def test_delta_pg_resetxlog(self):
#
# pgdata_restored = self.pgdata_content(node_restored.data_dir)
# self.compare_pgdata(pgdata, pgdata_restored)
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/exclude.py b/tests/exclude.py
index 2c4925881..cb3530cd5 100644
--- a/tests/exclude.py
+++ b/tests/exclude.py
@@ -3,19 +3,15 @@
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
-module_name = 'exclude'
-
-
class ExcludeTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
def test_exclude_temp_files(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -53,9 +49,6 @@ def test_exclude_temp_files(self):
# TODO check temporary tablespaces
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_exclude_temp_tables(self):
@@ -63,10 +56,9 @@ def test_exclude_temp_tables(self):
make node without archiving, create temp table, take full backup,
check that temp table not present in backup catalogue
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -139,9 +131,6 @@ def test_exclude_temp_tables(self):
"Found temp table file in backup catalogue.\n "
"Filepath: {0}".format(file))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_exclude_unlogged_tables_1(self):
"""
@@ -149,10 +138,9 @@ def test_exclude_unlogged_tables_1(self):
alter table to unlogged, take delta backup, restore delta backup,
check that PGDATA`s are physically the same
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -186,7 +174,7 @@ def test_exclude_unlogged_tables_1(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
@@ -197,9 +185,6 @@ def test_exclude_unlogged_tables_1(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_exclude_unlogged_tables_2(self):
"""
@@ -208,10 +193,9 @@ def test_exclude_unlogged_tables_2(self):
2. restore FULL, DELTA, PAGE to empty db,
ensure unlogged table exist and is epmty
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -279,19 +263,14 @@ def test_exclude_unlogged_tables_2(self):
'select count(*) from test')[0][0],
0)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
-
# @unittest.skip("skip")
def test_exclude_log_dir(self):
"""
check that by default 'log' and 'pg_log' directories are not backed up
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -321,18 +300,14 @@ def test_exclude_log_dir(self):
self.assertTrue(os.path.exists(path))
self.assertFalse(os.path.exists(log_file))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_exclude_log_dir_1(self):
"""
check that "--backup-pg-log" works correctly
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -361,6 +336,3 @@ def test_exclude_log_dir_1(self):
log_file = os.path.join(path, 'postgresql.log')
self.assertTrue(os.path.exists(path))
self.assertTrue(os.path.exists(log_file))
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/external.py b/tests/external.py
index a4e3d58f4..53f3c5449 100644
--- a/tests/external.py
+++ b/tests/external.py
@@ -6,8 +6,6 @@
import shutil
-module_name = 'external'
-
# TODO: add some ptrack tests
class ExternalTest(ProbackupTest, unittest.TestCase):
@@ -19,15 +17,14 @@ def test_basic_external(self):
with external directory, restore backup, check that
external directory was successfully copied
"""
- fname = self.id().split('.')[3]
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
set_replication=True)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
external_dir = self.get_tblspace_path(node, 'somedirectory')
# create directory in external_directory
@@ -91,9 +88,6 @@ def test_basic_external(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_external_none(self):
@@ -103,13 +97,12 @@ def test_external_none(self):
restore delta backup, check that
external directory was not copied
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
set_replication=True)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
external_dir = self.get_tblspace_path(node, 'somedirectory')
# create directory in external_directory
@@ -153,9 +146,6 @@ def test_external_none(self):
node.base_dir, exclude_dirs=['logs'])
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_external_dirs_overlapping(self):
@@ -164,13 +154,12 @@ def test_external_dirs_overlapping(self):
take backup with two external directories pointing to
the same directory, backup should fail
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
set_replication=True)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
external_dir1 = self.get_tblspace_path(node, 'external_dir1')
external_dir2 = self.get_tblspace_path(node, 'external_dir2')
@@ -207,9 +196,6 @@ def test_external_dirs_overlapping(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_external_dir_mapping(self):
"""
@@ -218,13 +204,12 @@ def test_external_dir_mapping(self):
check that restore with external-dir mapping will end with
success
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -247,7 +232,7 @@ def test_external_dir_mapping(self):
data_dir=external_dir2, options=["-j", "4"])
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
external_dir1_new = self.get_tblspace_path(node_restored, 'external_dir1')
@@ -300,20 +285,16 @@ def test_external_dir_mapping(self):
node_restored.base_dir, exclude_dirs=['logs'])
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_backup_multiple_external(self):
"""check that cmdline has priority over config"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -361,9 +342,6 @@ def test_backup_multiple_external(self):
node.base_dir, exclude_dirs=['logs'])
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_backward_compatibility(self):
@@ -376,10 +354,9 @@ def test_external_backward_compatibility(self):
if not self.probackup_old_path:
self.skipTest("You must specify PGPROBACKUPBIN_OLD"
" for run this test")
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -447,7 +424,7 @@ def test_external_backward_compatibility(self):
# RESTORE chain with new binary
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
@@ -466,9 +443,6 @@ def test_external_backward_compatibility(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_backward_compatibility_merge_1(self):
@@ -480,10 +454,9 @@ def test_external_backward_compatibility_merge_1(self):
if not self.probackup_old_path:
self.skipTest("You must specify PGPROBACKUPBIN_OLD"
" for run this test")
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -542,7 +515,7 @@ def test_external_backward_compatibility_merge_1(self):
# Restore merged backup
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
@@ -561,9 +534,6 @@ def test_external_backward_compatibility_merge_1(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_backward_compatibility_merge_2(self):
@@ -575,10 +545,9 @@ def test_external_backward_compatibility_merge_2(self):
if not self.probackup_old_path:
self.skipTest("You must specify PGPROBACKUPBIN_OLD"
" for run this test")
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -666,7 +635,7 @@ def test_external_backward_compatibility_merge_2(self):
# Restore merged backup
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
@@ -689,9 +658,6 @@ def test_external_backward_compatibility_merge_2(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_merge(self):
@@ -699,10 +665,9 @@ def test_external_merge(self):
if not self.probackup_old_path:
self.skipTest("You must specify PGPROBACKUPBIN_OLD"
" for run this test")
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -779,17 +744,13 @@ def test_external_merge(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_merge_skip_external_dirs(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -877,17 +838,13 @@ def test_external_merge_skip_external_dirs(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_merge_1(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -957,17 +914,13 @@ def test_external_merge_1(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_merge_3(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1050,17 +1003,13 @@ def test_external_merge_3(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_merge_2(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1144,17 +1093,13 @@ def test_external_merge_2(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_restore_external_changed_data(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1242,17 +1187,13 @@ def test_restore_external_changed_data(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_restore_external_changed_data_1(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1349,17 +1290,13 @@ def test_restore_external_changed_data_1(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_merge_external_changed_data(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1452,19 +1389,15 @@ def test_merge_external_changed_data(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_restore_skip_external(self):
"""
Check that --skip-external-dirs works correctly
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1523,9 +1456,6 @@ def test_restore_skip_external(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_dir_is_symlink(self):
@@ -1537,12 +1467,11 @@ def test_external_dir_is_symlink(self):
if os.name == 'nt':
self.skipTest('Skipped for Windows')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1557,7 +1486,7 @@ def test_external_dir_is_symlink(self):
backup_dir, 'node', node, options=["-j", "4", "--stream"])
# fill some directory with data
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
symlinked_dir = os.path.join(core_dir, 'symlinked')
self.restore_node(
@@ -1581,7 +1510,7 @@ def test_external_dir_is_symlink(self):
node.base_dir, exclude_dirs=['logs'])
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
# RESTORE
node_restored.cleanup()
@@ -1606,9 +1535,6 @@ def test_external_dir_is_symlink(self):
backup_dir, 'node',
backup_id=backup_id)['external-dirs'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_dir_contain_symlink_on_dir(self):
@@ -1620,12 +1546,11 @@ def test_external_dir_contain_symlink_on_dir(self):
if os.name == 'nt':
self.skipTest('Skipped for Windows')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1641,7 +1566,7 @@ def test_external_dir_contain_symlink_on_dir(self):
backup_dir, 'node', node, options=["-j", "4", "--stream"])
# fill some directory with data
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
symlinked_dir = os.path.join(core_dir, 'symlinked')
self.restore_node(
@@ -1666,7 +1591,7 @@ def test_external_dir_contain_symlink_on_dir(self):
node.base_dir, exclude_dirs=['logs'])
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
# RESTORE
node_restored.cleanup()
@@ -1691,9 +1616,6 @@ def test_external_dir_contain_symlink_on_dir(self):
backup_dir, 'node',
backup_id=backup_id)['external-dirs'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_dir_contain_symlink_on_file(self):
@@ -1705,12 +1627,11 @@ def test_external_dir_contain_symlink_on_file(self):
if os.name == 'nt':
self.skipTest('Skipped for Windows')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1726,7 +1647,7 @@ def test_external_dir_contain_symlink_on_file(self):
backup_dir, 'node', node, options=["-j", "4", "--stream"])
# fill some directory with data
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
symlinked_dir = os.path.join(core_dir, 'symlinked')
self.restore_node(
@@ -1753,7 +1674,7 @@ def test_external_dir_contain_symlink_on_file(self):
node.base_dir, exclude_dirs=['logs'])
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
# RESTORE
node_restored.cleanup()
@@ -1778,9 +1699,6 @@ def test_external_dir_contain_symlink_on_file(self):
backup_dir, 'node',
backup_id=backup_id)['external-dirs'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_external_dir_is_tablespace(self):
@@ -1788,12 +1706,11 @@ def test_external_dir_is_tablespace(self):
Check that backup fails with error
if external directory points to tablespace
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1828,21 +1745,17 @@ def test_external_dir_is_tablespace(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_restore_external_dir_not_empty(self):
"""
Check that backup fails with error
if external directory point to not empty tablespace and
if remapped directory also isn`t empty
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1908,9 +1821,6 @@ def test_restore_external_dir_not_empty(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_restore_external_dir_is_missing(self):
"""
take FULL backup with not empty external directory
@@ -1918,12 +1828,11 @@ def test_restore_external_dir_is_missing(self):
take DELTA backup with external directory, which
should fail
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1990,9 +1899,6 @@ def test_restore_external_dir_is_missing(self):
node.base_dir, exclude_dirs=['logs'])
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_merge_external_dir_is_missing(self):
"""
take FULL backup with not empty external directory
@@ -2003,12 +1909,11 @@ def test_merge_external_dir_is_missing(self):
merge it into FULL, restore and check
data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2078,9 +1983,6 @@ def test_merge_external_dir_is_missing(self):
node.base_dir, exclude_dirs=['logs'])
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_restore_external_dir_is_empty(self):
"""
take FULL backup with not empty external directory
@@ -2089,12 +1991,11 @@ def test_restore_external_dir_is_empty(self):
restore DELRA backup, check that restored
external directory is empty
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2142,9 +2043,6 @@ def test_restore_external_dir_is_empty(self):
node.base_dir, exclude_dirs=['logs'])
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_merge_external_dir_is_empty(self):
"""
take FULL backup with not empty external directory
@@ -2153,12 +2051,11 @@ def test_merge_external_dir_is_empty(self):
merge backups and restore FULL, check that restored
external directory is empty
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2209,9 +2106,6 @@ def test_merge_external_dir_is_empty(self):
node.base_dir, exclude_dirs=['logs'])
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_restore_external_dir_string_order(self):
"""
take FULL backup with not empty external directory
@@ -2220,12 +2114,11 @@ def test_restore_external_dir_string_order(self):
restore DELRA backup, check that restored
external directory is empty
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2289,9 +2182,6 @@ def test_restore_external_dir_string_order(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_merge_external_dir_string_order(self):
"""
take FULL backup with not empty external directory
@@ -2300,12 +2190,11 @@ def test_merge_external_dir_string_order(self):
restore DELRA backup, check that restored
external directory is empty
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- core_dir = os.path.join(self.tmp_path, module_name, fname)
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ core_dir = os.path.join(self.tmp_path, self.module_name, self.fname)
shutil.rmtree(core_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2372,9 +2261,6 @@ def test_merge_external_dir_string_order(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_smart_restore_externals(self):
"""
@@ -2383,13 +2269,12 @@ def test_smart_restore_externals(self):
make sure that files from externals are not copied during restore
https://github.com/postgrespro/pg_probackup/issues/63
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2451,9 +2336,6 @@ def test_smart_restore_externals(self):
for file in filelist_diff:
self.assertNotIn(file, logfile_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_external_validation(self):
"""
@@ -2462,13 +2344,12 @@ def test_external_validation(self):
corrupt external file in backup,
run validate which should fail
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -2522,6 +2403,3 @@ def test_external_validation(self):
'CORRUPT',
self.show_pb(backup_dir, 'node', full_id)['status'],
'Backup STATUS should be "CORRUPT"')
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/false_positive.py b/tests/false_positive.py
index 6ffc4db10..09dc323a8 100644
--- a/tests/false_positive.py
+++ b/tests/false_positive.py
@@ -1,13 +1,12 @@
import unittest
import os
+from asyncio import sleep
+
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
from datetime import datetime, timedelta
import subprocess
-module_name = 'false_positive'
-
-
class FalsePositive(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
@@ -16,13 +15,12 @@ def test_validate_wal_lost_segment(self):
"""
Loose segment located between backups. ExpectedFailure. This is BUG
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -47,19 +45,15 @@ def test_validate_wal_lost_segment(self):
backup_dir, 'node'))
########
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.expectedFailure
# Need to force validation of ancestor-chain
def test_incremental_backup_corrupt_full_1(self):
"""page-level backup with corrupted full backup"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -104,9 +98,6 @@ def test_incremental_backup_corrupt_full_1(self):
self.assertEqual(
self.show_pb(backup_dir, 'node')[0]['Status'], "ERROR")
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
@unittest.expectedFailure
def test_pg_10_waldir(self):
@@ -116,18 +107,18 @@ def test_pg_10_waldir(self):
if self.pg_config_version < self.version_to_num('10.0'):
self.skipTest('You need PostgreSQL >= 10 for this test')
- fname = self.id().split('.')[3]
wal_dir = os.path.join(
- os.path.join(self.tmp_path, module_name, fname), 'wal_dir')
+ os.path.join(self.tmp_path, self.module_name, self.fname), 'wal_dir')
+ import shutil
shutil.rmtree(wal_dir, ignore_errors=True)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=[
'--data-checksums',
'--waldir={0}'.format(wal_dir)])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -140,7 +131,7 @@ def test_pg_10_waldir(self):
# restore backup
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -154,9 +145,6 @@ def test_pg_10_waldir(self):
os.path.islink(os.path.join(node_restored.data_dir, 'pg_wal')),
'pg_wal should be symlink')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.expectedFailure
# @unittest.skip("skip")
def test_recovery_target_time_backup_victim(self):
@@ -165,10 +153,9 @@ def test_recovery_target_time_backup_victim(self):
probackup chooses valid backup
https://github.com/postgrespro/pg_probackup/issues/104
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -216,9 +203,6 @@ def test_recovery_target_time_backup_victim(self):
backup_dir, 'node',
options=['--recovery-target-time={0}'.format(target_time)])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.expectedFailure
# @unittest.skip("skip")
def test_recovery_target_lsn_backup_victim(self):
@@ -227,10 +211,9 @@ def test_recovery_target_lsn_backup_victim(self):
probackup chooses valid backup
https://github.com/postgrespro/pg_probackup/issues/104
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -280,9 +263,6 @@ def test_recovery_target_lsn_backup_victim(self):
backup_dir, 'node',
options=['--recovery-target-lsn={0}'.format(target_lsn)])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
@unittest.expectedFailure
def test_streaming_timeout(self):
@@ -291,10 +271,9 @@ def test_streaming_timeout(self):
message because our WAL streaming engine is "borrowed"
from pg_receivexlog
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -331,20 +310,16 @@ def test_streaming_timeout(self):
'ERROR: Problem in receivexlog',
log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
@unittest.expectedFailure
def test_validate_all_empty_catalog(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
try:
@@ -360,6 +335,3 @@ def test_validate_all_empty_catalog(self):
e.message,
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/helpers/ptrack_helpers.py b/tests/helpers/ptrack_helpers.py
index 1b90ac3ff..e35f57bce 100644
--- a/tests/helpers/ptrack_helpers.py
+++ b/tests/helpers/ptrack_helpers.py
@@ -1,6 +1,7 @@
# you need os for unittest to work
import os
import gc
+import unittest
from sys import exit, argv, version_info
import subprocess
import shutil
@@ -138,39 +139,57 @@ def __init__(self, message, cmd):
def __str__(self):
return '\n ERROR: {0}\n CMD: {1}'.format(repr(self.message), self.cmd)
+class PostgresNodeExtended(testgres.PostgresNode):
-def slow_start(self, replica=False):
+ def __init__(self, base_dir=None, *args, **kwargs):
+ super(PostgresNodeExtended, self).__init__(name='test', base_dir=base_dir, *args, **kwargs)
+ self.is_started = False
- # wait for https://github.com/postgrespro/testgres/pull/50
-# self.start()
-# self.poll_query_until(
-# "postgres",
-# "SELECT not pg_is_in_recovery()",
-# suppress={testgres.NodeConnection})
- if replica:
- query = 'SELECT pg_is_in_recovery()'
- else:
- query = 'SELECT not pg_is_in_recovery()'
+ def slow_start(self, replica=False):
- self.start()
- while True:
- try:
- output = self.safe_psql('template1', query).decode("utf-8").rstrip()
+ # wait for https://github.com/postgrespro/testgres/pull/50
+ # self.start()
+ # self.poll_query_until(
+ # "postgres",
+ # "SELECT not pg_is_in_recovery()",
+ # suppress={testgres.NodeConnection})
+ if replica:
+ query = 'SELECT pg_is_in_recovery()'
+ else:
+ query = 'SELECT not pg_is_in_recovery()'
- if output == 't':
- break
+ self.start()
+ while True:
+ try:
+ output = self.safe_psql('template1', query).decode("utf-8").rstrip()
+
+ if output == 't':
+ break
+
+ except testgres.QueryException as e:
+ if 'database system is starting up' in e.message:
+ pass
+ elif 'FATAL: the database system is not accepting connections' in e.message:
+ pass
+ elif replica and 'Hot standby mode is disabled' in e.message:
+ raise e
+ else:
+ raise e
- except testgres.QueryException as e:
- if 'database system is starting up' in e.message:
- pass
- elif 'FATAL: the database system is not accepting connections' in e.message:
- pass
- elif replica and 'Hot standby mode is disabled' in e.message:
- raise e
- else:
- raise e
+ sleep(0.5)
+
+ def start(self, *args, **kwargs):
+ if not self.is_started:
+ super(PostgresNodeExtended, self).start(*args, **kwargs)
+ self.is_started = True
+ return self
+
+ def stop(self, *args, **kwargs):
+ if self.is_started:
+ result = super(PostgresNodeExtended, self).stop(*args, **kwargs)
+ self.is_started = False
+ return result
- sleep(0.5)
class ProbackupTest(object):
# Class attributes
@@ -179,6 +198,13 @@ class ProbackupTest(object):
def __init__(self, *args, **kwargs):
super(ProbackupTest, self).__init__(*args, **kwargs)
+
+ self.nodes_to_cleanup = []
+
+ if isinstance(self, unittest.TestCase):
+ self.module_name = self.id().split('.')[1]
+ self.fname = self.id().split('.')[3]
+
if '-v' in argv or '--verbose' in argv:
self.verbose = True
else:
@@ -339,6 +365,45 @@ def __init__(self, *args, **kwargs):
os.environ["PGAPPNAME"] = "pg_probackup"
+ def is_test_result_ok(test_case):
+ # sources of solution:
+ # 1. python versions 2.7 - 3.10, verified on 3.10, 3.7, 2.7, taken from:
+ # https://tousu.in/qa/?qa=555402/unit-testing-getting-pythons-unittest-results-in-a-teardown-method&show=555403#a555403
+ #
+ # 2. python versions 3.11+ mixin, verified on 3.11, taken from: https://stackoverflow.com/a/39606065
+
+ if not isinstance(test_case, unittest.TestCase):
+ raise AssertionError("test_case is not instance of unittest.TestCase")
+
+ if hasattr(test_case, '_outcome'): # Python 3.4+
+ if hasattr(test_case._outcome, 'errors'):
+ # Python 3.4 - 3.10 (These two methods have no side effects)
+ result = test_case.defaultTestResult() # These two methods have no side effects
+ test_case._feedErrorsToResult(result, test_case._outcome.errors)
+ else:
+ # Python 3.11+
+ result = test_case._outcome.result
+ else: # Python 2.7, 3.0-3.3
+ result = getattr(test_case, '_outcomeForDoCleanups', test_case._resultForDoCleanups)
+
+ ok = all(test != test_case for test, text in result.errors + result.failures)
+
+ return ok
+
+ def tearDown(self):
+ if self.is_test_result_ok():
+ for node in self.nodes_to_cleanup:
+ node.cleanup()
+ self.del_test_dir(self.module_name, self.fname)
+
+ else:
+ for node in self.nodes_to_cleanup:
+ # TODO make decorator with proper stop() vs cleanup()
+ node._try_shutdown(max_attempts=1)
+ # node.cleanup()
+
+ self.nodes_to_cleanup.clear()
+
@property
def pg_config_version(self):
return self.version_to_num(
@@ -369,10 +434,10 @@ def make_empty_node(
shutil.rmtree(real_base_dir, ignore_errors=True)
os.makedirs(real_base_dir)
- node = testgres.get_new_node('test', base_dir=real_base_dir)
- # bound method slow_start() to 'node' class instance
- node.slow_start = slow_start.__get__(node)
+ node = PostgresNodeExtended(base_dir=real_base_dir)
node.should_rm_dirs = True
+ self.nodes_to_cleanup.append(node)
+
return node
def make_simple_node(
@@ -435,6 +500,7 @@ def make_simple_node(
if node.major_version >= 13:
self.set_auto_conf(
node, {}, 'postgresql.conf', ['wal_keep_segments'])
+
return node
def simple_bootstrap(self, node, role) -> None:
@@ -1648,16 +1714,9 @@ def get_ptrack_version(self, node):
def get_bin_path(self, binary):
return testgres.get_bin_path(binary)
- def clean_all(self):
- for o in gc.get_referrers(testgres.PostgresNode):
- if o.__class__ is testgres.PostgresNode:
- o.cleanup()
-
def del_test_dir(self, module_name, fname):
""" Del testdir and optimistically try to del module dir"""
- self.clean_all()
-
shutil.rmtree(
os.path.join(
self.tmp_path,
diff --git a/tests/incr_restore.py b/tests/incr_restore.py
index 5bd3711a1..613e4dd36 100644
--- a/tests/incr_restore.py
+++ b/tests/incr_restore.py
@@ -12,20 +12,16 @@
from testgres import QueryException
-module_name = 'incr_restore'
-
-
class IncrRestoreTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
def test_basic_incr_restore(self):
"""incremental restore in CHECKSUM mode"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -76,18 +72,14 @@ def test_basic_incr_restore(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_incr_restore_into_missing_directory(self):
""""""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -124,19 +116,15 @@ def test_basic_incr_restore_into_missing_directory(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_checksum_corruption_detection(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -181,20 +169,16 @@ def test_checksum_corruption_detection(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_restore_with_tablespace(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -224,19 +208,15 @@ def test_incr_restore_with_tablespace(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_restore_with_tablespace_1(self):
"""recovery to target timeline"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
set_replication=True)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -282,22 +262,18 @@ def test_incr_restore_with_tablespace_1(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_restore_with_tablespace_2(self):
"""
If "--tablespace-mapping" option is used with incremental restore,
then new directory must be empty.
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
set_replication=True)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -305,7 +281,7 @@ def test_incr_restore_with_tablespace_2(self):
self.backup_node(backup_dir, 'node', node, options=['--stream'])
node_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_1'))
# fill node1 with data
out = self.restore_node(
@@ -355,20 +331,16 @@ def test_incr_restore_with_tablespace_2(self):
pgdata_restored = self.pgdata_content(node_1.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_restore_with_tablespace_3(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -396,21 +368,17 @@ def test_incr_restore_with_tablespace_3(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_restore_with_tablespace_4(self):
"""
Check that system ID mismatch is detected,
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -427,7 +395,7 @@ def test_incr_restore_with_tablespace_4(self):
# recreate node
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
node.slow_start()
@@ -469,9 +437,6 @@ def test_incr_restore_with_tablespace_4(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
@unittest.skip("skip")
def test_incr_restore_with_tablespace_5(self):
@@ -481,13 +446,12 @@ def test_incr_restore_with_tablespace_5(self):
with some old content, that belongs to an instance
with different system id.
"""
- fname = self.id().split('.')[3]
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node1)
node1.slow_start()
@@ -503,7 +467,7 @@ def test_incr_restore_with_tablespace_5(self):
# recreate node
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'),
set_replication=True,
initdb_params=['--data-checksums'])
node2.slow_start()
@@ -530,21 +494,17 @@ def test_incr_restore_with_tablespace_5(self):
pgdata_restored = self.pgdata_content(node1.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_restore_with_tablespace_6(self):
"""
Empty pgdata, not empty tablespace
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -591,22 +551,18 @@ def test_incr_restore_with_tablespace_6(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_restore_with_tablespace_7(self):
"""
Restore backup without tablespace into
PGDATA with tablespace.
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -647,19 +603,15 @@ def test_incr_restore_with_tablespace_7(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_incr_restore_sanity(self):
"""recovery to target timeline"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
set_replication=True)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -690,7 +642,7 @@ def test_basic_incr_restore_sanity(self):
repr(e.message), self.cmd))
node_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_1'))
try:
self.restore_node(
@@ -714,9 +666,6 @@ def test_basic_incr_restore_sanity(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_checksum_restore(self):
"""
@@ -725,13 +674,12 @@ def test_incr_checksum_restore(self):
X - is instance, we want to return it to C state.
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
pg_options={'wal_log_hints': 'on'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -758,7 +706,7 @@ def test_incr_checksum_restore(self):
node.stop(['-m', 'immediate', '-D', node.data_dir])
node_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_1'))
node_1.cleanup()
self.restore_node(
@@ -803,9 +751,6 @@ def test_incr_checksum_restore(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_lsn_restore(self):
@@ -815,13 +760,12 @@ def test_incr_lsn_restore(self):
X - is instance, we want to return it to C state.
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
pg_options={'wal_log_hints': 'on'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -848,7 +792,7 @@ def test_incr_lsn_restore(self):
node.stop(['-m', 'immediate', '-D', node.data_dir])
node_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_1'))
node_1.cleanup()
self.restore_node(
@@ -892,9 +836,6 @@ def test_incr_lsn_restore(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_lsn_sanity(self):
"""
@@ -904,13 +845,12 @@ def test_incr_lsn_sanity(self):
X - is instance, we want to return it to state B.
fail is expected behaviour in case of lsn restore.
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
pg_options={'wal_log_hints': 'on'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -920,7 +860,7 @@ def test_incr_lsn_sanity(self):
node.pgbench_init(scale=10)
node_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_1'))
node_1.cleanup()
self.restore_node(
@@ -961,9 +901,6 @@ def test_incr_lsn_sanity(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_checksum_sanity(self):
"""
@@ -972,12 +909,11 @@ def test_incr_checksum_sanity(self):
X - is instance, we want to return it to state B.
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -987,7 +923,7 @@ def test_incr_checksum_sanity(self):
node.pgbench_init(scale=20)
node_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_1'))
node_1.cleanup()
self.restore_node(
@@ -1019,22 +955,17 @@ def test_incr_checksum_sanity(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
-
# @unittest.skip("skip")
def test_incr_checksum_corruption_detection(self):
"""
check that corrupted page got detected and replaced
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
# initdb_params=['--data-checksums'],
pg_options={'wal_log_hints': 'on'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1078,21 +1009,17 @@ def test_incr_checksum_corruption_detection(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_incr_lsn_corruption_detection(self):
"""
check that corrupted page got detected and replaced
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
pg_options={'wal_log_hints': 'on'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1136,20 +1063,16 @@ def test_incr_lsn_corruption_detection(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_incr_restore_multiple_external(self):
"""check that cmdline has priority over config"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1207,20 +1130,16 @@ def test_incr_restore_multiple_external(self):
node.base_dir, exclude_dirs=['logs'])
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_incr_lsn_restore_multiple_external(self):
"""check that cmdline has priority over config"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1278,22 +1197,18 @@ def test_incr_lsn_restore_multiple_external(self):
node.base_dir, exclude_dirs=['logs'])
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_incr_lsn_restore_backward(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={'wal_log_hints': 'on', 'hot_standby': 'on'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1386,23 +1301,19 @@ def test_incr_lsn_restore_backward(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(delta_pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_incr_checksum_restore_backward(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
'hot_standby': 'on'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1478,22 +1389,17 @@ def test_incr_checksum_restore_backward(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(delta_pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_make_replica_via_incr_checksum_restore(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'])
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -1503,7 +1409,7 @@ def test_make_replica_via_incr_checksum_restore(self):
master.slow_start()
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
master.pgbench_init(scale=20)
@@ -1551,22 +1457,17 @@ def test_make_replica_via_incr_checksum_restore(self):
pgbench = new_master.pgbench(options=['-T', '10', '-c', '1'])
pgbench.wait()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_make_replica_via_incr_lsn_restore(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'])
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -1576,7 +1477,7 @@ def test_make_replica_via_incr_lsn_restore(self):
master.slow_start()
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
master.pgbench_init(scale=20)
@@ -1624,20 +1525,16 @@ def test_make_replica_via_incr_lsn_restore(self):
pgbench = new_master.pgbench(options=['-T', '10', '-c', '1'])
pgbench.wait()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_incr_checksum_long_xact(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1694,9 +1591,6 @@ def test_incr_checksum_long_xact(self):
'select count(*) from t1').decode('utf-8').rstrip(),
'1')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
# This test will pass with Enterprise
@@ -1705,12 +1599,11 @@ def test_incr_checksum_long_xact(self):
def test_incr_lsn_long_xact_1(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1774,24 +1667,20 @@ def test_incr_lsn_long_xact_1(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_incr_lsn_long_xact_2(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
'full_page_writes': 'off',
'wal_log_hints': 'off'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1861,21 +1750,17 @@ def test_incr_lsn_long_xact_2(self):
'select count(*) from t1').decode('utf-8').rstrip(),
'1')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_incr_restore_zero_size_file_checksum(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -1934,21 +1819,17 @@ def test_incr_restore_zero_size_file_checksum(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata3, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_incr_restore_zero_size_file_lsn(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -2013,15 +1894,11 @@ def test_incr_restore_zero_size_file_lsn(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata3, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_incremental_partial_restore_exclude_checksum(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -2060,11 +1937,11 @@ def test_incremental_partial_restore_exclude_checksum(self):
# restore FULL backup into second node2
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'))
node1.cleanup()
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'))
node2.cleanup()
# restore some data into node2
@@ -2118,15 +1995,11 @@ def test_incremental_partial_restore_exclude_checksum(self):
self.assertNotIn('PANIC', output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_incremental_partial_restore_exclude_lsn(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -2167,11 +2040,11 @@ def test_incremental_partial_restore_exclude_lsn(self):
# restore FULL backup into second node2
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'))
node1.cleanup()
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'))
node2.cleanup()
# restore some data into node2
@@ -2228,15 +2101,11 @@ def test_incremental_partial_restore_exclude_lsn(self):
self.assertNotIn('PANIC', output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_incremental_partial_restore_exclude_tablespace_checksum(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -2282,13 +2151,13 @@ def test_incremental_partial_restore_exclude_tablespace_checksum(self):
# node1
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'))
node1.cleanup()
node1_tablespace = self.get_tblspace_path(node1, 'somedata')
# node2
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'))
node2.cleanup()
node2_tablespace = self.get_tblspace_path(node2, 'somedata')
@@ -2372,17 +2241,13 @@ def test_incremental_partial_restore_exclude_tablespace_checksum(self):
self.assertNotIn('PANIC', output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_incremental_pg_filenode_map(self):
"""
https://github.com/postgrespro/pg_probackup/issues/320
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -2391,7 +2256,7 @@ def test_incremental_pg_filenode_map(self):
node.slow_start()
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'),
initdb_params=['--data-checksums'])
node1.cleanup()
@@ -2432,7 +2297,4 @@ def test_incremental_pg_filenode_map(self):
'postgres',
'select 1')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# check that MinRecPoint and BackupStartLsn are correctly used in case of --incrementa-lsn
diff --git a/tests/init.py b/tests/init.py
index f5715d249..94b076fef 100644
--- a/tests/init.py
+++ b/tests/init.py
@@ -4,18 +4,14 @@
import shutil
-module_name = 'init'
-
-
class InitTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_success(self):
"""Success normal init"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- node = self.make_simple_node(base_dir=os.path.join(module_name, fname, 'node'))
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ node = self.make_simple_node(base_dir=os.path.join(self.module_name, self.fname, 'node'))
self.init_pb(backup_dir)
self.assertEqual(
dir_files(backup_dir),
@@ -64,15 +60,11 @@ def test_success(self):
e.message,
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(e.message, self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_already_exist(self):
"""Failure with backup catalog already existed"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- node = self.make_simple_node(base_dir=os.path.join(module_name, fname, 'node'))
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ node = self.make_simple_node(base_dir=os.path.join(self.module_name, self.fname, 'node'))
self.init_pb(backup_dir)
try:
self.show_pb(backup_dir, 'node')
@@ -84,15 +76,11 @@ def test_already_exist(self):
e.message,
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_abs_path(self):
"""failure with backup catalog should be given as absolute path"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- node = self.make_simple_node(base_dir=os.path.join(module_name, fname, 'node'))
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ node = self.make_simple_node(base_dir=os.path.join(self.module_name, self.fname, 'node'))
try:
self.run_pb(["init", "-B", os.path.relpath("%s/backup" % node.base_dir, self.dir_path)])
self.assertEqual(1, 0, 'Expecting Error due to initialization with non-absolute path in --backup-path. Output: {0} \n CMD: {1}'.format(
@@ -103,18 +91,14 @@ def test_abs_path(self):
e.message,
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_add_instance_idempotence(self):
"""
https://github.com/postgrespro/pg_probackup/issues/219
"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
- node = self.make_simple_node(base_dir=os.path.join(module_name, fname, 'node'))
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
+ node = self.make_simple_node(base_dir=os.path.join(self.module_name, self.fname, 'node'))
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -152,6 +136,3 @@ def test_add_instance_idempotence(self):
e.message,
"\n Unexpected Error Message: {0}\n CMD: {1}".format(
repr(e.message), self.cmd))
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/locking.py b/tests/locking.py
index 4042a1462..5367c2610 100644
--- a/tests/locking.py
+++ b/tests/locking.py
@@ -4,9 +4,6 @@
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
-module_name = 'locking'
-
-
class LockingTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
@@ -19,12 +16,11 @@ def test_locking_running_validate_1(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -64,7 +60,6 @@ def test_locking_running_validate_1(self):
# Clean after yourself
gdb.kill()
- self.del_test_dir(module_name, fname)
def test_locking_running_validate_2(self):
"""
@@ -76,12 +71,11 @@ def test_locking_running_validate_2(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -135,7 +129,6 @@ def test_locking_running_validate_2(self):
# Clean after yourself
gdb.kill()
- self.del_test_dir(module_name, fname)
def test_locking_running_validate_2_specific_id(self):
"""
@@ -148,12 +141,11 @@ def test_locking_running_validate_2_specific_id(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -236,7 +228,6 @@ def test_locking_running_validate_2_specific_id(self):
# Clean after yourself
gdb.kill()
- self.del_test_dir(module_name, fname)
def test_locking_running_3(self):
"""
@@ -248,12 +239,11 @@ def test_locking_running_3(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -308,7 +298,6 @@ def test_locking_running_3(self):
# Clean after yourself
gdb.kill()
- self.del_test_dir(module_name, fname)
def test_locking_restore_locked(self):
"""
@@ -320,12 +309,11 @@ def test_locking_restore_locked(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -352,7 +340,6 @@ def test_locking_restore_locked(self):
# Clean after yourself
gdb.kill()
- self.del_test_dir(module_name, fname)
def test_concurrent_delete_and_restore(self):
"""
@@ -364,12 +351,11 @@ def test_concurrent_delete_and_restore(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -411,7 +397,6 @@ def test_concurrent_delete_and_restore(self):
# Clean after yourself
gdb.kill()
- self.del_test_dir(module_name, fname)
def test_locking_concurrent_validate_and_backup(self):
"""
@@ -421,12 +406,11 @@ def test_locking_concurrent_validate_and_backup(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -449,7 +433,6 @@ def test_locking_concurrent_validate_and_backup(self):
# Clean after yourself
gdb.kill()
- self.del_test_dir(module_name, fname)
def test_locking_concurren_restore_and_delete(self):
"""
@@ -459,12 +442,11 @@ def test_locking_concurren_restore_and_delete(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -495,17 +477,15 @@ def test_locking_concurren_restore_and_delete(self):
# Clean after yourself
gdb.kill()
- self.del_test_dir(module_name, fname)
def test_backup_directory_name(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -549,18 +529,16 @@ def test_backup_directory_name(self):
self.show_pb(backup_dir, 'node', page_id_2))
# Clean after yourself
- self.del_test_dir(module_name, fname)
def test_empty_lock_file(self):
"""
https://github.com/postgrespro/pg_probackup/issues/308
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -594,21 +572,17 @@ def test_empty_lock_file(self):
# p1.wait()
# p2.wait()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_shared_lock(self):
"""
Make sure that shared lock leaves no files with pids
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -653,5 +627,3 @@ def test_shared_lock(self):
os.path.exists(lockfile_shr),
"File should not exist: {0}".format(lockfile_shr))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/logging.py b/tests/logging.py
index 70ebcf6d1..c5cdfa344 100644
--- a/tests/logging.py
+++ b/tests/logging.py
@@ -3,9 +3,6 @@
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
import datetime
-module_name = 'logging'
-
-
class LogTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
@@ -16,13 +13,12 @@ def test_log_rotation(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -43,17 +39,13 @@ def test_log_rotation(self):
gdb.run_until_break()
gdb.continue_execution_until_exit()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_log_filename_strftime(self):
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -76,17 +68,13 @@ def test_log_filename_strftime(self):
self.assertTrue(os.path.isfile(path))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_truncate_rotation_file(self):
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -151,17 +139,13 @@ def test_truncate_rotation_file(self):
self.assertTrue(os.path.isfile(rotation_file_path))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_unlink_rotation_file(self):
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -223,17 +207,13 @@ def test_unlink_rotation_file(self):
os.stat(log_file_path).st_size,
log_file_size)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_garbage_in_rotation_file(self):
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -261,9 +241,6 @@ def test_garbage_in_rotation_file(self):
# mangle .rotation file
with open(rotation_file_path, "w+b", 0) as f:
f.write(b"blah")
- f.flush()
- f.close
-
output = self.backup_node(
backup_dir, 'node', node,
options=[
@@ -302,24 +279,20 @@ def test_garbage_in_rotation_file(self):
os.stat(log_file_path).st_size,
log_file_size)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_issue_274(self):
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
node.slow_start()
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.backup_node(backup_dir, 'node', node, options=['--stream'])
@@ -370,6 +343,3 @@ def test_issue_274(self):
log_content = f.read()
self.assertIn('INFO: command:', log_content)
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/merge.py b/tests/merge.py
index 566de549b..ffa73263c 100644
--- a/tests/merge.py
+++ b/tests/merge.py
@@ -9,21 +9,17 @@
import time
import subprocess
-module_name = "merge"
-
-
class MergeTest(ProbackupTest, unittest.TestCase):
def test_basic_merge_full_page(self):
"""
Test MERGE command, it merges FULL backup with target PAGE backups
"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, "backup")
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, "backup")
# Initialize instance and backup directory
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=["--data-checksums"])
self.init_pb(backup_dir)
@@ -100,19 +96,15 @@ def test_basic_merge_full_page(self):
count2 = node.execute("postgres", "select count(*) from test")
self.assertEqual(count1, count2)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_merge_compressed_backups(self):
"""
Test MERGE command with compressed backups
"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, "backup")
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, "backup")
# Initialize instance and backup directory
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=["--data-checksums"])
self.init_pb(backup_dir)
@@ -163,18 +155,16 @@ def test_merge_compressed_backups(self):
# Clean after yourself
node.cleanup()
- self.del_test_dir(module_name, fname)
def test_merge_compressed_backups_1(self):
"""
Test MERGE command with compressed backups
"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, "backup")
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, "backup")
# Initialize instance and backup directory
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=["--data-checksums"])
self.init_pb(backup_dir)
@@ -234,18 +224,16 @@ def test_merge_compressed_backups_1(self):
# Clean after yourself
node.cleanup()
- self.del_test_dir(module_name, fname)
def test_merge_compressed_and_uncompressed_backups(self):
"""
Test MERGE command with compressed and uncompressed backups
"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, "backup")
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, "backup")
# Initialize instance and backup directory
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=["--data-checksums"],
)
@@ -306,18 +294,16 @@ def test_merge_compressed_and_uncompressed_backups(self):
# Clean after yourself
node.cleanup()
- self.del_test_dir(module_name, fname)
def test_merge_compressed_and_uncompressed_backups_1(self):
"""
Test MERGE command with compressed and uncompressed backups
"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, "backup")
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, "backup")
# Initialize instance and backup directory
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=["--data-checksums"],
)
@@ -380,18 +366,16 @@ def test_merge_compressed_and_uncompressed_backups_1(self):
# Clean after yourself
node.cleanup()
- self.del_test_dir(module_name, fname)
def test_merge_compressed_and_uncompressed_backups_2(self):
"""
Test MERGE command with compressed and uncompressed backups
"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, "backup")
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, "backup")
# Initialize instance and backup directory
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=["--data-checksums"],
)
@@ -450,11 +434,6 @@ def test_merge_compressed_and_uncompressed_backups_2(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- node.cleanup()
- self.del_test_dir(module_name, fname)
-
-
# @unittest.skip("skip")
def test_merge_tablespaces(self):
"""
@@ -463,10 +442,9 @@ def test_merge_tablespaces(self):
tablespace, take page backup, merge it and restore
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=['--data-checksums'],
)
@@ -538,10 +516,9 @@ def test_merge_tablespaces_1(self):
drop first tablespace and take delta backup,
merge it and restore
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=['--data-checksums'],
)
@@ -607,9 +584,6 @@ def test_merge_tablespaces_1(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_merge_page_truncate(self):
"""
make node, create table, take full backup,
@@ -617,17 +591,16 @@ def test_merge_page_truncate(self):
take page backup, merge full and page,
restore last page backup and check data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
'checkpoint_timeout': '300s'})
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -696,9 +669,6 @@ def test_merge_page_truncate(self):
self.assertEqual(result1, result2)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_merge_delta_truncate(self):
"""
make node, create table, take full backup,
@@ -706,17 +676,16 @@ def test_merge_delta_truncate(self):
take page backup, merge full and page,
restore last page backup and check data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
'checkpoint_timeout': '300s'})
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -785,9 +754,6 @@ def test_merge_delta_truncate(self):
self.assertEqual(result1, result2)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_merge_ptrack_truncate(self):
"""
make node, create table, take full backup,
@@ -798,10 +764,9 @@ def test_merge_ptrack_truncate(self):
if not self.ptrack:
self.skipTest('Skipped because ptrack support is disabled')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
ptrack_enable=True)
@@ -850,7 +815,7 @@ def test_merge_ptrack_truncate(self):
self.validate_pb(backup_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
old_tablespace = self.get_tblspace_path(node, 'somedata')
@@ -881,9 +846,6 @@ def test_merge_ptrack_truncate(self):
self.assertEqual(result1, result2)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_merge_delta_delete(self):
"""
@@ -891,10 +853,9 @@ def test_merge_delta_delete(self):
alter tablespace location, take delta backup, merge full and delta,
restore database.
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=['--data-checksums'],
pg_options={
'checkpoint_timeout': '30s',
@@ -943,7 +904,7 @@ def test_merge_delta_delete(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored')
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored')
)
node_restored.cleanup()
@@ -967,9 +928,6 @@ def test_merge_delta_delete(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_continue_failed_merge(self):
"""
@@ -977,11 +935,10 @@ def test_continue_failed_merge(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
base_dir=os.path.join(
- module_name, fname, 'node'),
+ self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1045,9 +1002,6 @@ def test_continue_failed_merge(self):
node.cleanup()
self.restore_node(backup_dir, 'node', node)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_continue_failed_merge_with_corrupted_delta_backup(self):
"""
@@ -1055,10 +1009,9 @@ def test_continue_failed_merge_with_corrupted_delta_backup(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -1145,19 +1098,15 @@ def test_continue_failed_merge_with_corrupted_delta_backup(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_continue_failed_merge_2(self):
"""
Check that failed MERGE on delete can be continued
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -1217,8 +1166,6 @@ def test_continue_failed_merge_2(self):
# Try to continue failed MERGE
self.merge_backup(backup_dir, "node", backup_id)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
def test_continue_failed_merge_3(self):
"""
@@ -1227,10 +1174,9 @@ def test_continue_failed_merge_3(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -1315,17 +1261,13 @@ def test_continue_failed_merge_3(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_merge_different_compression_algo(self):
"""
Check that backups with different compression algorithms can be merged
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1368,17 +1310,14 @@ def test_merge_different_compression_algo(self):
self.merge_backup(backup_dir, "node", backup_id)
- self.del_test_dir(module_name, fname)
-
def test_merge_different_wal_modes(self):
"""
Check that backups with different wal modes can be merged
correctly
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1410,8 +1349,6 @@ def test_merge_different_wal_modes(self):
self.assertEqual(
'STREAM', self.show_pb(backup_dir, 'node', backup_id)['wal'])
- self.del_test_dir(module_name, fname)
-
def test_crash_after_opening_backup_control_1(self):
"""
check that crashing after opening backup.control
@@ -1419,10 +1356,9 @@ def test_crash_after_opening_backup_control_1(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1462,8 +1398,6 @@ def test_crash_after_opening_backup_control_1(self):
self.assertEqual(
'MERGING', self.show_pb(backup_dir, 'node')[1]['status'])
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_crash_after_opening_backup_control_2(self):
"""
@@ -1473,10 +1407,9 @@ def test_crash_after_opening_backup_control_2(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1555,8 +1488,6 @@ def test_crash_after_opening_backup_control_2(self):
self.compare_pgdata(pgdata, pgdata_restored)
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_losing_file_after_failed_merge(self):
"""
@@ -1566,10 +1497,9 @@ def test_losing_file_after_failed_merge(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1648,17 +1578,14 @@ def test_losing_file_after_failed_merge(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- self.del_test_dir(module_name, fname)
-
def test_failed_merge_after_delete(self):
"""
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1731,17 +1658,14 @@ def test_failed_merge_after_delete(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- self.del_test_dir(module_name, fname)
-
def test_failed_merge_after_delete_1(self):
"""
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1809,17 +1733,14 @@ def test_failed_merge_after_delete_1(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- self.del_test_dir(module_name, fname)
-
def test_failed_merge_after_delete_2(self):
"""
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1873,17 +1794,14 @@ def test_failed_merge_after_delete_2(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- self.del_test_dir(module_name, fname)
-
def test_failed_merge_after_delete_3(self):
"""
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1963,8 +1881,6 @@ def test_failed_merge_after_delete_3(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- self.del_test_dir(module_name, fname)
-
# Skipped, because backups from the future are invalid.
# This cause a "ERROR: Can't assign backup_id, there is already a backup in future"
# now (PBCKP-259). We can conduct such a test again when we
@@ -1975,13 +1891,12 @@ def test_merge_backup_from_future(self):
take FULL backup, table PAGE backup from future,
try to merge page with FULL
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2021,7 +1936,7 @@ def test_merge_backup_from_future(self):
'SELECT * from pgbench_accounts')
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -2052,9 +1967,6 @@ def test_merge_backup_from_future(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_merge_multiple_descendants(self):
"""
@@ -2067,12 +1979,11 @@ def test_merge_multiple_descendants(self):
FULLb |
FULLa
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2241,9 +2152,6 @@ def test_merge_multiple_descendants(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_smart_merge(self):
"""
@@ -2253,13 +2161,12 @@ def test_smart_merge(self):
copied during restore
https://github.com/postgrespro/pg_probackup/issues/63
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2301,18 +2208,14 @@ def test_smart_merge(self):
with open(logfile, 'r') as f:
logfile_content = f.read()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_idempotent_merge(self):
"""
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2378,18 +2281,15 @@ def test_idempotent_merge(self):
self.assertEqual(
page_id_2, self.show_pb(backup_dir, 'node')[0]['id'])
- self.del_test_dir(module_name, fname)
-
def test_merge_correct_inheritance(self):
"""
Make sure that backup metainformation fields
'note' and 'expire-time' are correctly inherited
during merge
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2432,18 +2332,15 @@ def test_merge_correct_inheritance(self):
page_meta['expire-time'],
self.show_pb(backup_dir, 'node', page_id)['expire-time'])
- self.del_test_dir(module_name, fname)
-
def test_merge_correct_inheritance_1(self):
"""
Make sure that backup metainformation fields
'note' and 'expire-time' are correctly inherited
during merge
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2481,8 +2378,6 @@ def test_merge_correct_inheritance_1(self):
'expire-time',
self.show_pb(backup_dir, 'node', page_id))
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_multi_timeline_merge(self):
@@ -2497,10 +2392,9 @@ def test_multi_timeline_merge(self):
P must have F as parent
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2568,7 +2462,7 @@ def test_multi_timeline_merge(self):
"postgres", "select * from pgbench_accounts")
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'node', node_restored)
@@ -2598,9 +2492,6 @@ def test_multi_timeline_merge(self):
'--amcheck',
'-d', 'postgres', '-p', str(node_restored.port)])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_merge_page_header_map_retry(self):
@@ -2610,10 +2501,9 @@ def test_merge_page_header_map_retry(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2649,19 +2539,15 @@ def test_merge_page_header_map_retry(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_missing_data_file(self):
"""
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2710,18 +2596,15 @@ def test_missing_data_file(self):
'ERROR: Cannot open backup file "{0}": No such file or directory'.format(file_to_remove),
logfile_content)
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_missing_non_data_file(self):
"""
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2769,18 +2652,15 @@ def test_missing_non_data_file(self):
self.assertEqual(
'MERGING', self.show_pb(backup_dir, 'node')[1]['status'])
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_merge_remote_mode(self):
"""
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2827,16 +2707,13 @@ def test_merge_remote_mode(self):
self.assertEqual(
'OK', self.show_pb(backup_dir, 'node')[0]['status'])
- self.del_test_dir(module_name, fname)
-
def test_merge_pg_filenode_map(self):
"""
https://github.com/postgrespro/pg_probackup/issues/320
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -2845,7 +2722,7 @@ def test_merge_pg_filenode_map(self):
node.slow_start()
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'),
initdb_params=['--data-checksums'])
node1.cleanup()
@@ -2878,8 +2755,5 @@ def test_merge_pg_filenode_map(self):
'postgres',
'select 1')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# 1. Need new test with corrupted FULL backup
# 2. different compression levels
diff --git a/tests/option.py b/tests/option.py
index 61c60a1dd..eec1bab44 100644
--- a/tests/option.py
+++ b/tests/option.py
@@ -4,9 +4,6 @@
import locale
-module_name = 'option'
-
-
class OptionTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
@@ -41,14 +38,12 @@ def test_without_backup_path_3(self):
e.message,
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(e.message), self.cmd))
-
# @unittest.skip("skip")
def test_options_4(self):
"""check options test"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node'))
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -112,16 +107,12 @@ def test_options_4(self):
e.message,
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_options_5(self):
"""check options test"""
- fname = self.id().split(".")[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node'))
output = self.init_pb(backup_dir)
self.assertIn(
@@ -225,9 +216,6 @@ def test_options_5(self):
e.message,
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_help_6(self):
"""help options"""
diff --git a/tests/page.py b/tests/page.py
index c1cba6b40..e77e5c827 100644
--- a/tests/page.py
+++ b/tests/page.py
@@ -7,9 +7,6 @@
import gzip
import shutil
-module_name = 'page'
-
-
class PageTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
@@ -20,17 +17,16 @@ def test_basic_page_vacuum_truncate(self):
take page backup, take second page backup,
restore last page backup and check data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
'checkpoint_timeout': '300s'})
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -98,9 +94,6 @@ def test_basic_page_vacuum_truncate(self):
self.assertEqual(result1, result2)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_vacuum_truncate_1(self):
"""
@@ -109,10 +102,9 @@ def test_page_vacuum_truncate_1(self):
take page backup, insert some data,
take second page backup and check data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -159,7 +151,7 @@ def test_page_vacuum_truncate_1(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'node', node_restored)
@@ -171,9 +163,6 @@ def test_page_vacuum_truncate_1(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_stream(self):
"""
@@ -181,10 +170,9 @@ def test_page_stream(self):
restore them and check data correctness
"""
self.maxDiff = None
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -258,9 +246,6 @@ def test_page_stream(self):
self.assertEqual(page_result, page_result_new)
node.cleanup()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_archive(self):
"""
@@ -268,10 +253,9 @@ def test_page_archive(self):
restore them and check data correctness
"""
self.maxDiff = None
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -352,19 +336,15 @@ def test_page_archive(self):
self.assertEqual(page_result, page_result_new)
node.cleanup()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_multiple_segments(self):
"""
Make node, create table with multiple segments,
write some data to it, check page and data correctness
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -399,7 +379,7 @@ def test_page_multiple_segments(self):
# RESTORE NODE
restored_node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'restored_node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'restored_node'))
restored_node.cleanup()
tblspc_path = self.get_tblspace_path(node, 'somedata')
tblspc_path_new = self.get_tblspace_path(
@@ -427,9 +407,6 @@ def test_page_multiple_segments(self):
if self.paranoia:
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_delete(self):
"""
@@ -437,10 +414,9 @@ def test_page_delete(self):
delete everything from table, vacuum table, take page backup,
restore page backup, compare .
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=['--data-checksums'],
pg_options={
'checkpoint_timeout': '30s',
@@ -477,7 +453,7 @@ def test_page_delete(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -499,9 +475,6 @@ def test_page_delete(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_delete_1(self):
"""
@@ -509,10 +482,9 @@ def test_page_delete_1(self):
delete everything from table, vacuum table, take page backup,
restore page backup, compare .
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -554,7 +526,7 @@ def test_page_delete_1(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored')
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored')
)
node_restored.cleanup()
@@ -577,26 +549,22 @@ def test_page_delete_1(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_parallel_pagemap(self):
"""
Test for parallel WAL segments reading, during which pagemap is built
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
# Initialize instance and backup directory
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
pg_options={
"hot_standby": "on"
}
)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'),
)
self.init_pb(backup_dir)
@@ -652,18 +620,16 @@ def test_parallel_pagemap(self):
# Clean after yourself
node.cleanup()
node_restored.cleanup()
- self.del_test_dir(module_name, fname)
def test_parallel_pagemap_1(self):
"""
Test for parallel WAL segments reading, during which pagemap is built
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
# Initialize instance and backup directory
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
pg_options={}
)
@@ -704,7 +670,6 @@ def test_parallel_pagemap_1(self):
# Clean after yourself
node.cleanup()
- self.del_test_dir(module_name, fname)
# @unittest.skip("skip")
def test_page_backup_with_lost_wal_segment(self):
@@ -715,12 +680,11 @@ def test_page_backup_with_lost_wal_segment(self):
run page backup, expecting error because of missing wal segment
make sure that backup status is 'ERROR'
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -785,9 +749,6 @@ def test_page_backup_with_lost_wal_segment(self):
self.show_pb(backup_dir, 'node')[2]['status'],
'Backup {0} should have STATUS "ERROR"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_backup_with_corrupted_wal_segment(self):
"""
@@ -797,12 +758,11 @@ def test_page_backup_with_corrupted_wal_segment(self):
run page backup, expecting error because of missing wal segment
make sure that backup status is 'ERROR'
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -896,9 +856,6 @@ def test_page_backup_with_corrupted_wal_segment(self):
self.show_pb(backup_dir, 'node')[2]['status'],
'Backup {0} should have STATUS "ERROR"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_backup_with_alien_wal_segment(self):
"""
@@ -910,18 +867,17 @@ def test_page_backup_with_alien_wal_segment(self):
expecting error because of alien wal segment
make sure that backup status is 'ERROR'
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
alien_node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'alien_node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'alien_node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1017,20 +973,16 @@ def test_page_backup_with_alien_wal_segment(self):
self.show_pb(backup_dir, 'node')[2]['status'],
'Backup {0} should have STATUS "ERROR"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_multithread_page_backup_with_toast(self):
"""
make node, create toast, do multithread PAGE backup
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1050,9 +1002,6 @@ def test_multithread_page_backup_with_toast(self):
backup_dir, 'node', node,
backup_type='page', options=["-j", "4"])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_page_create_db(self):
"""
@@ -1060,10 +1009,9 @@ def test_page_create_db(self):
restore database and check it presense
"""
self.maxDiff = None
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1101,7 +1049,7 @@ def test_page_create_db(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -1162,9 +1110,6 @@ def test_page_create_db(self):
repr(e.message), self.cmd)
)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_multi_timeline_page(self):
@@ -1179,10 +1124,9 @@ def test_multi_timeline_page(self):
P must have F as parent
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1251,7 +1195,7 @@ def test_multi_timeline_page(self):
"postgres", "select * from pgbench_accounts")
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'node', node_restored)
@@ -1303,9 +1247,6 @@ def test_multi_timeline_page(self):
backup_list[4]['id'])
self.assertEqual(backup_list[5]['current-tli'], 7)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_multitimeline_page_1(self):
@@ -1317,10 +1258,9 @@ def test_multitimeline_page_1(self):
P must have F as parent
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={'wal_log_hints': 'on'})
@@ -1373,7 +1313,7 @@ def test_multitimeline_page_1(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'node', node_restored)
@@ -1384,22 +1324,18 @@ def test_multitimeline_page_1(self):
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
# @unittest.expectedFailure
def test_page_pg_resetxlog(self):
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
'shared_buffers': '512MB',
'max_wal_size': '3GB'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1478,7 +1414,7 @@ def test_page_pg_resetxlog(self):
# pgdata = self.pgdata_content(node.data_dir)
#
# node_restored = self.make_simple_node(
-# base_dir=os.path.join(module_name, fname, 'node_restored'))
+# base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
# node_restored.cleanup()
#
# self.restore_node(
@@ -1486,6 +1422,3 @@ def test_page_pg_resetxlog(self):
#
# pgdata_restored = self.pgdata_content(node_restored.data_dir)
# self.compare_pgdata(pgdata, pgdata_restored)
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/pgpro2068.py b/tests/pgpro2068.py
index 3baa0ba0b..434ce2800 100644
--- a/tests/pgpro2068.py
+++ b/tests/pgpro2068.py
@@ -9,9 +9,6 @@
from testgres import ProcessType
-module_name = '2068'
-
-
class BugTest(ProbackupTest, unittest.TestCase):
def test_minrecpoint_on_replica(self):
@@ -20,9 +17,8 @@ def test_minrecpoint_on_replica(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -33,7 +29,7 @@ def test_minrecpoint_on_replica(self):
'bgwriter_lru_multiplier': '4.0',
'max_wal_size': '256MB'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -45,7 +41,7 @@ def test_minrecpoint_on_replica(self):
# start replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'node', replica, options=['-R'])
@@ -190,6 +186,3 @@ def test_minrecpoint_on_replica(self):
# do basebackup
# do pg_probackup, expect error
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/pgpro560.py b/tests/pgpro560.py
index 7e10fef6a..b665fd200 100644
--- a/tests/pgpro560.py
+++ b/tests/pgpro560.py
@@ -6,9 +6,6 @@
from time import sleep
-module_name = 'pgpro560'
-
-
class CheckSystemID(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
@@ -20,13 +17,12 @@ def test_pgpro560_control_file_loss(self):
make backup
check that backup failed
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -49,10 +45,8 @@ def test_pgpro560_control_file_loss(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
# Return this file to avoid Postger fail
os.rename(os.path.join(node.base_dir, 'data', 'global', 'pg_control_copy'), file)
- self.del_test_dir(module_name, fname)
def test_pgpro560_systemid_mismatch(self):
"""
@@ -61,21 +55,20 @@ def test_pgpro560_systemid_mismatch(self):
feed to backup PGDATA from node1 and PGPORT from node2
check that backup failed
"""
- fname = self.id().split('.')[3]
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'),
set_replication=True,
initdb_params=['--data-checksums'])
node1.slow_start()
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'),
set_replication=True,
initdb_params=['--data-checksums'])
node2.slow_start()
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node1', node1)
@@ -128,6 +121,3 @@ def test_pgpro560_systemid_mismatch(self):
e.message,
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/pgpro589.py b/tests/pgpro589.py
index d6381a8b5..8ce8e1f56 100644
--- a/tests/pgpro589.py
+++ b/tests/pgpro589.py
@@ -5,9 +5,6 @@
import subprocess
-module_name = 'pgpro589'
-
-
class ArchiveCheck(ProbackupTest, unittest.TestCase):
def test_pgpro589(self):
@@ -17,12 +14,11 @@ def test_pgpro589(self):
check that backup status equal to ERROR
check that no files where copied to backup catalogue
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -74,6 +70,3 @@ def test_pgpro589(self):
"\n Start LSN was not found in archive but datafiles where "
"copied to backup catalogue.\n For example: {0}\n "
"It is not optimal".format(file))
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/ptrack.py b/tests/ptrack.py
index c02aba17c..6e5786f8c 100644
--- a/tests/ptrack.py
+++ b/tests/ptrack.py
@@ -10,9 +10,6 @@
from threading import Thread
-module_name = 'ptrack'
-
-
class PtrackTest(ProbackupTest, unittest.TestCase):
def setUp(self):
if self.pg_config_version < self.version_to_num('11.0'):
@@ -26,9 +23,9 @@ def test_drop_rel_during_backup_ptrack(self):
"""
self._check_gdb_flag_or_skip_test()
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
@@ -85,18 +82,15 @@ def test_drop_rel_during_backup_ptrack(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_without_full(self):
"""ptrack backup without validated full backup"""
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
ptrack_enable=True)
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -125,18 +119,15 @@ def test_ptrack_without_full(self):
self.show_pb(backup_dir, 'node')[0]['status'],
"ERROR")
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_threads(self):
"""ptrack multi thread backup mode"""
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
ptrack_enable=True)
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -156,9 +147,6 @@ def test_ptrack_threads(self):
backup_type="ptrack", options=["-j", "4"])
self.assertEqual(self.show_pb(backup_dir, 'node')[0]['status'], "OK")
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_stop_pg(self):
"""
@@ -166,9 +154,9 @@ def test_ptrack_stop_pg(self):
restart node, check that ptrack backup
can be taken
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -193,18 +181,15 @@ def test_ptrack_stop_pg(self):
backup_dir, 'node', node,
backup_type='ptrack', options=['--stream'])
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_multi_timeline_backup(self):
"""
t2 /------P2
t1 ------F---*-----P1
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -269,9 +254,6 @@ def test_ptrack_multi_timeline_backup(self):
self.assertEqual('0', balance)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_multi_timeline_backup_1(self):
"""
@@ -282,9 +264,9 @@ def test_ptrack_multi_timeline_backup_1(self):
t2 /------P2
t1 ---F--------*
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -343,17 +325,14 @@ def test_ptrack_multi_timeline_backup_1(self):
self.assertEqual('0', balance)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_eat_my_data(self):
"""
PGPRO-4051
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -372,7 +351,7 @@ def test_ptrack_eat_my_data(self):
self.backup_node(backup_dir, 'node', node)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
pgbench = node.pgbench(options=['-T', '300', '-c', '1', '--no-vacuum'])
@@ -422,16 +401,13 @@ def test_ptrack_eat_my_data(self):
'SELECT * FROM pgbench_accounts'),
'Data loss')
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_simple(self):
"""make node, make full and ptrack stream backups,"
" restore them and check data correctness"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -469,7 +445,7 @@ def test_ptrack_simple(self):
result = node.safe_psql("postgres", "SELECT * FROM t_heap")
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -491,15 +467,12 @@ def test_ptrack_simple(self):
result,
node_restored.safe_psql("postgres", "SELECT * FROM t_heap"))
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_unprivileged(self):
""""""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -690,9 +663,9 @@ def test_ptrack_unprivileged(self):
# @unittest.expectedFailure
def test_ptrack_enable(self):
"""make ptrack without full backup, should result in error"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True, initdb_params=['--data-checksums'],
pg_options={
'checkpoint_timeout': '30s',
@@ -728,9 +701,6 @@ def test_ptrack_enable(self):
' CMD: {1}'.format(repr(e.message), self.cmd)
)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_disable(self):
@@ -739,9 +709,9 @@ def test_ptrack_disable(self):
enable ptrack, restart postgresql, take ptrack backup
which should fail
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -793,15 +763,12 @@ def test_ptrack_disable(self):
)
)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_uncommitted_xact(self):
"""make ptrack backup while there is uncommitted open transaction"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -831,7 +798,7 @@ def test_ptrack_uncommitted_xact(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -851,18 +818,15 @@ def test_ptrack_uncommitted_xact(self):
if self.paranoia:
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_vacuum_full(self):
"""make node, make full and ptrack stream backups,
restore them and check data correctness"""
self._check_gdb_flag_or_skip_test()
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -915,7 +879,7 @@ def test_ptrack_vacuum_full(self):
process.join()
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
old_tablespace = self.get_tblspace_path(node, 'somedata')
@@ -938,18 +902,15 @@ def test_ptrack_vacuum_full(self):
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_vacuum_truncate(self):
"""make node, create table, take full backup,
delete last 3 pages, vacuum relation,
take ptrack backup, take second ptrack backup,
restore last ptrack backup and check data correctness"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -996,7 +957,7 @@ def test_ptrack_vacuum_truncate(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
old_tablespace = self.get_tblspace_path(node, 'somedata')
@@ -1021,9 +982,6 @@ def test_ptrack_vacuum_truncate(self):
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_get_block(self):
"""
@@ -1032,9 +990,9 @@ def test_ptrack_get_block(self):
"""
self._check_gdb_flag_or_skip_test()
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -1090,16 +1048,13 @@ def test_ptrack_get_block(self):
result,
node.safe_psql("postgres", "SELECT * FROM t_heap"))
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_stream(self):
"""make node, make full and ptrack stream backups,
restore them and check data correctness"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -1178,16 +1133,13 @@ def test_ptrack_stream(self):
ptrack_result_new = node.safe_psql("postgres", "SELECT * FROM t_heap")
self.assertEqual(ptrack_result, ptrack_result_new)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_archive(self):
"""make archive node, make full and ptrack backups,
check data correctness in restored instance"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -1288,9 +1240,6 @@ def test_ptrack_archive(self):
node.cleanup()
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
@unittest.skip("skip")
def test_ptrack_pgpro417(self):
"""
@@ -1298,9 +1247,9 @@ def test_ptrack_pgpro417(self):
delete ptrack backup. Try to take ptrack backup,
which should fail. Actual only for PTRACK 1.x
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -1366,9 +1315,6 @@ def test_ptrack_pgpro417(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
@unittest.skip("skip")
def test_page_pgpro417(self):
"""
@@ -1376,9 +1322,9 @@ def test_page_pgpro417(self):
delete page backup. Try to take ptrack backup, which should fail.
Actual only for PTRACK 1.x
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -1432,9 +1378,6 @@ def test_page_pgpro417(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
@unittest.skip("skip")
def test_full_pgpro417(self):
"""
@@ -1442,9 +1385,9 @@ def test_full_pgpro417(self):
Try to take ptrack backup, which should fail.
Relevant only for PTRACK 1.x
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -1504,18 +1447,15 @@ def test_full_pgpro417(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_create_db(self):
"""
Make node, take full backup, create database db1, take ptrack backup,
restore database and check it presense
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -1558,7 +1498,7 @@ def test_create_db(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -1619,9 +1559,6 @@ def test_create_db(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_create_db_on_replica(self):
"""
@@ -1630,9 +1567,9 @@ def test_create_db_on_replica(self):
create database db1, take ptrack backup from replica,
restore database and check it presense
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -1654,7 +1591,7 @@ def test_create_db_on_replica(self):
"md5(i::text)::tsvector as tsvector from generate_series(0,100) i")
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.backup_node(
@@ -1707,7 +1644,7 @@ def test_create_db_on_replica(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -1720,16 +1657,13 @@ def test_create_db_on_replica(self):
node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_alter_table_set_tablespace_ptrack(self):
"""Make node, create tablespace with table, take full backup,
alter tablespace location, take ptrack backup, restore database."""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -1776,7 +1710,7 @@ def test_alter_table_set_tablespace_ptrack(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -1810,17 +1744,14 @@ def test_alter_table_set_tablespace_ptrack(self):
#
# self.assertEqual(result, result_new, 'lost some data after restore')
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_alter_database_set_tablespace_ptrack(self):
"""Make node, create tablespace with database,"
" take full backup, alter tablespace location,"
" take ptrack backup, restore database."""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -1857,7 +1788,7 @@ def test_alter_database_set_tablespace_ptrack(self):
# RESTORE
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
backup_dir, 'node',
@@ -1878,18 +1809,15 @@ def test_alter_database_set_tablespace_ptrack(self):
node_restored.port = node.port
node_restored.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_drop_tablespace(self):
"""
Make node, create table, alter table tablespace, take ptrack backup,
move table from tablespace, take ptrack backup
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -1972,18 +1900,15 @@ def test_drop_tablespace(self):
if self.paranoia:
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_alter_tablespace(self):
"""
Make node, create table, alter table tablespace, take ptrack backup,
move table from tablespace, take ptrack backup
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -2029,7 +1954,7 @@ def test_ptrack_alter_tablespace(self):
# Restore ptrack backup
restored_node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'restored_node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'restored_node'))
restored_node.cleanup()
tblspc_path_new = self.get_tblspace_path(
restored_node, 'somedata_restored')
@@ -2087,18 +2012,15 @@ def test_ptrack_alter_tablespace(self):
"postgres", "select * from t_heap")
self.assertEqual(result, result_new)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_multiple_segments(self):
"""
Make node, create table, alter table tablespace,
take ptrack backup, move table from tablespace, take ptrack backup
"""
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -2163,7 +2085,7 @@ def test_ptrack_multiple_segments(self):
# RESTORE NODE
restored_node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'restored_node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'restored_node'))
restored_node.cleanup()
tblspc_path = self.get_tblspace_path(node, 'somedata')
tblspc_path_new = self.get_tblspace_path(
@@ -2196,9 +2118,6 @@ def test_ptrack_multiple_segments(self):
if self.paranoia:
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
@unittest.skip("skip")
def test_atexit_fail(self):
"""
@@ -2206,14 +2125,14 @@ def test_atexit_fail(self):
Relevant only for PTRACK 1.x
"""
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
pg_options={
'max_connections': '15'})
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -2248,9 +2167,6 @@ def test_atexit_fail(self):
"select * from pg_is_in_backup()").rstrip(),
"f")
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
@unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_clean(self):
@@ -2259,12 +2175,12 @@ def test_ptrack_clean(self):
Relevant only for PTRACK 1.x
"""
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -2356,9 +2272,6 @@ def test_ptrack_clean(self):
# check that ptrack bits are cleaned
self.check_ptrack_clean(idx_ptrack[i], idx_ptrack[i]['size'])
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
@unittest.skip("skip")
def test_ptrack_clean_replica(self):
"""
@@ -2367,14 +2280,14 @@ def test_ptrack_clean_replica(self):
Relevant only for PTRACK 1.x
"""
master = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
pg_options={
'archive_timeout': '30s'})
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'master', master)
master.slow_start()
@@ -2382,7 +2295,7 @@ def test_ptrack_clean_replica(self):
self.backup_node(backup_dir, 'master', master, options=['--stream'])
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -2494,18 +2407,16 @@ def test_ptrack_clean_replica(self):
# check that ptrack bits are cleaned
self.check_ptrack_clean(idx_ptrack[i], idx_ptrack[i]['size'])
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_cluster_on_btree(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -2557,18 +2468,15 @@ def test_ptrack_cluster_on_btree(self):
if node.major_version < 11:
self.check_ptrack_map_sanity(node, idx_ptrack)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_cluster_on_gist(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -2628,18 +2536,15 @@ def test_ptrack_cluster_on_gist(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_cluster_on_btree_replica(self):
master = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'master', master)
master.slow_start()
@@ -2652,7 +2557,7 @@ def test_ptrack_cluster_on_btree_replica(self):
self.backup_node(backup_dir, 'master', master, options=['--stream'])
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -2716,7 +2621,7 @@ def test_ptrack_cluster_on_btree_replica(self):
pgdata = self.pgdata_content(replica.data_dir)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node'))
node.cleanup()
self.restore_node(backup_dir, 'replica', node)
@@ -2724,17 +2629,14 @@ def test_ptrack_cluster_on_btree_replica(self):
pgdata_restored = self.pgdata_content(replica.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_cluster_on_gist_replica(self):
master = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
ptrack_enable=True)
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'master', master)
master.slow_start()
@@ -2747,7 +2649,7 @@ def test_ptrack_cluster_on_gist_replica(self):
self.backup_node(backup_dir, 'master', master, options=['--stream'])
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -2817,7 +2719,7 @@ def test_ptrack_cluster_on_gist_replica(self):
pgdata = self.pgdata_content(replica.data_dir)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node'))
node.cleanup()
self.restore_node(backup_dir, 'replica', node)
@@ -2826,20 +2728,17 @@ def test_ptrack_cluster_on_gist_replica(self):
pgdata_restored = self.pgdata_content(replica.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_empty(self):
"""Take backups of every available types and check that PTRACK is clean"""
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -2877,7 +2776,7 @@ def test_ptrack_empty(self):
node.safe_psql('postgres', 'checkpoint')
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
tblspace1 = self.get_tblspace_path(node, 'somedata')
@@ -2902,9 +2801,6 @@ def test_ptrack_empty(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_empty_replica(self):
@@ -2913,12 +2809,12 @@ def test_ptrack_empty_replica(self):
and check that PTRACK on replica is clean
"""
master = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
ptrack_enable=True)
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'master', master)
master.slow_start()
@@ -2931,7 +2827,7 @@ def test_ptrack_empty_replica(self):
self.backup_node(backup_dir, 'master', master, options=['--stream'])
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -2987,7 +2883,7 @@ def test_ptrack_empty_replica(self):
pgdata = self.pgdata_content(replica.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -2998,19 +2894,16 @@ def test_ptrack_empty_replica(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_truncate(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -3079,13 +2972,10 @@ def test_ptrack_truncate(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_basic_ptrack_truncate_replica(self):
master = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -3094,7 +2984,7 @@ def test_basic_ptrack_truncate_replica(self):
'archive_timeout': '10s',
'checkpoint_timeout': '5min'})
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'master', master)
master.slow_start()
@@ -3107,7 +2997,7 @@ def test_basic_ptrack_truncate_replica(self):
self.backup_node(backup_dir, 'master', master, options=['--stream'])
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -3189,7 +3079,7 @@ def test_basic_ptrack_truncate_replica(self):
pgdata = self.pgdata_content(replica.data_dir)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node'))
node.cleanup()
self.restore_node(backup_dir, 'replica', node, data_dir=node.data_dir)
@@ -3207,19 +3097,16 @@ def test_basic_ptrack_truncate_replica(self):
'postgres',
'select 1')
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_vacuum(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -3295,20 +3182,17 @@ def test_ptrack_vacuum(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored, comparision_exclusion)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_vacuum_replica(self):
master = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
pg_options={
'checkpoint_timeout': '30'})
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'master', master)
master.slow_start()
@@ -3321,7 +3205,7 @@ def test_ptrack_vacuum_replica(self):
self.backup_node(backup_dir, 'master', master, options=['--stream'])
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -3394,7 +3278,7 @@ def test_ptrack_vacuum_replica(self):
pgdata = self.pgdata_content(replica.data_dir)
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node'))
node.cleanup()
self.restore_node(backup_dir, 'replica', node, data_dir=node.data_dir)
@@ -3402,19 +3286,16 @@ def test_ptrack_vacuum_replica(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_vacuum_bits_frozen(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -3481,18 +3362,15 @@ def test_ptrack_vacuum_bits_frozen(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored, comparision_exclusion)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_ptrack_vacuum_bits_frozen_replica(self):
master = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'master', master)
master.slow_start()
@@ -3505,7 +3383,7 @@ def test_ptrack_vacuum_bits_frozen_replica(self):
self.backup_node(backup_dir, 'master', master, options=['--stream'])
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -3579,19 +3457,16 @@ def test_ptrack_vacuum_bits_frozen_replica(self):
pgdata_restored = self.pgdata_content(replica.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_vacuum_bits_visibility(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -3658,19 +3533,16 @@ def test_ptrack_vacuum_bits_visibility(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored, comparision_exclusion)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_vacuum_full_2(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
pg_options={ 'wal_log_hints': 'on' })
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -3736,19 +3608,16 @@ def test_ptrack_vacuum_full_2(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_vacuum_full_replica(self):
master = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'master', master)
master.slow_start()
@@ -3760,7 +3629,7 @@ def test_ptrack_vacuum_full_replica(self):
self.backup_node(backup_dir, 'master', master, options=['--stream'])
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -3837,19 +3706,16 @@ def test_ptrack_vacuum_full_replica(self):
pgdata_restored = self.pgdata_content(replica.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_vacuum_truncate_2(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -3905,7 +3771,7 @@ def test_ptrack_vacuum_truncate_2(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'node', node_restored)
@@ -3913,19 +3779,16 @@ def test_ptrack_vacuum_truncate_2(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_vacuum_truncate_replica(self):
master = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'master', master)
master.slow_start()
@@ -3938,7 +3801,7 @@ def test_ptrack_vacuum_truncate_replica(self):
self.backup_node(backup_dir, 'master', master, options=['--stream'])
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -4010,7 +3873,7 @@ def test_ptrack_vacuum_truncate_replica(self):
pgdata = self.pgdata_content(replica.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'replica', node_restored)
@@ -4018,9 +3881,6 @@ def test_ptrack_vacuum_truncate_replica(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
@unittest.skip("skip")
def test_ptrack_recovery(self):
"""
@@ -4028,12 +3888,12 @@ def test_ptrack_recovery(self):
Actual only for PTRACK 1.x
"""
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -4079,14 +3939,11 @@ def test_ptrack_recovery(self):
# check that ptrack has correct bits after recovery
self.check_ptrack_recovery(idx_ptrack[i])
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_recovery_1(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -4094,7 +3951,7 @@ def test_ptrack_recovery_1(self):
'shared_buffers': '512MB',
'max_wal_size': '3GB'})
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -4155,7 +4012,7 @@ def test_ptrack_recovery_1(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -4164,19 +4021,16 @@ def test_ptrack_recovery_1(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_zero_changes(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -4208,14 +4062,11 @@ def test_ptrack_zero_changes(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_ptrack_pg_resetxlog(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'],
@@ -4223,7 +4074,7 @@ def test_ptrack_pg_resetxlog(self):
'shared_buffers': '512MB',
'max_wal_size': '3GB'})
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -4322,7 +4173,7 @@ def test_ptrack_pg_resetxlog(self):
# pgdata = self.pgdata_content(node.data_dir)
#
# node_restored = self.make_simple_node(
-# base_dir=os.path.join(module_name, self.fname, 'node_restored'))
+# base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
# node_restored.cleanup()
#
# self.restore_node(
@@ -4331,19 +4182,16 @@ def test_ptrack_pg_resetxlog(self):
# pgdata_restored = self.pgdata_content(node_restored.data_dir)
# self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_corrupt_ptrack_map(self):
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -4495,9 +4343,6 @@ def test_corrupt_ptrack_map(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
-
# @unittest.skip("skip")
def test_horizon_lsn_ptrack(self):
"""
@@ -4511,9 +4356,9 @@ def test_horizon_lsn_ptrack(self):
self.version_to_num('2.4.15'),
'You need pg_probackup old_binary =< 2.4.15 for this test')
- backup_dir = os.path.join(self.tmp_path, module_name, self.fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, self.fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -4560,6 +4405,3 @@ def test_horizon_lsn_ptrack(self):
# make sure that backup size is exactly the same
self.assertEqual(delta_bytes, ptrack_bytes)
-
- # Clean after yourself
- self.del_test_dir(module_name, self.fname)
diff --git a/tests/remote.py b/tests/remote.py
index 4d46447f0..2d36d7346 100644
--- a/tests/remote.py
+++ b/tests/remote.py
@@ -5,21 +5,17 @@
from .helpers.cfs_helpers import find_by_name
-module_name = 'remote'
-
-
class RemoteTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_remote_sanity(self):
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -45,6 +41,3 @@ def test_remote_sanity(self):
# e.message,
# "\n Unexpected Error Message: {0}\n CMD: {1}".format(
# repr(e.message), self.cmd))
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/replica.py b/tests/replica.py
index d5c24fbc1..9c68de366 100644
--- a/tests/replica.py
+++ b/tests/replica.py
@@ -9,8 +9,6 @@
from time import sleep
-module_name = 'replica'
-
class ReplicaTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
@@ -21,15 +19,13 @@ def test_replica_switchover(self):
over the course of several switchovers
https://www.postgresql.org/message-id/54b059d4-2b48-13a4-6f43-95a087c92367%40postgrespro.ru
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'),
set_replication=True,
initdb_params=['--data-checksums'])
if self.get_version(node1) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -41,7 +37,7 @@ def test_replica_switchover(self):
# take full backup and restore it
self.backup_node(backup_dir, 'node1', node1, options=['--stream'])
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'))
node2.cleanup()
# create replica
@@ -92,9 +88,6 @@ def test_replica_switchover(self):
# https://github.com/postgrespro/pg_probackup/issues/251
self.validate_pb(backup_dir)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_replica_stream_ptrack_backup(self):
@@ -109,10 +102,9 @@ def test_replica_stream_ptrack_backup(self):
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
@@ -138,7 +130,7 @@ def test_replica_stream_ptrack_backup(self):
# take full backup and restore it
self.backup_node(backup_dir, 'master', master, options=['--stream'])
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
self.set_replica(master, replica)
@@ -172,7 +164,7 @@ def test_replica_stream_ptrack_backup(self):
# RESTORE FULL BACKUP TAKEN FROM PREVIOUS STEP
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node'))
node.cleanup()
self.restore_node(backup_dir, 'replica', data_dir=node.data_dir)
@@ -219,19 +211,15 @@ def test_replica_stream_ptrack_backup(self):
after = node.safe_psql("postgres", "SELECT * FROM t_heap")
self.assertEqual(before, after)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_replica_archive_page_backup(self):
"""
make archive master, take full and page archive backups from master,
set replica, make archive backup from replica
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -240,7 +228,6 @@ def test_replica_archive_page_backup(self):
'max_wal_size': '32MB'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -250,7 +237,7 @@ def test_replica_archive_page_backup(self):
master.slow_start()
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.backup_node(backup_dir, 'master', master)
@@ -305,7 +292,7 @@ def test_replica_archive_page_backup(self):
# RESTORE FULL BACKUP TAKEN FROM replica
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node'))
node.cleanup()
self.restore_node(backup_dir, 'replica', data_dir=node.data_dir)
@@ -363,26 +350,21 @@ def test_replica_archive_page_backup(self):
self.backup_node(
backup_dir, 'node', node, options=['--stream'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_make_replica_via_restore(self):
"""
make archive master, take full and page archive backups from master,
set replica, make archive backup from replica
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
'archive_timeout': '10s'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -392,7 +374,7 @@ def test_basic_make_replica_via_restore(self):
master.slow_start()
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.backup_node(backup_dir, 'master', master)
@@ -421,9 +403,6 @@ def test_basic_make_replica_via_restore(self):
backup_dir, 'replica', replica,
options=['--archive-timeout=30s', '--stream'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_take_backup_from_delayed_replica(self):
"""
@@ -431,16 +410,14 @@ def test_take_backup_from_delayed_replica(self):
restore full backup as delayed replica, launch pgbench,
take FULL, PAGE and DELTA backups from replica
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={'archive_timeout': '10s'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -450,7 +427,7 @@ def test_take_backup_from_delayed_replica(self):
master.slow_start()
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.backup_node(backup_dir, 'master', master)
@@ -530,9 +507,6 @@ def test_take_backup_from_delayed_replica(self):
pgbench.wait()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_replica_promote(self):
"""
@@ -541,10 +515,9 @@ def test_replica_promote(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -553,7 +526,6 @@ def test_replica_promote(self):
'max_wal_size': '32MB'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -563,7 +535,7 @@ def test_replica_promote(self):
master.slow_start()
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.backup_node(backup_dir, 'master', master)
@@ -624,19 +596,15 @@ def test_replica_promote(self):
'setting its status to ERROR'.format(backup_id),
log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_replica_stop_lsn_null_offset(self):
"""
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -644,7 +612,6 @@ def test_replica_stop_lsn_null_offset(self):
'wal_level': 'replica'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -661,7 +628,7 @@ def test_replica_stop_lsn_null_offset(self):
# Create replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'node', replica)
@@ -710,7 +677,6 @@ def test_replica_stop_lsn_null_offset(self):
# Clean after yourself
gdb_checkpointer.kill()
- self.del_test_dir(module_name, fname)
# @unittest.skip("skip")
def test_replica_stop_lsn_null_offset_next_record(self):
@@ -718,10 +684,9 @@ def test_replica_stop_lsn_null_offset_next_record(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -729,7 +694,6 @@ def test_replica_stop_lsn_null_offset_next_record(self):
'wal_level': 'replica'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -745,7 +709,7 @@ def test_replica_stop_lsn_null_offset_next_record(self):
# Create replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -812,19 +776,15 @@ def test_replica_stop_lsn_null_offset_next_record(self):
self.assertTrue(self.show_pb(backup_dir, 'replica')[0]['status'] == 'DONE')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_archive_replica_null_offset(self):
"""
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -832,7 +792,6 @@ def test_archive_replica_null_offset(self):
'wal_level': 'replica'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -845,7 +804,7 @@ def test_archive_replica_null_offset(self):
# Create replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'node', replica)
@@ -898,17 +857,13 @@ def test_archive_replica_null_offset(self):
print(output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_archive_replica_not_null_offset(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -916,7 +871,6 @@ def test_archive_replica_not_null_offset(self):
'wal_level': 'replica'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -929,7 +883,7 @@ def test_archive_replica_not_null_offset(self):
# Create replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'node', replica)
@@ -982,9 +936,6 @@ def test_archive_replica_not_null_offset(self):
"\n Unexpected Error Message: {0}\n CMD: {1}".format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_replica_toast(self):
"""
@@ -993,10 +944,9 @@ def test_replica_toast(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1005,7 +955,6 @@ def test_replica_toast(self):
'shared_buffers': '128MB'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -1022,7 +971,7 @@ def test_replica_toast(self):
# Create replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -1088,17 +1037,15 @@ def test_replica_toast(self):
# Clean after yourself
gdb_checkpointer.kill()
- self.del_test_dir(module_name, fname)
# @unittest.skip("skip")
def test_start_stop_lsn_in_the_same_segno(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1107,7 +1054,6 @@ def test_start_stop_lsn_in_the_same_segno(self):
'shared_buffers': '128MB'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -1122,7 +1068,7 @@ def test_start_stop_lsn_in_the_same_segno(self):
# Create replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -1167,17 +1113,13 @@ def test_start_stop_lsn_in_the_same_segno(self):
'--stream'],
return_id=False)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
def test_replica_promote_1(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1185,7 +1127,6 @@ def test_replica_promote_1(self):
'wal_level': 'replica'})
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -1199,7 +1140,7 @@ def test_replica_promote_1(self):
# Create replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -1242,17 +1183,13 @@ def test_replica_promote_1(self):
os.path.exists(wal_file_partial),
"File {0} disappeared".format(wal_file_partial))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_replica_promote_2(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1267,7 +1204,7 @@ def test_replica_promote_2(self):
# Create replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -1291,9 +1228,6 @@ def test_replica_promote_2(self):
backup_dir, 'master', replica, data_dir=replica.data_dir,
backup_type='page')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_replica_promote_archive_delta(self):
"""
@@ -1301,10 +1235,9 @@ def test_replica_promote_archive_delta(self):
t2 /------->
t1 --F---D1--D2--
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1312,7 +1245,6 @@ def test_replica_promote_archive_delta(self):
'archive_timeout': '30s'})
if self.get_version(node1) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -1328,7 +1260,7 @@ def test_replica_promote_archive_delta(self):
# Create replica
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'))
node2.cleanup()
self.restore_node(backup_dir, 'node', node2, node2.data_dir)
@@ -1416,9 +1348,6 @@ def test_replica_promote_archive_delta(self):
pgdata_restored = self.pgdata_content(node1.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_replica_promote_archive_page(self):
"""
@@ -1426,10 +1355,9 @@ def test_replica_promote_archive_page(self):
t2 /------->
t1 --F---P1--P2--
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1437,7 +1365,6 @@ def test_replica_promote_archive_page(self):
'archive_timeout': '30s'})
if self.get_version(node1) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -1453,7 +1380,7 @@ def test_replica_promote_archive_page(self):
# Create replica
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'))
node2.cleanup()
self.restore_node(backup_dir, 'node', node2, node2.data_dir)
@@ -1544,22 +1471,17 @@ def test_replica_promote_archive_page(self):
pgdata_restored = self.pgdata_content(node1.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_parent_choosing(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
master = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'master'),
+ base_dir=os.path.join(self.module_name, self.fname, 'master'),
set_replication=True,
initdb_params=['--data-checksums'])
if self.get_version(master) < self.version_to_num('9.6.0'):
- self.del_test_dir(module_name, fname)
self.skipTest(
'Skipped because backup from replica is not supported in PG 9.5')
@@ -1572,7 +1494,7 @@ def test_parent_choosing(self):
# Create replica
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
self.restore_node(backup_dir, 'master', replica)
@@ -1614,17 +1536,13 @@ def test_parent_choosing(self):
backup_dir, 'replica', replica,
backup_type='delta', options=['--stream'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_instance_from_the_past(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1661,17 +1579,13 @@ def test_instance_from_the_past(self):
"\n Unexpected Error Message: {0}\n CMD: {1}".format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_replica_via_basebackup(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={'hot_standby': 'on'})
@@ -1721,7 +1635,7 @@ def test_replica_via_basebackup(self):
node.slow_start()
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
pg_basebackup_path = self.get_bin_path('pg_basebackup')
@@ -1735,9 +1649,6 @@ def test_replica_via_basebackup(self):
self.set_auto_conf(node_restored, {'port': node_restored.port})
node_restored.slow_start(replica=True)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# TODO:
# null offset STOP LSN and latest record in previous segment is conrecord (manual only)
# archiving from promoted delayed replica
diff --git a/tests/restore.py b/tests/restore.py
index e99f1158e..2de3ecc0f 100644
--- a/tests/restore.py
+++ b/tests/restore.py
@@ -13,21 +13,17 @@
from stat import S_ISDIR
-module_name = 'restore'
-
-
class RestoreTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_restore_full_to_latest(self):
"""recovery to latest from full backup"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -67,18 +63,14 @@ def test_restore_full_to_latest(self):
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
self.assertEqual(before, after)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_full_page_to_latest(self):
"""recovery to latest from full + page backups"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -113,18 +105,14 @@ def test_restore_full_page_to_latest(self):
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
self.assertEqual(before, after)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_to_specific_timeline(self):
"""recovery to target timeline"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -179,19 +167,15 @@ def test_restore_to_specific_timeline(self):
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
self.assertEqual(before, after)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_to_time(self):
"""recovery to target time"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
pg_options={'TimeZone': 'GMT'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -229,18 +213,14 @@ def test_restore_to_time(self):
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
self.assertEqual(before, after)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_to_xid_inclusive(self):
"""recovery to target xid"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -289,18 +269,14 @@ def test_restore_to_xid_inclusive(self):
self.assertEqual(
len(node.execute("postgres", "SELECT * FROM tbl0005")), 1)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_to_xid_not_inclusive(self):
"""recovery with target inclusive false"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -350,22 +326,17 @@ def test_restore_to_xid_not_inclusive(self):
self.assertEqual(
len(node.execute("postgres", "SELECT * FROM tbl0005")), 0)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_to_lsn_inclusive(self):
"""recovery to target lsn"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
if self.get_version(node) < self.version_to_num('10.0'):
- self.del_test_dir(module_name, fname)
return
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -421,22 +392,17 @@ def test_restore_to_lsn_inclusive(self):
self.assertEqual(
len(node.execute("postgres", "SELECT * FROM tbl0005")), 2)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_to_lsn_not_inclusive(self):
"""recovery to target lsn"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
if self.get_version(node) < self.version_to_num('10.0'):
- self.del_test_dir(module_name, fname)
return
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -493,22 +459,18 @@ def test_restore_to_lsn_not_inclusive(self):
self.assertEqual(
len(node.execute("postgres", "SELECT * FROM tbl0005")), 1)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_full_ptrack_archive(self):
"""recovery to latest from archive full+ptrack backups"""
if not self.ptrack:
self.skipTest('Skipped because ptrack support is disabled')
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
ptrack_enable=True)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -547,22 +509,18 @@ def test_restore_full_ptrack_archive(self):
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
self.assertEqual(before, after)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_ptrack(self):
"""recovery to latest from archive full+ptrack+ptrack backups"""
if not self.ptrack:
self.skipTest('Skipped because ptrack support is disabled')
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
ptrack_enable=True)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -608,23 +566,19 @@ def test_restore_ptrack(self):
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
self.assertEqual(before, after)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_full_ptrack_stream(self):
"""recovery in stream mode to latest from full + ptrack backups"""
if not self.ptrack:
self.skipTest('Skipped because ptrack support is disabled')
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -663,9 +617,6 @@ def test_restore_full_ptrack_stream(self):
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
self.assertEqual(before, after)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_full_ptrack_under_load(self):
"""
@@ -675,14 +626,13 @@ def test_restore_full_ptrack_under_load(self):
if not self.ptrack:
self.skipTest('Skipped because ptrack support is disabled')
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -732,9 +682,6 @@ def test_restore_full_ptrack_under_load(self):
"postgres", "SELECT sum(delta) FROM pgbench_history")
self.assertEqual(bbalance, delta)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_full_under_load_ptrack(self):
"""
@@ -744,14 +691,13 @@ def test_restore_full_under_load_ptrack(self):
if not self.ptrack:
self.skipTest('Skipped because ptrack support is disabled')
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -803,18 +749,14 @@ def test_restore_full_under_load_ptrack(self):
"postgres", "SELECT sum(delta) FROM pgbench_history")
self.assertEqual(bbalance, delta)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_with_tablespace_mapping_1(self):
"""recovery using tablespace-mapping option"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -940,18 +882,14 @@ def test_restore_with_tablespace_mapping_1(self):
result = node.execute("postgres", "SELECT id FROM test OFFSET 1")
self.assertEqual(result[0][0], 2)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_with_tablespace_mapping_2(self):
"""recovery using tablespace-mapping option and page backup"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1017,18 +955,14 @@ def test_restore_with_tablespace_mapping_2(self):
count = node.execute("postgres", "SELECT count(*) FROM tbl1")
self.assertEqual(count[0][0], 4)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_with_missing_or_corrupted_tablespace_map(self):
"""restore backup with missing or corrupted tablespace_map"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1051,7 +985,7 @@ def test_restore_with_missing_or_corrupted_tablespace_map(self):
pgdata = self.pgdata_content(node.data_dir)
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'))
node2.cleanup()
olddir = self.get_tblspace_path(node, 'tblspace')
@@ -1147,22 +1081,18 @@ def test_restore_with_missing_or_corrupted_tablespace_map(self):
pgdata_restored = self.pgdata_content(node2.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_archive_node_backup_stream_restore_to_recovery_time(self):
"""
make node with archiving, make stream backup,
make PITR to Recovery Time
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1195,9 +1125,6 @@ def test_archive_node_backup_stream_restore_to_recovery_time(self):
result = node.psql("postgres", 'select * from t_heap')
self.assertTrue('does not exist' in result[2].decode("utf-8"))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_archive_node_backup_stream_restore_to_recovery_time(self):
@@ -1205,13 +1132,12 @@ def test_archive_node_backup_stream_restore_to_recovery_time(self):
make node with archiving, make stream backup,
make PITR to Recovery Time
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1242,9 +1168,6 @@ def test_archive_node_backup_stream_restore_to_recovery_time(self):
result = node.psql("postgres", 'select * from t_heap')
self.assertTrue('does not exist' in result[2].decode("utf-8"))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_archive_node_backup_stream_pitr(self):
@@ -1253,13 +1176,12 @@ def test_archive_node_backup_stream_pitr(self):
create table t_heap, make pitr to Recovery Time,
check that t_heap do not exists
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1290,9 +1212,6 @@ def test_archive_node_backup_stream_pitr(self):
result = node.psql("postgres", 'select * from t_heap')
self.assertEqual(True, 'does not exist' in result[2].decode("utf-8"))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_archive_node_backup_archive_pitr_2(self):
@@ -1301,12 +1220,11 @@ def test_archive_node_backup_archive_pitr_2(self):
create table t_heap, make pitr to Recovery Time,
check that t_heap do not exists
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1320,7 +1238,7 @@ def test_archive_node_backup_archive_pitr_2(self):
node.stop()
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
recovery_time = self.show_pb(
@@ -1348,9 +1266,6 @@ def test_archive_node_backup_archive_pitr_2(self):
result = node_restored.psql("postgres", 'select * from t_heap')
self.assertTrue('does not exist' in result[2].decode("utf-8"))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_archive_restore_to_restore_point(self):
@@ -1359,12 +1274,11 @@ def test_archive_restore_to_restore_point(self):
create table t_heap, make pitr to Recovery Time,
check that t_heap do not exists
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1401,18 +1315,14 @@ def test_archive_restore_to_restore_point(self):
self.assertEqual(result, result_new)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
# @unittest.expectedFailure
def test_zags_block_corrupt(self):
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1463,7 +1373,7 @@ def test_zags_block_corrupt(self):
"insert into tbl select i from generate_series(0,100) as i")
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'),
initdb_params=['--data-checksums'])
node_restored.cleanup()
@@ -1480,14 +1390,13 @@ def test_zags_block_corrupt(self):
@unittest.skip("skip")
# @unittest.expectedFailure
def test_zags_block_corrupt_1(self):
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
pg_options={
'full_page_writes': 'on'}
)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1538,7 +1447,7 @@ def test_zags_block_corrupt_1(self):
self.switch_wal_segment(node)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'),
initdb_params=['--data-checksums'])
pgdata = self.pgdata_content(node.data_dir)
@@ -1588,13 +1497,12 @@ def test_restore_chain(self):
ERROR delta backups, take valid delta backup,
restore must be successfull
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1670,19 +1578,15 @@ def test_restore_chain(self):
self.restore_node(backup_dir, 'node', node)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_chain_with_corrupted_backup(self):
"""more complex test_restore_chain()"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1850,9 +1754,6 @@ def test_restore_chain_with_corrupted_backup(self):
node.cleanup()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# Skipped, because backups from the future are invalid.
# This cause a "ERROR: Can't assign backup_id, there is already a backup in future"
# now (PBCKP-259). We can conduct such a test again when we
@@ -1860,13 +1761,12 @@ def test_restore_chain_with_corrupted_backup(self):
@unittest.skip("skip")
def test_restore_backup_from_future(self):
"""more complex test_restore_chain()"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1909,22 +1809,18 @@ def test_restore_backup_from_future(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_target_immediate_stream(self):
"""
correct handling of immediate recovery target
for STREAM backups
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -1966,22 +1862,18 @@ def test_restore_target_immediate_stream(self):
os.path.isfile(recovery_conf),
"File {0} do not exists".format(recovery_conf))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_target_immediate_archive(self):
"""
correct handling of immediate recovery target
for ARCHIVE backups
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2026,22 +1918,18 @@ def test_restore_target_immediate_archive(self):
with open(recovery_conf, 'r') as f:
self.assertIn("recovery_target = 'immediate'", f.read())
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_target_latest_archive(self):
"""
make sure that recovery_target 'latest'
is default recovery target
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2092,22 +1980,18 @@ def test_restore_target_latest_archive(self):
self.assertEqual(content_1, content_2)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_target_new_options(self):
"""
check that new --recovery-target-*
options are working correctly
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2272,9 +2156,6 @@ def test_restore_target_new_options(self):
node.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_smart_restore(self):
"""
@@ -2284,13 +2165,12 @@ def test_smart_restore(self):
copied during restore
https://github.com/postgrespro/pg_probackup/issues/63
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2336,9 +2216,6 @@ def test_smart_restore(self):
for file in filelist_diff:
self.assertNotIn(file, logfile_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_pg_11_group_access(self):
"""
@@ -2347,15 +2224,14 @@ def test_pg_11_group_access(self):
if self.pg_config_version < self.version_to_num('11.0'):
self.skipTest('You need PostgreSQL >= 11 for this test')
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=[
'--data-checksums',
'--allow-group-access'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -2367,7 +2243,7 @@ def test_pg_11_group_access(self):
# restore backup
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(
@@ -2377,18 +2253,14 @@ def test_pg_11_group_access(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_concurrent_drop_table(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2434,16 +2306,12 @@ def test_restore_concurrent_drop_table(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_lost_non_data_file(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2481,15 +2349,11 @@ def test_lost_non_data_file(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_partial_restore_exclude(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -2520,7 +2384,7 @@ def test_partial_restore_exclude(self):
# restore FULL backup
node_restored_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored_1'))
node_restored_1.cleanup()
try:
@@ -2557,7 +2421,7 @@ def test_partial_restore_exclude(self):
pgdata_restored_1 = self.pgdata_content(node_restored_1.data_dir)
node_restored_2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored_2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored_2'))
node_restored_2.cleanup()
self.restore_node(
@@ -2596,15 +2460,11 @@ def test_partial_restore_exclude(self):
self.assertNotIn('PANIC', output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_partial_restore_exclude_tablespace(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -2651,7 +2511,7 @@ def test_partial_restore_exclude_tablespace(self):
# restore FULL backup
node_restored_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored_1'))
node_restored_1.cleanup()
node1_tablespace = self.get_tblspace_path(node_restored_1, 'somedata')
@@ -2677,7 +2537,7 @@ def test_partial_restore_exclude_tablespace(self):
pgdata_restored_1 = self.pgdata_content(node_restored_1.data_dir)
node_restored_2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored_2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored_2'))
node_restored_2.cleanup()
node2_tablespace = self.get_tblspace_path(node_restored_2, 'somedata')
@@ -2719,16 +2579,12 @@ def test_partial_restore_exclude_tablespace(self):
self.assertNotIn('PANIC', output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_partial_restore_include(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -2759,7 +2615,7 @@ def test_partial_restore_include(self):
# restore FULL backup
node_restored_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored_1'))
node_restored_1.cleanup()
try:
@@ -2798,7 +2654,7 @@ def test_partial_restore_include(self):
pgdata_restored_1 = self.pgdata_content(node_restored_1.data_dir)
node_restored_2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored_2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored_2'))
node_restored_2.cleanup()
self.restore_node(
@@ -2845,9 +2701,6 @@ def test_partial_restore_include(self):
self.assertNotIn('PANIC', output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_partial_restore_backward_compatibility_1(self):
"""
old binary should be of version < 2.2.0
@@ -2855,10 +2708,9 @@ def test_partial_restore_backward_compatibility_1(self):
if not self.probackup_old_path:
self.skipTest("You must specify PGPROBACKUPBIN_OLD"
" for run this test")
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2881,7 +2733,7 @@ def test_partial_restore_backward_compatibility_1(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
try:
@@ -2941,7 +2793,7 @@ def test_partial_restore_backward_compatibility_1(self):
# get new node
node_restored_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored_1'))
node_restored_1.cleanup()
self.restore_node(
@@ -2961,10 +2813,9 @@ def test_partial_restore_backward_compatibility_merge(self):
if not self.probackup_old_path:
self.skipTest("You must specify PGPROBACKUPBIN_OLD"
" for run this test")
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2987,7 +2838,7 @@ def test_partial_restore_backward_compatibility_merge(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
try:
@@ -3047,7 +2898,7 @@ def test_partial_restore_backward_compatibility_merge(self):
# get new node
node_restored_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored_1'))
node_restored_1.cleanup()
# merge
@@ -3065,10 +2916,9 @@ def test_partial_restore_backward_compatibility_merge(self):
def test_empty_and_mangled_database_map(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -3096,7 +2946,7 @@ def test_empty_and_mangled_database_map(self):
f.close()
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
try:
@@ -3178,10 +3028,9 @@ def test_empty_and_mangled_database_map(self):
def test_missing_database_map(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'])
@@ -3375,7 +3224,7 @@ def test_missing_database_map(self):
pgdata = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
# backup has missing database_map and that is legal
@@ -3419,9 +3268,6 @@ def test_missing_database_map(self):
pgdata_restored = self.pgdata_content(node_restored.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_stream_restore_command_option(self):
"""
@@ -3436,14 +3282,13 @@ def test_stream_restore_command_option(self):
as replica, check that PostgreSQL recovery uses
restore_command to obtain WAL from archive.
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={'max_wal_size': '32MB'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -3500,20 +3345,16 @@ def test_stream_restore_command_option(self):
self.assertEqual('2', timeline_id)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_primary_conninfo(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -3526,7 +3367,7 @@ def test_restore_primary_conninfo(self):
#primary_conninfo = 'host=192.168.1.50 port=5432 user=foo password=foopass'
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
str_conninfo='host=192.168.1.50 port=5432 user=foo password=foopass'
@@ -3553,20 +3394,16 @@ def test_restore_primary_conninfo(self):
self.assertIn(str_conninfo, recovery_conf_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_primary_slot_info(self):
"""
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -3577,7 +3414,7 @@ def test_restore_primary_slot_info(self):
node.pgbench_init(scale=1)
replica = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'replica'))
+ base_dir=os.path.join(self.module_name, self.fname, 'replica'))
replica.cleanup()
node.safe_psql(
@@ -3598,17 +3435,13 @@ def test_restore_primary_slot_info(self):
replica.slow_start(replica=True)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_issue_249(self):
"""
https://github.com/postgrespro/pg_probackup/issues/249
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -3643,7 +3476,7 @@ def test_issue_249(self):
# restore FULL backup
node_restored_1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored_1'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored_1'))
node_restored_1.cleanup()
self.restore_node(
@@ -3667,9 +3500,6 @@ def test_issue_249(self):
except QueryException as e:
self.assertIn('FATAL', e.message)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_pg_12_probackup_recovery_conf_compatibility(self):
"""
https://github.com/postgrespro/pg_probackup/issues/249
@@ -3685,10 +3515,9 @@ def test_pg_12_probackup_recovery_conf_compatibility(self):
if self.version_to_num(self.old_probackup_version) >= self.version_to_num('2.4.5'):
self.assertTrue(False, 'You need pg_probackup < 2.4.5 for this test')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -3741,9 +3570,6 @@ def test_pg_12_probackup_recovery_conf_compatibility(self):
node.slow_start()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_drop_postgresql_auto_conf(self):
"""
https://github.com/postgrespro/pg_probackup/issues/249
@@ -3754,10 +3580,9 @@ def test_drop_postgresql_auto_conf(self):
if self.pg_config_version < self.version_to_num('12.0'):
self.skipTest('You need PostgreSQL >= 12 for this test')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -3786,9 +3611,6 @@ def test_drop_postgresql_auto_conf(self):
self.assertTrue(os.path.exists(auto_path))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_truncate_postgresql_auto_conf(self):
"""
https://github.com/postgrespro/pg_probackup/issues/249
@@ -3799,10 +3621,9 @@ def test_truncate_postgresql_auto_conf(self):
if self.pg_config_version < self.version_to_num('12.0'):
self.skipTest('You need PostgreSQL >= 12 for this test')
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -3831,18 +3652,14 @@ def test_truncate_postgresql_auto_conf(self):
self.assertTrue(os.path.exists(auto_path))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_concurrent_restore(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -3869,7 +3686,7 @@ def test_concurrent_restore(self):
pgdata1 = self.pgdata_content(node.data_dir)
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node.cleanup()
node_restored.cleanup()
@@ -3892,19 +3709,15 @@ def test_concurrent_restore(self):
self.compare_pgdata(pgdata1, pgdata2)
self.compare_pgdata(pgdata2, pgdata3)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# skip this test until https://github.com/postgrespro/pg_probackup/pull/399
@unittest.skip("skip")
def test_restore_issue_313(self):
"""
Check that partially restored PostgreSQL instance cannot be started
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -3925,7 +3738,7 @@ def test_restore_issue_313(self):
count += 1
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'node', node_restored)
@@ -3956,18 +3769,14 @@ def test_restore_issue_313(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_restore_with_waldir(self):
"""recovery using tablespace-mapping option and page backup"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -4011,6 +3820,3 @@ def test_restore_with_waldir(self):
wal_path=os.path.join(node.data_dir, "pg_xlog")
self.assertEqual(os.path.islink(wal_path), True)
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/retention.py b/tests/retention.py
index 4f95ad5e2..88432a00f 100644
--- a/tests/retention.py
+++ b/tests/retention.py
@@ -6,21 +6,17 @@
from distutils.dir_util import copy_tree
-module_name = 'retention'
-
-
class RetentionTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_retention_redundancy_1(self):
"""purge backups using redundancy-based retention policy"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -71,18 +67,14 @@ def test_retention_redundancy_1(self):
self.assertTrue(wal_name >= min_wal)
self.assertTrue(wal_name <= max_wal)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_retention_window_2(self):
"""purge backups using window-based retention policy"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -124,18 +116,14 @@ def test_retention_window_2(self):
self.delete_expired(backup_dir, 'node', options=['--expired'])
self.assertEqual(len(self.show_pb(backup_dir, 'node')), 2)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_retention_window_3(self):
"""purge all backups using window-based retention policy"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -171,18 +159,14 @@ def test_retention_window_3(self):
# count wal files in ARCHIVE
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_retention_window_4(self):
"""purge all backups using window-based retention policy"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -232,18 +216,14 @@ def test_retention_window_4(self):
n_wals = len(os.listdir(wals_dir))
self.assertTrue(n_wals == 0)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_window_expire_interleaved_incremental_chains(self):
"""complicated case of interleaved backup chains"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -356,18 +336,14 @@ def test_window_expire_interleaved_incremental_chains(self):
print(self.show_pb(
backup_dir, 'node', as_json=False, as_text=True))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_redundancy_expire_interleaved_incremental_chains(self):
"""complicated case of interleaved backup chains"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -466,18 +442,14 @@ def test_redundancy_expire_interleaved_incremental_chains(self):
print(self.show_pb(
backup_dir, 'node', as_json=False, as_text=True))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_window_merge_interleaved_incremental_chains(self):
"""complicated case of interleaved backup chains"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -603,9 +575,6 @@ def test_window_merge_interleaved_incremental_chains(self):
self.assertEqual(len(self.show_pb(backup_dir, 'node')), 2)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_window_merge_interleaved_incremental_chains_1(self):
"""
@@ -616,12 +585,11 @@ def test_window_merge_interleaved_incremental_chains_1(self):
FULLb
FULLa
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -745,9 +713,6 @@ def test_window_merge_interleaved_incremental_chains_1(self):
pgdata_restored_b3 = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata_b3, pgdata_restored_b3)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_window_merge_multiple_descendants(self):
"""
@@ -761,12 +726,11 @@ def test_basic_window_merge_multiple_descendants(self):
FULLb |
FULLa
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1005,9 +969,6 @@ def test_basic_window_merge_multiple_descendants(self):
self.show_pb(backup_dir, 'node')[0]['backup-mode'],
'FULL')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_window_merge_multiple_descendants_1(self):
"""
@@ -1021,12 +982,11 @@ def test_basic_window_merge_multiple_descendants_1(self):
FULLb |
FULLa
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1271,9 +1231,6 @@ def test_basic_window_merge_multiple_descendants_1(self):
'--retention-window=1',
'--delete-expired', '--log-level-console=log'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_window_chains(self):
"""
@@ -1286,12 +1243,11 @@ def test_window_chains(self):
PAGE
FULL
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1357,9 +1313,6 @@ def test_window_chains(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_window_chains_1(self):
"""
@@ -1372,12 +1325,11 @@ def test_window_chains_1(self):
PAGE
FULL
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1451,9 +1403,6 @@ def test_window_chains_1(self):
"Purging finished",
output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
def test_window_error_backups(self):
"""
@@ -1466,12 +1415,11 @@ def test_window_error_backups(self):
FULL
-------redundancy
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1488,9 +1436,6 @@ def test_window_error_backups(self):
# Change FULLb backup status to ERROR
# self.change_backup_status(backup_dir, 'node', backup_id_b, 'ERROR')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_window_error_backups_1(self):
"""
@@ -1501,12 +1446,11 @@ def test_window_error_backups_1(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1538,9 +1482,6 @@ def test_window_error_backups_1(self):
self.assertEqual(len(self.show_pb(backup_dir, 'node')), 4)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_window_error_backups_2(self):
"""
@@ -1551,12 +1492,11 @@ def test_window_error_backups_2(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1589,23 +1529,18 @@ def test_window_error_backups_2(self):
self.assertEqual(len(self.show_pb(backup_dir, 'node')), 3)
- # Clean after yourself
- # self.del_test_dir(module_name, fname)
-
def test_retention_redundancy_overlapping_chains(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
if self.get_version(node) < 90600:
- self.del_test_dir(module_name, fname)
self.skipTest('Skipped because ptrack support is disabled')
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1639,23 +1574,18 @@ def test_retention_redundancy_overlapping_chains(self):
self.validate_pb(backup_dir, 'node')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_retention_redundancy_overlapping_chains_1(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
if self.get_version(node) < 90600:
- self.del_test_dir(module_name, fname)
self.skipTest('Skipped because ptrack support is disabled')
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1689,19 +1619,15 @@ def test_retention_redundancy_overlapping_chains_1(self):
self.validate_pb(backup_dir, 'node')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_wal_purge_victim(self):
"""
https://github.com/postgrespro/pg_probackup/issues/103
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1746,9 +1672,6 @@ def test_wal_purge_victim(self):
"WARNING: Backup {0} has missing parent 0".format(page_id),
e.message)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_failed_merge_redundancy_retention(self):
"""
@@ -1756,11 +1679,10 @@ def test_failed_merge_redundancy_retention(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
base_dir=os.path.join(
- module_name, fname, 'node'),
+ self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -1844,9 +1766,6 @@ def test_failed_merge_redundancy_retention(self):
self.assertEqual(len(self.show_pb(backup_dir, 'node')), 10)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_wal_depth_1(self):
"""
|-------------B5----------> WAL timeline3
@@ -1855,10 +1774,9 @@ def test_wal_depth_1(self):
wal-depth=2
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
@@ -1901,7 +1819,7 @@ def test_wal_depth_1(self):
# Timeline 2
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
@@ -1960,8 +1878,6 @@ def test_wal_depth_1(self):
self.validate_pb(backup_dir, 'node')
- self.del_test_dir(module_name, fname)
-
def test_wal_purge(self):
"""
-------------------------------------> tli5
@@ -1982,10 +1898,9 @@ def test_wal_purge(self):
wal-depth=2
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2022,7 +1937,7 @@ def test_wal_purge(self):
# TLI 2
node_tli2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_tli2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_tli2'))
node_tli2.cleanup()
output = self.restore_node(
@@ -2056,7 +1971,7 @@ def test_wal_purge(self):
# TLI3
node_tli3 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_tli3'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_tli3'))
node_tli3.cleanup()
# Note, that successful validation here is a happy coincidence
@@ -2077,7 +1992,7 @@ def test_wal_purge(self):
# TLI4
node_tli4 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_tli4'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_tli4'))
node_tli4.cleanup()
self.restore_node(
@@ -2099,7 +2014,7 @@ def test_wal_purge(self):
# TLI5
node_tli5 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_tli5'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_tli5'))
node_tli5.cleanup()
self.restore_node(
@@ -2182,8 +2097,6 @@ def test_wal_purge(self):
self.validate_pb(backup_dir, 'node')
- self.del_test_dir(module_name, fname)
-
def test_wal_depth_2(self):
"""
-------------------------------------> tli5
@@ -2205,10 +2118,9 @@ def test_wal_depth_2(self):
wal-depth=2
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2243,7 +2155,7 @@ def test_wal_depth_2(self):
# TLI 2
node_tli2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_tli2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_tli2'))
node_tli2.cleanup()
output = self.restore_node(
@@ -2277,7 +2189,7 @@ def test_wal_depth_2(self):
# TLI3
node_tli3 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_tli3'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_tli3'))
node_tli3.cleanup()
# Note, that successful validation here is a happy coincidence
@@ -2298,7 +2210,7 @@ def test_wal_depth_2(self):
# TLI4
node_tli4 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_tli4'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_tli4'))
node_tli4.cleanup()
self.restore_node(
@@ -2320,7 +2232,7 @@ def test_wal_depth_2(self):
# TLI5
node_tli5 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_tli5'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_tli5'))
node_tli5.cleanup()
self.restore_node(
@@ -2439,8 +2351,6 @@ def test_wal_depth_2(self):
self.validate_pb(backup_dir, 'node')
- self.del_test_dir(module_name, fname)
-
def test_basic_wal_depth(self):
"""
B1---B1----B3-----B4----B5------> tli1
@@ -2450,10 +2360,9 @@ def test_basic_wal_depth(self):
wal-depth=1
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2542,18 +2451,15 @@ def test_basic_wal_depth(self):
self.validate_pb(backup_dir, 'node')
- self.del_test_dir(module_name, fname)
-
def test_concurrent_running_full_backup(self):
"""
https://github.com/postgrespro/pg_probackup/issues/328
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -2621,5 +2527,3 @@ def test_concurrent_running_full_backup(self):
self.assertEqual(
len(self.show_pb(backup_dir, 'node')),
6)
-
- self.del_test_dir(module_name, fname)
diff --git a/tests/set_backup.py b/tests/set_backup.py
index 02ce007bf..e789d174a 100644
--- a/tests/set_backup.py
+++ b/tests/set_backup.py
@@ -5,8 +5,6 @@
from sys import exit
from datetime import datetime, timedelta
-module_name = 'set_backup'
-
class SetBackupTest(ProbackupTest, unittest.TestCase):
@@ -14,10 +12,9 @@ class SetBackupTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
def test_set_backup_sanity(self):
"""general sanity for set-backup command"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -120,19 +117,15 @@ def test_set_backup_sanity(self):
# parse string to datetime object
#new_expire_time = datetime.strptime(new_expire_time, '%Y-%m-%d %H:%M:%S%z')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_retention_redundancy_pinning(self):
""""""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -174,18 +167,14 @@ def test_retention_redundancy_pinning(self):
'{1} is guarded by retention'.format(full_id, page_id),
log)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_retention_window_pinning(self):
"""purge all backups using window-based retention policy"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -237,9 +226,6 @@ def test_retention_window_pinning(self):
'{1} is guarded by retention'.format(backup_id_1, page1),
out)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_wal_retention_and_pinning(self):
"""
@@ -251,13 +237,12 @@ def test_wal_retention_and_pinning(self):
B1 B2---P---B3--->
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -317,9 +302,6 @@ def test_wal_retention_and_pinning(self):
'000000010000000000000004')
self.assertEqual(timeline['status'], 'OK')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_wal_retention_and_pinning_1(self):
"""
@@ -331,12 +313,11 @@ def test_wal_retention_and_pinning_1(self):
P---B1--->
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -383,19 +364,15 @@ def test_wal_retention_and_pinning_1(self):
self.validate_pb(backup_dir)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_add_note_newlines(self):
""""""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -418,19 +395,15 @@ def test_add_note_newlines(self):
backup_meta = self.show_pb(backup_dir, 'node', backup_id)
self.assertNotIn('note', backup_meta)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_add_big_note(self):
""""""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -472,19 +445,16 @@ def test_add_big_note(self):
backup_meta = self.show_pb(backup_dir, 'node', backup_id)
self.assertEqual(backup_meta['note'], note)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
# @unittest.skip("skip")
def test_add_big_note_1(self):
""""""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -504,6 +474,3 @@ def test_add_big_note_1(self):
print(backup_meta)
self.assertEqual(backup_meta['note'], note)
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/show.py b/tests/show.py
index 5a46e5ef7..c4b96499d 100644
--- a/tests/show.py
+++ b/tests/show.py
@@ -3,19 +3,15 @@
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
-module_name = 'show'
-
-
class ShowTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_show_1(self):
"""Status DONE and OK"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -31,17 +27,13 @@ def test_show_1(self):
)
self.assertIn("OK", self.show_pb(backup_dir, 'node', as_text=True))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_show_json(self):
"""Status DONE and OK"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -58,16 +50,12 @@ def test_show_json(self):
self.backup_node(backup_dir, 'node', node)
self.assertIn("OK", self.show_pb(backup_dir, 'node', as_text=True))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_corrupt_2(self):
"""Status CORRUPT"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -102,16 +90,12 @@ def test_corrupt_2(self):
)
self.assertIn("CORRUPT", self.show_pb(backup_dir, as_text=True))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_no_control_file(self):
"""backup.control doesn't exist"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -137,16 +121,12 @@ def test_no_control_file(self):
'doesn\'t exist',
output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_empty_control_file(self):
"""backup.control is empty"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -173,17 +153,13 @@ def test_empty_control_file(self):
'is empty',
output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_corrupt_control_file(self):
"""backup.control contains invalid option"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -205,9 +181,6 @@ def test_corrupt_control_file(self):
'WARNING: Invalid option "statuss" in file',
self.show_pb(backup_dir, 'node', as_json=False, as_text=True))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_corrupt_correctness(self):
@@ -215,10 +188,9 @@ def test_corrupt_correctness(self):
if not self.remote:
self.skipTest("You must enable PGPROBACKUP_SSH_REMOTE"
" for run this test")
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -299,9 +271,6 @@ def test_corrupt_correctness(self):
output_local['uncompressed-bytes'],
output_remote['uncompressed-bytes'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_corrupt_correctness_1(self):
@@ -309,10 +278,9 @@ def test_corrupt_correctness_1(self):
if not self.remote:
self.skipTest("You must enable PGPROBACKUP_SSH_REMOTE"
" for run this test")
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -397,9 +365,6 @@ def test_corrupt_correctness_1(self):
output_local['uncompressed-bytes'],
output_remote['uncompressed-bytes'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_corrupt_correctness_2(self):
@@ -407,10 +372,9 @@ def test_corrupt_correctness_2(self):
if not self.remote:
self.skipTest("You must enable PGPROBACKUP_SSH_REMOTE"
" for run this test")
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -512,17 +476,13 @@ def test_corrupt_correctness_2(self):
output_local['uncompressed-bytes'],
output_remote['uncompressed-bytes'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_color_with_no_terminal(self):
"""backup.control contains invalid option"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'],
pg_options={'autovacuum': 'off'})
@@ -547,6 +507,3 @@ def test_color_with_no_terminal(self):
'[0m', e.message,
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/time_consuming.py b/tests/time_consuming.py
index 8908dfd34..c0038c085 100644
--- a/tests/time_consuming.py
+++ b/tests/time_consuming.py
@@ -4,7 +4,6 @@
import subprocess
from time import sleep
-module_name = 'time_consuming'
class TimeConsumingTests(ProbackupTest, unittest.TestCase):
def test_pbckp150(self):
@@ -20,9 +19,8 @@ def test_pbckp150(self):
if not self.ptrack:
self.skipTest('Skipped because ptrack support is disabled')
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
ptrack_enable=self.ptrack,
initdb_params=['--data-checksums'],
@@ -39,7 +37,7 @@ def test_pbckp150(self):
self.set_auto_conf(node, {'wal_keep_segments': '1000'})
# init probackup and add an instance
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -77,6 +75,3 @@ def test_pbckp150(self):
backups = self.show_pb(backup_dir, 'node')
for b in backups:
self.assertEqual("OK", b['status'])
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/time_stamp.py b/tests/time_stamp.py
index c49d183da..170c62cd4 100644
--- a/tests/time_stamp.py
+++ b/tests/time_stamp.py
@@ -5,22 +5,19 @@
from time import sleep
-module_name = 'time_stamp'
-
class TimeStamp(ProbackupTest, unittest.TestCase):
def test_start_time_format(self):
"""Test backup ID changing after start-time editing in backup.control.
We should convert local time in UTC format"""
# Create simple node
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir="{0}/{1}/node".format(module_name, fname),
+ base_dir="{0}/{1}/node".format(self.module_name, self.fname),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -58,19 +55,16 @@ def test_start_time_format(self):
self.assertNotIn("backup ID in control file", output)
node.stop()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
def test_server_date_style(self):
"""Issue #112"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir="{0}/{1}/node".format(module_name, fname),
+ base_dir="{0}/{1}/node".format(self.module_name, self.fname),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={"datestyle": "GERMAN, DMY"})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.start()
@@ -78,18 +72,14 @@ def test_server_date_style(self):
self.backup_node(
backup_dir, 'node', node, options=['--stream', '-j 2'])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_handling_of_TZ_env_variable(self):
"""Issue #284"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir="{0}/{1}/node".format(module_name, fname),
+ base_dir="{0}/{1}/node".format(self.module_name, self.fname),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.start()
@@ -104,17 +94,13 @@ def test_handling_of_TZ_env_variable(self):
self.assertNotIn("backup ID in control file", output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
# @unittest.expectedFailure
def test_dst_timezone_handling(self):
"""for manual testing"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -180,16 +166,12 @@ def test_dst_timezone_handling(self):
stdout=subprocess.PIPE,
stderr=subprocess.PIPE).communicate()
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
def test_dst_timezone_handling_backward_compatibilty(self):
"""for manual testing"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -252,6 +234,3 @@ def test_dst_timezone_handling_backward_compatibilty(self):
['sudo', 'timedatectl', 'set-timezone', 'US/Moscow'],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE).communicate()
-
- # Clean after yourself
- self.del_test_dir(module_name, fname)
diff --git a/tests/validate.py b/tests/validate.py
index 966ad81a8..98a0fd13f 100644
--- a/tests/validate.py
+++ b/tests/validate.py
@@ -9,9 +9,6 @@
import hashlib
-module_name = 'validate'
-
-
class ValidateTest(ProbackupTest, unittest.TestCase):
# @unittest.skip("skip")
@@ -20,12 +17,11 @@ def test_basic_validate_nullified_heap_page_backup(self):
"""
make node with nullified heap block
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -71,9 +67,6 @@ def test_basic_validate_nullified_heap_page_backup(self):
pgdata_restored = self.pgdata_content(node.data_dir)
self.compare_pgdata(pgdata, pgdata_restored)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_validate_wal_unreal_values(self):
@@ -81,12 +74,11 @@ def test_validate_wal_unreal_values(self):
make node with archiving, make archive backup
validate to both real and unreal values
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -213,9 +205,6 @@ def test_validate_wal_unreal_values(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(self.output), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_basic_validate_corrupted_intermediate_backup(self):
"""
@@ -224,12 +213,11 @@ def test_basic_validate_corrupted_intermediate_backup(self):
run validate on PAGE1, expect PAGE1 to gain status CORRUPT
and PAGE2 gain status ORPHAN
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -298,9 +286,6 @@ def test_basic_validate_corrupted_intermediate_backup(self):
self.show_pb(backup_dir, 'node', backup_id_3)['status'],
'Backup STATUS should be "ORPHAN"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_corrupted_intermediate_backups(self):
"""
@@ -309,12 +294,11 @@ def test_validate_corrupted_intermediate_backups(self):
expect FULL and PAGE1 to gain status CORRUPT and
PAGE2 gain status ORPHAN
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -419,9 +403,6 @@ def test_validate_corrupted_intermediate_backups(self):
self.show_pb(backup_dir, 'node', backup_id_3)['status'],
'Backup STATUS should be "ORPHAN"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_specific_error_intermediate_backups(self):
"""
@@ -431,12 +412,11 @@ def test_validate_specific_error_intermediate_backups(self):
purpose of this test is to be sure that not only
CORRUPT backup descendants can be orphanized
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -507,9 +487,6 @@ def test_validate_specific_error_intermediate_backups(self):
self.show_pb(backup_dir, 'node', backup_id_3)['status'],
'Backup STATUS should be "ORPHAN"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_error_intermediate_backups(self):
"""
@@ -519,12 +496,11 @@ def test_validate_error_intermediate_backups(self):
purpose of this test is to be sure that not only
CORRUPT backup descendants can be orphanized
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -591,9 +567,6 @@ def test_validate_error_intermediate_backups(self):
self.show_pb(backup_dir, 'node', backup_id_3)['status'],
'Backup STATUS should be "ORPHAN"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_corrupted_intermediate_backups_1(self):
"""
@@ -602,12 +575,11 @@ def test_validate_corrupted_intermediate_backups_1(self):
expect PAGE1 to gain status CORRUPT, PAGE2, PAGE3, PAGE4 and PAGE5
to gain status ORPHAN
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -788,9 +760,6 @@ def test_validate_corrupted_intermediate_backups_1(self):
'OK', self.show_pb(backup_dir, 'node', backup_id_8)['status'],
'Backup STATUS should be "OK"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_specific_target_corrupted_intermediate_backups(self):
"""
@@ -799,12 +768,11 @@ def test_validate_specific_target_corrupted_intermediate_backups(self):
expect PAGE1 to gain status CORRUPT, PAGE2, PAGE3, PAGE4 and PAGE5 to
gain status ORPHAN
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -980,9 +948,6 @@ def test_validate_specific_target_corrupted_intermediate_backups(self):
self.assertEqual('ORPHAN', self.show_pb(backup_dir, 'node', backup_id_7)['status'], 'Backup STATUS should be "ORPHAN"')
self.assertEqual('OK', self.show_pb(backup_dir, 'node', backup_id_8)['status'], 'Backup STATUS should be "OK"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_instance_with_several_corrupt_backups(self):
"""
@@ -991,12 +956,11 @@ def test_validate_instance_with_several_corrupt_backups(self):
expect FULL1 to gain status CORRUPT, PAGE1_1 to gain status ORPHAN
FULL2 to gain status CORRUPT, PAGE2_1 to gain status ORPHAN
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1081,9 +1045,6 @@ def test_validate_instance_with_several_corrupt_backups(self):
'OK', self.show_pb(backup_dir, 'node', backup_id_6)['status'],
'Backup STATUS should be "OK"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_instance_with_several_corrupt_backups_interrupt(self):
"""
@@ -1091,12 +1052,11 @@ def test_validate_instance_with_several_corrupt_backups_interrupt(self):
"""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1180,9 +1140,6 @@ def test_validate_instance_with_several_corrupt_backups_interrupt(self):
self.assertNotIn(
'Interrupted while locking backup', log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_instance_with_corrupted_page(self):
"""
@@ -1190,12 +1147,11 @@ def test_validate_instance_with_corrupted_page(self):
corrupt file in PAGE1 backup and run validate on instance,
expect PAGE1 to gain status CORRUPT, PAGE2 to gain status ORPHAN
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1327,20 +1283,16 @@ def test_validate_instance_with_corrupted_page(self):
'OK', self.show_pb(backup_dir, 'node', backup_id_5)['status'],
'Backup STATUS should be "OK"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_instance_with_corrupted_full_and_try_restore(self):
"""make archive node, take FULL, PAGE1, PAGE2, FULL2, PAGE3 backups,
corrupt file in FULL backup and run validate on instance,
expect FULL to gain status CORRUPT, PAGE1 and PAGE2 to gain status ORPHAN,
try to restore backup with --no-validation option"""
- fname = self.id().split('.')[3]
- node = self.make_simple_node(base_dir=os.path.join(module_name, fname, 'node'),
+ node = self.make_simple_node(base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1423,19 +1375,15 @@ def test_validate_instance_with_corrupted_full_and_try_restore(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(self.output), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_instance_with_corrupted_full(self):
"""make archive node, take FULL, PAGE1, PAGE2, FULL2, PAGE3 backups,
corrupt file in FULL backup and run validate on instance,
expect FULL to gain status CORRUPT, PAGE1 and PAGE2 to gain status ORPHAN"""
- fname = self.id().split('.')[3]
- node = self.make_simple_node(base_dir=os.path.join(module_name, fname, 'node'),
+ node = self.make_simple_node(base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1517,18 +1465,14 @@ def test_validate_instance_with_corrupted_full(self):
self.assertEqual('OK', self.show_pb(backup_dir, 'node', backup_id_4)['status'], 'Backup STATUS should be "OK"')
self.assertEqual('OK', self.show_pb(backup_dir, 'node', backup_id_5)['status'], 'Backup STATUS should be "OK"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_corrupt_wal_1(self):
"""make archive node, take FULL1, PAGE1,PAGE2,FULL2,PAGE3,PAGE4 backups, corrupt all wal files, run validate, expect errors"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1579,17 +1523,13 @@ def test_validate_corrupt_wal_1(self):
self.show_pb(backup_dir, 'node', backup_id_2)['status'],
'Backup STATUS should be "CORRUPT"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_corrupt_wal_2(self):
"""make archive node, make full backup, corrupt all wal files, run validate to real xid, expect errors"""
- fname = self.id().split('.')[3]
- node = self.make_simple_node(base_dir=os.path.join(module_name, fname, 'node'),
+ node = self.make_simple_node(base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1645,9 +1585,6 @@ def test_validate_corrupt_wal_2(self):
self.show_pb(backup_dir, 'node', backup_id)['status'],
'Backup STATUS should be "CORRUPT"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_wal_lost_segment_1(self):
"""make archive node, make archive full backup,
@@ -1655,12 +1592,11 @@ def test_validate_wal_lost_segment_1(self):
run validate, expecting error because of missing wal segment
make sure that backup status is 'CORRUPT'
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1722,21 +1658,17 @@ def test_validate_wal_lost_segment_1(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_corrupt_wal_between_backups(self):
"""
make archive node, make full backup, corrupt all wal files,
run validate to real xid, expect errors
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1815,22 +1747,18 @@ def test_validate_corrupt_wal_between_backups(self):
self.show_pb(backup_dir, 'node')[1]['status'],
'Backup STATUS should be "OK"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_pgpro702_688(self):
"""
make node without archiving, make stream backup,
get Recovery Time, validate to Recovery Time
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
node.slow_start()
@@ -1856,22 +1784,18 @@ def test_pgpro702_688(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_pgpro688(self):
"""
make node with archiving, make backup, get Recovery Time,
validate to Recovery Time. Waiting PGPRO-688. RESOLVED
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -1885,9 +1809,6 @@ def test_pgpro688(self):
backup_dir, 'node', options=["--time={0}".format(recovery_time),
"-j", "4"])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
# @unittest.expectedFailure
def test_pgpro561(self):
@@ -1895,13 +1816,12 @@ def test_pgpro561(self):
make node with archiving, make stream backup,
restore it to node1, check that archiving is not successful on node1
"""
- fname = self.id().split('.')[3]
node1 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node1'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node1'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node1', node1)
self.set_archiving(backup_dir, 'node1', node1)
@@ -1911,7 +1831,7 @@ def test_pgpro561(self):
backup_dir, 'node1', node1, options=["--stream"])
node2 = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node2'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node2'))
node2.cleanup()
node1.psql(
@@ -1993,9 +1913,6 @@ def test_pgpro561(self):
self.assertFalse(
'pg_probackup archive-push completed successfully' in log_content)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_corrupted_full(self):
"""
@@ -2006,15 +1923,14 @@ def test_validate_corrupted_full(self):
remove corruption and run valudate again, check that
second full backup and his page backups are OK
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'],
pg_options={
'checkpoint_timeout': '30'})
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2114,9 +2030,6 @@ def test_validate_corrupted_full(self):
self.show_pb(backup_dir, 'node')[6]['status'] == 'ERROR')
self.assertTrue(self.show_pb(backup_dir, 'node')[7]['status'] == 'OK')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_corrupted_full_1(self):
"""
@@ -2130,13 +2043,12 @@ def test_validate_corrupted_full_1(self):
second page should be CORRUPT
third page should be ORPHAN
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2216,9 +2128,6 @@ def test_validate_corrupted_full_1(self):
self.assertTrue(self.show_pb(backup_dir, 'node')[5]['status'] == 'CORRUPT')
self.assertTrue(self.show_pb(backup_dir, 'node')[6]['status'] == 'ORPHAN')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_corrupted_full_2(self):
"""
@@ -2241,13 +2150,12 @@ def test_validate_corrupted_full_2(self):
remove corruption from PAGE2_2 and run validate on PAGE2_4
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2578,9 +2486,6 @@ def test_validate_corrupted_full_2(self):
self.assertTrue(self.show_pb(backup_dir, 'node')[1]['status'] == 'OK')
self.assertTrue(self.show_pb(backup_dir, 'node')[0]['status'] == 'OK')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_corrupted_full_missing(self):
"""
@@ -2593,13 +2498,12 @@ def test_validate_corrupted_full_missing(self):
second full backup and his firts page backups are OK,
third page should be ORPHAN
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -2811,18 +2715,14 @@ def test_validate_corrupted_full_missing(self):
self.assertTrue(self.show_pb(backup_dir, 'node')[1]['status'] == 'OK')
self.assertTrue(self.show_pb(backup_dir, 'node')[0]['status'] == 'OK')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
def test_file_size_corruption_no_validate(self):
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
# initdb_params=['--data-checksums'],
)
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
@@ -2873,9 +2773,6 @@ def test_file_size_corruption_no_validate(self):
"ERROR: Backup files restoring failed" in e.message,
repr(e.message))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_specific_backup_with_missing_backup(self):
"""
@@ -2892,13 +2789,12 @@ def test_validate_specific_backup_with_missing_backup(self):
PAGE1_1
FULL1
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -3016,9 +2912,6 @@ def test_validate_specific_backup_with_missing_backup(self):
self.assertTrue(self.show_pb(backup_dir, 'node')[1]['status'] == 'OK')
self.assertTrue(self.show_pb(backup_dir, 'node')[0]['status'] == 'OK')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_specific_backup_with_missing_backup_1(self):
"""
@@ -3035,13 +2928,12 @@ def test_validate_specific_backup_with_missing_backup_1(self):
PAGE1_1
FULL1
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -3137,9 +3029,6 @@ def test_validate_specific_backup_with_missing_backup_1(self):
self.assertTrue(self.show_pb(backup_dir, 'node')[1]['status'] == 'OK')
self.assertTrue(self.show_pb(backup_dir, 'node')[0]['status'] == 'OK')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_with_missing_backup_1(self):
"""
@@ -3156,13 +3045,12 @@ def test_validate_with_missing_backup_1(self):
PAGE1_1
FULL1
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -3326,9 +3214,6 @@ def test_validate_with_missing_backup_1(self):
self.assertTrue(self.show_pb(backup_dir, 'node')[1]['status'] == 'OK')
self.assertTrue(self.show_pb(backup_dir, 'node')[0]['status'] == 'OK')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validate_with_missing_backup_2(self):
"""
@@ -3345,13 +3230,12 @@ def test_validate_with_missing_backup_2(self):
PAGE1_1
FULL1
"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -3486,19 +3370,15 @@ def test_validate_with_missing_backup_2(self):
self.assertTrue(self.show_pb(backup_dir, 'node')[1]['status'] == 'OK')
self.assertTrue(self.show_pb(backup_dir, 'node')[0]['status'] == 'OK')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_corrupt_pg_control_via_resetxlog(self):
""" PGPRO-2096 """
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -3556,18 +3436,14 @@ def test_corrupt_pg_control_via_resetxlog(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_validation_after_backup(self):
""""""
self._check_gdb_flag_or_skip_test()
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -3596,19 +3472,15 @@ def test_validation_after_backup(self):
self.show_pb(backup_dir, 'node', backup_id)['status'],
'Backup STATUS should be "ERROR"')
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_validate_corrupt_tablespace_map(self):
"""
Check that corruption in tablespace_map is detected
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -3651,9 +3523,6 @@ def test_validate_corrupt_tablespace_map(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
#TODO fix the test
@unittest.expectedFailure
# @unittest.skip("skip")
@@ -3661,10 +3530,9 @@ def test_validate_target_lsn(self):
"""
Check validation to specific LSN
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -3683,7 +3551,7 @@ def test_validate_target_lsn(self):
"from generate_series(0,10000) i")
node_restored = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node_restored'))
+ base_dir=os.path.join(self.module_name, self.fname, 'node_restored'))
node_restored.cleanup()
self.restore_node(backup_dir, 'node', node_restored)
@@ -3709,17 +3577,13 @@ def test_validate_target_lsn(self):
'--recovery-target-timeline=2',
'--recovery-target-lsn={0}'.format(target_lsn)])
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
def test_partial_validate_empty_and_mangled_database_map(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -3783,16 +3647,12 @@ def test_partial_validate_empty_and_mangled_database_map(self):
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
def test_partial_validate_exclude(self):
""""""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -3855,17 +3715,13 @@ def test_partial_validate_exclude(self):
self.assertIn(
"VERBOSE: Skip file validation due to partial restore", output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
@unittest.skip("skip")
def test_partial_validate_include(self):
"""
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
self.init_pb(backup_dir)
@@ -3917,18 +3773,14 @@ def test_partial_validate_include(self):
self.assertNotIn(
"VERBOSE: Skip file validation due to partial restore", output)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.skip("skip")
def test_not_validate_diffenent_pg_version(self):
"""Do not validate backup, if binary is compiled with different PG version"""
- fname = self.id().split('.')[3]
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
initdb_params=['--data-checksums'])
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
self.init_pb(backup_dir)
self.add_instance(backup_dir, 'node', node)
self.set_archiving(backup_dir, 'node', node)
@@ -3971,19 +3823,15 @@ def test_not_validate_diffenent_pg_version(self):
"\n Unexpected Error Message: {0}\n CMD: {1}".format(
repr(e.message), self.cmd))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_validate_corrupt_page_header_map(self):
"""
Check that corruption in page_header_map is detected
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -4045,19 +3893,15 @@ def test_validate_corrupt_page_header_map(self):
self.assertIn("WARNING: Some backups are not valid", e.message)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_validate_truncated_page_header_map(self):
"""
Check that corruption in page_header_map is detected
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -4108,19 +3952,15 @@ def test_validate_truncated_page_header_map(self):
self.assertIn("INFO: Backup {0} data files are valid".format(ok_2), e.message)
self.assertIn("WARNING: Some backups are not valid", e.message)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_validate_missing_page_header_map(self):
"""
Check that corruption in page_header_map is detected
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -4168,19 +4008,15 @@ def test_validate_missing_page_header_map(self):
self.assertIn("INFO: Backup {0} data files are valid".format(ok_2), e.message)
self.assertIn("WARNING: Some backups are not valid", e.message)
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# @unittest.expectedFailure
# @unittest.skip("skip")
def test_no_validate_tablespace_map(self):
"""
Check that --no-validate is propagated to tablespace_map
"""
- fname = self.id().split('.')[3]
- backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+ backup_dir = os.path.join(self.tmp_path, self.module_name, self.fname, 'backup')
node = self.make_simple_node(
- base_dir=os.path.join(module_name, fname, 'node'),
+ base_dir=os.path.join(self.module_name, self.fname, 'node'),
set_replication=True,
initdb_params=['--data-checksums'])
@@ -4233,9 +4069,6 @@ def test_no_validate_tablespace_map(self):
tblspace_new,
"Symlink '{0}' do not points to '{1}'".format(tablespace_link, tblspace_new))
- # Clean after yourself
- self.del_test_dir(module_name, fname)
-
# validate empty backup list
# page from future during validate
# page from future during backup