tests: compatibility module added

Author: gsmolk

tests/__init__.py

@@ -1,10 +1,10 @@
 import unittest
 
-from . import init_test, merge, option_test, show_test, \
+from . import init_test, merge, option_test, show_test, compatibility, \
     backup_test, delete_test, delta, restore_test, validate_test, \
     retention_test, ptrack_clean, ptrack_cluster, \
-    ptrack_move_to_tablespace, ptrack_recovery, ptrack_truncate, ptrack_vacuum, \
-    ptrack_vacuum_bits_frozen, ptrack_vacuum_bits_visibility, \
+    ptrack_move_to_tablespace, ptrack_recovery, ptrack_truncate, \
+    ptrack_vacuum, ptrack_vacuum_bits_frozen, ptrack_vacuum_bits_visibility, \
     ptrack_vacuum_full, ptrack_vacuum_truncate, pgpro560, pgpro589, \
     false_positive, replica, compression, page, ptrack, archive, \
     exclude, cfs_backup, cfs_restore, cfs_validate_backup, auth_test
@@ -15,6 +15,7 @@ def load_tests(loader, tests, pattern):
 #    suite.addTests(loader.loadTestsFromModule(auth_test))
     suite.addTests(loader.loadTestsFromModule(archive))
     suite.addTests(loader.loadTestsFromModule(backup_test))
+    suite.addTests(loader.loadTestsFromModule(compatibility))
     suite.addTests(loader.loadTestsFromModule(cfs_backup))
     suite.addTests(loader.loadTestsFromModule(cfs_restore))
 #    suite.addTests(loader.loadTestsFromModule(cfs_validate_backup))

tests/compatibility.py

@@ -0,0 +1,105 @@
+import unittest
+import subprocess
+import os
+from .helpers.ptrack_helpers import ProbackupTest, ProbackupException, archive_script
+from sys import exit
+
+module_name = 'compatibility'
+
+
+class CompatibilityTest(ProbackupTest, unittest.TestCase):
+
+    # @unittest.expectedFailure
+    # @unittest.skip("skip")
+    def test_show_previous_version_catalog(self):
+        """Description in jira issue PGPRO-434"""
+        fname = self.id().split('.')[3]
+        backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+        node = self.make_simple_node(
+            base_dir="{0}/{1}/node".format(module_name, fname),
+            set_replication=True,
+            initdb_params=['--data-checksums'],
+            pg_options={
+                'max_wal_senders': '2',
+                'checkpoint_timeout': '30s'}
+            )
+        self.init_pb(backup_dir, old_binary=True)
+        self.show_pb(backup_dir)
+
+        self.add_instance(backup_dir, 'node', node, old_binary=True)
+        self.show_pb(backup_dir)
+
+        self.set_archiving(backup_dir, 'node', node, old_binary=True)
+        node.slow_start()
+
+        node.pgbench_init(scale=10)
+
+        # FULL backup
+        self.backup_node(
+            backup_dir, 'node', node, old_binary=True)
+
+        if self.paranoia:
+            pgdata = self.pgdata_content(node.data_dir)
+
+        self.show_pb(backup_dir)
+        self.validate_pb(backup_dir)
+
+        # RESTORE
+        node_restored = self.make_simple_node(
+            base_dir="{0}/{1}/node_restored".format(module_name, fname))
+
+        node_restored.cleanup()
+
+        self.restore_node(
+                backup_dir, 'node', node_restored,
+                options=["-j", "4", "--recovery-target-action=promote"])
+
+        if self.paranoia:
+            pgdata_restored = self.pgdata_content(node_restored.data_dir)
+            self.compare_pgdata(pgdata, pgdata_restored)
+
+        # Incremental BACKUP
+        pgbench = node.pgbench(
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            options=["-c", "4", "-T", "10"]
+        )
+
+        self.backup_node(
+            backup_dir, 'node', node, backup_type='page',
+            old_binary=True)
+
+        if self.paranoia:
+            pgdata = self.pgdata_content(node.data_dir)
+
+        node_restored.cleanup()
+        self.restore_node(
+            backup_dir, 'node', node_restored,
+            options=["-j", "4", "--recovery-target-action=promote"])
+
+        if self.paranoia:
+            pgdata_restored = self.pgdata_content(node_restored.data_dir)
+            self.compare_pgdata(pgdata, pgdata_restored)
+
+        # Incremental BACKUP with new binary
+        pgbench = node.pgbench(
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            options=["-c", "4", "-T", "10"]
+        )
+
+        self.backup_node(
+            backup_dir, 'node', node,
+            backup_type='page')
+
+        if self.paranoia:
+            pgdata = self.pgdata_content(node.data_dir)
+
+        node_restored.cleanup()
+        self.restore_node(
+            backup_dir, 'node', node_restored,
+            options=["-j", "4", "--recovery-target-action=promote"])
+
+        if self.paranoia:
+            pgdata_restored = self.pgdata_content(node_restored.data_dir)
+            self.compare_pgdata(pgdata, pgdata_restored)

