[PBCKP-259]: Fix test_start_time for checking that backup and restore can be performed with start-time option.

Fix checking that time of new backup later, than latest existing backup

Author: dlepikhova

src/pg_probackup.c

@@ -993,6 +993,8 @@ main(int argc, char *argv[])
 			return do_catchup(catchup_source_pgdata, catchup_destination_pgdata, num_threads, !no_sync,
 				exclude_absolute_paths_list, exclude_relative_paths_list);
 		case RESTORE_CMD:
+			if (start_time != INVALID_BACKUP_ID)
+				current.backup_id = start_time;
 			return do_restore_or_validate(instanceState, current.backup_id,
 							recovery_target_options,
 							restore_params, no_sync);

tests/backup.py

@@ -3402,7 +3402,7 @@ def test_pg_stop_backup_missing_permissions(self):
 
     # @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'),
@@ -3417,85 +3417,27 @@ def test_start_time(self):
         node.slow_start()
 
         # FULL backup
-        startTime = int(time())
-        self.backup_node(
-            backup_dir, 'node', node, backup_type="full",
-            options=['--stream', '--start-time', str(startTime)])
-
-        # DELTA backup
-        startTime = int(time())
-        self.backup_node(
-            backup_dir, 'node', node, backup_type="delta",
-            options=['--stream', '--start-time', str(startTime)])
-
-        # PAGE backup
-        startTime = int(time())
-        self.backup_node(
-            backup_dir, 'node', node, backup_type="page",
-            options=['--stream', '--start-time', str(startTime)])
-
-        if self.ptrack and node.major_version > 11:
-            node.safe_psql(
-                "postgres",
-                "create extension ptrack")
-
-            # PTRACK backup
-            startTime = int(time())
-            self.backup_node(
-                backup_dir, 'node', node, backup_type="ptrack",
-                options=['--stream', '--start-time', str(startTime)])
-
-        # Clean after yourself
-        self.del_test_dir(module_name, fname)
-
-    # @unittest.skip("skip")
-    def test_start_time_incorrect_time(self):
-
-        fname = self.id().split('.')[3]
-        node = self.make_simple_node(
-            base_dir=os.path.join(module_name, 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')
-        self.init_pb(backup_dir)
-        self.add_instance(backup_dir, 'node', node)
-        self.set_archiving(backup_dir, 'node', node)
-        node.slow_start()
-
-        startTime = int(time())
-        #backup with correct start time
+        startTime = str(int(time()))
         self.backup_node(
+            backup_dir, 'node', node, backup_type='full',
+            options=['--stream', '--start-time={0}'.format(startTime)])
+        # restore FULL backup by the start-time
+        node.cleanup()
+        self.restore_node(
             backup_dir, 'node', node,
-            options=['--stream', '--start-time', str(startTime)])
-        #backups with incorrect start time
-        try:
-            self.backup_node(
-            backup_dir, 'node', node, backup_type="full",
-            options=['--stream', '--start-time', str(startTime-10000)])
-            # we should die here because exception is what we expect to happen
-            self.assertEqual(
-                1, 0,
-                "Expecting Error because start time for new backup must be newer "
-                "\n Output: {0} \n CMD: {1}".format(
-                    repr(self.output), self.cmd))
-        except ProbackupException as e:
-            self.assertRegex(
-                e.message,
-                r"ERROR: Can't assign backup_id from requested start_time \(\w*\), this time must be later that backup \w*\n",
-                "\n Unexpected Error Message: {0}\n CMD: {1}".format(
-                    repr(e.message), self.cmd))
+            options=['--start-time={0}'.format(startTime)])
 
+        #FULL backup with incorrect start time
         try:
+            startTime = str(int(time()-100000))
             self.backup_node(
-            backup_dir, 'node', node, backup_type="delta",
-            options=['--stream', '--start-time', str(startTime-10000)])
+            backup_dir, 'node', node, backup_type='full',
+            options=['--stream', '--start-time={0}'.format(startTime)])
             # we should die here because exception is what we expect to happen
             self.assertEqual(
                 1, 0,
-                "Expecting Error because start time for new backup must be newer "
-                "\n Output: {0} \n CMD: {1}".format(
+                'Expecting Error because start time for new backup must be newer '
+                '\n Output: {0} \n CMD: {1}'.format(
                     repr(self.output), self.cmd))
         except ProbackupException as e:
             self.assertRegex(
@@ -3504,44 +3446,46 @@ def test_start_time_incorrect_time(self):
                 "\n Unexpected Error Message: {0}\n CMD: {1}".format(
                     repr(e.message), self.cmd))
 
-        try:
-            self.backup_node(
-            backup_dir, 'node', node, backup_type="page",
-            options=['--stream', '--start-time', str(startTime-10000)])
-            # we should die here because exception is what we expect to happen
-            self.assertEqual(
-                1, 0,
-                "Expecting Error because start time for new backup must be newer "
-                "\n Output: {0} \n CMD: {1}".format(
-                    repr(self.output), self.cmd))
-        except ProbackupException as e:
-            self.assertRegex(
-                e.message,
-                r"ERROR: Can't assign backup_id from requested start_time \(\w*\), this time must be later that backup \w*\n",
-                "\n Unexpected Error Message: {0}\n CMD: {1}".format(
-                    repr(e.message), self.cmd))
+        # DELTA backup
+        node.slow_start()
+        startTime = str(int(time()))
+        self.backup_node(
+            backup_dir, 'node', node, backup_type='delta',
+            options=['--stream', '--start-time={0}'.format(startTime)])
+        # restore DELTA backup by the start-time
+        node.cleanup()
+        self.restore_node(
+            backup_dir, 'node', node,
+            options=['--start-time={0}'.format(startTime)])
 
-        if self.ptrack and node.major_version > 11:
+        # PAGE backup
+        node.slow_start()
+        startTime = str(int(time()))
+        self.backup_node(
+            backup_dir, 'node', node, backup_type='page',
+            options=['--stream', '--start-time={0}'.format(startTime)])
+        # restore PAGE backup by the start-time
+        node.cleanup()
+        self.restore_node(
+            backup_dir, 'node', node,
+            options=['--start-time={0}'.format(startTime)])
+
+        # PTRACK backup
+        if self.ptrack:
+            node.slow_start()
             node.safe_psql(
-                "postgres",
-                "create extension ptrack")
+                'postgres',
+                'create extension ptrack')
 
