tests: minor fixes

tests/archive.py

@@ -246,7 +246,7 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
 
     # @unittest.skip("skip")
     def test_pgpro434_3(self):
-        """Check pg_stop_backup_timeout"""
+        """Check pg_stop_backup_timeout, needed backup_timeout"""
         fname = self.id().split('.')[3]
         backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
         node = self.make_simple_node(
@@ -466,6 +466,7 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
         # Settings for Replica
         self.restore_node(backup_dir, 'master', replica)
         self.set_replica(master, replica, synchronous=True)
+        self.add_instance(backup_dir, 'replica', replica)
         self.set_archiving(backup_dir, 'replica', replica, replica=True)
         replica.start()
 
@@ -481,7 +482,9 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
             "from generate_series(256,512) i")
         before = master.safe_psql("postgres", "SELECT * FROM t_heap")
         # ADD INSTANCE 'REPLICA'
-        self.add_instance(backup_dir, 'replica', replica)
+
+        sleep(1)
+
         backup_id = self.backup_node(
             backup_dir, 'replica', replica,
             options=[

tests/backup_test.py

@@ -439,7 +439,9 @@ class BackupTest(ProbackupTest, unittest.TestCase):
 
         self.create_tblspace_in_node(
             node, 'tblspace1',
-            tblspc_path=(os.path.join(node.data_dir, 'pg_clog', '100500'))
+            tblspc_path=(
+                os.path.join(
+                    node.data_dir, 'somedirectory', '100500'))
             )
 
         self.create_tblspace_in_node(

tests/exclude.py

@@ -94,7 +94,7 @@ class ExcludeTest(ProbackupTest, unittest.TestCase):
         conn = node.connect()
         with node.connect("postgres") as conn:
 
-            conn.execute("create unlogged table test as select generate_series(0,50050000)::text")
+            conn.execute("create unlogged table test as select generate_series(0,5005000)::text")
             conn.commit()
 
             conn.execute("create index test_idx on test (generate_series)")

tests/helpers/ptrack_helpers.py

@@ -207,7 +207,6 @@ class ProbackupTest(object):
         node.should_rm_dirs = True
         node.init(
            initdb_params=initdb_params, allow_streaming=set_replication)
-        print(node.data_dir)
 
         # Sane default parameters, not a shit with fsync = off from testgres
         node.append_conf("postgresql.auto.conf", "max_connections = 100")

tests/ptrack.py

@@ -171,7 +171,8 @@ class PtrackTest(ProbackupTest, unittest.TestCase):
 
         # Physical comparison
         if self.paranoia:
-            pgdata_restored = self.pgdata_content(node_restored.data_dir, ignore_ptrack=False)
+            pgdata_restored = self.pgdata_content(
+                node_restored.data_dir, ignore_ptrack=False)
             self.compare_pgdata(pgdata, pgdata_restored)
 
         node_restored.append_conf(
@@ -1746,7 +1747,9 @@ class PtrackTest(ProbackupTest, unittest.TestCase):
         try:
             self.backup_node(
                 backup_dir, 'node', node, backup_type='ptrack',
-                options=["--stream", "-j 30"]
+                options=[
+                    "--stream", "-j 30",
+                    "--log-level-file=verbose"]
             )
             # we should die here because exception is what we expect to happen
             self.assertEqual(

tests/ptrack_clean.py

@@ -1,6 +1,7 @@
 import os
 import unittest
 from .helpers.ptrack_helpers import ProbackupTest, idx_ptrack
+import time
 
 
 module_name = 'ptrack_clean'
@@ -32,14 +33,25 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
         # Create table and indexes
         node.safe_psql(
             "postgres",
-            "create sequence t_seq; create table t_heap tablespace somedata as select i as id, nextval('t_seq') as t_seq, md5(i::text) as text, md5(repeat(i::text,10))::tsvector as tsvector from generate_series(0,256) i")
+            "create sequence t_seq; create table t_heap tablespace somedata "
+            "as select i as id, nextval('t_seq') as t_seq, "
+            "md5(i::text) as text, "
+            "md5(repeat(i::text,10))::tsvector as tsvector "
+            "from generate_series(0,256) i")
         for i in idx_ptrack:
             if idx_ptrack[i]['type'] != 'heap' and idx_ptrack[i]['type'] != 'seq':
-                node.safe_psql("postgres", "create index {0} on {1} using {2}({3}) tablespace somedata".format(
+                node.safe_psql(
-                    i, idx_ptrack[i]['relation'], idx_ptrack[i]['type'], idx_ptrack[i]['column']))
+                    "postgres",
+                    "create index {0} on {1} using {2}({3}) "
+                    "tablespace somedata".format(
+                        i, idx_ptrack[i]['relation'],
+                        idx_ptrack[i]['type'],
+                        idx_ptrack[i]['column']))
 
         # Take FULL backup to clean every ptrack
-        self.backup_node(backup_dir, 'node', node, options=['-j10', '--stream'])
+        self.backup_node(
+            backup_dir, 'node', node,
+            options=['-j10', '--stream'])
         node.safe_psql('postgres', 'checkpoint')
 
         for i in idx_ptrack:
@@ -53,13 +65,17 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
             self.check_ptrack_clean(idx_ptrack[i], idx_ptrack[i]['size'])
 
         # Update everything and vacuum it
-        node.safe_psql('postgres', "update t_heap set t_seq = nextval('t_seq'), text = md5(text), tsvector = md5(repeat(tsvector::text, 10))::tsvector;")
+        node.safe_psql(
+            'postgres',
+            "update t_heap set t_seq = nextval('t_seq'), "
+            "text = md5(text), "
+            "tsvector = md5(repeat(tsvector::text, 10))::tsvector;")
         node.safe_psql('postgres', 'vacuum t_heap')
 
         # Take PTRACK backup to clean every ptrack
         backup_id = self.backup_node(
             backup_dir, 'node', node, backup_type='ptrack',
-            options=['-j100', '--log-level-file=verbose'])
+            options=['-j10', '--log-level-file=verbose'])
         node.safe_psql('postgres', 'checkpoint')
 
         for i in idx_ptrack:
@@ -74,11 +90,17 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
             self.check_ptrack_clean(idx_ptrack[i], idx_ptrack[i]['size'])
 
         # Update everything and vacuum it
-        node.safe_psql('postgres', "update t_heap set t_seq = nextval('t_seq'), text = md5(text), tsvector = md5(repeat(tsvector::text, 10))::tsvector;")
+        node.safe_psql(
+            'postgres',
+            "update t_heap set t_seq = nextval('t_seq'), "
+            "text = md5(text), "
+            "tsvector = md5(repeat(tsvector::text, 10))::tsvector;")
         node.safe_psql('postgres', 'vacuum t_heap')
 
         # Take PAGE backup to clean every ptrack
-        self.backup_node(backup_dir, 'node', node, backup_type='page', options=['-j10'])
+        self.backup_node(
+            backup_dir, 'node', node,
+            backup_type='page', options=['-j10'])
         node.safe_psql('postgres', 'checkpoint')
 
         for i in idx_ptrack:
@@ -100,10 +122,14 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
     def test_ptrack_clean_replica(self):
         """Take backups of every available types from master and check that PTRACK on replica is clean"""
         fname = self.id().split('.')[3]
-        master = self.make_simple_node(base_dir="{0}/{1}/master".format(module_name, fname),
+        master = self.make_simple_node(
+            base_dir="{0}/{1}/master".format(module_name, fname),
             set_replication=True,
             initdb_params=['--data-checksums'],
-            pg_options={'ptrack_enable': 'on', 'wal_level': 'replica', 'max_wal_senders': '2'})
+            pg_options={
+                'ptrack_enable': 'on',
+                'wal_level': 'replica',
+                'max_wal_senders': '2'})
         backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
         self.init_pb(backup_dir)
         self.add_instance(backup_dir, 'master', master)
@@ -111,28 +137,43 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
 
         self.backup_node(backup_dir, 'master', master, options=['--stream'])
 
-        replica = self.make_simple_node(base_dir="{0}/{1}/replica".format(module_name, fname))
+        replica = self.make_simple_node(
+            base_dir="{0}/{1}/replica".format(module_name, fname))
         replica.cleanup()
 
         self.restore_node(backup_dir, 'master', replica)
 
         self.add_instance(backup_dir, 'replica', replica)
-        self.set_replica(master, replica)
+        self.set_replica(master, replica, synchronous=True)
         self.set_archiving(backup_dir, 'replica', replica, replica=True)
         replica.start()
 
         # Create table and indexes
         master.safe_psql(
             "postgres",
-            "create sequence t_seq; create table t_heap as select i as id, nextval('t_seq') as t_seq, md5(i::text) as text, md5(repeat(i::text,10))::tsvector as tsvector from generate_series(0,256) i")
+            "create sequence t_seq; create table t_heap as select i as id, "
+            "nextval('t_seq') as t_seq, md5(i::text) as text, "
+            "md5(repeat(i::text,10))::tsvector as tsvector "
+            "from generate_series(0,256) i")
         for i in idx_ptrack:
             if idx_ptrack[i]['type'] != 'heap' and idx_ptrack[i]['type'] != 'seq':
-                master.safe_psql("postgres", "create index {0} on {1} using {2}({3})".format(
+                master.safe_psql(
-                    i, idx_ptrack[i]['relation'], idx_ptrack[i]['type'], idx_ptrack[i]['column']))
+                    "postgres",
+                    "create index {0} on {1} using {2}({3})".format(
+                        i, idx_ptrack[i]['relation'],
+                        idx_ptrack[i]['type'],
+                        idx_ptrack[i]['column']))
 
         # Take FULL backup to clean every ptrack
-        self.backup_node(backup_dir, 'replica', replica, options=['-j10', '--stream',
+        self.backup_node(
-            '--master-host=localhost', '--master-db=postgres', '--master-port={0}'.format(master.port)])
+            backup_dir,
+            'replica',
+            replica,
+            options=[
+                '-j10', '--stream',
+                '--master-host=localhost',
+                '--master-db=postgres',
+                '--master-port={0}'.format(master.port)])
         master.safe_psql('postgres', 'checkpoint')
 
         for i in idx_ptrack:
@@ -146,12 +187,24 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
             self.check_ptrack_clean(idx_ptrack[i], idx_ptrack[i]['size'])
 
         # Update everything and vacuum it
-        master.safe_psql('postgres', "update t_heap set t_seq = nextval('t_seq'), text = md5(text), tsvector = md5(repeat(tsvector::text, 10))::tsvector;")
+        master.safe_psql(
+            'postgres',
+            "update t_heap set t_seq = nextval('t_seq'), "
+            "text = md5(text), "
+            "tsvector = md5(repeat(tsvector::text, 10))::tsvector;")
         master.safe_psql('postgres', 'vacuum t_heap')
 
         # Take PTRACK backup to clean every ptrack
-        backup_id = self.backup_node(backup_dir, 'replica', replica, backup_type='ptrack', options=['-j10', '--stream',
+        backup_id = self.backup_node(
-            '--master-host=localhost', '--master-db=postgres', '--master-port={0}'.format(master.port)])
+            backup_dir,
+            'replica',
+            replica,
+            backup_type='ptrack',
+            options=[
+                '-j10', '--stream',
+                '--master-host=localhost',
+                '--master-db=postgres',
+                '--master-port={0}'.format(master.port)])
         master.safe_psql('postgres', 'checkpoint')
 
         for i in idx_ptrack:
@@ -166,16 +219,25 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
             self.check_ptrack_clean(idx_ptrack[i], idx_ptrack[i]['size'])
 
         # Update everything and vacuum it
-        master.safe_psql('postgres', "update t_heap set t_seq = nextval('t_seq'), text = md5(text), tsvector = md5(repeat(tsvector::text, 10))::tsvector;")
+        master.safe_psql(
+            'postgres',
+            "update t_heap set t_seq = nextval('t_seq'), text = md5(text), "
+            "tsvector = md5(repeat(tsvector::text, 10))::tsvector;")
         master.safe_psql('postgres', 'vacuum t_heap')
         master.safe_psql('postgres', 'checkpoint')
 
         # Take PAGE backup to clean every ptrack
-        self.backup_node(backup_dir, 'replica', replica, backup_type='page', options=['-j10',
+        self.backup_node(
-            '--master-host=localhost', '--master-db=postgres', '--master-port={0}'.format(master.port)])
+            backup_dir,
+            'replica',
+            replica,
+            backup_type='page',
+            options=[
+                '-j10', '--master-host=localhost',
+                '--master-db=postgres',
+                '--master-port={0}'.format(master.port)])
         master.safe_psql('postgres', 'checkpoint')
 
-
         for i in idx_ptrack:
             # get new size of heap and indexes and calculate it in pages
             idx_ptrack[i]['size'] = self.get_fork_size(replica, i)