[Test, Description("Makes sure the connection goes through the proper state lifecycle")]

public async Task Basic_lifecycle()

{

await using var conn = CreateConnection();

var eventOpen = false;

var eventClosed = false;

conn.StateChange += (s, e) =>

{

if (e is { OriginalState: ConnectionState.Closed, CurrentState: ConnectionState.Open })

eventOpen = true;

if (e is { OriginalState: ConnectionState.Open, CurrentState: ConnectionState.Closed })

eventClosed = true;

};

Assert.That(conn.State, Is.EqualTo(ConnectionState.Closed));

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Closed));

await conn.OpenAsync();

Assert.That(conn.State, Is.EqualTo(ConnectionState.Open));

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Open));

Assert.That(eventOpen, Is.True);

await using (var cmd = new NpgsqlCommand("SELECT 1", conn))

await using (var reader = await cmd.ExecuteReaderAsync())

{

await reader.ReadAsync();

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Open | ConnectionState.Fetching));

Assert.That(conn.State, Is.EqualTo(ConnectionState.Open));

}

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Open));

Assert.That(conn.State, Is.EqualTo(ConnectionState.Open));

await conn.CloseAsync();

Assert.That(conn.State, Is.EqualTo(ConnectionState.Closed));

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Closed));

Assert.That(eventClosed, Is.True);

}

[Test, Description("Makes sure the connection goes through the proper state lifecycle")]

public async Task Broken_lifecycle([Values] bool openFromClose)

{

await using var dataSource = CreateDataSource();

await using var conn = dataSource.CreateConnection();

var eventOpen = false;

var eventClosed = false;

conn.StateChange += (s, e) =>

{

if (e is { OriginalState: ConnectionState.Closed, CurrentState: ConnectionState.Open })

eventOpen = true;

if (e is { OriginalState: ConnectionState.Open, CurrentState: ConnectionState.Closed })

eventClosed = true;

};

Assert.That(conn.State, Is.EqualTo(ConnectionState.Closed));

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Closed));

await conn.OpenAsync();

await using var transaction = await conn.BeginTransactionAsync();

Assert.That(conn.State, Is.EqualTo(ConnectionState.Open));

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Open));

Assert.That(eventOpen, Is.True);

var sleep = conn.ExecuteNonQueryAsync("SELECT pg_sleep(5)");

// Wait for a query

await Task.Delay(1000);

await using (var killingConn = await OpenConnectionAsync())

killingConn.ExecuteNonQuery($"SELECT pg_terminate_backend({conn.ProcessID})");

Assert.ThrowsAsync<PostgresException>(() => sleep);

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Broken));

Assert.That(conn.State, Is.EqualTo(ConnectionState.Closed));

Assert.That(eventClosed, Is.True);

Assert.That(conn.Connector is null);

Assert.That(conn.NpgsqlDataSource.Statistics.Total, Is.EqualTo(0));

if (openFromClose)

{

await conn.CloseAsync();

Assert.That(conn.State, Is.EqualTo(ConnectionState.Closed));

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Closed));

Assert.That(eventClosed, Is.True);

}

Assert.DoesNotThrowAsync(conn.OpenAsync);

Assert.That(await conn.ExecuteScalarAsync("SELECT 1"), Is.EqualTo(1));

Assert.That(conn.NpgsqlDataSource.Statistics.Total, Is.EqualTo(1));

Assert.DoesNotThrowAsync(conn.CloseAsync);

}

[Test]

public async Task Break_while_open()

{

await using var dataSource = CreateDataSource();

await using var conn = await dataSource.OpenConnectionAsync();

using (var conn2 = await OpenConnectionAsync())

conn2.ExecuteNonQuery($"SELECT pg_terminate_backend({conn.ProcessID})");

// Allow some time for the pg_terminate to kill our connection

using (var cmd = CreateSleepCommand(conn, 10))

Assert.That(() => cmd.ExecuteNonQuery(), Throws.Exception

.AssignableTo<NpgsqlException>());

Assert.That(conn.State, Is.EqualTo(ConnectionState.Closed));

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Broken));

}

#region Connection Errors

#if IGNORE

[Test]

[TestCase(true)]

[TestCase(false)]

public async Task Connection_refused(bool pooled)