-            try:
-                self.backup_node(
-                    backup_dir, 'node', node, backup_type='ptrack',
-                    options=['--stream', '--start-time', str(startTime-10000)])
-                # we should die here because exception is what we expect to happen
-                self.assertEqual(
-                    1, 0,
-                    "Expecting Error because start time for new backup must be newer "
-                    "\n Output: {0} \n CMD: {1}".format(
-                        repr(self.output), self.cmd))
-            except ProbackupException as e:
-                self.assertRegex(
-                    e.message,
-                    r"ERROR: Can't assign backup_id from requested start_time \(\w*\), this time must be later that backup \w*\n",
-                    "\n Unexpected Error Message: {0}\n CMD: {1}".format(
-                        repr(e.message), self.cmd))
+            startTime = str(int(time()))
+            self.backup_node(
+                backup_dir, 'node', node, backup_type='ptrack',
+                options=['--stream', '--start-time={0}'.format(startTime)])
+
+            node.cleanup()
+            self.restore_node(
+                backup_dir, 'node', node,
+                options=['--start-time={0}'.format(startTime)])
 
         # Clean after yourself
         self.del_test_dir(module_name, fname)
@@ -3632,141 +3576,3 @@ def test_start_time_few_nodes(self):
         # Clean after yourself
         self.del_test_dir(module_name, fname)
 
