# Copyright (c) 2021-2025, PostgreSQL Global Development Group

use strict;
use warnings FATAL => 'all';

use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
use Test::More;

if ($PostgreSQL::Test::Utils::is_msys2)
{
	plan skip_all => 'High bit name tests fail on Msys2';
}

# We're going to use byte sequences that aren't valid UTF-8 strings.  Use
# LATIN1, which accepts any byte and has a conversion from each byte to UTF-8.
$ENV{LC_ALL} = 'C';
$ENV{PGCLIENTENCODING} = 'LATIN1';

# Create database and user names covering the range of LATIN1
# characters, for use in a connection string by pg_dumpall.  Skip ','
# because of pg_regress --create-role, skip [\n\r] because pg_dumpall
# does not allow them.  We also skip many ASCII letters, to keep the
# total number of tested characters to what will fit in four names.
# The odds of finding something interesting by testing all ASCII letters
# seem too small to justify the cycles of testing a fifth name.
my $dbname1 =
	'regression'
  . generate_ascii_string(1, 9)
  . generate_ascii_string(11, 12)
  . generate_ascii_string(14, 33)
  . (
	$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'
  . generate_ascii_string(88, 99)                             # skip 'd'-'w'
  . generate_ascii_string(120, 149);
my $dbname3 = 'regression' . generate_ascii_string(150, 202);
my $dbname4 = 'regression' . generate_ascii_string(203, 255);

(my $username1 = $dbname1) =~ s/^regression/regress_/;
(my $username2 = $dbname2) =~ s/^regression/regress_/;
(my $username3 = $dbname3) =~ s/^regression/regress_/;
(my $username4 = $dbname4) =~ s/^regression/regress_/;

my $src_bootstrap_super = 'regress_postgres';
my $dst_bootstrap_super = 'boot';

my $node = PostgreSQL::Test::Cluster->new('main');
$node->init(
	extra => [
		'--username' => $src_bootstrap_super,
		'--locale' => 'C',
		'--encoding' => 'LATIN1',
	]);

# prep pg_hba.conf and pg_ident.conf
$node->run_log(
	[
		$ENV{PG_REGRESS},
		'--config-auth' => $node->data_dir,
		'--user' => $src_bootstrap_super,
		'--create-role' => "$username1,$username2,$username3,$username4",
	]);
$node->start;

my $backupdir = $node->backup_dir;
my $discard = "$backupdir/discard.sql";
my $plain = "$backupdir/plain.sql";
my $dirfmt = "$backupdir/dirfmt";

$node->run_log(
	[ 'createdb', '--username' => $src_bootstrap_super, $dbname1 ]);
$node->run_log(
	[
		'createuser',
		'--username' => $src_bootstrap_super,
		'--superuser',
		$username1,
	]);
$node->run_log(
	[ 'createdb', '--username' => $src_bootstrap_super, $dbname2 ]);
$node->run_log(
	[
		'createuser',
		'--username' => $src_bootstrap_super,
		'--superuser',
		$username2,
	]);
$node->run_log(
	[ 'createdb', '--username' => $src_bootstrap_super, $dbname3 ]);
$node->run_log(
	[
		'createuser',
		'--username' => $src_bootstrap_super,
		'--superuser',
		$username3,
	]);
$node->run_log(
	[ 'createdb', '--username' => $src_bootstrap_super, $dbname4 ]);
$node->run_log(
	[
		'createuser',
		'--username' => $src_bootstrap_super,
		'--superuser',
		$username4,
	]);


# For these tests, pg_dumpall --roles-only is used because it produces
# a short dump.
$node->command_ok(
	[
		'pg_dumpall', '--roles-only',
		'--file' => $discard,
		'--dbname' => $node->connstr($dbname1),
		'--username' => $username4,
	],
	'pg_dumpall with long ASCII name 1');
$node->command_ok(
	[
		'pg_dumpall', '--no-sync', '--roles-only',
		'--file' => $discard,
		'--dbname' => $node->connstr($dbname2),
		'--username' => $username3,
	],
	'pg_dumpall with long ASCII name 2');
$node->command_ok(
	[
		'pg_dumpall', '--no-sync', '--roles-only',
		'--file' => $discard,
		'--dbname' => $node->connstr($dbname3),
		'--username' => $username2,
	],
	'pg_dumpall with long ASCII name 3');
$node->command_ok(
	[
		'pg_dumpall', '--no-sync', '--roles-only',
		'--file' => $discard,
		'--dbname' => $node->connstr($dbname4),
		'--username' => $username1,
	],
	'pg_dumpall with long ASCII name 4');
$node->command_ok(
	[
		'pg_dumpall', '--no-sync', '--roles-only',
		'--username' => $src_bootstrap_super,
		'--dbname' => 'dbname=template1',
	],
	'pg_dumpall --dbname accepts connection string');

$node->run_log(
	[ 'createdb', '--username' => $src_bootstrap_super, "foo\n\rbar" ]);

# not sufficient to use --roles-only here
$node->command_fails(
	[
		'pg_dumpall', '--no-sync',
		'--username' => $src_bootstrap_super,
		'--file' => $discard,
	],
	'pg_dumpall with \n\r in database name');
$node->run_log(
	[ 'dropdb', '--username' => $src_bootstrap_super, "foo\n\rbar" ]);


# make a table, so the parallel worker has something to dump
$node->safe_psql(
	$dbname1,
	'CREATE TABLE t0()',
	extra_params => [ '--username' => $src_bootstrap_super ]);

# XXX no printed message when this fails, just SIGPIPE termination
$node->command_ok(
	[
		'pg_dump',
		'--format' => 'directory',
		'--no-sync',
		'--jobs' => 2,
		'--file' => $dirfmt,
		'--username' => $username1,
		$node->connstr($dbname1),
	],
	'parallel dump');

# recreate $dbname1 for restore test
$node->run_log([ 'dropdb', '--username' => $src_bootstrap_super, $dbname1 ]);
$node->run_log(
	[ 'createdb', '--username' => $src_bootstrap_super, $dbname1 ]);

$node->command_ok(
	[
		'pg_restore',
		'--verbose',
		'--dbname' => 'template1',
		'--jobs' => 2,
		'--username' => $username1,
		$dirfmt,
	],
	'parallel restore');

$node->run_log([ 'dropdb', '--username' => $src_bootstrap_super, $dbname1 ]);

$node->command_ok(
	[
		'pg_restore',
		'--create',
		'--verbose',
		'--dbname' => 'template1',
		'--jobs' => 2,
		'--username' => $username1,
		$dirfmt,
	],
	'parallel restore with create');


$node->command_ok(
	[
		'pg_dumpall',
		'--no-sync',
		'--file' => $plain,
		'--username' => $username1,
	],
	'take full dump');
system_log('cat', $plain);
my ($stderr, $result);
my $restore_super = qq{regress_a'b\\c=d\\ne"f};
$restore_super =~ s/"//g
  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 = PostgreSQL::Test::Cluster->new('destination_envar');
$envar_node->init(
	extra => [
		'--username' => $dst_bootstrap_super,
		'--locale' => 'C',
		'--encoding' => 'LATIN1',
	],
	auth_extra =>
	  [ '--user' => $dst_bootstrap_super, '--create-role' => $restore_super ],
);
$envar_node->start;

# make superuser for restore
$envar_node->run_log(
	[
		'createuser',
		'--username' => $dst_bootstrap_super,
		'--superuser', $restore_super,
	]);

{
	local $ENV{PGPORT} = $envar_node->port;
	local $ENV{PGUSER} = $restore_super;
	$result = run_log([ 'psql', '--no-psqlrc', '--file' => $plain ],
		'2>' => \$stderr);
}
ok($result,
	'restore full dump using environment variables for connection parameters'
);
is($stderr, '', 'no dump errors');


# Restore full dump through psql using command-line options for
# dbname/user connection parameters.  "\connect dbname=" forgets
# user/port from command line.

my $cmdline_node = PostgreSQL::Test::Cluster->new('destination_cmdline');
$cmdline_node->init(
	extra => [
		'--username' => $dst_bootstrap_super,
		'--locale' => 'C',
		'--encoding' => 'LATIN1',
	],
	auth_extra =>
	  [ '--user' => $dst_bootstrap_super, '--create-role' => $restore_super ],
);
$cmdline_node->start;
$cmdline_node->run_log(
	[
		'createuser',
		'--username' => $dst_bootstrap_super,
		'--superuser',
		$restore_super,
	]);
{
	$result = run_log(
		[
			'psql',
			'--port' => $cmdline_node->port,
			'--username' => $restore_super,
			'--no-psqlrc',
			'--file' => $plain,
		],
		'2>' => \$stderr);
}
ok($result,
	'restore full dump with command-line options for connection parameters');
is($stderr, '', 'no dump errors');

done_testing();