{

var csb = new NpgsqlConnectionStringBuilder(ConnectionString) { Port = 44444, Pooling = pooled };

using (var conn = new NpgsqlConnection(csb)) {

Assert.That(() => conn.Open(), Throws.Exception

.TypeOf<SocketException>()

// CoreCLR currently has an issue which causes the wrong SocketErrorCode to be set on Linux:

// https://github.com/dotnet/corefx/issues/8464

.With.Property(nameof(SocketException.SocketErrorCode)).EqualTo(SocketError.ConnectionRefused)

);

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Closed));

}

}

[Test]

[TestCase(true)]

[TestCase(false)]

public async Task Connection_refused_async(bool pooled)

{

var csb = new NpgsqlConnectionStringBuilder(ConnectionString) { Port = 44444, Pooling = pooled };

using (var conn = new NpgsqlConnection(csb))

{

Assert.That(async () => await conn.OpenAsync(), Throws.Exception

.TypeOf<SocketException>()

.With.Property(nameof(SocketException.SocketErrorCode)).EqualTo(SocketError.ConnectionRefused)

);

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Closed));

}

}

#endif

[Test]

public void Invalid_Username()

{

var connString = new NpgsqlConnectionStringBuilder(ConnectionString)

{

Username = "unknown", Pooling = false

}.ToString();

using var conn = new NpgsqlConnection(connString);

Assert.That(conn.Open, Throws.Exception

.TypeOf<PostgresException>()

.With.Property(nameof(PostgresException.SqlState)).EqualTo(PostgresErrorCodes.InvalidPassword)

);

Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Closed));

}

[Test]

public void Bad_database()

{

using var dataSource = CreateDataSource(csb => csb.Database = "does_not_exist");

using var conn = dataSource.CreateConnection();

Assert.That(() => conn.Open(),

Throws.Exception.TypeOf<PostgresException>()

.With.Property(nameof(PostgresException.SqlState)).EqualTo(PostgresErrorCodes.InvalidCatalogName)

);

}

[Test, Description("Tests that mandatory connection string parameters are indeed mandatory")]

public void Mandatory_connection_string_params()

=> Assert.Throws<ArgumentNullException>(() =>

new NpgsqlConnection("User ID=npgsql_tests;Password=npgsql_tests;Database=npgsql_tests"));

[Test, Description("Reuses the same connection instance for a failed connection, then a successful one")]

public async Task Fail_connect_then_succeed([Values] bool pooling)

{

var dbName = GetUniqueIdentifier(nameof(Fail_connect_then_succeed));

await using var conn1 = await OpenConnectionAsync();

await conn1.ExecuteNonQueryAsync($"DROP DATABASE IF EXISTS \"{dbName}\"");

try

{

await using var dataSource = CreateDataSource(csb =>

{

csb.Database = dbName;

csb.Pooling = pooling;

});

await using var conn2 = dataSource.CreateConnection();

var pgEx = Assert.ThrowsAsync<PostgresException>(conn2.OpenAsync)!;

Assert.That(pgEx.SqlState, Is.EqualTo(PostgresErrorCodes.InvalidCatalogName)); // database doesn't exist

Assert.That(conn2.FullState, Is.EqualTo(ConnectionState.Closed));

await conn1.ExecuteNonQueryAsync($"CREATE DATABASE \"{dbName}\" TEMPLATE template0");

Assert.DoesNotThrowAsync(conn2.OpenAsync);

Assert.DoesNotThrowAsync(conn2.CloseAsync);

}

finally

{

await conn1.ExecuteNonQueryAsync($"DROP DATABASE IF EXISTS \"{dbName}\"");

}

}

[Test]

public void Open_timeout_unknown_ip([Values(true, false)] bool async)

{

const int timeoutSeconds = 2;

var unknownIp = Environment.GetEnvironmentVariable("NPGSQL_UNKNOWN_IP");

if (unknownIp is null)

{

Assert.Ignore("NPGSQL_UNKNOWN_IP isn't defined and is required for connection timeout tests");

return;

}

using var dataSource = CreateDataSource(csb =>

{

csb.Host = unknownIp;

csb.Timeout = timeoutSeconds;

});

using var conn = dataSource.CreateConnection();

var sw = Stopwatch.StartNew();

if (async)

{

Assert.That(async () => await conn.OpenAsync(), Throws.Exception

.TypeOf<NpgsqlException>()

.With.InnerException.TypeOf<TimeoutException>());

}

else

{

Assert.That(() => conn.Open(), Throws.Exception

.TypeOf<NpgsqlException>()

.With.InnerException.TypeOf<TimeoutException>());

}

Assert.That(sw.Elapsed.TotalMilliseconds, Is.GreaterThanOrEqualTo(timeoutSeconds * 1000 - 100),

$"Timeout was supposed to happen after {timeoutSeconds} seconds, but fired after {sw.Elapsed.TotalSeconds}");

Assert.That(conn.State, Is.EqualTo(ConnectionState.Closed));

}

