diff options
Diffstat (limited to 'src')
136 files changed, 635 insertions, 635 deletions
diff --git a/src/bin/initdb/t/001_initdb.pl b/src/bin/initdb/t/001_initdb.pl index 635ff79b475..6796d8520ed 100644 --- a/src/bin/initdb/t/001_initdb.pl +++ b/src/bin/initdb/t/001_initdb.pl @@ -9,11 +9,11 @@ use strict; 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"; diff --git a/src/bin/pg_amcheck/t/001_basic.pl b/src/bin/pg_amcheck/t/001_basic.pl index 6f60e3ec1f5..d44fe60a4ca 100644 --- a/src/bin/pg_amcheck/t/001_basic.pl +++ b/src/bin/pg_amcheck/t/001_basic.pl @@ -4,7 +4,7 @@ use strict; use warnings; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More tests => 8; program_help_ok('pg_amcheck'); diff --git a/src/bin/pg_amcheck/t/002_nonesuch.pl b/src/bin/pg_amcheck/t/002_nonesuch.pl index e30c1cc5464..513a18d6718 100644 --- a/src/bin/pg_amcheck/t/002_nonesuch.pl +++ b/src/bin/pg_amcheck/t/002_nonesuch.pl @@ -4,13 +4,13 @@ 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; diff --git a/src/bin/pg_amcheck/t/003_check.pl b/src/bin/pg_amcheck/t/003_check.pl index c26e5eda676..5913fcc5305 100644 --- a/src/bin/pg_amcheck/t/003_check.pl +++ b/src/bin/pg_amcheck/t/003_check.pl @@ -4,8 +4,8 @@ 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; @@ -120,7 +120,7 @@ sub perform_all_corruptions() } # Test set-up -$node = PostgresNode->new('test'); +$node = PostgreSQL::Test::Cluster->new('test'); $node->init; $node->append_conf('postgresql.conf', 'autovacuum=off'); $node->start; @@ -316,7 +316,7 @@ plan_to_remove_relation_file('db2', 's1.t1_btree'); # 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 diff --git a/src/bin/pg_amcheck/t/004_verify_heapam.pl b/src/bin/pg_amcheck/t/004_verify_heapam.pl index a9f485e527b..4ca7ed297c0 100644 --- a/src/bin/pg_amcheck/t/004_verify_heapam.pl +++ b/src/bin/pg_amcheck/t/004_verify_heapam.pl @@ -4,8 +4,8 @@ use strict; use warnings; -use PostgresNode; -use TestLib; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; use Fcntl qw(:seek); use Test::More; @@ -178,7 +178,7 @@ umask(0077); # 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'); diff --git a/src/bin/pg_amcheck/t/005_opclass_damage.pl b/src/bin/pg_amcheck/t/005_opclass_damage.pl index e87d81d7d42..2f86f4f2a40 100644 --- a/src/bin/pg_amcheck/t/005_opclass_damage.pl +++ b/src/bin/pg_amcheck/t/005_opclass_damage.pl @@ -6,11 +6,11 @@ # 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; diff --git a/src/bin/pg_archivecleanup/t/010_pg_archivecleanup.pl b/src/bin/pg_archivecleanup/t/010_pg_archivecleanup.pl index 8d689b9601c..6b3f486cfa0 100644 --- a/src/bin/pg_archivecleanup/t/010_pg_archivecleanup.pl +++ b/src/bin/pg_archivecleanup/t/010_pg_archivecleanup.pl @@ -3,14 +3,14 @@ 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', diff --git a/src/bin/pg_basebackup/t/010_pg_basebackup.pl b/src/bin/pg_basebackup/t/010_pg_basebackup.pl index a2cb2a7679d..89f45b77a34 100644 --- a/src/bin/pg_basebackup/t/010_pg_basebackup.pl +++ b/src/bin/pg_basebackup/t/010_pg_basebackup.pl @@ -8,17 +8,17 @@ use Config; 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); @@ -238,14 +238,14 @@ $node->start; # 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', @@ -270,7 +270,7 @@ SKIP: 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); @@ -279,7 +279,7 @@ SKIP: 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. diff --git a/src/bin/pg_basebackup/t/020_pg_receivewal.pl b/src/bin/pg_basebackup/t/020_pg_receivewal.pl index 0b33d739005..b93493b5e9b 100644 --- a/src/bin/pg_basebackup/t/020_pg_receivewal.pl +++ b/src/bin/pg_basebackup/t/020_pg_receivewal.pl @@ -3,8 +3,8 @@ 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'); @@ -14,7 +14,7 @@ program_options_handling_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; diff --git a/src/bin/pg_basebackup/t/030_pg_recvlogical.pl b/src/bin/pg_basebackup/t/030_pg_recvlogical.pl index fe7fe762954..90da1662e33 100644 --- a/src/bin/pg_basebackup/t/030_pg_recvlogical.pl +++ b/src/bin/pg_basebackup/t/030_pg_recvlogical.pl @@ -3,15 +3,15 @@ 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); diff --git a/src/bin/pg_checksums/t/001_basic.pl b/src/bin/pg_checksums/t/001_basic.pl index 62e78a50438..e9eb3197a62 100644 --- a/src/bin/pg_checksums/t/001_basic.pl +++ b/src/bin/pg_checksums/t/001_basic.pl @@ -3,7 +3,7 @@ use strict; use warnings; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More tests => 8; program_help_ok('pg_checksums'); diff --git a/src/bin/pg_checksums/t/002_actions.pl b/src/bin/pg_checksums/t/002_actions.pl index 0b3e19ab7c6..20a5f278404 100644 --- a/src/bin/pg_checksums/t/002_actions.pl +++ b/src/bin/pg_checksums/t/002_actions.pl @@ -7,8 +7,8 @@ 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; @@ -93,7 +93,7 @@ sub check_relation_corruption } # 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; @@ -207,7 +207,7 @@ check_relation_corruption($node, 'corrupt1', 'pg_default'); 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'); diff --git a/src/bin/pg_config/t/001_pg_config.pl b/src/bin/pg_config/t/001_pg_config.pl index d8829faea6c..6c7f9b8602c 100644 --- a/src/bin/pg_config/t/001_pg_config.pl +++ b/src/bin/pg_config/t/001_pg_config.pl @@ -3,7 +3,7 @@ use strict; use warnings; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More tests => 20; program_help_ok('pg_config'); diff --git a/src/bin/pg_controldata/t/001_pg_controldata.pl b/src/bin/pg_controldata/t/001_pg_controldata.pl index ce31cfbd3b3..ad7bacace58 100644 --- a/src/bin/pg_controldata/t/001_pg_controldata.pl +++ b/src/bin/pg_controldata/t/001_pg_controldata.pl @@ -3,8 +3,8 @@ 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'); @@ -14,7 +14,7 @@ command_fails(['pg_controldata'], 'pg_controldata without arguments fails'); 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 ], diff --git a/src/bin/pg_ctl/t/001_start_stop.pl b/src/bin/pg_ctl/t/001_start_stop.pl index 1d8d6bbb701..f95352bf94f 100644 --- a/src/bin/pg_ctl/t/001_start_stop.pl +++ b/src/bin/pg_ctl/t/001_start_stop.pl @@ -7,12 +7,12 @@ use warnings; 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'); @@ -25,11 +25,11 @@ command_ok([ 'pg_ctl', 'initdb', '-D', "$tempdir/data", '-o', '-N' ], '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) @@ -44,7 +44,7 @@ else 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') { diff --git a/src/bin/pg_ctl/t/002_status.pl b/src/bin/pg_ctl/t/002_status.pl index c6f4fac57b6..a74e6e3b91c 100644 --- a/src/bin/pg_ctl/t/002_status.pl +++ b/src/bin/pg_ctl/t/002_status.pl @@ -4,16 +4,16 @@ 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 ], diff --git a/src/bin/pg_ctl/t/003_promote.pl b/src/bin/pg_ctl/t/003_promote.pl index 547b3d8893c..50819db92b3 100644 --- a/src/bin/pg_ctl/t/003_promote.pl +++ b/src/bin/pg_ctl/t/003_promote.pl @@ -4,18 +4,18 @@ 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( @@ -30,7 +30,7 @@ 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); @@ -47,7 +47,7 @@ ok( $node_standby->poll_query_until( '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; diff --git a/src/bin/pg_ctl/t/004_logrotate.pl b/src/bin/pg_ctl/t/004_logrotate.pl index 13e91f3bc97..3813a3b1fd0 100644 --- a/src/bin/pg_ctl/t/004_logrotate.pl +++ b/src/bin/pg_ctl/t/004_logrotate.pl @@ -4,8 +4,8 @@ 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); @@ -60,7 +60,7 @@ sub check_log_pattern } # 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( diff --git a/src/bin/pg_dump/t/001_basic.pl b/src/bin/pg_dump/t/001_basic.pl index d6731855eda..863f4da3d80 100644 --- a/src/bin/pg_dump/t/001_basic.pl +++ b/src/bin/pg_dump/t/001_basic.pl @@ -5,11 +5,11 @@ use strict; 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 diff --git a/src/bin/pg_dump/t/002_pg_dump.pl b/src/bin/pg_dump/t/002_pg_dump.pl index 7e00f4ddbb1..2eece79250a 100644 --- a/src/bin/pg_dump/t/002_pg_dump.pl +++ b/src/bin/pg_dump/t/002_pg_dump.pl @@ -5,11 +5,11 @@ use strict; 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. @@ -25,7 +25,7 @@ my $tempdir = TestLib::tempdir; # 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 @@ -3577,7 +3577,7 @@ my %tests = ( ######################################### # 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; diff --git a/src/bin/pg_dump/t/003_pg_dump_with_server.pl b/src/bin/pg_dump/t/003_pg_dump_with_server.pl index a879ae28d8d..66d9563d86b 100644 --- a/src/bin/pg_dump/t/003_pg_dump_with_server.pl +++ b/src/bin/pg_dump/t/003_pg_dump_with_server.pl @@ -4,13 +4,13 @@ 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; diff --git a/src/bin/pg_dump/t/010_dump_connstr.pl b/src/bin/pg_dump/t/010_dump_connstr.pl index c4b60c5d2a4..b36e2a42af2 100644 --- a/src/bin/pg_dump/t/010_dump_connstr.pl +++ b/src/bin/pg_dump/t/010_dump_connstr.pl @@ -4,11 +4,11 @@ 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'; } @@ -34,7 +34,7 @@ my $dbname1 = . 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' @@ -51,7 +51,7 @@ my $dbname4 = 'regression' . generate_ascii_string(203, 255); 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' ]); @@ -175,13 +175,13 @@ system_log('cat', $plain); 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' ], @@ -208,7 +208,7 @@ is($stderr, '', 'no dump errors'); # 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' ], diff --git a/src/bin/pg_resetwal/t/001_basic.pl b/src/bin/pg_resetwal/t/001_basic.pl index f01a4d2d483..0f86aea68ed 100644 --- a/src/bin/pg_resetwal/t/001_basic.pl +++ b/src/bin/pg_resetwal/t/001_basic.pl @@ -4,15 +4,15 @@ 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 ], diff --git a/src/bin/pg_resetwal/t/002_corrupted.pl b/src/bin/pg_resetwal/t/002_corrupted.pl index ac915ef91fc..fd0c3ecb23e 100644 --- a/src/bin/pg_resetwal/t/002_corrupted.pl +++ b/src/bin/pg_resetwal/t/002_corrupted.pl @@ -6,11 +6,11 @@ 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'; diff --git a/src/bin/pg_rewind/t/001_basic.pl b/src/bin/pg_rewind/t/001_basic.pl index d636f35f5e5..7738c306d22 100644 --- a/src/bin/pg_rewind/t/001_basic.pl +++ b/src/bin/pg_rewind/t/001_basic.pl @@ -3,7 +3,7 @@ use strict; use warnings; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More tests => 23; use FindBin; diff --git a/src/bin/pg_rewind/t/002_databases.pl b/src/bin/pg_rewind/t/002_databases.pl index 72c4b225a7f..f3fba68fd63 100644 --- a/src/bin/pg_rewind/t/002_databases.pl +++ b/src/bin/pg_rewind/t/002_databases.pl @@ -3,7 +3,7 @@ use strict; use warnings; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More tests => 7; use FindBin; diff --git a/src/bin/pg_rewind/t/003_extrafiles.pl b/src/bin/pg_rewind/t/003_extrafiles.pl index 672c5e586ba..c363b2b362d 100644 --- a/src/bin/pg_rewind/t/003_extrafiles.pl +++ b/src/bin/pg_rewind/t/003_extrafiles.pl @@ -5,7 +5,7 @@ use strict; use warnings; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More tests => 5; use File::Find; diff --git a/src/bin/pg_rewind/t/004_pg_xlog_symlink.pl b/src/bin/pg_rewind/t/004_pg_xlog_symlink.pl index 8fb0ab3eadd..92952173cb9 100644 --- a/src/bin/pg_rewind/t/004_pg_xlog_symlink.pl +++ b/src/bin/pg_rewind/t/004_pg_xlog_symlink.pl @@ -8,7 +8,7 @@ use strict; use warnings; use File::Copy; use File::Path qw(rmtree); -use TestLib; +use PostgreSQL::Test::Utils; use Test::More tests => 5; use FindBin; @@ -20,7 +20,7 @@ sub run_test { 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); diff --git a/src/bin/pg_rewind/t/005_same_timeline.pl b/src/bin/pg_rewind/t/005_same_timeline.pl index efe1d4c77f5..85a2f20b116 100644 --- a/src/bin/pg_rewind/t/005_same_timeline.pl +++ b/src/bin/pg_rewind/t/005_same_timeline.pl @@ -7,7 +7,7 @@ # use strict; use warnings; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More tests => 1; use FindBin; diff --git a/src/bin/pg_rewind/t/006_options.pl b/src/bin/pg_rewind/t/006_options.pl index 81793899e59..30c7bb46d26 100644 --- a/src/bin/pg_rewind/t/006_options.pl +++ b/src/bin/pg_rewind/t/006_options.pl @@ -6,15 +6,15 @@ # 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', diff --git a/src/bin/pg_rewind/t/007_standby_source.pl b/src/bin/pg_rewind/t/007_standby_source.pl index 2a717f5a2e7..d23411bb5b3 100644 --- a/src/bin/pg_rewind/t/007_standby_source.pl +++ b/src/bin/pg_rewind/t/007_standby_source.pl @@ -26,16 +26,16 @@ 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; @@ -58,13 +58,13 @@ primary_psql("CHECKPOINT"); # # 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; diff --git a/src/bin/pg_rewind/t/008_min_recovery_point.pl b/src/bin/pg_rewind/t/008_min_recovery_point.pl index 7a390f4abd1..ad80cb3a089 100644 --- a/src/bin/pg_rewind/t/008_min_recovery_point.pl +++ b/src/bin/pg_rewind/t/008_min_recovery_point.pl @@ -32,15 +32,15 @@ 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( @@ -60,11 +60,11 @@ $node_1->safe_psql('postgres', "INSERT INTO public.bar VALUES ('in both')"); 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; diff --git a/src/bin/pg_rewind/t/RewindTest.pm b/src/bin/pg_rewind/t/RewindTest.pm index 367b99a438f..5546ce456cd 100644 --- a/src/bin/pg_rewind/t/RewindTest.pm +++ b/src/bin/pg_rewind/t/RewindTest.pm @@ -40,9 +40,9 @@ use Exporter 'import'; 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( @@ -128,7 +128,7 @@ sub setup_cluster # 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 @@ -176,7 +176,7 @@ sub create_standby 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(); @@ -226,7 +226,7 @@ sub run_pg_rewind 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"; @@ -315,7 +315,7 @@ sub run_pg_rewind # 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 diff --git a/src/bin/pg_test_fsync/t/001_basic.pl b/src/bin/pg_test_fsync/t/001_basic.pl index c0d0effd92d..8c71f1111ef 100644 --- a/src/bin/pg_test_fsync/t/001_basic.pl +++ b/src/bin/pg_test_fsync/t/001_basic.pl @@ -5,7 +5,7 @@ use strict; use warnings; use Config; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More tests => 12; ######################################### diff --git a/src/bin/pg_test_timing/t/001_basic.pl b/src/bin/pg_test_timing/t/001_basic.pl index 72e5a42b6f2..3e58926c961 100644 --- a/src/bin/pg_test_timing/t/001_basic.pl +++ b/src/bin/pg_test_timing/t/001_basic.pl @@ -5,7 +5,7 @@ use strict; use warnings; use Config; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More tests => 12; ######################################### diff --git a/src/bin/pg_verifybackup/t/001_basic.pl b/src/bin/pg_verifybackup/t/001_basic.pl index 4ad1c3f0a99..33d6b38d33d 100644 --- a/src/bin/pg_verifybackup/t/001_basic.pl +++ b/src/bin/pg_verifybackup/t/001_basic.pl @@ -3,10 +3,10 @@ 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'); diff --git a/src/bin/pg_verifybackup/t/002_algorithm.pl b/src/bin/pg_verifybackup/t/002_algorithm.pl index 7dc1af982a3..5c429ea7fcf 100644 --- a/src/bin/pg_verifybackup/t/002_algorithm.pl +++ b/src/bin/pg_verifybackup/t/002_algorithm.pl @@ -8,11 +8,11 @@ use warnings; 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; diff --git a/src/bin/pg_verifybackup/t/003_corruption.pl b/src/bin/pg_verifybackup/t/003_corruption.pl index 509390f9757..7a8c5d7a040 100644 --- a/src/bin/pg_verifybackup/t/003_corruption.pl +++ b/src/bin/pg_verifybackup/t/003_corruption.pl @@ -8,17 +8,17 @@ use warnings; 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!; @@ -107,7 +107,7 @@ for my $scenario (@scenario) # 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 diff --git a/src/bin/pg_verifybackup/t/004_options.pl b/src/bin/pg_verifybackup/t/004_options.pl index d4210fd293b..22b1444091a 100644 --- a/src/bin/pg_verifybackup/t/004_options.pl +++ b/src/bin/pg_verifybackup/t/004_options.pl @@ -8,12 +8,12 @@ use warnings; 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'; diff --git a/src/bin/pg_verifybackup/t/005_bad_manifest.pl b/src/bin/pg_verifybackup/t/005_bad_manifest.pl index 1420cfb352c..c8ea12838ce 100644 --- a/src/bin/pg_verifybackup/t/005_bad_manifest.pl +++ b/src/bin/pg_verifybackup/t/005_bad_manifest.pl @@ -8,11 +8,11 @@ use strict; 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', diff --git a/src/bin/pg_verifybackup/t/006_encoding.pl b/src/bin/pg_verifybackup/t/006_encoding.pl index c0667b7f43c..21c4198b1c9 100644 --- a/src/bin/pg_verifybackup/t/006_encoding.pl +++ b/src/bin/pg_verifybackup/t/006_encoding.pl @@ -7,11 +7,11 @@ use strict; 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'; diff --git a/src/bin/pg_verifybackup/t/007_wal.pl b/src/bin/pg_verifybackup/t/007_wal.pl index dc85b2a7745..6eb245a9ef4 100644 --- a/src/bin/pg_verifybackup/t/007_wal.pl +++ b/src/bin/pg_verifybackup/t/007_wal.pl @@ -8,12 +8,12 @@ use warnings; 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'; diff --git a/src/bin/pg_waldump/t/001_basic.pl b/src/bin/pg_waldump/t/001_basic.pl index fb2f807dc3b..fdc968a5ee0 100644 --- a/src/bin/pg_waldump/t/001_basic.pl +++ b/src/bin/pg_waldump/t/001_basic.pl @@ -3,7 +3,7 @@ use strict; use warnings; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More tests => 8; program_help_ok('pg_waldump'); diff --git a/src/bin/pgbench/t/001_pgbench_with_server.pl b/src/bin/pgbench/t/001_pgbench_with_server.pl index 7ca96e58cab..69ffa595dd4 100644 --- a/src/bin/pgbench/t/001_pgbench_with_server.pl +++ b/src/bin/pgbench/t/001_pgbench_with_server.pl @@ -4,13 +4,13 @@ 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; @@ -20,7 +20,7 @@ $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', @@ -252,7 +252,7 @@ select $$'Valame Dios!' dijo Sancho; 'no le dije yo a vuestra merced que mirase 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 ',], @@ -293,7 +293,7 @@ select $$'Valame Dios!' dijo Sancho; 'no le dije yo a vuestra merced que mirase 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\?'''], @@ -338,7 +338,7 @@ select $$'Valame Dios!' dijo Sancho; 'no le dije yo a vuestra merced que mirase 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\.\.\.'], diff --git a/src/bin/pgbench/t/002_pgbench_no_server.pl b/src/bin/pgbench/t/002_pgbench_no_server.pl index da38d9b1d21..703eff490ba 100644 --- a/src/bin/pgbench/t/002_pgbench_no_server.pl +++ b/src/bin/pgbench/t/002_pgbench_no_server.pl @@ -8,7 +8,7 @@ use strict; use warnings; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More; # create a directory for scripts @@ -16,7 +16,7 @@ my $testname = $0; $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}\": $!"); diff --git a/src/bin/psql/t/001_basic.pl b/src/bin/psql/t/001_basic.pl index eb9041d1f33..6ca0bc75d00 100644 --- a/src/bin/psql/t/001_basic.pl +++ b/src/bin/psql/t/001_basic.pl @@ -4,8 +4,8 @@ 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'); @@ -60,7 +60,7 @@ foreach my $arg (qw(commands variables)) 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{ diff --git a/src/bin/psql/t/010_tab_completion.pl b/src/bin/psql/t/010_tab_completion.pl index dbca56afadc..55b318517ea 100644 --- a/src/bin/psql/t/010_tab_completion.pl +++ b/src/bin/psql/t/010_tab_completion.pl @@ -4,8 +4,8 @@ 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; @@ -34,7 +34,7 @@ if ($@) } # start a new server -my $node = PostgresNode->new('main'); +my $node = PostgreSQL::Test::Cluster->new('main'); $node->init; $node->start; @@ -48,7 +48,7 @@ $node->safe_psql('postgres', # 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 diff --git a/src/bin/psql/t/020_cancel.pl b/src/bin/psql/t/020_cancel.pl index 0ca8e1743db..28d72caf2ac 100644 --- a/src/bin/psql/t/020_cancel.pl +++ b/src/bin/psql/t/020_cancel.pl @@ -4,14 +4,14 @@ 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; @@ -44,7 +44,7 @@ SKIP: { 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) diff --git a/src/bin/scripts/t/010_clusterdb.pl b/src/bin/scripts/t/010_clusterdb.pl index aae5ea985b7..0ba4aa4876e 100644 --- a/src/bin/scripts/t/010_clusterdb.pl +++ b/src/bin/scripts/t/010_clusterdb.pl @@ -4,15 +4,15 @@ 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; diff --git a/src/bin/scripts/t/011_clusterdb_all.pl b/src/bin/scripts/t/011_clusterdb_all.pl index 6ba71780de3..d040b95cfbf 100644 --- a/src/bin/scripts/t/011_clusterdb_all.pl +++ b/src/bin/scripts/t/011_clusterdb_all.pl @@ -4,11 +4,11 @@ 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; diff --git a/src/bin/scripts/t/020_createdb.pl b/src/bin/scripts/t/020_createdb.pl index 3db2f13ae21..cb8e26c7731 100644 --- a/src/bin/scripts/t/020_createdb.pl +++ b/src/bin/scripts/t/020_createdb.pl @@ -4,15 +4,15 @@ 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; diff --git a/src/bin/scripts/t/040_createuser.pl b/src/bin/scripts/t/040_createuser.pl index 3da8b7ae755..a865c01f5a7 100644 --- a/src/bin/scripts/t/040_createuser.pl +++ b/src/bin/scripts/t/040_createuser.pl @@ -4,15 +4,15 @@ 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; diff --git a/src/bin/scripts/t/050_dropdb.pl b/src/bin/scripts/t/050_dropdb.pl index b9f0592bcaa..5c9342f290d 100644 --- a/src/bin/scripts/t/050_dropdb.pl +++ b/src/bin/scripts/t/050_dropdb.pl @@ -4,15 +4,15 @@ 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; diff --git a/src/bin/scripts/t/070_dropuser.pl b/src/bin/scripts/t/070_dropuser.pl index 26dadaf4a5f..5d6e75c9033 100644 --- a/src/bin/scripts/t/070_dropuser.pl +++ b/src/bin/scripts/t/070_dropuser.pl @@ -4,15 +4,15 @@ 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; diff --git a/src/bin/scripts/t/080_pg_isready.pl b/src/bin/scripts/t/080_pg_isready.pl index 4f1184953ed..42be32decc3 100644 --- a/src/bin/scripts/t/080_pg_isready.pl +++ b/src/bin/scripts/t/080_pg_isready.pl @@ -4,8 +4,8 @@ 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'); @@ -14,7 +14,7 @@ program_options_handling_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; diff --git a/src/bin/scripts/t/090_reindexdb.pl b/src/bin/scripts/t/090_reindexdb.pl index 541504d8f01..5384b74ccdb 100644 --- a/src/bin/scripts/t/090_reindexdb.pl +++ b/src/bin/scripts/t/090_reindexdb.pl @@ -4,15 +4,15 @@ 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; @@ -21,7 +21,7 @@ $ENV{PGOPTIONS} = '--client-min-messages=WARNING'; # 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';"); diff --git a/src/bin/scripts/t/091_reindexdb_all.pl b/src/bin/scripts/t/091_reindexdb_all.pl index 34174e4d71a..acb24189765 100644 --- a/src/bin/scripts/t/091_reindexdb_all.pl +++ b/src/bin/scripts/t/091_reindexdb_all.pl @@ -4,10 +4,10 @@ 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; diff --git a/src/bin/scripts/t/100_vacuumdb.pl b/src/bin/scripts/t/100_vacuumdb.pl index 0f1e5bb2788..6937a35bc4a 100644 --- a/src/bin/scripts/t/100_vacuumdb.pl +++ b/src/bin/scripts/t/100_vacuumdb.pl @@ -4,15 +4,15 @@ 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; diff --git a/src/bin/scripts/t/101_vacuumdb_all.pl b/src/bin/scripts/t/101_vacuumdb_all.pl index a60fc79aae7..3dfbfbfdb28 100644 --- a/src/bin/scripts/t/101_vacuumdb_all.pl +++ b/src/bin/scripts/t/101_vacuumdb_all.pl @@ -4,10 +4,10 @@ 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; diff --git a/src/bin/scripts/t/102_vacuumdb_stages.pl b/src/bin/scripts/t/102_vacuumdb_stages.pl index c15057a763e..f7bd45ba922 100644 --- a/src/bin/scripts/t/102_vacuumdb_stages.pl +++ b/src/bin/scripts/t/102_vacuumdb_stages.pl @@ -4,10 +4,10 @@ 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; diff --git a/src/bin/scripts/t/200_connstr.pl b/src/bin/scripts/t/200_connstr.pl index f702e32f00e..b2fa50a1c6d 100644 --- a/src/bin/scripts/t/200_connstr.pl +++ b/src/bin/scripts/t/200_connstr.pl @@ -4,8 +4,8 @@ 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 @@ -23,7 +23,7 @@ my $dbname2 = 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; diff --git a/src/test/authentication/t/001_password.pl b/src/test/authentication/t/001_password.pl index 16570a4e2cb..11ca525c6c6 100644 --- a/src/test/authentication/t/001_password.pl +++ b/src/test/authentication/t/001_password.pl @@ -10,8 +10,8 @@ use strict; use warnings; -use PostgresNode; -use TestLib; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; use Test::More; if (!$use_unix_sockets) { @@ -64,7 +64,7 @@ sub test_role } # 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; @@ -136,7 +136,7 @@ $ENV{"PGCHANNELBINDING"} = 'require'; 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"}; diff --git a/src/test/authentication/t/002_saslprep.pl b/src/test/authentication/t/002_saslprep.pl index acd379df316..766fed67cc5 100644 --- a/src/test/authentication/t/002_saslprep.pl +++ b/src/test/authentication/t/002_saslprep.pl @@ -7,8 +7,8 @@ use strict; use warnings; -use PostgresNode; -use TestLib; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; use Test::More; if (!$use_unix_sockets) { @@ -64,7 +64,7 @@ sub test_login # 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; diff --git a/src/test/kerberos/t/001_auth.pl b/src/test/kerberos/t/001_auth.pl index 968be3952f4..13d664dda04 100644 --- a/src/test/kerberos/t/001_auth.pl +++ b/src/test/kerberos/t/001_auth.pl @@ -16,8 +16,8 @@ use strict; use warnings; -use TestLib; -use PostgresNode; +use PostgreSQL::Test::Utils; +use PostgreSQL::Test::Cluster; use Test::More; use Time::HiRes qw(usleep); @@ -69,15 +69,15 @@ my $host = 'auth-test-localhost.postgresql.example.com'; 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'; @@ -167,7 +167,7 @@ END 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{ diff --git a/src/test/ldap/t/001_auth.pl b/src/test/ldap/t/001_auth.pl index 104002d149a..5a9a0098327 100644 --- a/src/test/ldap/t/001_auth.pl +++ b/src/test/ldap/t/001_auth.pl @@ -3,8 +3,8 @@ 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') @@ -51,21 +51,21 @@ elsif ($^O eq 'freebsd') $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"; @@ -155,7 +155,7 @@ system_or_bail 'ldappasswd', '-x', '-y', $ldap_pwfile, '-s', 'secret2', 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; diff --git a/src/test/modules/brin/t/01_workitems.pl b/src/test/modules/brin/t/01_workitems.pl index ea2e2944a15..48bb8abfe6e 100644 --- a/src/test/modules/brin/t/01_workitems.pl +++ b/src/test/modules/brin/t/01_workitems.pl @@ -6,11 +6,11 @@ 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; diff --git a/src/test/modules/commit_ts/t/001_base.pl b/src/test/modules/commit_ts/t/001_base.pl index 0c504421d44..16f0f122534 100644 --- a/src/test/modules/commit_ts/t/001_base.pl +++ b/src/test/modules/commit_ts/t/001_base.pl @@ -6,11 +6,11 @@ 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; diff --git a/src/test/modules/commit_ts/t/002_standby.pl b/src/test/modules/commit_ts/t/002_standby.pl index 227eddeda26..c22956c9ea0 100644 --- a/src/test/modules/commit_ts/t/002_standby.pl +++ b/src/test/modules/commit_ts/t/002_standby.pl @@ -6,12 +6,12 @@ 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( @@ -22,7 +22,7 @@ $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; diff --git a/src/test/modules/commit_ts/t/003_standby_2.pl b/src/test/modules/commit_ts/t/003_standby_2.pl index 27c5bfbfb73..a6e9f4188e9 100644 --- a/src/test/modules/commit_ts/t/003_standby_2.pl +++ b/src/test/modules/commit_ts/t/003_standby_2.pl @@ -6,12 +6,12 @@ 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{ @@ -21,7 +21,7 @@ $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; diff --git a/src/test/modules/commit_ts/t/004_restart.pl b/src/test/modules/commit_ts/t/004_restart.pl index 5d92c5a2e6d..c0f3a7c8af5 100644 --- a/src/test/modules/commit_ts/t/004_restart.pl +++ b/src/test/modules/commit_ts/t/004_restart.pl @@ -4,11 +4,11 @@ # 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; diff --git a/src/test/modules/libpq_pipeline/t/001_libpq_pipeline.pl b/src/test/modules/libpq_pipeline/t/001_libpq_pipeline.pl index 7f648b19a26..4f9b67f2544 100644 --- a/src/test/modules/libpq_pipeline/t/001_libpq_pipeline.pl +++ b/src/test/modules/libpq_pipeline/t/001_libpq_pipeline.pl @@ -5,11 +5,11 @@ use strict; 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; @@ -19,7 +19,7 @@ my ($out, $err) = run_command([ 'libpq_pipeline', 'tests' ]); 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) { @@ -29,7 +29,7 @@ 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; diff --git a/src/test/modules/ssl_passphrase_callback/t/001_testfunc.pl b/src/test/modules/ssl_passphrase_callback/t/001_testfunc.pl index 1f28f303f1a..7fcba283e99 100644 --- a/src/test/modules/ssl_passphrase_callback/t/001_testfunc.pl +++ b/src/test/modules/ssl_passphrase_callback/t/001_testfunc.pl @@ -6,9 +6,9 @@ use warnings; use File::Copy; -use TestLib; +use PostgreSQL::Test::Utils; use Test::More; -use PostgresNode; +use PostgreSQL::Test::Cluster; unless (($ENV{with_ssl} || "") eq 'openssl') { @@ -20,7 +20,7 @@ my $rot13pass = "SbbOnE1"; # 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'"); @@ -63,7 +63,7 @@ like( $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'); diff --git a/src/test/modules/test_misc/t/001_constraint_validation.pl b/src/test/modules/test_misc/t/001_constraint_validation.pl index 7c1929f8053..147daf08326 100644 --- a/src/test/modules/test_misc/t/001_constraint_validation.pl +++ b/src/test/modules/test_misc/t/001_constraint_validation.pl @@ -5,12 +5,12 @@ 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'); diff --git a/src/test/modules/test_pg_dump/t/001_base.pl b/src/test/modules/test_pg_dump/t/001_base.pl index 17c404c81f2..16f7610883b 100644 --- a/src/test/modules/test_pg_dump/t/001_base.pl +++ b/src/test/modules/test_pg_dump/t/001_base.pl @@ -5,11 +5,11 @@ use strict; 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 @@ -28,7 +28,7 @@ my $tempdir = TestLib::tempdir; # 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 @@ -712,7 +712,7 @@ my %tests = ( ######################################### # 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; diff --git a/src/test/perl/Makefile b/src/test/perl/Makefile index 3d3a95b52fd..60cdbe777bb 100644 --- a/src/test/perl/Makefile +++ b/src/test/perl/Makefile @@ -16,20 +16,20 @@ include $(top_builddir)/src/Makefile.global 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 diff --git a/src/test/perl/PostgresNode.pm b/src/test/perl/PostgreSQL/Test/Cluster.pm index 465fdb68708..86eb920ea10 100644 --- a/src/test/perl/PostgresNode.pm +++ b/src/test/perl/PostgreSQL/Test/Cluster.pm @@ -5,13 +5,13 @@ =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(); @@ -61,7 +61,7 @@ PostgresNode - class representing PostgreSQL server instance 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; @@ -69,15 +69,15 @@ PostgresNode - class representing PostgreSQL server instance $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. @@ -85,7 +85,7 @@ The IPC::Run module is required. =cut -package PostgresNode; +package PostgreSQL::Test::Cluster; use strict; use warnings; @@ -100,11 +100,11 @@ use File::Spec; 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); @@ -116,10 +116,10 @@ INIT # 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'; @@ -369,8 +369,8 @@ sub set_replication_conf 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"; @@ -419,13 +419,13 @@ sub init 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"; @@ -437,7 +437,7 @@ sub init # 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 @@ -510,7 +510,7 @@ sub append_conf 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"); @@ -538,7 +538,7 @@ sub adjust_conf 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 ? '' : '= '; @@ -587,7 +587,7 @@ sub backup 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', @@ -652,7 +652,7 @@ sub _backup_fs print "# pg_start_backup: $stdout\n"; } - RecursiveCopy::copypath( + PostgreSQL::Test::RecursiveCopy::copypath( $self->data_dir, $backup_path, filterfn => sub { @@ -682,7 +682,7 @@ sub _backup_fs =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. @@ -732,10 +732,10 @@ sub init_from_backup 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'); @@ -743,7 +743,7 @@ sub init_from_backup else { rmdir($data_path); - RecursiveCopy::copypath($backup_path, $data_path); + PostgreSQL::Test::RecursiveCopy::copypath($backup_path, $data_path); } chmod(0700, $data_path); @@ -827,13 +827,13 @@ sub start # 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; } @@ -865,7 +865,7 @@ sub kill9 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; } @@ -894,7 +894,7 @@ sub stop $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; } @@ -917,7 +917,7 @@ sub reload 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; } @@ -943,7 +943,7 @@ sub restart # -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); @@ -969,7 +969,7 @@ sub promote 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; } @@ -993,7 +993,7 @@ sub logrotate 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; } @@ -1018,7 +1018,7 @@ primary_conninfo='$root_connstr' 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"; @@ -1029,9 +1029,9 @@ sub enable_restoring # 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"}; @@ -1086,7 +1086,7 @@ sub set_standby_mode 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"; @@ -1097,9 +1097,9 @@ sub enable_archiving # 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"}; @@ -1141,9 +1141,9 @@ sub _update_pid =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. @@ -1216,11 +1216,11 @@ sub new 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}) @@ -1242,7 +1242,7 @@ sub new 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; @@ -1272,9 +1272,9 @@ sub _set_pg_version $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 @@ -1286,7 +1286,7 @@ sub _set_pg_version 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}; @@ -1331,7 +1331,7 @@ sub _get_env 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 @@ -1394,14 +1394,14 @@ Locate an unprivileged (high) TCP port that's not currently bound to 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 @@ -1440,7 +1440,7 @@ sub get_free_port 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) : ()) { @@ -1474,7 +1474,7 @@ sub can_bind # 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; @@ -1496,7 +1496,7 @@ END 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; @@ -2008,7 +2008,7 @@ sub _pgbench_make_files 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}); } } @@ -2194,7 +2194,7 @@ sub connect_ok } 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) { @@ -2264,7 +2264,7 @@ sub connect_fails 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) { @@ -2343,8 +2343,8 @@ $stderr); =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 @@ -2356,7 +2356,7 @@ sub command_ok local %ENV = $self->_get_env(); - TestLib::command_ok(@_); + PostgreSQL::Test::Utils::command_ok(@_); return; } @@ -2364,7 +2364,7 @@ sub command_ok =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 @@ -2376,7 +2376,7 @@ sub command_fails local %ENV = $self->_get_env(); - TestLib::command_fails(@_); + PostgreSQL::Test::Utils::command_fails(@_); return; } @@ -2384,7 +2384,7 @@ sub command_fails =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 @@ -2396,7 +2396,7 @@ sub command_like local %ENV = $self->_get_env(); - TestLib::command_like(@_); + PostgreSQL::Test::Utils::command_like(@_); return; } @@ -2404,7 +2404,7 @@ sub command_like =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 @@ -2416,7 +2416,7 @@ sub command_fails_like local %ENV = $self->_get_env(); - TestLib::command_fails_like(@_); + PostgreSQL::Test::Utils::command_fails_like(@_); return; } @@ -2424,7 +2424,7 @@ sub command_fails_like =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 @@ -2437,7 +2437,7 @@ sub command_checks_all local %ENV = $self->_get_env(); - TestLib::command_checks_all(@_); + PostgreSQL::Test::Utils::command_checks_all(@_); return; } @@ -2460,9 +2460,9 @@ sub issues_sql_like 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; } @@ -2471,8 +2471,8 @@ sub issues_sql_like =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 @@ -2482,7 +2482,7 @@ sub run_log local %ENV = $self->_get_env(); - TestLib::run_log(@_); + PostgreSQL::Test::Utils::run_log(@_); return; } @@ -2563,8 +2563,8 @@ sub wait_for_catchup . 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; } diff --git a/src/test/perl/RecursiveCopy.pm b/src/test/perl/PostgreSQL/Test/RecursiveCopy.pm index 8a9cc722b55..dd320a605e3 100644 --- a/src/test/perl/RecursiveCopy.pm +++ b/src/test/perl/PostgreSQL/Test/RecursiveCopy.pm @@ -5,18 +5,18 @@ =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; @@ -54,7 +54,7 @@ attempted. =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; diff --git a/src/test/perl/SimpleTee.pm b/src/test/perl/PostgreSQL/Test/SimpleTee.pm index 681a36a0f8e..80a56fc0ea8 100644 --- a/src/test/perl/SimpleTee.pm +++ b/src/test/perl/PostgreSQL/Test/SimpleTee.pm @@ -10,7 +10,7 @@ # 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; diff --git a/src/test/perl/TestLib.pm b/src/test/perl/PostgreSQL/Test/Utils.pm index 06aae1760eb..f29d43f1f32 100644 --- a/src/test/perl/TestLib.pm +++ b/src/test/perl/PostgreSQL/Test/Utils.pm @@ -5,11 +5,11 @@ =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'); @@ -19,19 +19,19 @@ TestLib - helper module for writing PostgreSQL's C<prove> tests. # 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. @@ -40,7 +40,7 @@ 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; @@ -56,7 +56,7 @@ use File::Spec; 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 @@ -212,9 +212,9 @@ INIT # 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 diff --git a/src/test/perl/PostgresVersion.pm b/src/test/perl/PostgreSQL/Version.pm index 5ff701ce112..08c7f7f5191 100644 --- a/src/test/perl/PostgresVersion.pm +++ b/src/test/perl/PostgreSQL/Version.pm @@ -1,6 +1,6 @@ ############################################################################ # -# PostgresVersion.pm +# PostgreSQL/Version.pm # # Module encapsulating Postgres Version numbers # @@ -12,13 +12,13 @@ =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; @@ -37,12 +37,12 @@ PostgresVersion - class representing PostgreSQL version numbers =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; @@ -60,9 +60,9 @@ use overload =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`; @@ -103,7 +103,7 @@ sub new # 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. diff --git a/src/test/perl/README b/src/test/perl/README index b2a5541557b..0e9a00ea058 100644 --- a/src/test/perl/README +++ b/src/test/perl/README @@ -40,15 +40,15 @@ Each test script should begin with: 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; @@ -76,7 +76,7 @@ Read the documentation for more on how to write tests: 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 ----------- diff --git a/src/test/recovery/t/001_stream_rep.pl b/src/test/recovery/t/001_stream_rep.pl index 9916a36012c..bc62ec66bce 100644 --- a/src/test/recovery/t/001_stream_rep.pl +++ b/src/test/recovery/t/001_stream_rep.pl @@ -4,12 +4,12 @@ # 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( @@ -22,7 +22,7 @@ my $backup_name = 'my_backup'; $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; @@ -37,7 +37,7 @@ $node_standby_1->backup('my_backup_2'); $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; diff --git a/src/test/recovery/t/002_archiving.pl b/src/test/recovery/t/002_archiving.pl index ce60159f036..24852c97fda 100644 --- a/src/test/recovery/t/002_archiving.pl +++ b/src/test/recovery/t/002_archiving.pl @@ -4,13 +4,13 @@ # 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); @@ -23,7 +23,7 @@ $node_primary->start; $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', @@ -62,7 +62,7 @@ is($result, qq(1000), 'check content from archives'); # 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; diff --git a/src/test/recovery/t/003_recovery_targets.pl b/src/test/recovery/t/003_recovery_targets.pl index 78ef60d3b2d..0d0636b85c0 100644 --- a/src/test/recovery/t/003_recovery_targets.pl +++ b/src/test/recovery/t/003_recovery_targets.pl @@ -4,8 +4,8 @@ # 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); @@ -23,7 +23,7 @@ sub test_recovery_standby 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); @@ -52,7 +52,7 @@ sub test_recovery_standby } # 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 @@ -138,7 +138,7 @@ test_recovery_standby('LSN', 'standby_5', $node_primary, \@recovery_params, 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( @@ -158,7 +158,7 @@ ok($logfile =~ qr/multiple recovery targets specified/, # 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, diff --git a/src/test/recovery/t/004_timeline_switch.pl b/src/test/recovery/t/004_timeline_switch.pl index 07b15270438..56dd1c4f1aa 100644 --- a/src/test/recovery/t/004_timeline_switch.pl +++ b/src/test/recovery/t/004_timeline_switch.pl @@ -5,8 +5,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 => 3; $ENV{PGDATABASE} = 'postgres'; @@ -15,7 +15,7 @@ $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; @@ -24,11 +24,11 @@ my $backup_name = 'my_backup'; $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; @@ -76,7 +76,7 @@ is($result, qq(2000), 'check content of standby 2'); # 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( @@ -88,7 +88,7 @@ $node_primary_2->start; $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); diff --git a/src/test/recovery/t/005_replay_delay.pl b/src/test/recovery/t/005_replay_delay.pl index 0b56380e0a7..db44c287d26 100644 --- a/src/test/recovery/t/005_replay_delay.pl +++ b/src/test/recovery/t/005_replay_delay.pl @@ -5,12 +5,12 @@ 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; @@ -23,7 +23,7 @@ my $backup_name = 'my_backup'; $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); @@ -58,7 +58,7 @@ ok(time() - $primary_insert_time >= $delay, # 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; diff --git a/src/test/recovery/t/006_logical_decoding.pl b/src/test/recovery/t/006_logical_decoding.pl index cc116062c2c..1655298bf5b 100644 --- a/src/test/recovery/t/006_logical_decoding.pl +++ b/src/test/recovery/t/006_logical_decoding.pl @@ -8,13 +8,13 @@ # 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( diff --git a/src/test/recovery/t/007_sync_rep.pl b/src/test/recovery/t/007_sync_rep.pl index 3b031addf76..0d0e60b7723 100644 --- a/src/test/recovery/t/007_sync_rep.pl +++ b/src/test/recovery/t/007_sync_rep.pl @@ -4,8 +4,8 @@ # 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 @@ -51,7 +51,7 @@ sub start_standby_and_wait } # 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'; @@ -63,19 +63,19 @@ $node_primary->backup($backup_name); # 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); @@ -125,7 +125,7 @@ standby3|3|sync), 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; diff --git a/src/test/recovery/t/008_fsm_truncation.pl b/src/test/recovery/t/008_fsm_truncation.pl index b1082546a81..e8c59678fdb 100644 --- a/src/test/recovery/t/008_fsm_truncation.pl +++ b/src/test/recovery/t/008_fsm_truncation.pl @@ -8,11 +8,11 @@ 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( @@ -28,7 +28,7 @@ autovacuum = off $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; diff --git a/src/test/recovery/t/009_twophase.pl b/src/test/recovery/t/009_twophase.pl index 66a256208c4..b11832b99a9 100644 --- a/src/test/recovery/t/009_twophase.pl +++ b/src/test/recovery/t/009_twophase.pl @@ -5,8 +5,8 @@ use strict; use warnings; -use PostgresNode; -use TestLib; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; use Test::More tests => 24; my $psql_out = ''; @@ -31,7 +31,7 @@ sub configure_and_reload # 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( @@ -42,7 +42,7 @@ $node_london->start; $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; diff --git a/src/test/recovery/t/010_logical_decoding_timelines.pl b/src/test/recovery/t/010_logical_decoding_timelines.pl index 2a9cf3b79c3..68d94ac91c9 100644 --- a/src/test/recovery/t/010_logical_decoding_timelines.pl +++ b/src/test/recovery/t/010_logical_decoding_timelines.pl @@ -24,8 +24,8 @@ 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 (); @@ -34,7 +34,7 @@ use Scalar::Util qw(blessed); 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[ @@ -74,7 +74,7 @@ $node_primary->backup_fs_hot($backup_name); $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, diff --git a/src/test/recovery/t/011_crash_recovery.pl b/src/test/recovery/t/011_crash_recovery.pl index 72fc603e6d2..d7806e66715 100644 --- a/src/test/recovery/t/011_crash_recovery.pl +++ b/src/test/recovery/t/011_crash_recovery.pl @@ -6,14 +6,14 @@ # 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; diff --git a/src/test/recovery/t/012_subtransactions.pl b/src/test/recovery/t/012_subtransactions.pl index a3655a076b8..dbdc2d38bd3 100644 --- a/src/test/recovery/t/012_subtransactions.pl +++ b/src/test/recovery/t/012_subtransactions.pl @@ -5,12 +5,12 @@ 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( @@ -22,7 +22,7 @@ $node_primary->backup('primary_backup'); $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; diff --git a/src/test/recovery/t/013_crash_restart.pl b/src/test/recovery/t/013_crash_restart.pl index b5e3457753f..49aee1e243f 100644 --- a/src/test/recovery/t/013_crash_restart.pl +++ b/src/test/recovery/t/013_crash_restart.pl @@ -13,8 +13,8 @@ # use strict; use warnings; -use PostgresNode; -use TestLib; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; use Test::More; use Config; @@ -27,11 +27,11 @@ plan tests => 18; # 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; @@ -105,7 +105,7 @@ $monitor_stdout = ''; $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"); @@ -184,7 +184,7 @@ $monitor_stderr = ''; # 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, diff --git a/src/test/recovery/t/014_unlogged_reinit.pl b/src/test/recovery/t/014_unlogged_reinit.pl index 4c22663b644..7d6b0e3c683 100644 --- a/src/test/recovery/t/014_unlogged_reinit.pl +++ b/src/test/recovery/t/014_unlogged_reinit.pl @@ -8,11 +8,11 @@ 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; @@ -31,9 +31,9 @@ ok(-f "$pgdata/$baseUnloggedPath", 'main fork in base exists'); # 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', diff --git a/src/test/recovery/t/015_promotion_pages.pl b/src/test/recovery/t/015_promotion_pages.pl index 562c4cd3e4f..b0f5ae615a6 100644 --- a/src/test/recovery/t/015_promotion_pages.pl +++ b/src/test/recovery/t/015_promotion_pages.pl @@ -7,12 +7,12 @@ # 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. @@ -25,7 +25,7 @@ $alpha->start; # 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 diff --git a/src/test/recovery/t/016_min_consistency.pl b/src/test/recovery/t/016_min_consistency.pl index 23f4c427453..87995a73ea6 100644 --- a/src/test/recovery/t/016_min_consistency.pl +++ b/src/test/recovery/t/016_min_consistency.pl @@ -9,8 +9,8 @@ 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 @@ -43,7 +43,7 @@ sub find_largest_lsn } # 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 @@ -61,7 +61,7 @@ $primary->start; # 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; diff --git a/src/test/recovery/t/017_shm.pl b/src/test/recovery/t/017_shm.pl index 5548a1556d3..29667d1f398 100644 --- a/src/test/recovery/t/017_shm.pl +++ b/src/test/recovery/t/017_shm.pl @@ -9,9 +9,9 @@ use warnings; 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 @@ -30,7 +30,7 @@ else 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"; @@ -43,7 +43,7 @@ sub log_ipcs } # 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 @@ -116,7 +116,7 @@ log_ipcs(); $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 @@ -175,7 +175,7 @@ like($single_stderr, $pre_existing_msg, 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(); diff --git a/src/test/recovery/t/018_wal_optimize.pl b/src/test/recovery/t/018_wal_optimize.pl index 3bedeffcae1..5fd5ad80499 100644 --- a/src/test/recovery/t/018_wal_optimize.pl +++ b/src/test/recovery/t/018_wal_optimize.pl @@ -12,8 +12,8 @@ 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 @@ -45,7 +45,7 @@ sub run_wal_optimize { 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( @@ -60,7 +60,7 @@ wal_skip_threshold = 0 # 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. @@ -148,11 +148,11 @@ wal_skip_threshold = 0 # 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. diff --git a/src/test/recovery/t/019_replslot_limit.pl b/src/test/recovery/t/019_replslot_limit.pl index e065c5c008c..2275e28a502 100644 --- a/src/test/recovery/t/019_replslot_limit.pl +++ b/src/test/recovery/t/019_replslot_limit.pl @@ -7,17 +7,17 @@ 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( @@ -41,7 +41,7 @@ my $backup_name = 'my_backup'; $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'"); @@ -260,7 +260,7 @@ ok($failed, 'check that replication has been broken'); $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( @@ -281,7 +281,7 @@ max_slot_wal_keep_size = 0 )); $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'"); @@ -305,7 +305,7 @@ $node_standby->stop; # 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; @@ -313,7 +313,7 @@ if ($TestLib::windows_os) # 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( @@ -329,7 +329,7 @@ $node_primary3->safe_psql('postgres', $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'"); @@ -419,7 +419,7 @@ sub find_in_log 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); diff --git a/src/test/recovery/t/020_archive_status.pl b/src/test/recovery/t/020_archive_status.pl index cea65735a39..68a21eb82ce 100644 --- a/src/test/recovery/t/020_archive_status.pl +++ b/src/test/recovery/t/020_archive_status.pl @@ -6,12 +6,12 @@ # 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); @@ -27,7 +27,7 @@ my $primary_data = $primary->data_dir; # 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( @@ -138,7 +138,7 @@ $primary->poll_query_until('postgres', 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; @@ -174,7 +174,7 @@ ok( -f "$standby1_data/$segment_path_2_done", # 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; diff --git a/src/test/recovery/t/021_row_visibility.pl b/src/test/recovery/t/021_row_visibility.pl index 7f40977976b..2d409434ef4 100644 --- a/src/test/recovery/t/021_row_visibility.pl +++ b/src/test/recovery/t/021_row_visibility.pl @@ -6,13 +6,13 @@ 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; @@ -26,7 +26,7 @@ my $backup_name = 'my_backup'; $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'); @@ -187,7 +187,7 @@ sub send_query_and_wait $$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/; diff --git a/src/test/recovery/t/022_crash_temp_files.pl b/src/test/recovery/t/022_crash_temp_files.pl index cc8c8664e28..bf95a30761a 100644 --- a/src/test/recovery/t/022_crash_temp_files.pl +++ b/src/test/recovery/t/022_crash_temp_files.pl @@ -4,8 +4,8 @@ # 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; @@ -26,11 +26,11 @@ else # 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', @@ -131,7 +131,7 @@ $killme_stdout2 = ''; $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 @@ -220,7 +220,7 @@ $killme_stdout2 = ''; $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 diff --git a/src/test/recovery/t/023_pitr_prepared_xact.pl b/src/test/recovery/t/023_pitr_prepared_xact.pl index a1ff97d070a..4fcc7ad4002 100644 --- a/src/test/recovery/t/023_pitr_prepared_xact.pl +++ b/src/test/recovery/t/023_pitr_prepared_xact.pl @@ -4,13 +4,13 @@ # 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{ @@ -24,7 +24,7 @@ $node_primary->backup($backup_name); # 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, diff --git a/src/test/recovery/t/024_archive_recovery.pl b/src/test/recovery/t/024_archive_recovery.pl index 32be5c42515..70ef9c7e672 100644 --- a/src/test/recovery/t/024_archive_recovery.pl +++ b/src/test/recovery/t/024_archive_recovery.pl @@ -4,14 +4,14 @@ # 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 @@ -66,7 +66,7 @@ sub test_recovery_wal_level_minimal { 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, diff --git a/src/test/recovery/t/025_stuck_on_old_timeline.pl b/src/test/recovery/t/025_stuck_on_old_timeline.pl index 00ee9fcaedd..4e0f6291f4e 100644 --- a/src/test/recovery/t/025_stuck_on_old_timeline.pl +++ b/src/test/recovery/t/025_stuck_on_old_timeline.pl @@ -8,15 +8,15 @@ # 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 @@ -28,10 +28,10 @@ $node_primary->init(allows_streaming => 1, has_archiving => 1); # 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"' @@ -47,7 +47,7 @@ my $backup_name = 'my_backup'; $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, @@ -60,7 +60,7 @@ $node_standby->backup($backup_name, backup_options => ['-Xnone']); # 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); diff --git a/src/test/recovery/t/026_overwrite_contrecord.pl b/src/test/recovery/t/026_overwrite_contrecord.pl index b7d3b6e03d4..70705ab91de 100644 --- a/src/test/recovery/t/026_overwrite_contrecord.pl +++ b/src/test/recovery/t/026_overwrite_contrecord.pl @@ -6,8 +6,8 @@ use strict; use warnings; use FindBin; -use PostgresNode; -use TestLib; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; use Test::More; plan tests => 3; @@ -17,7 +17,7 @@ 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; @@ -70,7 +70,7 @@ unlink $node->basedir . "/pgdata/pg_wal/$endfile" # 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; diff --git a/src/test/regress/pg_regress.c b/src/test/regress/pg_regress.c index 0343e6e66d4..2c8a600bad1 100644 --- a/src/test/regress/pg_regress.c +++ b/src/test/regress/pg_regress.c @@ -822,7 +822,7 @@ initialize_environment(void) * 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 */ diff --git a/src/test/ssl/t/001_ssltests.pl b/src/test/ssl/t/001_ssltests.pl index 80e318f32e8..2f30d117634 100644 --- a/src/test/ssl/t/001_ssltests.pl +++ b/src/test/ssl/t/001_ssltests.pl @@ -4,8 +4,8 @@ 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; @@ -65,7 +65,7 @@ push @keys, 'client_wrongperms'; #### 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 diff --git a/src/test/ssl/t/002_scram.pl b/src/test/ssl/t/002_scram.pl index 1dfa2b91f32..983554263fb 100644 --- a/src/test/ssl/t/002_scram.pl +++ b/src/test/ssl/t/002_scram.pl @@ -5,8 +5,8 @@ use strict; use warnings; -use PostgresNode; -use TestLib; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; use Test::More; use File::Copy; @@ -38,7 +38,7 @@ my $common_connstr; # 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 diff --git a/src/test/ssl/t/SSLServer.pm b/src/test/ssl/t/SSLServer.pm index 804d0082452..c5999e0b333 100644 --- a/src/test/ssl/t/SSLServer.pm +++ b/src/test/ssl/t/SSLServer.pm @@ -30,8 +30,8 @@ package SSLServer; 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; diff --git a/src/test/subscription/t/001_rep_changes.pl b/src/test/subscription/t/001_rep_changes.pl index d89875a98bb..9531d81f19d 100644 --- a/src/test/subscription/t/001_rep_changes.pl +++ b/src/test/subscription/t/001_rep_changes.pl @@ -4,17 +4,17 @@ # 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; diff --git a/src/test/subscription/t/002_types.pl b/src/test/subscription/t/002_types.pl index 79fc046f2df..1606d478d9a 100644 --- a/src/test/subscription/t/002_types.pl +++ b/src/test/subscription/t/002_types.pl @@ -5,17 +5,17 @@ # 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; diff --git a/src/test/subscription/t/003_constraints.pl b/src/test/subscription/t/003_constraints.pl index 3767d24f92b..752daabd968 100644 --- a/src/test/subscription/t/003_constraints.pl +++ b/src/test/subscription/t/003_constraints.pl @@ -4,17 +4,17 @@ # 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; diff --git a/src/test/subscription/t/004_sync.pl b/src/test/subscription/t/004_sync.pl index f07c306e5b7..aae9bb41416 100644 --- a/src/test/subscription/t/004_sync.pl +++ b/src/test/subscription/t/004_sync.pl @@ -4,17 +4,17 @@ # 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"); diff --git a/src/test/subscription/t/005_encoding.pl b/src/test/subscription/t/005_encoding.pl index 9df474beb5a..ea991f5a888 100644 --- a/src/test/subscription/t/005_encoding.pl +++ b/src/test/subscription/t/005_encoding.pl @@ -4,17 +4,17 @@ # 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' ]); diff --git a/src/test/subscription/t/006_rewrite.pl b/src/test/subscription/t/006_rewrite.pl index ec4d641230b..0e189469f71 100644 --- a/src/test/subscription/t/006_rewrite.pl +++ b/src/test/subscription/t/006_rewrite.pl @@ -4,15 +4,15 @@ # 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; diff --git a/src/test/subscription/t/007_ddl.pl b/src/test/subscription/t/007_ddl.pl index 1a3a1dcf14d..8c869c5c15c 100644 --- a/src/test/subscription/t/007_ddl.pl +++ b/src/test/subscription/t/007_ddl.pl @@ -4,15 +4,15 @@ # 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; diff --git a/src/test/subscription/t/008_diff_schema.pl b/src/test/subscription/t/008_diff_schema.pl index 3af3d25604e..50a83b52182 100644 --- a/src/test/subscription/t/008_diff_schema.pl +++ b/src/test/subscription/t/008_diff_schema.pl @@ -4,17 +4,17 @@ # 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; diff --git a/src/test/subscription/t/009_matviews.pl b/src/test/subscription/t/009_matviews.pl index 2e7d0d44138..f93ce1ef350 100644 --- a/src/test/subscription/t/009_matviews.pl +++ b/src/test/subscription/t/009_matviews.pl @@ -4,15 +4,15 @@ # 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; diff --git a/src/test/subscription/t/010_truncate.pl b/src/test/subscription/t/010_truncate.pl index 0e6ecf9c2fc..448032edf14 100644 --- a/src/test/subscription/t/010_truncate.pl +++ b/src/test/subscription/t/010_truncate.pl @@ -4,17 +4,17 @@ # 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)); diff --git a/src/test/subscription/t/011_generated.pl b/src/test/subscription/t/011_generated.pl index a8e7fbd9dab..781c87fddc2 100644 --- a/src/test/subscription/t/011_generated.pl +++ b/src/test/subscription/t/011_generated.pl @@ -4,17 +4,17 @@ # 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; diff --git a/src/test/subscription/t/012_collation.pl b/src/test/subscription/t/012_collation.pl index 09873911886..06f19160e3f 100644 --- a/src/test/subscription/t/012_collation.pl +++ b/src/test/subscription/t/012_collation.pl @@ -5,8 +5,8 @@ # (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') @@ -18,13 +18,13 @@ else 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' ]); diff --git a/src/test/subscription/t/013_partition.pl b/src/test/subscription/t/013_partition.pl index c89d4952219..c75a07d6b35 100644 --- a/src/test/subscription/t/013_partition.pl +++ b/src/test/subscription/t/013_partition.pl @@ -4,21 +4,21 @@ # 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; diff --git a/src/test/subscription/t/014_binary.pl b/src/test/subscription/t/014_binary.pl index 4e8aeb2e413..3dd69fb502d 100644 --- a/src/test/subscription/t/014_binary.pl +++ b/src/test/subscription/t/014_binary.pl @@ -5,17 +5,17 @@ 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; diff --git a/src/test/subscription/t/015_stream.pl b/src/test/subscription/t/015_stream.pl index da6761f81ea..debb74cc65e 100644 --- a/src/test/subscription/t/015_stream.pl +++ b/src/test/subscription/t/015_stream.pl @@ -4,19 +4,19 @@ # 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; diff --git a/src/test/subscription/t/016_stream_subxact.pl b/src/test/subscription/t/016_stream_subxact.pl index 4aae98a66ec..92c756dc2e9 100644 --- a/src/test/subscription/t/016_stream_subxact.pl +++ b/src/test/subscription/t/016_stream_subxact.pl @@ -4,19 +4,19 @@ # 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; diff --git a/src/test/subscription/t/017_stream_ddl.pl b/src/test/subscription/t/017_stream_ddl.pl index 50bd6e31173..8d8310ecbe8 100644 --- a/src/test/subscription/t/017_stream_ddl.pl +++ b/src/test/subscription/t/017_stream_ddl.pl @@ -4,19 +4,19 @@ # 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; diff --git a/src/test/subscription/t/018_stream_subxact_abort.pl b/src/test/subscription/t/018_stream_subxact_abort.pl index 63fe248a047..df21377a6ec 100644 --- a/src/test/subscription/t/018_stream_subxact_abort.pl +++ b/src/test/subscription/t/018_stream_subxact_abort.pl @@ -4,19 +4,19 @@ # 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; diff --git a/src/test/subscription/t/019_stream_subxact_ddl_abort.pl b/src/test/subscription/t/019_stream_subxact_ddl_abort.pl index 176a7024861..5e062f191c3 100644 --- a/src/test/subscription/t/019_stream_subxact_ddl_abort.pl +++ b/src/test/subscription/t/019_stream_subxact_ddl_abort.pl @@ -5,19 +5,19 @@ # 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; diff --git a/src/test/subscription/t/020_messages.pl b/src/test/subscription/t/020_messages.pl index ecf9b192a34..408a3ad1d6b 100644 --- a/src/test/subscription/t/020_messages.pl +++ b/src/test/subscription/t/020_messages.pl @@ -4,18 +4,18 @@ # 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; diff --git a/src/test/subscription/t/021_twophase.pl b/src/test/subscription/t/021_twophase.pl index 19f096295f2..f8597cfdaa2 100644 --- a/src/test/subscription/t/021_twophase.pl +++ b/src/test/subscription/t/021_twophase.pl @@ -4,8 +4,8 @@ # 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; ############################### @@ -13,14 +13,14 @@ 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)); diff --git a/src/test/subscription/t/022_twophase_cascade.pl b/src/test/subscription/t/022_twophase_cascade.pl index a38c5e78fe6..8b402d63c07 100644 --- a/src/test/subscription/t/022_twophase_cascade.pl +++ b/src/test/subscription/t/022_twophase_cascade.pl @@ -7,8 +7,8 @@ # use strict; use warnings; -use PostgresNode; -use TestLib; +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; use Test::More tests => 41; ############################### @@ -18,7 +18,7 @@ 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 @@ -26,7 +26,7 @@ logical_decoding_work_mem = 64kB )); $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 @@ -34,7 +34,7 @@ logical_decoding_work_mem = 64kB )); $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 diff --git a/src/test/subscription/t/023_twophase_stream.pl b/src/test/subscription/t/023_twophase_stream.pl index c72c6b5ef41..bc5a17581ce 100644 --- a/src/test/subscription/t/023_twophase_stream.pl +++ b/src/test/subscription/t/023_twophase_stream.pl @@ -4,8 +4,8 @@ # 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; ############################### @@ -13,7 +13,7 @@ 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 @@ -22,7 +22,7 @@ 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->append_conf('postgresql.conf', qq( max_prepared_transactions = 10 diff --git a/src/test/subscription/t/024_add_drop_pub.pl b/src/test/subscription/t/024_add_drop_pub.pl index 24493a9c4e3..9384b3a9c46 100644 --- a/src/test/subscription/t/024_add_drop_pub.pl +++ b/src/test/subscription/t/024_add_drop_pub.pl @@ -4,17 +4,17 @@ # 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; diff --git a/src/test/subscription/t/100_bugs.pl b/src/test/subscription/t/100_bugs.pl index baa4a907713..34a60fd9ab9 100644 --- a/src/test/subscription/t/100_bugs.pl +++ b/src/test/subscription/t/100_bugs.pl @@ -4,8 +4,8 @@ # 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 @@ -19,11 +19,11 @@ use Test::More tests => 5; # 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; @@ -81,7 +81,7 @@ $node_subscriber->stop('fast'); # 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; @@ -108,7 +108,7 @@ $node_publisher->stop('fast'); # # 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)) @@ -158,15 +158,15 @@ is($node_twoways->safe_psql('d2', "SELECT count(f) FROM t2"), # 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; |