tests/helpers/ptrack_helpers.py

@@ -252,6 +252,16 @@ def __init__(self, *args, **kwargs):
         os.environ['PATH'] = os.path.dirname(
             self.probackup_path) + ":" + os.environ['PATH']
 
+        if "PGPROBACKUPBIN_OLD" in self.test_env:
+            if (
+                os.path.isfile(self.test_env["PGPROBACKUPBIN_OLD"]) and
+                os.access(self.test_env["PGPROBACKUPBIN_OLD"], os.X_OK)
+            ):
+                self.probackup_old_path = self.test_env["PGPROBACKUPBIN_OLD"]
+            else:
+                if self.verbose:
+                    print('PGPROBACKUPBIN_OLD is not an executable file')
+
     def make_simple_node(
             self,
             base_dir=None,
@@ -534,13 +544,22 @@ def check_ptrack_clean(self, idx_dict, size):
                     )
                 )
 
-    def run_pb(self, command, async=False, gdb=False):
+    def run_pb(self, command, async=False, gdb=False, old_binary=False):
+        if not self.probackup_old_path and old_binary:
+            print("PGPROBACKUPBIN_OLD is not set")
+            exit(1)
+
+        if old_binary:
+            binary_path = self.probackup_old_path
+        else:
+            binary_path = self.probackup_path
+
         try:
-            self.cmd = [' '.join(map(str, [self.probackup_path] + command))]
+            self.cmd = [' '.join(map(str, [binary_path] + command))]
             if self.verbose:
                 print(self.cmd)
             if gdb:
-                return GDBobj([self.probackup_path] + command, self.verbose)
+                return GDBobj([binary_path] + command, self.verbose)
             if async:
                 return subprocess.Popen(
                     self.cmd,
@@ -550,7 +569,7 @@ def run_pb(self, command, async=False, gdb=False):
                 )
             else:
                 self.output = subprocess.check_output(
-                    [self.probackup_path] + command,
+                    [binary_path] + command,
                     stderr=subprocess.STDOUT,
                     env=self.test_env
                     ).decode("utf-8")
@@ -586,37 +605,45 @@ def run_binary(self, command, async=False):
         except subprocess.CalledProcessError as e:
             raise ProbackupException(e.output.decode("utf-8"), command)
 
-    def init_pb(self, backup_dir):
+    def init_pb(self, backup_dir, old_binary=False):
 
         shutil.rmtree(backup_dir, ignore_errors=True)
+
         return self.run_pb([
             "init",
             "-B", backup_dir
-        ])
+            ],
+            old_binary=old_binary
+        )
 
-    def add_instance(self, backup_dir, instance, node):
+    def add_instance(self, backup_dir, instance, node, old_binary=False):
 
         return self.run_pb([
             "add-instance",
             "--instance={0}".format(instance),
             "-B", backup_dir,
             "-D", node.data_dir
-        ])
+            ],
+            old_binary=old_binary
+        )
 
-    def del_instance(self, backup_dir, instance):
+    def del_instance(self, backup_dir, instance, old_binary=False):
 
         return self.run_pb([
             "del-instance",
             "--instance={0}".format(instance),
             "-B", backup_dir
-        ])
+            ],
+            old_binary=old_binary
+        )
 
     def clean_pb(self, backup_dir):
         shutil.rmtree(backup_dir, ignore_errors=True)
 
     def backup_node(
             self, backup_dir, instance, node, data_dir=False,
-            backup_type="full", options=[], async=False, gdb=False
+            backup_type="full", options=[], async=False, gdb=False,
+            old_binary=False
             ):
         if not node and not data_dir:
             print('You must provide ether node or data_dir for backup')
@@ -639,23 +666,23 @@ def backup_node(
         if backup_type:
             cmd_list += ["-b", backup_type]
 
-        return self.run_pb(cmd_list + options, async, gdb)
+        return self.run_pb(cmd_list + options, async, gdb, old_binary)
 
     def merge_backup(
             self, backup_dir, instance, backup_id, async=False,
-            gdb=False, options=[]):
+            gdb=False, old_binary=False, options=[]):
         cmd_list = [
             "merge",
             "-B", backup_dir,
             "--instance={0}".format(instance),
             "-i", backup_id
         ]
 