[Test]

public void Connect_timeout_cancel()

{

var unknownIp = Environment.GetEnvironmentVariable("NPGSQL_UNKNOWN_IP");

if (unknownIp is null)

{

Assert.Ignore("NPGSQL_UNKNOWN_IP isn't defined and is required for connection cancellation tests");

return;

}

var connString = new NpgsqlConnectionStringBuilder(ConnectionString)

{

Host = unknownIp,

Pooling = false,

Timeout = 30

}.ToString();

using var conn = new NpgsqlConnection(connString);

var cts = new CancellationTokenSource(1000);

Assert.That(async () => await conn.OpenAsync(cts.Token), Throws.Exception.TypeOf<OperationCanceledException>());

Assert.That(conn.State, Is.EqualTo(ConnectionState.Closed));

}

[Test]

public void Bad_hostname()

{

using var dataSource = CreateDataSource(csb => csb.Host = "hostname.that.does.not.exist");

using var conn = dataSource.CreateConnection();

Assert.That(

() => conn.Open(),

Throws.Exception

.TypeOf<NpgsqlException>()

.With

.Property(nameof(NpgsqlException.InnerException))

.TypeOf<SocketException>()

);

}

[Test]

public void Bad_hostname_async()

{

using var dataSource = CreateDataSource(csb => csb.Host = "hostname.that.does.not.exist");

using var conn = dataSource.CreateConnection();

Assert.That(

async () => await conn.OpenAsync(),

Throws.Exception

.TypeOf<NpgsqlException>()

.With

.Property(nameof(NpgsqlException.InnerException))

.TypeOf<SocketException>()

);

}

#endregion

#region Client Encoding

[Test, IssueLink("https://github.com/npgsql/npgsql/issues/1065")]

public async Task Client_encoding_is_UTF8_by_default()

{

using var conn = await OpenConnectionAsync();

Assert.That(await conn.ExecuteScalarAsync("SHOW client_encoding"), Is.EqualTo("UTF8"));

}

[Test, IssueLink("https://github.com/npgsql/npgsql/issues/1065")]

[NonParallelizable] // Sets environment variable

public async Task Client_encoding_env_var()

{

using (var testConn = await OpenConnectionAsync())

Assert.That(await testConn.ExecuteScalarAsync("SHOW client_encoding"), Is.Not.EqualTo("SQL_ASCII"));

// Note that the pool is unaware of the environment variable, so if a connection is

// returned from the pool it may contain the wrong client_encoding

using var _ = SetEnvironmentVariable("PGCLIENTENCODING", "SQL_ASCII");

await using var dataSource = CreateDataSource();

await using var conn = await dataSource.OpenConnectionAsync();

Assert.That(await conn.ExecuteScalarAsync("SHOW client_encoding"), Is.EqualTo("SQL_ASCII"));

}

[Test, IssueLink("https://github.com/npgsql/npgsql/issues/1065")]

public async Task Client_encoding_connection_param()

{

using (var conn = await OpenConnectionAsync())

Assert.That(await conn.ExecuteScalarAsync("SHOW client_encoding"), Is.Not.EqualTo("SQL_ASCII"));

await using var dataSource = CreateDataSource(csb => csb.ClientEncoding = "SQL_ASCII");

using (var conn = await dataSource.OpenConnectionAsync())

Assert.That(await conn.ExecuteScalarAsync("SHOW client_encoding"), Is.EqualTo("SQL_ASCII"));

}

#endregion Client Encoding

#region Timezone

[Test, IssueLink("https://github.com/npgsql/npgsql/issues/1634")]

[NonParallelizable] // Sets environment variable

public async Task Timezone_env_var()

