new tests added

tests/validate_test.py

@@ -304,3 +304,111 @@ class ValidateTest(ProbackupTest, unittest.TestCase):
 
         # 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="{0}/{1}/node".format(module_name, fname),
+            set_replication=True,
+            initdb_params=['--data-checksums'],
+            pg_options={'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, 'node', node)
+        node.start()
+
+        backup_id = self.backup_node(backup_dir, 'node', node, options=["--stream"])
+        recovery_time = self.show_pb(backup_dir, 'node', backup_id)['recovery-time']
+
+        self.assertIn("INFO: backup validation completed successfully on"),
+            self.validate_pb(backup_dir, 'node', node, options=["--time='{0}'".format(recovery_time)])
+
+        # 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="{0}/{1}/node".format(module_name, fname),
+            set_replication=True,
+            initdb_params=['--data-checksums'],
+            pg_options={'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, 'node', node)
+        self.set_archiving(backup_dir, 'node', node)
+        node.start()
+
+        backup_id = self.backup_node(backup_dir, 'node', node)
+        recovery_time = self.show_pb(backup_dir, 'node', backup_id)['recovery-time']
+
+        # Uncommenting this section will make this test True Positive
+        #node.safe_psql("postgres", "select pg_create_restore_point('123')")
+        #node.safe_psql("postgres", "select txid_current()")
+        #node.safe_psql("postgres", "select pg_switch_xlog()")
+        ####
+
+        #try:
+        self.validate_pb(backup_dir, 'node', options=["--time='{0}'".format(recovery_time)])
+        # we should die here because exception is what we expect to happen
+        # self.assertEqual(1, 0, "Expecting Error because it should not be possible safely validate 'Recovery Time' without wal record with timestamp.\n Output: {0} \n CMD: {1}".format(
+        #    repr(self.output), self.cmd))
+        # except ProbackupException as e:
+        # self.assertTrue('WARNING: recovery can be done up to time {0}'.format(recovery_time) in 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_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="{0}/{1}/node1".format(module_name, fname),
+            set_replication=True,
+            initdb_params=['--data-checksums'],
+            pg_options={'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, 'node1', node1)
+        self.set_archiving(backup_dir, 'node1', node1)
+        node1.start()
+
+        backup_id = self.backup_node(backup_dir, 'node1', node1, options=["--stream"])
+
+        node2 = self.make_simple_node(base_dir="{0}/{1}/node2".format(module_name, fname))
+        node2.cleanup()
+
+        node1.psql(
+            "postgres",
+            "create table t_heap as select i as id, md5(i::text) as text, md5(repeat(i::text,10))::tsvector as tsvector from generate_series(0,256) i")
+
+        self.backup_node(backup_dir, 'node1', node1, backup_type='page', options=["--stream"])
+        self.restore_node(backup_dir, 'node1', data_dir=node2.data_dir)
+        node2.append_conf('postgresql.auto.conf', 'port = {0}'.format(node2.port))
+        node2.start()
+
+        timeline_node1 = node1.get_control_data()["Latest checkpoint's TimeLineID"]
+        timeline_node2 = node2.get_control_data()["Latest checkpoint's TimeLineID"]
+        self.assertEqual(timeline_node1, timeline_node2, "Timelines on Master and Node1 should be equal. This is unexpected")
+
+        archive_command_node1 = node1.safe_psql("postgres", "show archive_command")
+        archive_command_node2 = node2.safe_psql("postgres", "show archive_command")
+        self.assertEqual(archive_command_node1, archive_command_node2, "Archive command on Master and Node should be equal. This is unexpected")
+
+        result = node2.safe_psql("postgres", "select last_failed_wal from pg_stat_get_archiver() where last_failed_wal is not NULL")
+        # self.assertEqual(res, six.b(""), 'Restored Node1 failed to archive segment {0} due to having the same archive command as Master'.format(res.rstrip()))
+        if result == "":
+            self.assertEqual(1, 0, 'Error is expected due to Master and Node1 having the common archive and archive_command')
+
+        # Clean after yourself
+        self.del_test_dir(module_name, fname)