use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Fcntl qw(:seek);
use Test::More tests => 272;
#
# Test set-up
#
-$node = PostgresNode->new('test');
+$node = PostgreSQL::Test::Cluster->new('test');
$node->init;
$node->append_conf('postgresql.conf', 'autovacuum=off');
$node->start;
use warnings;
use Config;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 4;
#
# Test set-up
#
-$node = PostgresNode->new('CIC_test');
+$node = PostgreSQL::Test::Cluster->new('CIC_test');
$node->init;
$node->append_conf('postgresql.conf', 'lock_timeout = 180000');
$node->start;
use warnings;
use Config;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 6;
#
# Test set-up
#
-$node = PostgresNode->new('CIC_2PC_test');
+$node = PostgreSQL::Test::Cluster->new('CIC_2PC_test');
$node->init;
$node->append_conf('postgresql.conf', 'max_prepared_transactions = 10');
$node->append_conf('postgresql.conf', 'lock_timeout = 180000');
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 4;
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->append_conf('postgresql.conf',
"shared_preload_libraries = 'auto_explain'");
# Test generic xlog record work for bloom index replication.
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 31;
my $node_primary;
}
# Initialize primary node
-$node_primary = PostgresNode->new('primary');
+$node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1);
$node_primary->start;
my $backup_name = 'my_backup';
$node_primary->backup($backup_name);
# Create streaming standby linking to primary
-$node_standby = PostgresNode->new('standby');
+$node_standby = PostgreSQL::Test::Cluster->new('standby');
$node_standby->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
$node_standby->start;
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 8;
#########################################
use strict;
use warnings;
use File::Path qw(rmtree);
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 2;
# Test set-up
-my $node = PostgresNode->new('test');
+my $node = PostgreSQL::Test::Cluster->new('test');
$node->init(allows_streaming => 'logical');
$node->append_conf('postgresql.conf', 'synchronous_commit = on');
$node->start;
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 8;
program_help_ok('vacuumlo');
use warnings;
use Fcntl ':mode';
use File::stat qw{lstat};
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 22;
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
my $xlogdir = "$tempdir/pgxlog";
my $datadir = "$tempdir/data";
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 8;
program_help_ok('pg_amcheck');
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 76;
# Test set-up
my ($node, $port);
-$node = PostgresNode->new('test');
+$node = PostgreSQL::Test::Cluster->new('test');
$node->init;
$node->start;
$port = $node->port;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Fcntl qw(:seek);
use Test::More tests => 63;
}
# Test set-up
-$node = PostgresNode->new('test');
+$node = PostgreSQL::Test::Cluster->new('test');
$node->init;
$node->append_conf('postgresql.conf', 'autovacuum=off');
$node->start;
# Leave 'db3' uncorrupted
#
-# Standard first arguments to TestLib functions
+# Standard first arguments to PostgreSQL::Test::Utils functions
my @cmd = ('pg_amcheck', '-p', $port);
# Regular expressions to match various expected output
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Fcntl qw(:seek);
use Test::More;
# Set up the node. Once we create and corrupt the table,
# autovacuum workers visiting the table could crash the backend.
# Disable autovacuum so that won't happen.
-my $node = PostgresNode->new('test');
+my $node = PostgreSQL::Test::Cluster->new('test');
$node->init;
$node->append_conf('postgresql.conf', 'autovacuum=off');
#
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 5;
-my $node = PostgresNode->new('test');
+my $node = PostgreSQL::Test::Cluster->new('test');
$node->init;
$node->start;
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 42;
program_help_ok('pg_archivecleanup');
program_version_ok('pg_archivecleanup');
program_options_handling_ok('pg_archivecleanup');
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
my @walfiles = (
'00000001000000370000000C.gz', '00000001000000370000000D',
use File::Basename qw(basename dirname);
use File::Path qw(rmtree);
use Fcntl qw(:seek);
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 110;
program_help_ok('pg_basebackup');
program_version_ok('pg_basebackup');
program_options_handling_ok('pg_basebackup');
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
# Set umask so test directories and files are created with default permissions
umask(0077);
# to our physical temp location. That way we can use shorter names
# for the tablespace directories, which hopefully won't run afoul of
# the 99 character length limit.
-my $sys_tempdir = TestLib::tempdir_short;
-my $real_sys_tempdir = TestLib::perl2host($sys_tempdir) . "/tempdir";
+my $sys_tempdir = PostgreSQL::Test::Utils::tempdir_short;
+my $real_sys_tempdir = PostgreSQL::Test::Utils::perl2host($sys_tempdir) . "/tempdir";
my $shorter_tempdir = $sys_tempdir . "/tempdir";
dir_symlink "$tempdir", $shorter_tempdir;
mkdir "$tempdir/tblspc1";
my $realTsDir = "$real_sys_tempdir/tblspc1";
-my $real_tempdir = TestLib::perl2host($tempdir);
+my $real_tempdir = PostgreSQL::Test::Utils::perl2host($tempdir);
$node->safe_psql('postgres',
"CREATE TABLESPACE tblspc1 LOCATION '$realTsDir';");
$node->safe_psql('postgres',
skip "no tar program available", 1
if (!defined $tar || $tar eq '');
- my $node2 = PostgresNode->new('replica');
+ my $node2 = PostgreSQL::Test::Cluster->new('replica');
# Recover main data directory
$node2->init_from_backup($node, 'tarbackup2', tar_program => $tar);
my $repTsDir = "$tempdir/tblspc1replica";
my $realRepTsDir = "$real_sys_tempdir/tblspc1replica";
mkdir $repTsDir;
- TestLib::system_or_bail($tar, 'xf', $tblspc_tars[0], '-C', $repTsDir);
+ PostgreSQL::Test::Utils::system_or_bail($tar, 'xf', $tblspc_tars[0], '-C', $repTsDir);
# Update tablespace map to point to new directory.
# XXX Ideally pg_basebackup would handle this.
use strict;
use warnings;
-use TestLib;
-use PostgresNode;
+use PostgreSQL::Test::Utils;
+use PostgreSQL::Test::Cluster;
use Test::More tests => 27;
program_help_ok('pg_receivewal');
# Set umask so test directories and files are created with default permissions
umask(0077);
-my $primary = PostgresNode->new('primary');
+my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
$primary->start;
use strict;
use warnings;
-use TestLib;
-use PostgresNode;
+use PostgreSQL::Test::Utils;
+use PostgreSQL::Test::Cluster;
use Test::More tests => 20;
program_help_ok('pg_recvlogical');
program_version_ok('pg_recvlogical');
program_options_handling_ok('pg_recvlogical');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
# Initialize node without replication settings
$node->init(allows_streaming => 1, has_archiving => 1);
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 8;
program_help_ok('pg_checksums');
use strict;
use warnings;
use Config;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Fcntl qw(:seek);
use Test::More tests => 66;
}
# Initialize node with checksums disabled.
-my $node = PostgresNode->new('node_checksum');
+my $node = PostgreSQL::Test::Cluster->new('node_checksum');
$node->init();
my $pgdata = $node->data_dir;
my $basedir = $node->basedir;
my $tablespace_dir = "$basedir/ts_corrupt_dir";
mkdir($tablespace_dir);
-$tablespace_dir = TestLib::perl2host($tablespace_dir);
+$tablespace_dir = PostgreSQL::Test::Utils::perl2host($tablespace_dir);
$node->safe_psql('postgres',
"CREATE TABLESPACE ts_corrupt LOCATION '$tablespace_dir';");
check_relation_corruption($node, 'corrupt2', 'ts_corrupt');
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 20;
program_help_ok('pg_config');
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 17;
program_help_ok('pg_controldata');
command_fails([ 'pg_controldata', 'nonexistent' ],
'pg_controldata with nonexistent directory fails');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
command_like([ 'pg_controldata', $node->data_dir ],
use Config;
use Fcntl ':mode';
use File::stat qw{lstat};
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 24;
-my $tempdir = TestLib::tempdir;
-my $tempdir_short = TestLib::tempdir_short;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
+my $tempdir_short = PostgreSQL::Test::Utils::tempdir_short;
program_help_ok('pg_ctl');
program_version_ok('pg_ctl');
'pg_ctl initdb');
command_ok([ $ENV{PG_REGRESS}, '--config-auth', "$tempdir/data" ],
'configure authentication');
-my $node_port = PostgresNode::get_free_port();
+my $node_port = PostgreSQL::Test::Cluster::get_free_port();
open my $conf, '>>', "$tempdir/data/postgresql.conf";
print $conf "fsync = off\n";
print $conf "port = $node_port\n";
-print $conf TestLib::slurp_file($ENV{TEMP_CONFIG})
+print $conf PostgreSQL::Test::Utils::slurp_file($ENV{TEMP_CONFIG})
if defined $ENV{TEMP_CONFIG};
if ($use_unix_sockets)
close $conf;
my $ctlcmd = [
'pg_ctl', 'start', '-D', "$tempdir/data", '-l',
- "$TestLib::log_path/001_start_stop_server.log"
+ "$PostgreSQL::Test::Utils::log_path/001_start_stop_server.log"
];
if ($Config{osname} ne 'msys')
{
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 3;
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
command_exit_is([ 'pg_ctl', 'status', '-D', "$tempdir/nonexistent" ],
4, 'pg_ctl status with nonexistent directory');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
command_exit_is([ 'pg_ctl', 'status', '-D', $node->data_dir ],
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 12;
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
command_fails_like(
[ 'pg_ctl', '-D', "$tempdir/nonexistent", 'promote' ],
qr/directory .* does not exist/,
'pg_ctl promote with nonexistent directory');
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1);
command_fails_like(
qr/not in standby mode/,
'pg_ctl promote of primary instance fails');
-my $node_standby = PostgresNode->new('standby');
+my $node_standby = PostgreSQL::Test::Cluster->new('standby');
$node_primary->backup('my_backup');
$node_standby->init_from_backup($node_primary, 'my_backup',
has_streaming => 1);
'promoted standby is not in recovery');
# same again with default wait option
-$node_standby = PostgresNode->new('standby2');
+$node_standby = PostgreSQL::Test::Cluster->new('standby2');
$node_standby->init_from_backup($node_primary, 'my_backup',
has_streaming => 1);
$node_standby->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 10;
use Time::HiRes qw(usleep);
}
# Set up node with logging collector
-my $node = PostgresNode->new('primary');
+my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init();
$node->append_conf(
'postgresql.conf', qq(
use warnings;
use Config;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 82;
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
#########################################
# Basic checks
use warnings;
use Config;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
###############################################################
# Definition of the pg_dump runs to make.
# the full command and arguments to run. Note that this is run
# using $node->command_ok(), so the port does not need to be
# specified and is pulled from $PGPORT, which is set by the
-# PostgresNode system.
+# PostgreSQL::Test::Cluster system.
#
# restore_cmd is the pg_restore command to run, if any. Note
# that this should generally be used when the pg_dump goes to
#########################################
# Create a PG instance to test actually dumping from
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 3;
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
my $port = $node->port;
$node->init;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
-if ($TestLib::is_msys2)
+if ($PostgreSQL::Test::Utils::is_msys2)
{
plan skip_all => 'High bit name tests fail on Msys2';
}
. generate_ascii_string(1, 9)
. generate_ascii_string(11, 12)
. generate_ascii_string(14, 33)
- . ($TestLib::windows_os ? '' : '"x"') # IPC::Run mishandles '"' on Windows
+ . ($PostgreSQL::Test::Utils::windows_os ? '' : '"x"') # IPC::Run mishandles '"' on Windows
. generate_ascii_string(35, 43) # skip ','
. generate_ascii_string(45, 54);
my $dbname2 = 'regression' . generate_ascii_string(55, 65) # skip 'B'-'W'
my $src_bootstrap_super = 'regress_postgres';
my $dst_bootstrap_super = 'boot';
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init(extra =>
[ '-U', $src_bootstrap_super, '--locale=C', '--encoding=LATIN1' ]);
my ($stderr, $result);
my $restore_super = qq{regress_a'b\\c=d\\ne"f};
$restore_super =~ s/"//g
- if $TestLib::windows_os; # IPC::Run mishandles '"' on Windows
+ if $PostgreSQL::Test::Utils::windows_os; # IPC::Run mishandles '"' on Windows
# Restore full dump through psql using environment variables for
# dbname/user connection parameters
-my $envar_node = PostgresNode->new('destination_envar');
+my $envar_node = PostgreSQL::Test::Cluster->new('destination_envar');
$envar_node->init(
extra =>
[ '-U', $dst_bootstrap_super, '--locale=C', '--encoding=LATIN1' ],
# dbname/user connection parameters. "\connect dbname=" forgets
# user/port from command line.
-my $cmdline_node = PostgresNode->new('destination_cmdline');
+my $cmdline_node = PostgreSQL::Test::Cluster->new('destination_cmdline');
$cmdline_node->init(
extra =>
[ '-U', $dst_bootstrap_super, '--locale=C', '--encoding=LATIN1' ],
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 12;
program_help_ok('pg_resetwal');
program_version_ok('pg_resetwal');
program_options_handling_ok('pg_resetwal');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
command_like([ 'pg_resetwal', '-n', $node->data_dir ],
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 6;
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
my $pg_control = $node->data_dir . '/global/pg_control';
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 23;
use FindBin;
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 7;
use FindBin;
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 5;
use File::Find;
use warnings;
use File::Copy;
use File::Path qw(rmtree);
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 5;
use FindBin;
{
my $test_mode = shift;
- my $primary_xlogdir = "${TestLib::tmp_check}/xlog_primary";
+ my $primary_xlogdir = "${PostgreSQL::Test::Utils::tmp_check}/xlog_primary";
rmtree($primary_xlogdir);
RewindTest::setup_cluster($test_mode);
#
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 1;
use FindBin;
#
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 12;
program_help_ok('pg_rewind');
program_version_ok('pg_rewind');
program_options_handling_ok('pg_rewind');
-my $primary_pgdata = TestLib::tempdir;
-my $standby_pgdata = TestLib::tempdir;
+my $primary_pgdata = PostgreSQL::Test::Utils::tempdir;
+my $standby_pgdata = PostgreSQL::Test::Utils::tempdir;
command_fails(
[
'pg_rewind', '--debug',
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 3;
use FindBin;
use lib $FindBin::RealBin;
use File::Copy;
-use PostgresNode;
+use PostgreSQL::Test::Cluster;
use RewindTest;
-my $tmp_folder = TestLib::tempdir;
+my $tmp_folder = PostgreSQL::Test::Utils::tempdir;
my $node_a;
my $node_b;
#
# A (primary) <--- B (standby) <--- C (standby)
$node_a->backup('my_backup');
-$node_b = PostgresNode->new('node_b');
+$node_b = PostgreSQL::Test::Cluster->new('node_b');
$node_b->init_from_backup($node_a, 'my_backup', has_streaming => 1);
$node_b->set_standby_mode();
$node_b->start;
$node_b->backup('my_backup');
-$node_c = PostgresNode->new('node_c');
+$node_c = PostgreSQL::Test::Cluster->new('node_c');
$node_c->init_from_backup($node_b, 'my_backup', has_streaming => 1);
$node_c->set_standby_mode();
$node_c->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 3;
use File::Copy;
-my $tmp_folder = TestLib::tempdir;
+my $tmp_folder = PostgreSQL::Test::Utils::tempdir;
-my $node_1 = PostgresNode->new('node_1');
+my $node_1 = PostgreSQL::Test::Cluster->new('node_1');
$node_1->init(allows_streaming => 1);
$node_1->append_conf(
'postgresql.conf', qq(
my $backup_name = 'my_backup';
$node_1->backup($backup_name);
-my $node_2 = PostgresNode->new('node_2');
+my $node_2 = PostgreSQL::Test::Cluster->new('node_2');
$node_2->init_from_backup($node_1, $backup_name, has_streaming => 1);
$node_2->start;
-my $node_3 = PostgresNode->new('node_3');
+my $node_3 = PostgreSQL::Test::Cluster->new('node_3');
$node_3->init_from_backup($node_1, $backup_name, has_streaming => 1);
$node_3->start;
use File::Copy;
use File::Path qw(rmtree);
use IPC::Run qw(run);
-use PostgresNode;
-use RecursiveCopy;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::RecursiveCopy;
+use PostgreSQL::Test::Utils;
use Test::More;
our @EXPORT = qw(
# Initialize primary, data checksums are mandatory
$node_primary =
- PostgresNode->new('primary' . ($extra_name ? "_${extra_name}" : ''));
+ PostgreSQL::Test::Cluster->new('primary' . ($extra_name ? "_${extra_name}" : ''));
# Set up pg_hba.conf and pg_ident.conf for the role running
# pg_rewind. This role is used for all the tests, and has
my $extra_name = shift;
$node_standby =
- PostgresNode->new('standby' . ($extra_name ? "_${extra_name}" : ''));
+ PostgreSQL::Test::Cluster->new('standby' . ($extra_name ? "_${extra_name}" : ''));
$node_primary->backup('my_backup');
$node_standby->init_from_backup($node_primary, 'my_backup');
my $connstr_primary = $node_primary->connstr();
my $primary_pgdata = $node_primary->data_dir;
my $standby_pgdata = $node_standby->data_dir;
my $standby_connstr = $node_standby->connstr('postgres');
- my $tmp_folder = TestLib::tempdir;
+ my $tmp_folder = PostgreSQL::Test::Utils::tempdir;
# Append the rewind-specific role to the connection string.
$standby_connstr = "$standby_connstr user=rewind_user";
# segments from the old primary to the archives. These
# will be used by pg_rewind.
rmtree($node_primary->archive_dir);
- RecursiveCopy::copypath($node_primary->data_dir . "/pg_wal",
+ PostgreSQL::Test::RecursiveCopy::copypath($node_primary->data_dir . "/pg_wal",
$node_primary->archive_dir);
# Fast way to remove entire directory content
use warnings;
use Config;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 12;
#########################################
use warnings;
use Config;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 12;
#########################################
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 16;
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
program_help_ok('pg_verifybackup');
program_version_ok('pg_verifybackup');
use Cwd;
use Config;
use File::Path qw(rmtree);
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 19;
-my $primary = PostgresNode->new('primary');
+my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
$primary->start;
use Cwd;
use Config;
use File::Path qw(rmtree);
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 44;
-my $primary = PostgresNode->new('primary');
+my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
$primary->start;
# Include a user-defined tablespace in the hopes of detecting problems in that
# area.
-my $source_ts_path = TestLib::perl2host(TestLib::tempdir_short());
+my $source_ts_path = PostgreSQL::Test::Utils::perl2host(PostgreSQL::Test::Utils::tempdir_short());
my $source_ts_prefix = $source_ts_path;
$source_ts_prefix =~ s!(^[A-Z]:/[^/]*)/.*!$1!;
# Take a backup and check that it verifies OK.
my $backup_path = $primary->backup_dir . '/' . $name;
- my $backup_ts_path = TestLib::perl2host(TestLib::tempdir_short());
+ my $backup_ts_path = PostgreSQL::Test::Utils::perl2host(PostgreSQL::Test::Utils::tempdir_short());
# The tablespace map parameter confuses Msys2, which tries to mangle
# it. Tell it not to.
# See https://www.msys2.org/wiki/Porting/#filesystem-namespaces
use Cwd;
use Config;
use File::Path qw(rmtree);
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 25;
# Start up the server and take a backup.
-my $primary = PostgresNode->new('primary');
+my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
$primary->start;
my $backup_path = $primary->backup_dir . '/test_options';
use warnings;
use Cwd;
use Config;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 58;
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
test_bad_manifest(
'input string ended unexpectedly',
use warnings;
use Cwd;
use Config;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 5;
-my $primary = PostgresNode->new('primary');
+my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
$primary->start;
my $backup_path = $primary->backup_dir . '/test_encoding';
use Cwd;
use Config;
use File::Path qw(rmtree);
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 9;
# Start up the server and take a backup.
-my $primary = PostgresNode->new('primary');
+my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
$primary->start;
my $backup_path = $primary->backup_dir . '/test_wal';
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 8;
program_help_ok('pg_waldump');
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
use Config;
# start a pgbench specific server
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
my $ts = $node->basedir . '/regress_pgbench_tap_1_ts_dir';
mkdir $ts or die "cannot create directory $ts";
# this takes care of WIN-specific path issues
-my $ets = TestLib::perl2host($ts);
+my $ets = PostgreSQL::Test::Utils::perl2host($ts);
# the next commands will issue a syntax error if the path contains a "'"
$node->safe_psql('postgres',
select column1::jsonb from (values (:value), (:long)) as q;
]
});
-my $log = TestLib::slurp_file($node->logfile);
+my $log = PostgreSQL::Test::Utils::slurp_file($node->logfile);
unlike(
$log,
qr[DETAIL: parameters: \$1 = '\{ invalid ',],
select column1::jsonb from (values (:value), (:long)) as q;
]
});
-$log = TestLib::slurp_file($node->logfile);
+$log = PostgreSQL::Test::Utils::slurp_file($node->logfile);
like(
$log,
qr[DETAIL: parameters: \$1 = '\{ invalid ', \$2 = '''Valame Dios!'' dijo Sancho; ''no le dije yo a vuestra merced que mirase bien lo que hacia\?'''],
select column1::jsonb from (values (:value), (:long)) as q;
]
});
-$log = TestLib::slurp_file($node->logfile);
+$log = PostgreSQL::Test::Utils::slurp_file($node->logfile);
like(
$log,
qr[DETAIL: parameters: \$1 = '\{ inval\.\.\.', \$2 = '''Valame\.\.\.'],
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More;
# create a directory for scripts
$testname =~ s,.*/,,;
$testname =~ s/\.pl$//;
-my $testdir = "$TestLib::tmp_check/t_${testname}_stuff";
+my $testdir = "$PostgreSQL::Test::Utils::tmp_check/t_${testname}_stuff";
mkdir $testdir
or BAIL_OUT("could not create test directory \"${testdir}\": $!");
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 25;
program_help_ok('psql');
is($stderr, '', "psql --help=$arg nothing to stderr");
}
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->append_conf(
'postgresql.conf', q{
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
use IPC::Run qw(pump finish timer);
use Data::Dumper;
}
# start a new server
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
# their ~/.psql_history, so be sure to redirect history into a temp file.
# We might as well put it in the test log directory, so that buildfarm runs
# capture the result for possible debugging purposes.
-my $historyfile = "${TestLib::log_path}/010_psql_history.txt";
+my $historyfile = "${PostgreSQL::Test::Utils::log_path}/010_psql_history.txt";
$ENV{PSQL_HISTORY} = $historyfile;
# Another pitfall for developers is that they might have a ~/.inputrc
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 2;
use Time::HiRes qw(usleep);
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
pump $h while length $stdin;
my $count;
my $psql_pid;
- until (-s "$tempdir/psql.pid" and ($psql_pid = TestLib::slurp_file("$tempdir/psql.pid")) =~ /^\d+\n/s)
+ until (-s "$tempdir/psql.pid" and ($psql_pid = PostgreSQL::Test::Utils::slurp_file("$tempdir/psql.pid")) =~ /^\d+\n/s)
{
($count++ < 180 * 100) or die "pid file did not appear";
usleep(10_000)
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 14;
program_help_ok('clusterdb');
program_version_ok('clusterdb');
program_options_handling_ok('clusterdb');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 2;
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 22;
program_help_ok('createdb');
program_version_ok('createdb');
program_options_handling_ok('createdb');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 17;
program_help_ok('createuser');
program_version_ok('createuser');
program_options_handling_ok('createuser');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 13;
program_help_ok('dropdb');
program_version_ok('dropdb');
program_options_handling_ok('dropdb');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 11;
program_help_ok('dropuser');
program_version_ok('dropuser');
program_options_handling_ok('dropuser');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 10;
program_help_ok('pg_isready');
command_fails(['pg_isready'], 'fails with no server running');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 58;
program_help_ok('reindexdb');
program_version_ok('reindexdb');
program_options_handling_ok('reindexdb');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
# Create a tablespace for testing.
my $tbspace_path = $node->basedir . '/regress_reindex_tbspace';
mkdir $tbspace_path or die "cannot create directory $tbspace_path";
-$tbspace_path = TestLib::perl2host($tbspace_path);
+$tbspace_path = PostgreSQL::Test::Utils::perl2host($tbspace_path);
my $tbspace_name = 'reindex_tbspace';
$node->safe_psql('postgres',
"CREATE TABLESPACE $tbspace_name LOCATION '$tbspace_path';");
use strict;
use warnings;
-use PostgresNode;
+use PostgreSQL::Test::Cluster;
use Test::More tests => 2;
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 58;
program_help_ok('vacuumdb');
program_version_ok('vacuumdb');
program_options_handling_ok('vacuumdb');
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
+use PostgreSQL::Test::Cluster;
use Test::More tests => 2;
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
+use PostgreSQL::Test::Cluster;
use Test::More tests => 4;
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 3;
# Tests to check connection string handling in utilities
my $dbname3 = generate_ascii_string(130, 192);
my $dbname4 = generate_ascii_string(193, 255);
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init(extra => [ '--locale=C', '--encoding=LATIN1' ]);
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
if (!$use_unix_sockets)
{
}
# Initialize primary node
-my $node = PostgresNode->new('primary');
+my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init;
$node->append_conf('postgresql.conf', "log_connections = on\n");
$node->start;
test_role($node, 'scram_role', 'scram-sha-256', 2);
# Test .pgpass processing; but use a temp file, don't overwrite the real one!
-my $pgpassfile = "${TestLib::tmp_check}/pgpass";
+my $pgpassfile = "${PostgreSQL::Test::Utils::tmp_check}/pgpass";
delete $ENV{"PGPASSWORD"};
delete $ENV{"PGCHANNELBINDING"};
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
if (!$use_unix_sockets)
{
# Initialize primary node. Force UTF-8 encoding, so that we can use non-ASCII
# characters in the passwords below.
-my $node = PostgresNode->new('primary');
+my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init(extra => [ '--locale=C', '--encoding=UTF8' ]);
$node->start;
use strict;
use warnings;
-use TestLib;
-use PostgresNode;
+use PostgreSQL::Test::Utils;
+use PostgreSQL::Test::Cluster;
use Test::More;
use Time::HiRes qw(usleep);
my $hostaddr = '127.0.0.1';
my $realm = 'EXAMPLE.COM';
-my $krb5_conf = "${TestLib::tmp_check}/krb5.conf";
-my $kdc_conf = "${TestLib::tmp_check}/kdc.conf";
-my $krb5_cache = "${TestLib::tmp_check}/krb5cc";
-my $krb5_log = "${TestLib::log_path}/krb5libs.log";
-my $kdc_log = "${TestLib::log_path}/krb5kdc.log";
-my $kdc_port = PostgresNode::get_free_port();
-my $kdc_datadir = "${TestLib::tmp_check}/krb5kdc";
-my $kdc_pidfile = "${TestLib::tmp_check}/krb5kdc.pid";
-my $keytab = "${TestLib::tmp_check}/krb5.keytab";
+my $krb5_conf = "${PostgreSQL::Test::Utils::tmp_check}/krb5.conf";
+my $kdc_conf = "${PostgreSQL::Test::Utils::tmp_check}/kdc.conf";
+my $krb5_cache = "${PostgreSQL::Test::Utils::tmp_check}/krb5cc";
+my $krb5_log = "${PostgreSQL::Test::Utils::log_path}/krb5libs.log";
+my $kdc_log = "${PostgreSQL::Test::Utils::log_path}/krb5kdc.log";
+my $kdc_port = PostgreSQL::Test::Cluster::get_free_port();
+my $kdc_datadir = "${PostgreSQL::Test::Utils::tmp_check}/krb5kdc";
+my $kdc_pidfile = "${PostgreSQL::Test::Utils::tmp_check}/krb5kdc.pid";
+my $keytab = "${PostgreSQL::Test::Utils::tmp_check}/krb5.keytab";
my $dbname = 'postgres';
my $username = 'test1';
note "setting up PostgreSQL instance";
-my $node = PostgresNode->new('node');
+my $node = PostgreSQL::Test::Cluster->new('node');
$node->init;
$node->append_conf(
'postgresql.conf', qq{
use strict;
use warnings;
-use TestLib;
-use PostgresNode;
+use PostgreSQL::Test::Utils;
+use PostgreSQL::Test::Cluster;
use Test::More;
if ($ENV{with_ldap} eq 'yes')
$ENV{PATH} = "$ldap_bin_dir:$ENV{PATH}" if $ldap_bin_dir;
-my $ldap_datadir = "${TestLib::tmp_check}/openldap-data";
-my $slapd_certs = "${TestLib::tmp_check}/slapd-certs";
-my $slapd_conf = "${TestLib::tmp_check}/slapd.conf";
-my $slapd_pidfile = "${TestLib::tmp_check}/slapd.pid";
-my $slapd_logfile = "${TestLib::log_path}/slapd.log";
-my $ldap_conf = "${TestLib::tmp_check}/ldap.conf";
+my $ldap_datadir = "${PostgreSQL::Test::Utils::tmp_check}/openldap-data";
+my $slapd_certs = "${PostgreSQL::Test::Utils::tmp_check}/slapd-certs";
+my $slapd_conf = "${PostgreSQL::Test::Utils::tmp_check}/slapd.conf";
+my $slapd_pidfile = "${PostgreSQL::Test::Utils::tmp_check}/slapd.pid";
+my $slapd_logfile = "${PostgreSQL::Test::Utils::log_path}/slapd.log";
+my $ldap_conf = "${PostgreSQL::Test::Utils::tmp_check}/ldap.conf";
my $ldap_server = 'localhost';
-my $ldap_port = PostgresNode::get_free_port();
-my $ldaps_port = PostgresNode::get_free_port();
+my $ldap_port = PostgreSQL::Test::Cluster::get_free_port();
+my $ldaps_port = PostgreSQL::Test::Cluster::get_free_port();
my $ldap_url = "ldap://$ldap_server:$ldap_port";
my $ldaps_url = "ldaps://$ldap_server:$ldaps_port";
my $ldap_basedn = 'dc=example,dc=net';
my $ldap_rootdn = 'cn=Manager,dc=example,dc=net';
my $ldap_rootpw = 'secret';
-my $ldap_pwfile = "${TestLib::tmp_check}/ldappassword";
+my $ldap_pwfile = "${PostgreSQL::Test::Utils::tmp_check}/ldappassword";
note "setting up slapd";
note "setting up PostgreSQL instance";
-my $node = PostgresNode->new('node');
+my $node = PostgreSQL::Test::Cluster->new('node');
$node->init;
$node->append_conf('postgresql.conf', "log_connections = on\n");
$node->start;
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 2;
-use PostgresNode;
+use PostgreSQL::Test::Cluster;
-my $node = PostgresNode->new('tango');
+my $node = PostgreSQL::Test::Cluster->new('tango');
$node->init;
$node->append_conf('postgresql.conf', 'autovacuum_naptime=1s');
$node->start;
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 2;
-use PostgresNode;
+use PostgreSQL::Test::Cluster;
-my $node = PostgresNode->new('foxtrot');
+my $node = PostgreSQL::Test::Cluster->new('foxtrot');
$node->init;
$node->append_conf('postgresql.conf', 'track_commit_timestamp = on');
$node->start;
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 4;
-use PostgresNode;
+use PostgreSQL::Test::Cluster;
my $bkplabel = 'backup';
-my $primary = PostgresNode->new('primary');
+my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
$primary->append_conf(
$primary->start;
$primary->backup($bkplabel);
-my $standby = PostgresNode->new('standby');
+my $standby = PostgreSQL::Test::Cluster->new('standby');
$standby->init_from_backup($primary, $bkplabel, has_streaming => 1);
$standby->start;
use strict;
use warnings;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More tests => 4;
-use PostgresNode;
+use PostgreSQL::Test::Cluster;
my $bkplabel = 'backup';
-my $primary = PostgresNode->new('primary');
+my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
$primary->append_conf(
'postgresql.conf', qq{
$primary->start;
$primary->backup($bkplabel);
-my $standby = PostgresNode->new('standby');
+my $standby = PostgreSQL::Test::Cluster->new('standby');
$standby->init_from_backup($primary, $bkplabel, has_streaming => 1);
$standby->start;
# Testing of commit timestamps preservation across restarts
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 16;
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1);
$node_primary->append_conf('postgresql.conf', 'track_commit_timestamp = on');
$node_primary->start;
use warnings;
use Config;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
die "oops: $err" unless $err eq '';
my @tests = split(/\s+/, $out);
-mkdir "$TestLib::tmp_check/traces";
+mkdir "$PostgreSQL::Test::Utils::tmp_check/traces";
for my $testname (@tests)
{
pipeline_abort transaction disallowed_in_pipeline)) > 0;
# For a bunch of tests, generate a libpq trace file too.
- my $traceout = "$TestLib::tmp_check/traces/$testname.trace";
+ my $traceout = "$PostgreSQL::Test::Utils::tmp_check/traces/$testname.trace";
if ($cmptrace)
{
push @extraargs, "-t", $traceout;
use File::Copy;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Test::More;
-use PostgresNode;
+use PostgreSQL::Test::Cluster;
unless (($ENV{with_ssl} || "") eq 'openssl')
{
# see the Makefile for how the certificate and key have been generated
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->append_conf('postgresql.conf',
"ssl_passphrase.passphrase = '$rot13pass'");
$node->append_conf('postgresql.conf', "ssl_passphrase.passphrase = 'blurfl'");
# try to start the server again
-my $ret = TestLib::system_log('pg_ctl', '-D', $node->data_dir, '-l',
+my $ret = PostgreSQL::Test::Utils::system_log('pg_ctl', '-D', $node->data_dir, '-l',
$node->logfile, 'start');
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 42;
# Initialize a test cluster
-my $node = PostgresNode->new('primary');
+my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init();
# Turn message level up to DEBUG1 so that we get the messages we want to see
$node->append_conf('postgresql.conf', 'client_min_messages = DEBUG1');
use warnings;
use Config;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
###############################################################
# This structure is based off of the src/bin/pg_dump/t test
# the full command and arguments to run. Note that this is run
# using $node->command_ok(), so the port does not need to be
# specified and is pulled from $PGPORT, which is set by the
-# PostgresNode system.
+# PostgreSQL::Test::Cluster system.
#
# restore_cmd is the pg_restore command to run, if any. Note
# that this should generally be used when the pg_dump goes to
#########################################
# Create a PG instance to test actually dumping from
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
ifeq ($(enable_tap_tests),yes)
installdirs:
- $(MKDIR_P) '$(DESTDIR)$(pgxsdir)/$(subdir)'
+ $(MKDIR_P) '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgreSQL/Test'
install: all installdirs
- $(INSTALL_DATA) $(srcdir)/TestLib.pm '$(DESTDIR)$(pgxsdir)/$(subdir)/TestLib.pm'
- $(INSTALL_DATA) $(srcdir)/SimpleTee.pm '$(DESTDIR)$(pgxsdir)/$(subdir)/SimpleTee.pm'
- $(INSTALL_DATA) $(srcdir)/RecursiveCopy.pm '$(DESTDIR)$(pgxsdir)/$(subdir)/RecursiveCopy.pm'
- $(INSTALL_DATA) $(srcdir)/PostgresNode.pm '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgresNode.pm'
- $(INSTALL_DATA) $(srcdir)/PostgresVersion.pm '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgresVersion.pm'
+ $(INSTALL_DATA) $(srcdir)/PostgreSQL/Test/Utils.pm '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgreSQL/Test/Utils.pm'
+ $(INSTALL_DATA) $(srcdir)/PostgreSQL/Test/SimpleTee.pm '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgreSQL/Test/SimpleTee.pm'
+ $(INSTALL_DATA) $(srcdir)/PostgreSQL/Test/RecursiveCopy.pm '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgreSQL/Test/RecursiveCopy.pm'
+ $(INSTALL_DATA) $(srcdir)/PostgreSQL/Test/Cluster.pm '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgreSQL/Test/Cluster.pm'
+ $(INSTALL_DATA) $(srcdir)/PostgreSQL/Version.pm '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgreSQL/Version.pm'
uninstall:
- rm -f '$(DESTDIR)$(pgxsdir)/$(subdir)/TestLib.pm'
- rm -f '$(DESTDIR)$(pgxsdir)/$(subdir)/SimpleTee.pm'
- rm -f '$(DESTDIR)$(pgxsdir)/$(subdir)/RecursiveCopy.pm'
- rm -f '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgresNode.pm'
- rm -f '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgresVersion.pm'
+ rm -f '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgreSQL/Test/Utils.pm'
+ rm -f '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgreSQL/Test/SimpleTee.pm'
+ rm -f '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgreSQL/Test/RecursiveCopy.pm'
+ rm -f '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgreSQL/Test/Cluster.pm'
+ rm -f '$(DESTDIR)$(pgxsdir)/$(subdir)/PostgreSQL/Version.pm'
endif
=head1 NAME
-PostgresNode - class representing PostgreSQL server instance
+PostgreSQL::Test::Cluster - class representing PostgreSQL server instance
=head1 SYNOPSIS
- use PostgresNode;
+ use PostgreSQL::Test::Cluster;
- my $node = PostgresNode->new('mynode');
+ my $node = PostgreSQL::Test::Cluster->new('mynode');
# Create a data directory with initdb
$node->init();
my $ret = $node->backup_fs_cold('testbackup3')
# Restore it to create a new independent node (not a replica)
- my $other_node = PostgresNode->new('mycopy');
+ my $other_node = PostgreSQL::Test::Cluster->new('mycopy');
$other_node->init_from_backup($node, 'testbackup');
$other_node->start;
$node->stop('fast');
# Find a free, unprivileged TCP port to bind some other service to
- my $port = PostgresNode::get_free_port();
+ my $port = PostgreSQL::Test::Cluster::get_free_port();
=head1 DESCRIPTION
-PostgresNode contains a set of routines able to work on a PostgreSQL node,
+PostgreSQL::Test::Cluster contains a set of routines able to work on a PostgreSQL node,
allowing to start, stop, backup and initialize it with various options.
The set of nodes managed by a given test is also managed by this module.
-In addition to node management, PostgresNode instances have some wrappers
+In addition to node management, PostgreSQL::Test::Cluster instances have some wrappers
around Test::More functions to run commands with an environment set up to
point to the instance.
=cut
-package PostgresNode;
+package PostgreSQL::Test::Cluster;
use strict;
use warnings;
use File::stat qw(stat);
use File::Temp ();
use IPC::Run;
-use PostgresVersion;
-use RecursiveCopy;
+use PostgreSQL::Version;
+use PostgreSQL::Test::RecursiveCopy;
use Socket;
use Test::More;
-use TestLib ();
+use PostgreSQL::Test::Utils ();
use Time::HiRes qw(usleep);
use Scalar::Util qw(blessed);
# Set PGHOST for backward compatibility. This doesn't work for own_host
# nodes, so prefer to not rely on this when writing new tests.
- $use_tcp = !$TestLib::use_unix_sockets;
+ $use_tcp = !$PostgreSQL::Test::Utils::use_unix_sockets;
$test_localhost = "127.0.0.1";
$last_host_assigned = 1;
- $test_pghost = $use_tcp ? $test_localhost : TestLib::tempdir_short;
+ $test_pghost = $use_tcp ? $test_localhost : PostgreSQL::Test::Utils::tempdir_short;
$ENV{PGHOST} = $test_pghost;
$ENV{PGDATABASE} = 'postgres';
or croak "set_replication_conf only works with the default host";
open my $hba, '>>', "$pgdata/pg_hba.conf";
- print $hba "\n# Allow replication (set up by PostgresNode.pm)\n";
- if ($TestLib::windows_os && !$TestLib::use_unix_sockets)
+ print $hba "\n# Allow replication (set up by PostgreSQL::Test::Cluster.pm)\n";
+ if ($PostgreSQL::Test::Utils::windows_os && !$PostgreSQL::Test::Utils::use_unix_sockets)
{
print $hba
"host replication all $test_localhost/32 sspi include_realm=1 map=regress\n";
mkdir $self->backup_dir;
mkdir $self->archive_dir;
- TestLib::system_or_bail('initdb', '-D', $pgdata, '-A', 'trust', '-N',
+ PostgreSQL::Test::Utils::system_or_bail('initdb', '-D', $pgdata, '-A', 'trust', '-N',
@{ $params{extra} });
- TestLib::system_or_bail($ENV{PG_REGRESS}, '--config-auth', $pgdata,
+ PostgreSQL::Test::Utils::system_or_bail($ENV{PG_REGRESS}, '--config-auth', $pgdata,
@{ $params{auth_extra} });
open my $conf, '>>', "$pgdata/postgresql.conf";
- print $conf "\n# Added by PostgresNode.pm\n";
+ print $conf "\n# Added by PostgreSQL::Test::Cluster.pm\n";
print $conf "fsync = off\n";
print $conf "restart_after_crash = off\n";
print $conf "log_line_prefix = '%m [%p] %q%a '\n";
# TEMP_CONFIG. Otherwise, print it before TEMP_CONFIG, thereby permitting
# overrides. Settings that merely improve performance or ease debugging
# belong before TEMP_CONFIG.
- print $conf TestLib::slurp_file($ENV{TEMP_CONFIG})
+ print $conf PostgreSQL::Test::Utils::slurp_file($ENV{TEMP_CONFIG})
if defined $ENV{TEMP_CONFIG};
# XXX Neutralize any stats_temp_directory in TEMP_CONFIG. Nodes running
my $conffile = $self->data_dir . '/' . $filename;
- TestLib::append_to_file($conffile, $str . "\n");
+ PostgreSQL::Test::Utils::append_to_file($conffile, $str . "\n");
chmod($self->group_access() ? 0640 : 0600, $conffile)
or die("unable to set permissions for $conffile");
my $conffile = $self->data_dir . '/' . $filename;
- my $contents = TestLib::slurp_file($conffile);
+ my $contents = PostgreSQL::Test::Utils::slurp_file($conffile);
my @lines = split(/\n/, $contents);
my @result;
my $eq = $skip_equals ? '' : '= ';
local %ENV = $self->_get_env();
print "# Taking pg_basebackup $backup_name from node \"$name\"\n";
- TestLib::system_or_bail(
+ PostgreSQL::Test::Utils::system_or_bail(
'pg_basebackup', '-D',
$backup_path, '-h',
$self->host, '-p',
print "# pg_start_backup: $stdout\n";
}
- RecursiveCopy::copypath(
+ PostgreSQL::Test::RecursiveCopy::copypath(
$self->data_dir,
$backup_path,
filterfn => sub {
=item $node->init_from_backup(root_node, backup_name)
Initialize a node from a backup, which may come from this node or a different
-node. root_node must be a PostgresNode reference, backup_name the string name
+node. root_node must be a PostgreSQL::Test::Cluster reference, backup_name the string name
of a backup previously created on that node with $node->backup.
Does not start the node after initializing it.
if (defined $params{tar_program})
{
mkdir($data_path);
- TestLib::system_or_bail($params{tar_program}, 'xf',
+ PostgreSQL::Test::Utils::system_or_bail($params{tar_program}, 'xf',
$backup_path . '/base.tar',
'-C', $data_path);
- TestLib::system_or_bail(
+ PostgreSQL::Test::Utils::system_or_bail(
$params{tar_program}, 'xf',
$backup_path . '/pg_wal.tar', '-C',
$data_path . '/pg_wal');
else
{
rmdir($data_path);
- RecursiveCopy::copypath($backup_path, $data_path);
+ PostgreSQL::Test::RecursiveCopy::copypath($backup_path, $data_path);
}
chmod(0700, $data_path);
# sub init) so that it does not get copied to standbys.
# -w is now the default but having it here does no harm and helps
# compatibility with older versions.
- $ret = TestLib::system_log('pg_ctl', '-w', '-D', $self->data_dir, '-l',
+ $ret = PostgreSQL::Test::Utils::system_log('pg_ctl', '-w', '-D', $self->data_dir, '-l',
$self->logfile, '-o', "--cluster-name=$name", 'start');
if ($ret != 0)
{
print "# pg_ctl start failed; logfile:\n";
- print TestLib::slurp_file($self->logfile);
+ print PostgreSQL::Test::Utils::slurp_file($self->logfile);
BAIL_OUT("pg_ctl start failed") unless $params{fail_ok};
return 0;
}
print "### Killing node \"$name\" using signal 9\n";
# kill(9, ...) fails under msys Perl 5.8.8, so fall back on pg_ctl.
kill(9, $self->{_pid})
- or TestLib::system_or_bail('pg_ctl', 'kill', 'KILL', $self->{_pid});
+ or PostgreSQL::Test::Utils::system_or_bail('pg_ctl', 'kill', 'KILL', $self->{_pid});
$self->{_pid} = undef;
return;
}
$mode = 'fast' unless defined $mode;
return unless defined $self->{_pid};
print "### Stopping node \"$name\" using mode $mode\n";
- TestLib::system_or_bail('pg_ctl', '-D', $pgdata, '-m', $mode, 'stop');
+ PostgreSQL::Test::Utils::system_or_bail('pg_ctl', '-D', $pgdata, '-m', $mode, 'stop');
$self->_update_pid(0);
return;
}
local %ENV = $self->_get_env();
print "### Reloading node \"$name\"\n";
- TestLib::system_or_bail('pg_ctl', '-D', $pgdata, 'reload');
+ PostgreSQL::Test::Utils::system_or_bail('pg_ctl', '-D', $pgdata, 'reload');
return;
}
# -w is now the default but having it here does no harm and helps
# compatibility with older versions.
- TestLib::system_or_bail('pg_ctl', '-w', '-D', $pgdata, '-l', $logfile,
+ PostgreSQL::Test::Utils::system_or_bail('pg_ctl', '-w', '-D', $pgdata, '-l', $logfile,
'restart');
$self->_update_pid(1);
local %ENV = $self->_get_env();
print "### Promoting node \"$name\"\n";
- TestLib::system_or_bail('pg_ctl', '-D', $pgdata, '-l', $logfile,
+ PostgreSQL::Test::Utils::system_or_bail('pg_ctl', '-D', $pgdata, '-l', $logfile,
'promote');
return;
}
local %ENV = $self->_get_env();
print "### Rotating log in node \"$name\"\n";
- TestLib::system_or_bail('pg_ctl', '-D', $pgdata, '-l', $logfile,
+ PostgreSQL::Test::Utils::system_or_bail('pg_ctl', '-D', $pgdata, '-l', $logfile,
'logrotate');
return;
}
sub enable_restoring
{
my ($self, $root_node, $standby) = @_;
- my $path = TestLib::perl2host($root_node->archive_dir);
+ my $path = PostgreSQL::Test::Utils::perl2host($root_node->archive_dir);
my $name = $self->name;
print "### Enabling WAL restore for node \"$name\"\n";
# in this routine, using only one back-slash, need to be properly changed
# first. Paths also need to be double-quoted to prevent failures where
# the path contains spaces.
- $path =~ s{\\}{\\\\}g if ($TestLib::windows_os);
+ $path =~ s{\\}{\\\\}g if ($PostgreSQL::Test::Utils::windows_os);
my $copy_command =
- $TestLib::windows_os
+ $PostgreSQL::Test::Utils::windows_os
? qq{copy "$path\\\\%f" "%p"}
: qq{cp "$path/%f" "%p"};
sub enable_archiving
{
my ($self) = @_;
- my $path = TestLib::perl2host($self->archive_dir);
+ my $path = PostgreSQL::Test::Utils::perl2host($self->archive_dir);
my $name = $self->name;
print "### Enabling WAL archiving for node \"$name\"\n";
# in this routine, using only one back-slash, need to be properly changed
# first. Paths also need to be double-quoted to prevent failures where
# the path contains spaces.
- $path =~ s{\\}{\\\\}g if ($TestLib::windows_os);
+ $path =~ s{\\}{\\\\}g if ($PostgreSQL::Test::Utils::windows_os);
my $copy_command =
- $TestLib::windows_os
+ $PostgreSQL::Test::Utils::windows_os
? qq{copy "%p" "$path\\\\%f"}
: qq{cp "%p" "$path/%f"};
=pod
-=item PostgresNode->new(node_name, %params)
+=item PostgreSQL::Test::Cluster->new(node_name, %params)
-Build a new object of class C<PostgresNode> (or of a subclass, if you have
+Build a new object of class C<PostgreSQL::Test::Cluster> (or of a subclass, if you have
one), assigning a free port number. Remembers the node, to prevent its port
number from being reused for another node, and to ensure that it gets
shut down when the test script exits.
my $node = {
_port => $port,
_host => $host,
- _basedir => "$TestLib::tmp_check/t_${testname}_${name}_data",
+ _basedir => "$PostgreSQL::Test::Utils::tmp_check/t_${testname}_${name}_data",
_name => $name,
_logfile_generation => 0,
- _logfile_base => "$TestLib::log_path/${testname}_${name}",
- _logfile => "$TestLib::log_path/${testname}_${name}.log"
+ _logfile_base => "$PostgreSQL::Test::Utils::log_path/${testname}_${name}",
+ _logfile => "$PostgreSQL::Test::Utils::log_path/${testname}_${name}.log"
};
if ($params{install_path})
my $v = $node->{_pg_version};
- carp("PostgresNode isn't fully compatible with version " . $v)
+ carp("PostgreSQL::Test::Cluster isn't fully compatible with version " . $v)
if $v < 12;
return $node;
$pg_config = "$inst/bin/pg_config";
BAIL_OUT("pg_config not found: $pg_config")
unless -e $pg_config
- or ($TestLib::windows_os and -e "$pg_config.exe");
+ or ($PostgreSQL::Test::Utils::windows_os and -e "$pg_config.exe");
BAIL_OUT("pg_config not executable: $pg_config")
- unless $TestLib::windows_os or -x $pg_config;
+ unless $PostgreSQL::Test::Utils::windows_os or -x $pg_config;
# Leave $pg_config install_path qualified, to be sure we get the right
# version information, below, or die trying
my $version_line = qx{$pg_config --version};
BAIL_OUT("$pg_config failed: $!") if $?;
- $self->{_pg_version} = PostgresVersion->new($version_line);
+ $self->{_pg_version} = PostgreSQL::Version->new($version_line);
BAIL_OUT("could not parse pg_config --version output: $version_line")
unless defined $self->{_pg_version};
my $inst = $self->{_install_path};
if ($inst)
{
- if ($TestLib::windows_os)
+ if ($PostgreSQL::Test::Utils::windows_os)
{
# Windows picks up DLLs from the PATH rather than *LD_LIBRARY_PATH
# choose the right path separator
anything. This is used by C<new()>, and also by some test cases that need to
start other, non-Postgres servers.
-Ports assigned to existing PostgresNode objects are automatically
+Ports assigned to existing PostgreSQL::Test::Cluster objects are automatically
excluded, even if those servers are not currently running.
XXX A port available now may become unavailable by the time we start
the desired service.
Note: this is not an instance method. As it's not exported it should be
-called from outside the module as C<PostgresNode::get_free_port()>.
+called from outside the module as C<PostgreSQL::Test::Cluster::get_free_port()>.
=cut
if ($found == 1)
{
foreach my $addr (qw(127.0.0.1),
- ($use_tcp && $TestLib::windows_os)
+ ($use_tcp && $PostgreSQL::Test::Utils::windows_os)
? qw(127.0.0.2 127.0.0.3 0.0.0.0)
: ())
{
# As in postmaster, don't use SO_REUSEADDR on Windows
setsockopt(SOCK, SOL_SOCKET, SO_REUSEADDR, pack("l", 1))
- unless $TestLib::windows_os;
+ unless $PostgreSQL::Test::Utils::windows_os;
my $ret = bind(SOCK, $paddr) && listen(SOCK, SOMAXCONN);
close(SOCK);
return $ret;
next if defined $ENV{'PG_TEST_NOCLEAN'};
# clean basedir on clean test invocation
- $node->clean_node if $exit_code == 0 && TestLib::all_tests_passing();
+ $node->clean_node if $exit_code == 0 && PostgreSQL::Test::Utils::all_tests_passing();
}
$? = $exit_code;
ok(0, "$filename must not already exist");
unlink $filename or die "cannot unlink $filename: $!";
}
- TestLib::append_to_file($filename, $$files{$fn});
+ PostgreSQL::Test::Utils::append_to_file($filename, $$files{$fn});
}
}
}
if (@log_like or @log_unlike)
{
- my $log_contents = TestLib::slurp_file($self->logfile, $log_location);
+ my $log_contents = PostgreSQL::Test::Utils::slurp_file($self->logfile, $log_location);
while (my $regex = shift @log_like)
{
if (@log_like or @log_unlike)
{
- my $log_contents = TestLib::slurp_file($self->logfile, $log_location);
+ my $log_contents = PostgreSQL::Test::Utils::slurp_file($self->logfile, $log_location);
while (my $regex = shift @log_like)
{
=item $node->command_ok(...)
-Runs a shell command like TestLib::command_ok, but with PGHOST and PGPORT set
-so that the command will default to connecting to this PostgresNode.
+Runs a shell command like PostgreSQL::Test::Utils::command_ok, but with PGHOST and PGPORT set
+so that the command will default to connecting to this PostgreSQL::Test::Cluster.
=cut
local %ENV = $self->_get_env();
- TestLib::command_ok(@_);
+ PostgreSQL::Test::Utils::command_ok(@_);
return;
}
=item $node->command_fails(...)
-TestLib::command_fails with our connection parameters. See command_ok(...)
+PostgreSQL::Test::Utils::command_fails with our connection parameters. See command_ok(...)
=cut
local %ENV = $self->_get_env();
- TestLib::command_fails(@_);
+ PostgreSQL::Test::Utils::command_fails(@_);
return;
}
=item $node->command_like(...)
-TestLib::command_like with our connection parameters. See command_ok(...)
+PostgreSQL::Test::Utils::command_like with our connection parameters. See command_ok(...)
=cut
local %ENV = $self->_get_env();
- TestLib::command_like(@_);
+ PostgreSQL::Test::Utils::command_like(@_);
return;
}
=item $node->command_fails_like(...)
-TestLib::command_fails_like with our connection parameters. See command_ok(...)
+PostgreSQL::Test::Utils::command_fails_like with our connection parameters. See command_ok(...)
=cut
local %ENV = $self->_get_env();
- TestLib::command_fails_like(@_);
+ PostgreSQL::Test::Utils::command_fails_like(@_);
return;
}
=item $node->command_checks_all(...)
-TestLib::command_checks_all with our connection parameters. See
+PostgreSQL::Test::Utils::command_checks_all with our connection parameters. See
command_ok(...)
=cut
local %ENV = $self->_get_env();
- TestLib::command_checks_all(@_);
+ PostgreSQL::Test::Utils::command_checks_all(@_);
return;
}
my $log_location = -s $self->logfile;
- my $result = TestLib::run_log($cmd);
+ my $result = PostgreSQL::Test::Utils::run_log($cmd);
ok($result, "@$cmd exit code 0");
- my $log = TestLib::slurp_file($self->logfile, $log_location);
+ my $log = PostgreSQL::Test::Utils::slurp_file($self->logfile, $log_location);
like($log, $expected_sql, "$test_name: SQL found in server log");
return;
}
=item $node->run_log(...)
-Runs a shell command like TestLib::run_log, but with connection parameters set
-so that the command will default to connecting to this PostgresNode.
+Runs a shell command like PostgreSQL::Test::Utils::run_log, but with connection parameters set
+so that the command will default to connecting to this PostgreSQL::Test::Cluster.
=cut
local %ENV = $self->_get_env();
- TestLib::run_log(@_);
+ PostgreSQL::Test::Utils::run_log(@_);
return;
}
. join(', ', keys(%valid_modes))
unless exists($valid_modes{$mode});
- # Allow passing of a PostgresNode instance as shorthand
- if (blessed($standby_name) && $standby_name->isa("PostgresNode"))
+ # Allow passing of a PostgreSQL::Test::Cluster instance as shorthand
+ if (blessed($standby_name) && $standby_name->isa("PostgreSQL::Test::Cluster"))
{
$standby_name = $standby_name->name;
}
=head1 NAME
-RecursiveCopy - simple recursive copy implementation
+PostgreSQL::Test::RecursiveCopy - simple recursive copy implementation
=head1 SYNOPSIS
-use RecursiveCopy;
+use PostgreSQL::Test::RecursiveCopy;
-RecursiveCopy::copypath($from, $to, filterfn => sub { return 1; });
-RecursiveCopy::copypath($from, $to);
+PostgreSQL::Test::RecursiveCopy::copypath($from, $to, filterfn => sub { return 1; });
+PostgreSQL::Test::RecursiveCopy::copypath($from, $to);
=cut
-package RecursiveCopy;
+package PostgreSQL::Test::RecursiveCopy;
use strict;
use warnings;
=head1 EXAMPLES
- RecursiveCopy::copypath('/some/path', '/empty/dir',
+ PostgreSQL::Test::RecursiveCopy::copypath('/some/path', '/empty/dir',
filterfn => sub {
# omit log/ and contents
my $src = shift;
# method is currently implemented; that's all we need. We don't want to
# depend on IO::Tee just for this.
-package SimpleTee;
+package PostgreSQL::Test::SimpleTee;
use strict;
use warnings;
=head1 NAME
-
TestLib - helper module for writing PostgreSQL's C<prove> tests.
+
PostgreSQL::Test::Utils - helper module for writing PostgreSQL's C<prove> tests.
=head1 SYNOPSIS
- use TestLib;
+ use PostgreSQL::Test::Utils;
# Test basic output of a command
program_help_ok('initdb');
# Test option combinations
command_fails(['initdb', '--invalid-option'],
'command fails with invalid option');
- my $tempdir = TestLib::tempdir;
+ my $tempdir = PostgreSQL::Test::Utils::tempdir;
command_ok('initdb', '-D', $tempdir);
# Miscellanea
- print "on Windows" if $TestLib::windows_os;
- my $path = TestLib::perl2host($backup_dir);
+ print "on Windows" if $PostgreSQL::Test::Utils::windows_os;
+ my $path = PostgreSQL::Test::Utils::perl2host($backup_dir);
ok(check_mode_recursive($stream_dir, 0700, 0600),
"check stream dir permissions");
- TestLib::system_log('pg_ctl', 'kill', 'QUIT', $slow_pid);
+ PostgreSQL::Test::Utils::system_log('pg_ctl', 'kill', 'QUIT', $slow_pid);
=head1 DESCRIPTION
-C<TestLib> contains a set of routines dedicated to environment setup for
+C<PostgreSQL::Test::Utils> contains a set of routines dedicated to environment setup for
a PostgreSQL regression test run and includes some low-level routines
aimed at controlling command execution, logging and test functions.
# This module should never depend on any other PostgreSQL regression test
# modules.
-package TestLib;
+package PostgreSQL::Test::Utils;
use strict;
use warnings;
use File::stat qw(stat);
use File::Temp ();
use IPC::Run;
-use SimpleTee;
+use PostgreSQL::Test::SimpleTee;
# specify a recent enough version of Test::More to support the
# done_testing() function
# in the log.
my $builder = Test::More->builder;
my $fh = $builder->output;
- tie *$fh, "SimpleTee", $orig_stdout, $testlog;
+ tie *$fh, "PostgreSQL::Test::SimpleTee", $orig_stdout, $testlog;
$fh = $builder->failure_output;
- tie *$fh, "SimpleTee", $orig_stderr, $testlog;
+ tie *$fh, "PostgreSQL::Test::SimpleTee", $orig_stderr, $testlog;
# Enable auto-flushing for all the file handles. Stderr and stdout are
# redirected to the same file, and buffering causes the lines to appear
############################################################################
#
-# PostgresVersion.pm
+# PostgreSQL/Version.pm
#
# Module encapsulating Postgres Version numbers
#
=head1 NAME
-PostgresVersion - class representing PostgreSQL version numbers
+PostgreSQL::Version - class representing PostgreSQL version numbers
=head1 SYNOPSIS
- use PostgresVersion;
+ use PostgreSQL::Version;
- my $version = PostgresVersion->new($version_arg);
+ my $version = PostgreSQL::Version->new($version_arg);
# compare two versions
my $bool = $version1 <= $version2;
=head1 DESCRIPTION
-PostgresVersion encapsulates Postgres version numbers, providing parsing
+PostgreSQL::Version encapsulates Postgres version numbers, providing parsing
of common version formats and comparison operations.
=cut
-package PostgresVersion;
+package PostgreSQL::Version;
use strict;
use warnings;
=over
-=item PostgresVersion->new($version)
+=item PostgreSQL::Version->new($version)
-Create a new PostgresVersion instance.
+Create a new PostgreSQL::Version instance.
The argument can be a number like 12, or a string like '12.2' or the output
of a Postgres command like `psql --version` or `pg_config --version`;
# Routine which compares the _pg_version_array obtained for the two
# arguments and returns -1, 0, or 1, allowing comparison between two
-# PostgresVersion objects or a PostgresVersion and a version string or number.
+# PostgreSQL::Version objects or a PostgreSQL::Version and a version string or number.
#
# If the second argument is not a blessed object we call the constructor
# to make one.
use strict;
use warnings;
- use PostgresNode;
- use TestLib;
+ use PostgreSQL::Test::Cluster;
+ use PostgreSQL::Test::Utils;
# Replace with the number of tests to execute:
use Test::More tests => 1;
then it will generally need to set up one or more nodes, run commands
against them and evaluate the results. For example:
- my $node = PostgresNode->new('primary');
+ my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init;
$node->start;
For available PostgreSQL-specific test methods and some example tests read the
perldoc for the test modules, e.g.:
- perldoc src/test/perl/PostgresNode.pm
+ perldoc src/test/perl/PostgreSQL/Test/Cluster.pm
Portability
-----------
# Minimal test testing streaming replication
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 49;
# Initialize primary node
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
# A specific role is created to perform some tests related to replication,
# and it needs proper authentication configuration.
$node_primary->init(
$node_primary->backup($backup_name);
# Create streaming standby linking to primary
-my $node_standby_1 = PostgresNode->new('standby_1');
+my $node_standby_1 = PostgreSQL::Test::Cluster->new('standby_1');
$node_standby_1->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
$node_standby_1->start;
$node_primary->start;
# Create second standby node linking to standby 1
-my $node_standby_2 = PostgresNode->new('standby_2');
+my $node_standby_2 = PostgreSQL::Test::Cluster->new('standby_2');
$node_standby_2->init_from_backup($node_standby_1, $backup_name,
has_streaming => 1);
$node_standby_2->start;
# test for archiving with hot standby
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 3;
use File::Copy;
# Initialize primary node, doing archives
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(
has_archiving => 1,
allows_streaming => 1);
$node_primary->backup($backup_name);
# Initialize standby node from backup, fetching WAL from archives
-my $node_standby = PostgresNode->new('standby');
+my $node_standby = PostgreSQL::Test::Cluster->new('standby');
$node_standby->init_from_backup($node_primary, $backup_name,
has_restoring => 1);
$node_standby->append_conf('postgresql.conf',
# promoted.
$node_standby->promote;
-my $node_standby2 = PostgresNode->new('standby2');
+my $node_standby2 = PostgreSQL::Test::Cluster->new('standby2');
$node_standby2->init_from_backup($node_primary, $backup_name,
has_restoring => 1);
$node_standby2->start;
# Test for recovery targets: name, timestamp, XID
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 9;
use Time::HiRes qw(usleep);
my $num_rows = shift;
my $until_lsn = shift;
- my $node_standby = PostgresNode->new($node_name);
+ my $node_standby = PostgreSQL::Test::Cluster->new($node_name);
$node_standby->init_from_backup($node_primary, 'my_backup',
has_restoring => 1);
}
# Initialize primary node
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(has_archiving => 1, allows_streaming => 1);
# Bump the transaction ID epoch. This is useful to stress the portability
test_recovery_standby('multiple overriding settings',
'standby_6', $node_primary, \@recovery_params, "3000", $lsn3);
-my $node_standby = PostgresNode->new('standby_7');
+my $node_standby = PostgreSQL::Test::Cluster->new('standby_7');
$node_standby->init_from_backup($node_primary, 'my_backup',
has_restoring => 1);
$node_standby->append_conf(
# Check behavior when recovery ends before target is reached
-$node_standby = PostgresNode->new('standby_8');
+$node_standby = PostgreSQL::Test::Cluster->new('standby_8');
$node_standby->init_from_backup(
$node_primary, 'my_backup',
has_restoring => 1,
use strict;
use warnings;
use File::Path qw(rmtree);
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 3;
$ENV{PGDATABASE} = 'postgres';
# on a new timeline.
# Initialize primary node
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1);
$node_primary->start;
$node_primary->backup($backup_name);
# Create two standbys linking to it
-my $node_standby_1 = PostgresNode->new('standby_1');
+my $node_standby_1 = PostgreSQL::Test::Cluster->new('standby_1');
$node_standby_1->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
$node_standby_1->start;
-my $node_standby_2 = PostgresNode->new('standby_2');
+my $node_standby_2 = PostgreSQL::Test::Cluster->new('standby_2');
$node_standby_2->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
$node_standby_2->start;
# when WAL archiving is enabled.
# Initialize primary node
-my $node_primary_2 = PostgresNode->new('primary_2');
+my $node_primary_2 = PostgreSQL::Test::Cluster->new('primary_2');
$node_primary_2->init(allows_streaming => 1, has_archiving => 1);
$node_primary_2->append_conf(
'postgresql.conf', qq(
$node_primary_2->backup($backup_name);
# Create standby node
-my $node_standby_3 = PostgresNode->new('standby_3');
+my $node_standby_3 = PostgreSQL::Test::Cluster->new('standby_3');
$node_standby_3->init_from_backup($node_primary_2, $backup_name,
has_streaming => 1);
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 3;
# Initialize primary node
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1);
$node_primary->start;
$node_primary->backup($backup_name);
# Create streaming standby from backup
-my $node_standby = PostgresNode->new('standby');
+my $node_standby = PostgreSQL::Test::Cluster->new('standby');
my $delay = 3;
$node_standby->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
# Check that recovery can be paused or resumed expectedly.
-my $node_standby2 = PostgresNode->new('standby2');
+my $node_standby2 = PostgreSQL::Test::Cluster->new('standby2');
$node_standby2->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
$node_standby2->start;
# are required.
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 14;
use Config;
# Initialize primary node
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1);
$node_primary->append_conf(
'postgresql.conf', qq(
# Minimal test testing synchronous replication sync_state transition
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 11;
# Query checking sync_priority and sync_state of each standby
}
# Initialize primary node
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1);
$node_primary->start;
my $backup_name = 'primary_backup';
# the ordering of each one of them in the WAL sender array of the primary.
# Create standby1 linking to primary
-my $node_standby_1 = PostgresNode->new('standby1');
+my $node_standby_1 = PostgreSQL::Test::Cluster->new('standby1');
$node_standby_1->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
start_standby_and_wait($node_primary, $node_standby_1);
# Create standby2 linking to primary
-my $node_standby_2 = PostgresNode->new('standby2');
+my $node_standby_2 = PostgreSQL::Test::Cluster->new('standby2');
$node_standby_2->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
start_standby_and_wait($node_primary, $node_standby_2);
# Create standby3 linking to primary
-my $node_standby_3 = PostgresNode->new('standby3');
+my $node_standby_3 = PostgreSQL::Test::Cluster->new('standby3');
$node_standby_3->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
start_standby_and_wait($node_primary, $node_standby_3);
start_standby_and_wait($node_primary, $node_standby_1);
# Create standby4 linking to primary
-my $node_standby_4 = PostgresNode->new('standby4');
+my $node_standby_4 = PostgreSQL::Test::Cluster->new('standby4');
$node_standby_4->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
$node_standby_4->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 1;
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1);
$node_primary->append_conf(
$node_primary->start;
$node_primary->backup('primary_backup');
-my $node_standby = PostgresNode->new('standby');
+my $node_standby = PostgreSQL::Test::Cluster->new('standby');
$node_standby->init_from_backup($node_primary, 'primary_backup',
has_streaming => 1);
$node_standby->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 24;
my $psql_out = '';
# Set up two nodes, which will alternately be primary and replication standby.
# Setup london node
-my $node_london = PostgresNode->new("london");
+my $node_london = PostgreSQL::Test::Cluster->new("london");
$node_london->init(allows_streaming => 1);
$node_london->append_conf(
'postgresql.conf', qq(
$node_london->backup('london_backup');
# Setup paris node
-my $node_paris = PostgresNode->new('paris');
+my $node_paris = PostgreSQL::Test::Cluster->new('paris');
$node_paris->init_from_backup($node_london, 'london_backup',
has_streaming => 1);
$node_paris->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 13;
use File::Copy;
use IPC::Run ();
my ($stdout, $stderr, $ret);
# Initialize primary node
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1, has_archiving => 1);
$node_primary->append_conf(
'postgresql.conf', q[
$node_primary->safe_psql('postgres',
q[SELECT pg_create_physical_replication_slot('phys_slot');]);
-my $node_replica = PostgresNode->new('replica');
+my $node_replica = PostgreSQL::Test::Cluster->new('replica');
$node_replica->init_from_backup(
$node_primary, $backup_name,
has_streaming => 1,
#
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
use Config;
plan tests => 3;
-my $node = PostgresNode->new('primary');
+my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init(allows_streaming => 1);
$node->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 12;
# Setup primary node
-my $node_primary = PostgresNode->new("primary");
+my $node_primary = PostgreSQL::Test::Cluster->new("primary");
$node_primary->init(allows_streaming => 1);
$node_primary->append_conf(
'postgresql.conf', qq(
$node_primary->psql('postgres', "CREATE TABLE t_012_tbl (id int)");
# Setup standby node
-my $node_standby = PostgresNode->new('standby');
+my $node_standby = PostgreSQL::Test::Cluster->new('standby');
$node_standby->init_from_backup($node_primary, 'primary_backup',
has_streaming => 1);
$node_standby->start;
#
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
use Config;
# is really wrong.
my $psql_timeout = IPC::Run::timer(60);
-my $node = PostgresNode->new('primary');
+my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init(allows_streaming => 1);
$node->start();
-# by default PostgresNode doesn't doesn't restart after a crash
+# by default PostgreSQL::Test::Cluster doesn't doesn't restart after a crash
$node->safe_psql(
'postgres',
q[ALTER SYSTEM SET restart_after_crash = 1;
$monitor_stderr = '';
# kill once with QUIT - we expect psql to exit, while emitting error message first
-my $ret = TestLib::system_log('pg_ctl', 'kill', 'QUIT', $pid);
+my $ret = PostgreSQL::Test::Utils::system_log('pg_ctl', 'kill', 'QUIT', $pid);
# Exactly process should have been alive to be killed
is($ret, 0, "killed process with SIGQUIT");
# kill with SIGKILL this time - we expect the backend to exit, without
# being able to emit an error message
-$ret = TestLib::system_log('pg_ctl', 'kill', 'KILL', $pid);
+$ret = PostgreSQL::Test::Utils::system_log('pg_ctl', 'kill', 'KILL', $pid);
is($ret, 0, "killed process with KILL");
# Check that psql sees the server as being terminated. No WARNING,
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 12;
-my $node = PostgresNode->new('main');
+my $node = PostgreSQL::Test::Cluster->new('main');
$node->init;
$node->start;
# Create an unlogged table in a tablespace.
-my $tablespaceDir = TestLib::tempdir;
+my $tablespaceDir = PostgreSQL::Test::Utils::tempdir;
-my $realTSDir = TestLib::perl2host($tablespaceDir);
+my $realTSDir = PostgreSQL::Test::Utils::perl2host($tablespaceDir);
$node->safe_psql('postgres', "CREATE TABLESPACE ts1 LOCATION '$realTSDir'");
$node->safe_psql('postgres',
# recovery point defined.
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 1;
# Initialize primary node
-my $alpha = PostgresNode->new('alpha');
+my $alpha = PostgreSQL::Test::Cluster->new('alpha');
$alpha->init(allows_streaming => 1);
# Setting wal_log_hints to off is important to get invalid page
# references.
# setup/start a standby
$alpha->backup('bkp');
-my $bravo = PostgresNode->new('bravo');
+my $bravo = PostgreSQL::Test::Cluster->new('bravo');
$bravo->init_from_backup($alpha, 'bkp', has_streaming => 1);
$bravo->append_conf('postgresql.conf', <<EOF);
checkpoint_timeout=1h
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 1;
# Find the largest LSN in the set of pages part of the given relation
}
# Initialize primary node
-my $primary = PostgresNode->new('primary');
+my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(allows_streaming => 1);
# Set shared_buffers to a very low value to enforce discard and flush
# setup/start a standby
$primary->backup('bkp');
-my $standby = PostgresNode->new('standby');
+my $standby = PostgreSQL::Test::Cluster->new('standby');
$standby->init_from_backup($primary, 'bkp', has_streaming => 1);
$standby->start;
use Config;
use File::stat qw(stat);
use IPC::Run 'run';
-use PostgresNode;
+use PostgreSQL::Test::Cluster;
use Test::More;
-use TestLib;
+use PostgreSQL::Test::Utils;
use Time::HiRes qw(usleep);
# If we don't have shmem support, skip the whole thing
plan tests => 4;
}
-my $tempdir = TestLib::tempdir;
+my $tempdir = PostgreSQL::Test::Utils::tempdir;
# Log "ipcs" diffs on a best-effort basis, swallowing any error.
my $ipcs_before = "$tempdir/ipcs_before";
}
# Node setup.
-my $gnat = PostgresNode->new('gnat');
+my $gnat = PostgreSQL::Test::Cluster->new('gnat');
$gnat->init;
# Create a shmem segment that will conflict with gnat's first choice
$gnat->start;
log_ipcs();
-my $regress_shlib = TestLib::perl2host($ENV{REGRESS_SHLIB});
+my $regress_shlib = PostgreSQL::Test::Utils::perl2host($ENV{REGRESS_SHLIB});
$gnat->safe_psql('postgres', <<EOSQL);
CREATE FUNCTION wait_pid(int)
RETURNS void
log_ipcs();
# cleanup slow backend
-TestLib::system_log('pg_ctl', 'kill', 'QUIT', $slow_pid);
+PostgreSQL::Test::Utils::system_log('pg_ctl', 'kill', 'QUIT', $slow_pid);
$slow_client->finish; # client has detected backend termination
log_ipcs();
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 38;
sub check_orphan_relfilenodes
{
my $wal_level = shift;
- my $node = PostgresNode->new("node_$wal_level");
+ my $node = PostgreSQL::Test::Cluster->new("node_$wal_level");
$node->init;
$node->append_conf(
'postgresql.conf', qq(
# Setup
my $tablespace_dir = $node->basedir . '/tablespace_other';
mkdir($tablespace_dir);
- $tablespace_dir = TestLib::perl2host($tablespace_dir);
+ $tablespace_dir = PostgreSQL::Test::Utils::perl2host($tablespace_dir);
my $result;
# Test redo of CREATE TABLESPACE.
# Data file for COPY query in subsequent tests
my $basedir = $node->basedir;
my $copy_file = "$basedir/copy_data.txt";
- TestLib::append_to_file(
+ PostgreSQL::Test::Utils::append_to_file(
$copy_file, qq(20000,30000
20001,30001
20002,30002));
- $copy_file = TestLib::perl2host($copy_file);
+ $copy_file = PostgreSQL::Test::Utils::perl2host($copy_file);
# Test truncation with inserted tuples using both INSERT and COPY. Tuples
# inserted after the truncation should be seen.
use strict;
use warnings;
-use TestLib;
-use PostgresNode;
+use PostgreSQL::Test::Utils;
+use PostgreSQL::Test::Cluster;
use File::Path qw(rmtree);
-use Test::More tests => $TestLib::windows_os ? 16 : 20;
+use Test::More tests => $PostgreSQL::Test::Utils::windows_os ? 16 : 20;
use Time::HiRes qw(usleep);
$ENV{PGDATABASE} = 'postgres';
# Initialize primary node, setting wal-segsize to 1MB
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1, extra => ['--wal-segsize=1']);
$node_primary->append_conf(
'postgresql.conf', qq(
$node_primary->backup($backup_name);
# Create a standby linking to it using the replication slot
-my $node_standby = PostgresNode->new('standby_1');
+my $node_standby = PostgreSQL::Test::Cluster->new('standby_1');
$node_standby->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
$node_standby->append_conf('postgresql.conf', "primary_slot_name = 'rep1'");
$node_primary->stop;
$node_standby->stop;
-my $node_primary2 = PostgresNode->new('primary2');
+my $node_primary2 = PostgreSQL::Test::Cluster->new('primary2');
$node_primary2->init(allows_streaming => 1);
$node_primary2->append_conf(
'postgresql.conf', qq(
));
$node_primary2->start;
-$node_standby = PostgresNode->new('standby_2');
+$node_standby = PostgreSQL::Test::Cluster->new('standby_2');
$node_standby->init_from_backup($node_primary2, $backup_name,
has_streaming => 1);
$node_standby->append_conf('postgresql.conf', "primary_slot_name = 'rep1'");
# The next test depends on Perl's `kill`, which apparently is not
# portable to Windows. (It would be nice to use Test::More's `subtest`,
# but that's not in the ancient version we require.)
-if ($TestLib::windows_os)
+if ($PostgreSQL::Test::Utils::windows_os)
{
done_testing();
exit;
# Get a slot terminated while the walsender is active
# We do this by sending SIGSTOP to the walsender. Skip this on Windows.
-my $node_primary3 = PostgresNode->new('primary3');
+my $node_primary3 = PostgreSQL::Test::Cluster->new('primary3');
$node_primary3->init(allows_streaming => 1, extra => ['--wal-segsize=1']);
$node_primary3->append_conf(
'postgresql.conf', qq(
$backup_name = 'my_backup';
$node_primary3->backup($backup_name);
# Create standby
-my $node_standby3 = PostgresNode->new('standby_3');
+my $node_standby3 = PostgreSQL::Test::Cluster->new('standby_3');
$node_standby3->init_from_backup($node_primary3, $backup_name,
has_streaming => 1);
$node_standby3->append_conf('postgresql.conf', "primary_slot_name = 'rep3'");
my ($node, $pat, $off) = @_;
$off = 0 unless defined $off;
- my $log = TestLib::slurp_file($node->logfile);
+ my $log = PostgreSQL::Test::Utils::slurp_file($node->logfile);
return 0 if (length($log) <= $off);
$log = substr($log, $off);
#
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 16;
use Config;
-my $primary = PostgresNode->new('primary');
+my $primary = PostgreSQL::Test::Cluster->new('primary');
$primary->init(
has_archiving => 1,
allows_streaming => 1);
# a portable solution, use an archive command based on a command known to
# work but will fail: copy with an incorrect original path.
my $incorrect_command =
- $TestLib::windows_os
+ $PostgreSQL::Test::Utils::windows_os
? qq{copy "%p_does_not_exist" "%f_does_not_exist"}
: qq{cp "%p_does_not_exist" "%f_does_not_exist"};
$primary->safe_psql(
or die "Timed out while waiting for archiving to finish";
# Test standby with archive_mode = on.
-my $standby1 = PostgresNode->new('standby');
+my $standby1 = PostgreSQL::Test::Cluster->new('standby');
$standby1->init_from_backup($primary, 'backup', has_restoring => 1);
$standby1->append_conf('postgresql.conf', "archive_mode = on");
my $standby1_data = $standby1->data_dir;
# command to fail to persist the .ready files. Note that this node
# has inherited the archive command of the previous cold backup that
# will cause archiving failures.
-my $standby2 = PostgresNode->new('standby2');
+my $standby2 = PostgreSQL::Test::Cluster->new('standby2');
$standby2->init_from_backup($primary, 'backup', has_restoring => 1);
$standby2->append_conf('postgresql.conf', 'archive_mode = always');
my $standby2_data = $standby2->data_dir;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 10;
use Config;
# Initialize primary node
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(allows_streaming => 1);
$node_primary->append_conf('postgresql.conf', 'max_prepared_transactions=10');
$node_primary->start;
$node_primary->backup($backup_name);
# Create streaming standby from backup
-my $node_standby = PostgresNode->new('standby');
+my $node_standby = PostgreSQL::Test::Cluster->new('standby');
$node_standby->init_from_backup($node_primary, $backup_name,
has_streaming => 1);
$node_standby->append_conf('postgresql.conf', 'max_prepared_transactions=10');
$$psql{run}->pump_nb();
while (1)
{
- # See PostgresNode.pm's psql()
+ # See PostgreSQL::Test::Cluster.pm's psql()
$$psql{stdout} =~ s/\r\n/\n/g if $Config{osname} eq 'msys';
last if $$psql{stdout} =~ /$untl/;
# Test remove of temporary files after a crash.
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
use Config;
# is really wrong.
my $psql_timeout = IPC::Run::timer(60);
-my $node = PostgresNode->new('node_crash');
+my $node = PostgreSQL::Test::Cluster->new('node_crash');
$node->init();
$node->start();
-# By default, PostgresNode doesn't restart after crash
+# By default, PostgreSQL::Test::Cluster doesn't restart after crash
# Reduce work_mem to generate temporary file with a few number of rows
$node->safe_psql(
'postgres',
$killme_stderr2 = '';
# Kill with SIGKILL
-my $ret = TestLib::system_log('pg_ctl', 'kill', 'KILL', $pid);
+my $ret = PostgreSQL::Test::Utils::system_log('pg_ctl', 'kill', 'KILL', $pid);
is($ret, 0, 'killed process with KILL');
# Close psql session
$killme_stderr2 = '';
# Kill with SIGKILL
-$ret = TestLib::system_log('pg_ctl', 'kill', 'KILL', $pid);
+$ret = PostgreSQL::Test::Utils::system_log('pg_ctl', 'kill', 'KILL', $pid);
is($ret, 0, 'killed process with KILL');
# Close psql session
# Test for point-in-time-recovery (PITR) with prepared transactions
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 1;
use File::Compare;
# Initialize and start primary node with WAL archiving
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
$node_primary->init(has_archiving => 1, allows_streaming => 1);
$node_primary->append_conf(
'postgresql.conf', qq{
# Initialize node for PITR targeting a very specific restore point, just
# after a PREPARE TRANSACTION is issued so as we finish with a promoted
# node where this 2PC transaction needs an explicit COMMIT PREPARED.
-my $node_pitr = PostgresNode->new('node_pitr');
+my $node_pitr = PostgreSQL::Test::Cluster->new('node_pitr');
$node_pitr->init_from_backup(
$node_primary, $backup_name,
standby => 0,
# Test for archive recovery of WAL generated with wal_level=minimal
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 2;
use Time::HiRes qw(usleep);
# Initialize and start node with wal_level = replica and WAL archiving
# enabled.
-my $node = PostgresNode->new('orig');
+my $node = PostgreSQL::Test::Cluster->new('orig');
$node->init(has_archiving => 1, allows_streaming => 1);
my $replica_config = q[
wal_level = replica
{
my ($node_name, $node_text, $standby_setting) = @_;
- my $recovery_node = PostgresNode->new($node_name);
+ my $recovery_node = PostgreSQL::Test::Cluster->new($node_name);
$recovery_node->init_from_backup(
$node, $backup_name,
has_restoring => 1,
# standby can follow the new primary (promoted standby).
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use File::Basename;
use FindBin;
use Test::More tests => 1;
# Initialize primary node
-my $node_primary = PostgresNode->new('primary');
+my $node_primary = PostgreSQL::Test::Cluster->new('primary');
# Set up an archive command that will copy the history file but not the WAL
# files. No real archive command should behave this way; the point is to
# Note: consistent use of forward slashes here avoids any escaping problems
# that arise from use of backslashes. That means we need to double-quote all
# the paths in the archive_command
-my $perlbin = TestLib::perl2host($^X);
-$perlbin =~ s!\\!/!g if $TestLib::windows_os;
+my $perlbin = PostgreSQL::Test::Utils::perl2host($^X);
+$perlbin =~ s!\\!/!g if $PostgreSQL::Test::Utils::windows_os;
my $archivedir_primary = $node_primary->archive_dir;
-$archivedir_primary =~ s!\\!/!g if $TestLib::windows_os;
+$archivedir_primary =~ s!\\!/!g if $PostgreSQL::Test::Utils::windows_os;
$node_primary->append_conf(
'postgresql.conf', qq(
archive_command = '"$perlbin" "$FindBin::RealBin/cp_history_files" "%p" "$archivedir_primary/%f"'
$node_primary->backup($backup_name);
# Create streaming standby linking to primary
-my $node_standby = PostgresNode->new('standby');
+my $node_standby = PostgreSQL::Test::Cluster->new('standby');
$node_standby->init_from_backup(
$node_primary, $backup_name,
allows_streaming => 1,
# Create cascading standby but don't start it yet.
# Must set up both streaming and archiving.
-my $node_cascade = PostgresNode->new('cascade');
+my $node_cascade = PostgreSQL::Test::Cluster->new('cascade');
$node_cascade->init_from_backup($node_standby, $backup_name,
has_streaming => 1);
$node_cascade->enable_restoring($node_primary);
use warnings;
use FindBin;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
plan tests => 3;
# that the replica replays the "overwrite contrecord" from that new
# file.
-my $node = PostgresNode->new('primary');
+my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init(allows_streaming => 1);
$node->append_conf('postgresql.conf', 'wal_keep_size=1GB');
$node->start;
# OK, create a standby at this spot.
$node->backup_fs_cold('backup');
-my $node_standby = PostgresNode->new('standby');
+my $node_standby = PostgreSQL::Test::Cluster->new('standby');
$node_standby->init_from_backup($node, 'backup', has_streaming => 1);
$node_standby->start;
* won't mess things up.) Also, set PGPORT to the temp port, and set
* PGHOST depending on whether we are using TCP or Unix sockets.
*
- * This list should be kept in sync with TestLib.pm.
+ * This list should be kept in sync with PostgreSQL/Test/Utils.pm.
*/
unsetenv("PGCHANNELBINDING");
/* PGCLIENTENCODING, see above */
use strict;
use warnings;
use Config qw ( %Config );
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
use File::Copy;
#### Set up the server.
note "setting up data directory";
-my $node = PostgresNode->new('primary');
+my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init;
# PGHOST is enforced here to set up the node, subsequent connections
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
use File::Copy;
# Set up the server.
note "setting up data directory";
-my $node = PostgresNode->new('primary');
+my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init;
# PGHOST is enforced here to set up the node, subsequent connections
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use File::Basename;
use File::Copy;
use Test::More;
# Basic logical replication test
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 32;
# Initialize publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# by logical replication
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 4;
# Initialize publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# This test checks that constraints work on subscriber
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 6;
# Initialize publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Tests for logical replication table syncing
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 8;
# Initialize publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->append_conf('postgresql.conf',
"wal_retrieve_retry_interval = 1ms");
# Test replication between databases with different encodings
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 1;
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(
allows_streaming => 'logical',
extra => [ '--locale=C', '--encoding=UTF8' ]);
$node_publisher->start;
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(
allows_streaming => 'logical',
extra => [ '--locale=C', '--encoding=LATIN1' ]);
# Test logical replication behavior with heap rewrites
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 2;
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Test some logical replication DDL behavior
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 1;
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Test behavior with different schema on subscriber
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 5;
# Create publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Test materialized views behavior
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 1;
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Test TRUNCATE
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 14;
# setup
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->append_conf('postgresql.conf',
qq(max_logical_replication_workers = 6));
# Test generated columns
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 2;
# setup
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# (only works with ICU)
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More;
if ($ENV{with_icu} eq 'yes')
plan skip_all => 'ICU not supported by this build';
}
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(
allows_streaming => 'logical',
extra => [ '--locale=C', '--encoding=UTF8' ]);
$node_publisher->start;
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(
allows_streaming => 'logical',
extra => [ '--locale=C', '--encoding=UTF8' ]);
# Test logical replication with partitioned tables
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 62;
# setup
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
-my $node_subscriber1 = PostgresNode->new('subscriber1');
+my $node_subscriber1 = PostgreSQL::Test::Cluster->new('subscriber1');
$node_subscriber1->init(allows_streaming => 'logical');
$node_subscriber1->start;
-my $node_subscriber2 = PostgresNode->new('subscriber2');
+my $node_subscriber2 = PostgreSQL::Test::Cluster->new('subscriber2');
$node_subscriber2->init(allows_streaming => 'logical');
$node_subscriber2->start;
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 5;
# Create and initialize a publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
# Create and initialize subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Test streaming of simple large transaction
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 4;
# Create publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->append_conf('postgresql.conf',
'logical_decoding_work_mem = 64kB');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Test streaming of large transaction containing large subtransactions
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 2;
# Create publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->append_conf('postgresql.conf',
'logical_decoding_work_mem = 64kB');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Test streaming of large transaction with DDL and subtransactions
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 3;
# Create publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->append_conf('postgresql.conf',
'logical_decoding_work_mem = 64kB');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Test streaming of large transaction containing multiple subtransactions and rollbacks
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 4;
# Create publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->append_conf('postgresql.conf',
'logical_decoding_work_mem = 64kB');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# rollbacks
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 2;
# Create publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->append_conf('postgresql.conf',
'logical_decoding_work_mem = 64kB');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Tests that logical decoding messages
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 5;
# Create publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->append_conf('postgresql.conf', 'autovacuum = off');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# logical replication of 2PC test
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 24;
###############################
###############################
# Initialize publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->append_conf('postgresql.conf',
qq(max_prepared_transactions = 10));
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->append_conf('postgresql.conf',
qq(max_prepared_transactions = 10));
#
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 41;
###############################
# Initialize nodes
# node_A
-my $node_A = PostgresNode->new('node_A');
+my $node_A = PostgreSQL::Test::Cluster->new('node_A');
$node_A->init(allows_streaming => 'logical');
$node_A->append_conf('postgresql.conf', qq(
max_prepared_transactions = 10
));
$node_A->start;
# node_B
-my $node_B = PostgresNode->new('node_B');
+my $node_B = PostgreSQL::Test::Cluster->new('node_B');
$node_B->init(allows_streaming => 'logical');
$node_B->append_conf('postgresql.conf', qq(
max_prepared_transactions = 10
));
$node_B->start;
# node_C
-my $node_C = PostgresNode->new('node_C');
+my $node_C = PostgreSQL::Test::Cluster->new('node_C');
$node_C->init(allows_streaming => 'logical');
$node_C->append_conf('postgresql.conf', qq(
max_prepared_transactions = 10
# Test logical replication of 2PC with streaming.
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 18;
###############################
###############################
# Initialize publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->append_conf('postgresql.conf', qq(
max_prepared_transactions = 10
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->append_conf('postgresql.conf', qq(
max_prepared_transactions = 10
# This test checks behaviour of ALTER SUBSCRIPTION ... ADD/DROP PUBLICATION
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 3;
# Initialize publisher node
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
# Create subscriber node
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# Tests for various bugs found over time
use strict;
use warnings;
-use PostgresNode;
-use TestLib;
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
use Test::More tests => 5;
# Bug #15114
# fix was to avoid the constant expressions simplification in
# RelationGetIndexAttrBitmap(), so it's safe to call in more contexts.
-my $node_publisher = PostgresNode->new('publisher');
+my $node_publisher = PostgreSQL::Test::Cluster->new('publisher');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
-my $node_subscriber = PostgresNode->new('subscriber');
+my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber');
$node_subscriber->init(allows_streaming => 'logical');
$node_subscriber->start;
# identity set before accepting updates. If it did not it would cause
# an error when an update was attempted.
-$node_publisher = PostgresNode->new('publisher2');
+$node_publisher = PostgreSQL::Test::Cluster->new('publisher2');
$node_publisher->init(allows_streaming => 'logical');
$node_publisher->start;
#
# Initial sync doesn't complete; the protocol was not being followed per
# expectations after commit 07082b08cc5d.
-my $node_twoways = PostgresNode->new('twoways');
+my $node_twoways = PostgreSQL::Test::Cluster->new('twoways');
$node_twoways->init(allows_streaming => 'logical');
$node_twoways->start;
for my $db (qw(d1 d2))
# Verify table data is synced with cascaded replication setup. This is mainly
# to test whether the data written by tablesync worker gets replicated.
-my $node_pub = PostgresNode->new('testpublisher1');
+my $node_pub = PostgreSQL::Test::Cluster->new('testpublisher1');
$node_pub->init(allows_streaming => 'logical');
$node_pub->start;
-my $node_pub_sub = PostgresNode->new('testpublisher_subscriber');
+my $node_pub_sub = PostgreSQL::Test::Cluster->new('testpublisher_subscriber');
$node_pub_sub->init(allows_streaming => 'logical');
$node_pub_sub->start;
-my $node_sub = PostgresNode->new('testsubscriber1');
+my $node_sub = PostgreSQL::Test::Cluster->new('testsubscriber1');
$node_sub->init(allows_streaming => 'logical');
$node_sub->start;
projects / users / rhaas / postgres.git / commitdiff