{

string newTimezone;

using (var conn1 = await OpenConnectionAsync())

{

newTimezone = (string?)await conn1.ExecuteScalarAsync("SHOW TIMEZONE") == "Africa/Bamako"

? "Africa/Lagos"

: "Africa/Bamako";

}

// Note that the pool is unaware of the environment variable, so if a connection is

// returned from the pool it may contain the wrong timezone

using var _ = SetEnvironmentVariable("PGTZ", newTimezone);

await using var dataSource = CreateDataSource();

using var conn2 = await dataSource.OpenConnectionAsync();

Assert.That(await conn2.ExecuteScalarAsync("SHOW TIMEZONE"), Is.EqualTo(newTimezone));

}

[Test, IssueLink("https://github.com/npgsql/npgsql/issues/1634")]

public async Task Timezone_connection_param()

{

string newTimezone;

using (var conn = await OpenConnectionAsync())

{

newTimezone = (string?)await conn.ExecuteScalarAsync("SHOW TIMEZONE") == "Africa/Bamako"

? "Africa/Lagos"

: "Africa/Bamako";

}

await using var dataSource = CreateDataSource(csb => csb.Timezone = newTimezone);

using (var conn = await dataSource.OpenConnectionAsync())

Assert.That(await conn.ExecuteScalarAsync("SHOW TIMEZONE"), Is.EqualTo(newTimezone));

}

#endregion Timezone

#region Application Name

[Test, IssueLink("https://github.com/npgsql/npgsql/issues/6133")]

[NonParallelizable] // Sets environment variable

public async Task Application_name_env_var()

{

const string testAppName = "MyTestApp";

// Note that the pool is unaware of the environment variable, so if a connection is

// returned from the pool it may contain the wrong application name

using var _ = SetEnvironmentVariable("PGAPPNAME", testAppName);

await using var dataSource = CreateDataSource();

await using var conn = await dataSource.OpenConnectionAsync();

Assert.That(conn.PostgresParameters["application_name"], Is.EqualTo(testAppName));

}

[Test]

public async Task Application_name_connection_param()

{

const string testAppName = "MyTestApp2";

await using var dataSource = CreateDataSource(csb => csb.ApplicationName = testAppName);

await using var conn = await dataSource.OpenConnectionAsync();

Assert.That(conn.PostgresParameters["application_name"], Is.EqualTo(testAppName));

}

[Test]

[NonParallelizable] // Sets environment variable

public async Task Application_name_connection_param_overrides_env_var()

{

const string envAppName = "EnvApp";

const string connAppName = "ConnApp";

using var _ = SetEnvironmentVariable("PGAPPNAME", envAppName);

await using var dataSource = CreateDataSource(csb => csb.ApplicationName = connAppName);

await using var conn = await dataSource.OpenConnectionAsync();

Assert.That(conn.PostgresParameters["application_name"], Is.EqualTo(connAppName));

}

#endregion Application Name

#region ConnectionString - Host

[TestCase("127.0.0.1", ExpectedResult = new [] { "127.0.0.1:5432" })]

[TestCase("127.0.0.1:5432", ExpectedResult = new [] { "127.0.0.1:5432" })]

[TestCase("::1", ExpectedResult = new [] { "::1:5432" })]

[TestCase("[::1]", ExpectedResult = new [] { "[::1]:5432" })]

[TestCase("[::1]:5432", ExpectedResult = new [] { "[::1]:5432" })]

[TestCase("localhost", ExpectedResult = new [] { "localhost:5432" })]

[TestCase("localhost:5432", ExpectedResult = new [] { "localhost:5432" })]

[TestCase("127.0.0.1,127.0.0.1:5432,::1,[::1],[::1]:5432,localhost,localhost:5432",

ExpectedResult = new []

{

"127.0.0.1:5432",

"127.0.0.1:5432",

"::1:5432",

"[::1]:5432",

"[::1]:5432",

"localhost:5432",

"localhost:5432"

})]

[Test, IssueLink("https://github.com/npgsql/npgsql/issues/3802")]

public string[] ConnectionString_Host(string host)

{

var dataSourceBuilder = new NpgsqlDataSourceBuilder

{

ConnectionStringBuilder = { Host = host }

};

using var dataSource = dataSourceBuilder.BuildMultiHost();

return dataSource.Pools.Select(ds => $"{ds.Settings.Host}:{ds.Settings.Port}").ToArray()!;

}

#endregion ConnectionString - Host

[Test]

public async Task Unix_domain_socket()

{

if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))