-    # @unittest.skip("skip")
-    def test_start_time_few_nodes_incorrect_time(self):
-
-        fname = self.id().split('.')[3]
-        node1 = self.make_simple_node(
-            base_dir=os.path.join(module_name, 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')
-        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'),
-            ptrack_enable=self.ptrack,
-            initdb_params=['--data-checksums'])
-
-        backup_dir2 = os.path.join(self.tmp_path, module_name, fname, 'backup2')
-        self.init_pb(backup_dir2)
-        self.add_instance(backup_dir2, 'node2', node2)
-        self.set_archiving(backup_dir2, 'node2', node2)
-        node2.slow_start()
-
-        # FULL backup
-        startTime = int(time())
-        self.backup_node(
-            backup_dir1, 'node1', node1, backup_type="full",
-            options=['--stream', '--start-time', str(startTime)])
-        self.backup_node(
-            backup_dir2, 'node2', node2, backup_type="full",
-            options=['--stream', '--start-time', str(startTime-10000)])
-
-        show_backup1 = self.show_pb(backup_dir1, 'node1')[0]
-        show_backup2 = self.show_pb(backup_dir2, 'node2')[0]
-        self.assertGreater(show_backup1['id'], show_backup2['id'])
-
-        # DELTA backup
-        startTime = int(time())
-        self.backup_node(
-            backup_dir1, 'node1', node1, backup_type="delta",
-            options=['--stream', '--start-time', str(startTime)])
-        # make backup with start time definitelly earlier, than existing
-        try:
-            self.backup_node(
-                backup_dir2, 'node2', node2, backup_type="delta",
-                options=['--stream', '--start-time', str(10000)])
-            self.assertEqual(
-                    1, 0,
-                    "Expecting Error because start time for new backup must be newer "
-                    "\n Output: {0} \n CMD: {1}".format(
-                        repr(self.output), self.cmd))
-        except ProbackupException as e:
-            self.assertIn(
-                "ERROR: Can't assign backup_id from requested start_time (7PS), this time must be later that backup",
-                e.message,
-                "\n Unexpected Error Message: {0}\n CMD: {1}".format(
-                    repr(e.message), self.cmd))
-
-        show_backup1 = self.show_pb(backup_dir1, 'node1')[1]
-        show_backup2 = self.show_pb(backup_dir2, 'node2')[0]
-        self.assertGreater(show_backup1['id'], show_backup2['id'])
-
-        # PAGE backup
-        startTime = int(time())
-        self.backup_node(
-            backup_dir1, 'node1', node1, backup_type="page",
-            options=['--stream', '--start-time', str(startTime)])
-        # make backup with start time definitelly earlier, than existing
-        try:
-            self.backup_node(
-                backup_dir2, 'node2', node2, backup_type="page",
-                options=['--stream', '--start-time', str(10000)])
-            self.assertEqual(
-                    1, 0,
-                    "Expecting Error because start time for new backup must be newer "
-                    "\n Output: {0} \n CMD: {1}".format(
-                        repr(self.output), self.cmd))
-        except ProbackupException as e:
-            self.assertIn(
-                "ERROR: Can't assign backup_id from requested start_time (7PS), this time must be later that backup",
-                e.message,
-                "\n Unexpected Error Message: {0}\n CMD: {1}".format(
-                    repr(e.message), self.cmd))
-
-        show_backup1 = self.show_pb(backup_dir1, 'node1')[2]
-        show_backup2 = self.show_pb(backup_dir2, 'node2')[0]
-        self.assertGreater(show_backup1['id'], show_backup2['id'])
-
-        # PTRACK backup
-        startTime = int(time())
-        if self.ptrack:
-            node1.safe_psql(
-                "postgres",
-                "create extension ptrack")
-            self.backup_node(
-                backup_dir1, 'node1', node1, backup_type="ptrack",
-                options=['--stream', '--start-time', str(startTime)])
-
-            node2.safe_psql(
-                "postgres",
-                "create extension ptrack")
-            # make backup with start time definitelly earlier, than existing
-            try:
-                self.backup_node(
-                    backup_dir2, 'node2', node2, backup_type="ptrack",
-                    options=['--stream', '--start-time', str(10000)])
-                self.assertEqual(
-                    1, 0,
-                    "Expecting Error because start time for new backup must be newer "
-                    "\n Output: {0} \n CMD: {1}".format(
-                        repr(self.output), self.cmd))
-            except ProbackupException as e:
-                self.assertIn(
-                    "ERROR: Can't assign backup_id from requested start_time (7PS), this time must be later that backup",
-                    e.message,
-                    "\n Unexpected Error Message: {0}\n CMD: {1}".format(
-                        repr(e.message), self.cmd))
-
-        # FULL backup
-        startTime = int(time())
-        self.backup_node(
-            backup_dir1, 'node1', node1, backup_type="full",
-            options=['--stream', '--start-time', str(startTime)])
-        self.backup_node(
-            backup_dir2, 'node2', node2, backup_type="full",
-            options=['--stream', '--start-time', str(startTime)])
-
-        show_backups_node1 = self.show_pb(backup_dir1, 'node1')
-        show_backup1 = show_backups_node1[len(show_backups_node1) - 1]
-        show_backup2 = self.show_pb(backup_dir2, 'node2')[1]
-        self.assertEqual(show_backup1['id'], show_backup2['id'])
-
-        # Clean after yourself
-        self.del_test_dir(module_name, fname)

tests/helpers/ptrack_helpers.py

@@ -980,9 +980,6 @@ def backup_node(
         if not old_binary:
             cmd_list += ['--no-sync']
 
-        if startTime:
-            cmd_list += ['--start-time', startTime]
-
         return self.run_pb(cmd_list + options, asynchronous, gdb, old_binary, return_id, env=env)
 
     def checkdb_node(