-        return self.run_pb(cmd_list + options, async, gdb)
+        return self.run_pb(cmd_list + options, async, gdb, old_binary)
 
     def restore_node(
             self, backup_dir, instance, node=False,
-            data_dir=None, backup_id=None, options=[]
+            data_dir=None, backup_id=None, old_binary=False, options=[]
             ):
         if data_dir is None:
             data_dir = node.data_dir
@@ -669,11 +696,11 @@ def restore_node(
         if backup_id:
             cmd_list += ["-i", backup_id]
 
-        return self.run_pb(cmd_list + options)
+        return self.run_pb(cmd_list + options, old_binary=old_binary)
 
     def show_pb(
             self, backup_dir, instance=None, backup_id=None,
-            options=[], as_text=False, as_json=True
+            options=[], as_text=False, as_json=True, old_binary=False
             ):
 
         backup_list = []
@@ -693,11 +720,11 @@ def show_pb(
 
         if as_text:
             # You should print it when calling as_text=true
-            return self.run_pb(cmd_list + options)
+            return self.run_pb(cmd_list + options, old_binary=old_binary)
 
         # get show result as list of lines
         if as_json:
-            data = json.loads(self.run_pb(cmd_list + options))
+            data = json.loads(self.run_pb(cmd_list + options, old_binary=old_binary))
         #    print(data)
             for instance_data in data:
                 # find specific instance if requested
@@ -713,7 +740,8 @@ def show_pb(
                         backup_list.append(backup)
             return backup_list
         else:
-            show_splitted = self.run_pb(cmd_list + options).splitlines()
+            show_splitted = self.run_pb(
+                cmd_list + options, old_binary=old_binary).splitlines()
             if instance is not None and backup_id is None:
                 # cut header(ID, Mode, etc) from show as single string
                 header = show_splitted[1:2][0]
@@ -768,7 +796,7 @@ def show_pb(
 
     def validate_pb(
             self, backup_dir, instance=None,
-            backup_id=None, options=[]
+            backup_id=None, options=[], old_binary=False
             ):
 
         cmd_list = [
@@ -780,9 +808,11 @@ def validate_pb(
         if backup_id:
             cmd_list += ["-i", backup_id]
 
-        return self.run_pb(cmd_list + options)
+        return self.run_pb(cmd_list + options, old_binary=old_binary)
 
-    def delete_pb(self, backup_dir, instance, backup_id=None, options=[]):
+    def delete_pb(
+            self, backup_dir, instance,
+            backup_id=None, options=[], old_binary=False):
         cmd_list = [
             "delete",
             "-B", backup_dir
@@ -792,24 +822,25 @@ def delete_pb(self, backup_dir, instance, backup_id=None, options=[]):
         if backup_id:
             cmd_list += ["-i", backup_id]
 
-        return self.run_pb(cmd_list + options)
+        return self.run_pb(cmd_list + options, old_binary=old_binary)
 
-    def delete_expired(self, backup_dir, instance, options=[]):
+    def delete_expired(
+            self, backup_dir, instance, options=[], old_binary=False):
         cmd_list = [
             "delete", "--expired", "--wal",
             "-B", backup_dir,
             "--instance={0}".format(instance)
         ]
-        return self.run_pb(cmd_list + options)
+        return self.run_pb(cmd_list + options, old_binary=old_binary)
 
-    def show_config(self, backup_dir, instance):
+    def show_config(self, backup_dir, instance, old_binary=False):
         out_dict = {}
         cmd_list = [
             "show-config",
             "-B", backup_dir,
             "--instance={0}".format(instance)
         ]
-        res = self.run_pb(cmd_list).splitlines()
+        res = self.run_pb(cmd_list, old_binary=old_binary).splitlines()
         for line in res:
             if not line.startswith('#'):
                 name, var = line.partition(" = ")[::2]
@@ -830,7 +861,8 @@ def get_recovery_conf(self, node):
         return out_dict
 
     def set_archiving(
-            self, backup_dir, instance, node, replica=False, overwrite=False):
+            self, backup_dir, instance, node, replica=False, overwrite=False,
+            old_binary=False):
 
         if replica:
             archive_mode = 'always'
@@ -966,7 +998,6 @@ def switch_wal_segment(self, node):
                 node.execute("select pg_switch_wal()")
             else:
                 node.execute("select pg_switch_xlog()")
-        sleep(1)
 
     def get_version(self, node):
         return self.version_to_num(

tests/restore_test.py

@@ -1330,7 +1330,7 @@ def test_zags_block_corrupt_1(self):
             pg_options={
                 'wal_level': 'replica',
                 'autovacuum': 'off',
-                'full_page_write': 'on'}
+                'full_page_writes': 'on'}
             )
         backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
         self.init_pb(backup_dir)