{

if (Environment.OSVersion.Version.Major < 10 || Environment.OSVersion.Version.Build < 17093)

Assert.Ignore("Unix-domain sockets support was introduced in Windows build 17093");

// On Windows we first need a classic IP connection to make sure we're running against the

// right backend version

using var versionConnection = await OpenConnectionAsync();

MinimumPgVersion(versionConnection, "13.0", "Unix-domain sockets support on Windows was introduced in PostgreSQL 13");

}

var port = new NpgsqlConnectionStringBuilder(ConnectionString).Port;

var candidateDirectories = new[] { "/var/run/postgresql", "/tmp", Environment.GetEnvironmentVariable("TMP") ?? "C:\\" };

var dir = candidateDirectories.FirstOrDefault(d => File.Exists(Path.Combine(d, $".s.PGSQL.{port}")));

if (dir == null)

{

IgnoreExceptOnBuildServer("No PostgreSQL unix domain socket was found");

return;

}

try

{

await using var dataSource = CreateDataSource(csb => csb.Host = dir);

await using var conn = await dataSource.OpenConnectionAsync();

await using var tx = await conn.BeginTransactionAsync();

Assert.That(await conn.ExecuteScalarAsync("SELECT 1", tx), Is.EqualTo(1));

Assert.That(conn.DataSource, Is.EqualTo(Path.Combine(dir, $".s.PGSQL.{port}")));

}

catch (Exception ex)

{

IgnoreExceptOnBuildServer($"Connection via unix domain socket failed: {ex}");

}

}

[Test]

[Platform(Exclude = "MacOsX", Reason = "Fails only on mac, needs to be investigated")]

public async Task Unix_abstract_domain_socket()

{

if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))

{

Assert.Ignore("Abstract unix-domain sockets are not supported on windows");

}

// We first need a classic IP connection to make sure we're running against the

// right backend version

using var versionConnection = await OpenConnectionAsync();

MinimumPgVersion(versionConnection, "14.0", "Abstract unix-domain sockets support was introduced in PostgreSQL 14");

var csb = new NpgsqlConnectionStringBuilder(ConnectionString)

{

Host = "@/npgsql_unix"

};

try

{

await using var dataSource = CreateDataSource(csb.ToString());

await using var conn = await dataSource.OpenConnectionAsync();

await using var tx = await conn.BeginTransactionAsync();

Assert.That(await conn.ExecuteScalarAsync("SELECT 1", tx), Is.EqualTo(1));

Assert.That(conn.DataSource, Is.EqualTo(Path.Combine(csb.Host, $".s.PGSQL.{csb.Port}")));

}

catch (Exception ex)

{

IgnoreExceptOnBuildServer($"Connection via abstract unix domain socket failed: {ex}");

}

}

[Test, IssueLink("https://github.com/npgsql/npgsql/issues/903")]

public void DataSource_property()

{

using var conn = new NpgsqlConnection();

Assert.That(conn.DataSource, Is.EqualTo(string.Empty));

var csb = new NpgsqlConnectionStringBuilder(ConnectionString);

conn.ConnectionString = csb.ConnectionString;

Assert.That(conn.DataSource, Is.EqualTo($"tcp://{csb.Host}:{csb.Port}"));

csb.Host = "127.0.0.1, 127.0.0.2";

conn.ConnectionString = csb.ConnectionString;

Assert.That(conn.DataSource, Is.EqualTo(string.Empty));

}

#region Server version

[Test]

public async Task PostgreSqlVersion_ServerVersion()

{

await using var c = new NpgsqlConnection(ConnectionString);

Assert.That(() => c.PostgreSqlVersion, Throws.InvalidOperationException

.With.Message.EqualTo("Connection is not open"));

Assert.That(() => c.ServerVersion, Throws.InvalidOperationException

.With.Message.EqualTo("Connection is not open"));

await c.OpenAsync();

var backendVersionString = (string)(await c.ExecuteScalarAsync("SHOW server_version"))!;

Assert.That(backendVersionString, Is.EqualTo(c.ServerVersion));

Assert.That(backendVersionString, Does.Contain(

new[] { "rc", "beta", "devel" }.Any(x => backendVersionString.Contains(x))

? c.PostgreSqlVersion.Major.ToString()

: c.PostgreSqlVersion.ToString()));

}

[TestCase("X13.0")]

[TestCase("13.")]

[TestCase("13.1.")]

[TestCase("13.1.1.")]

[TestCase("13.1.1.1.")]

[TestCase("13.1.1.1.1")]

public void ParseVersion_fails(string versionString)

=> Assert.That(() => TestDbInfo.ParseServerVersion(versionString), Throws.Exception);

[TestCase("13.3", ExpectedResult = "13.3")]

[TestCase("13.3X", ExpectedResult = "13.3")]

[TestCase("9.6.4", ExpectedResult = "9.6.4")]

[TestCase("9.6.4X", ExpectedResult = "9.6.4")]

[TestCase("9.5alpha2", ExpectedResult = "9.5")]

[TestCase("9.5alpha2X", ExpectedResult = "9.5")]

[TestCase("9.5devel", ExpectedResult = "9.5")]

[TestCase("9.5develX", ExpectedResult = "9.5")]

[TestCase("9.5deveX", ExpectedResult = "9.5")]

[TestCase("9.4beta3", ExpectedResult = "9.4")]

[TestCase("9.4rc1", ExpectedResult = "9.4")]

[TestCase("9.4rc1X", ExpectedResult = "9.4")]

[TestCase("13devel", ExpectedResult = "13.0")]

[TestCase("13beta1", ExpectedResult = "13.0")]

// The following should not occur as PostgreSQL version string in the wild these days but we support it.

[TestCase("13", ExpectedResult = "13.0")]

[TestCase("13X", ExpectedResult = "13.0")]

[TestCase("13alpha1", ExpectedResult = "13.0")]

[TestCase("13alpha", ExpectedResult = "13.0")]

[TestCase("13alphX", ExpectedResult = "13.0")]

[TestCase("13beta", ExpectedResult = "13.0")]

[TestCase("13betX", ExpectedResult = "13.0")]

[TestCase("13rc1", ExpectedResult = "13.0")]

[TestCase("13rc", ExpectedResult = "13.0")]

[TestCase("13rX", ExpectedResult = "13.0")]

[TestCase("99999.99999.99999.99999", ExpectedResult = "99999.99999.99999.99999")]

[TestCase("99999.99999.99999.99999X", ExpectedResult = "99999.99999.99999.99999")]

[TestCase("99999.99999.99999.99999devel", ExpectedResult = "99999.99999.99999.99999")]

[TestCase("99999.99999.99999.99999alpha99999", ExpectedResult = "99999.99999.99999.99999")]

[TestCase("99999.99999.99999alpha99999", ExpectedResult = "99999.99999.99999")]

[TestCase("99999.99999.99999.99999beta99999", ExpectedResult = "99999.99999.99999.99999")]

[TestCase("99999.99999.99999beta99999", ExpectedResult = "99999.99999.99999")]

[TestCase("99999.99999.99999.99999rc99999", ExpectedResult = "99999.99999.99999.99999")]

[TestCase("99999.99999.99999rc99999", ExpectedResult = "99999.99999.99999")]

public string ParseVersion_succeeds(string versionString)

=> TestDbInfo.ParseServerVersion(versionString).ToString();

class TestDbInfo : NpgsqlDatabaseInfo

{

public TestDbInfo(string host, int port, string databaseName, Version version) : base(host, port, databaseName, version)

=> throw new NotImplementedException();

protected override IEnumerable<PostgresType> GetTypes()

=> throw new NotImplementedException();

public new static Version ParseServerVersion(string versionString)

=> NpgsqlDatabaseInfo.ParseServerVersion(versionString);

}

#endregion Server version

[Test]

public void Setting_connection_string_while_open_throws()

{

using var conn = new NpgsqlConnection();

conn.ConnectionString = ConnectionString;

conn.Open();

Assert.That(() => conn.ConnectionString = "", Throws.Exception.TypeOf<InvalidOperationException>());

}

[Test]

public void Empty_constructor()

{

var conn = new NpgsqlConnection();

Assert.That(conn.ConnectionTimeout, Is.EqualTo(NpgsqlConnectionStringBuilder.DefaultTimeout));

Assert.That(conn.ConnectionString, Is.SameAs(string.Empty));

Assert.That(() => conn.Open(), Throws.Exception.TypeOf<InvalidOperationException>());

}

[Test]

public void Constructor_with_null_connection_string()

{

var conn = new NpgsqlConnection(null);

Assert.That(conn.ConnectionString, Is.SameAs(string.Empty));

Assert.That(() => conn.Open(), Throws.Exception.TypeOf<InvalidOperationException>());