using System;

using System.Data;

using System.IO;

using System.Net.Sockets;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

using NUnit.Framework;

namespace Npgsql.Tests

{

public class ExceptionTests : TestBase

{

[Test, Description("Generates a basic server-side exception, checks that it's properly raised and populated")]

public void Basic()

{

using (var conn = OpenConnection())

{

// Make sure messages are in English

conn.ExecuteNonQuery(@"SET lc_messages='en_US.UTF-8'");

conn.ExecuteNonQuery(@"

CREATE OR REPLACE FUNCTION pg_temp.emit_exception() RETURNS VOID AS

'BEGIN RAISE EXCEPTION ''testexception'' USING ERRCODE = ''12345''; END;'

LANGUAGE 'plpgsql';

");

PostgresException ex = null!;

try

{

conn.ExecuteNonQuery("SELECT pg_temp.emit_exception()");

Assert.Fail("No exception was thrown");

}

catch (PostgresException e)

{

ex = e;

}

Assert.That(ex.MessageText, Is.EqualTo("testexception"));

Assert.That(ex.Severity, Is.EqualTo("ERROR"));

Assert.That(ex.InvariantSeverity, Is.EqualTo("ERROR"));

Assert.That(ex.SqlState, Is.EqualTo("12345"));

Assert.That(ex.Position, Is.EqualTo(0));

var data = ex.Data;

Assert.That(data[nameof(PostgresException.Severity)], Is.EqualTo("ERROR"));

Assert.That(data[nameof(PostgresException.SqlState)], Is.EqualTo("12345"));

Assert.That(data.Contains(nameof(PostgresException.Position)), Is.False);

var exString = ex.ToString();

Assert.That(exString, Contains.Substring(nameof(PostgresException.Severity) + ": ERROR"));

Assert.That(exString, Contains.Substring(nameof(PostgresException.SqlState) + ": 12345"));

Assert.That(conn.ExecuteScalar("SELECT 1"), Is.EqualTo(1), "Connection in bad state after an exception");

}

}

[Test]

public void ExceptionFieldsArePopulated()

{

using (var conn = OpenConnection())

{

TestUtil.MinimumPgVersion(conn, "9.3.0", "5 error fields haven't been added yet");

conn.ExecuteNonQuery("CREATE TEMP TABLE uniqueviolation (id INT NOT NULL, CONSTRAINT uniqueviolation_pkey PRIMARY KEY (id))");

conn.ExecuteNonQuery("INSERT INTO uniqueviolation (id) VALUES(1)");

try

{

conn.ExecuteNonQuery("INSERT INTO uniqueviolation (id) VALUES(1)");

}

catch (PostgresException ex)

{

Assert.That(ex.ColumnName, Is.Null, "ColumnName should not be populated for unique violations");

Assert.That(ex.TableName, Is.EqualTo("uniqueviolation"));

Assert.That(ex.SchemaName, Does.StartWith("pg_temp"));

Assert.That(ex.ConstraintName, Is.EqualTo("uniqueviolation_pkey"));

Assert.That(ex.DataTypeName, Is.Null, "DataTypeName should not be populated for unique violations");

}

}

}

[Test]

public void ColumnNameExceptionFieldIsPopulated()

{

using (var conn = OpenConnection())

{

TestUtil.MinimumPgVersion(conn, "9.3.0", "5 error fields haven't been added yet");

conn.ExecuteNonQuery("CREATE TEMP TABLE notnullviolation (id INT NOT NULL)");

try

{

conn.ExecuteNonQuery("INSERT INTO notnullviolation (id) VALUES(NULL)");

}

catch (PostgresException ex)

{

Assert.That(ex.SchemaName, Does.StartWith("pg_temp"));

Assert.That(ex.TableName, Is.EqualTo("notnullviolation"));

Assert.That(ex.ColumnName, Is.EqualTo("id"));

}

}

}

[Test]

[NonParallelizable]

public void DataTypeNameExceptionFieldIsPopulated()

{

// On reading the source code for PostgreSQL9.3beta1, the only time that the

// datatypename field is populated is when using domain types. So here we'll

// create a domain that simply does not allow NULLs then try and cast NULL

// to it.

const string dropDomain = @"DROP DOMAIN IF EXISTS public.intnotnull";

const string createDomain = @"CREATE DOMAIN public.intnotnull AS INT NOT NULL";

const string castStatement = @"SELECT CAST(NULL AS public.intnotnull)";

using (var conn = OpenConnection())

{

TestUtil.MinimumPgVersion(conn, "9.3.0", "5 error fields haven't been added yet");

try

{

var command = new NpgsqlCommand(dropDomain, conn);

command.ExecuteNonQuery();

command = new NpgsqlCommand(createDomain, conn);

command.ExecuteNonQuery();

command = new NpgsqlCommand(castStatement, conn);

//Cause the NOT NULL violation

command.ExecuteNonQuery();

}

catch (PostgresException ex)

{

Assert.AreEqual("public", ex.SchemaName);

Assert.AreEqual("intnotnull", ex.DataTypeName);

}

}

}

[Test]

public void NpgsqlExceptionInAsync()

{

using (var conn = OpenConnection())

{

Assert.That(async () => await conn.ExecuteNonQueryAsync("MALFORMED"),

Throws.Exception.TypeOf<PostgresException>());

// Just in case, anything but a PostgresException would trigger the connection breaking, check that

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

}

}

[Test]

public void NpgsqlExceptionTransience()

{

Assert.True(new NpgsqlException("", new IOException()).IsTransient);

Assert.True(new NpgsqlException("", new SocketException()).IsTransient);

Assert.False(new NpgsqlException().IsTransient);

Assert.False(new NpgsqlException("", new Exception("Inner Exception")).IsTransient);

}

[Test]

public void PostgresExceptionTransience()

{

Assert.True(CreateWithSqlState("53300").IsTransient);

Assert.False(CreateWithSqlState("0").IsTransient);

PostgresException CreateWithSqlState(string sqlState)

{

var info = CreateSerializationInfo();

info.AddValue(nameof(PostgresException.Severity), null);

info.AddValue(nameof(PostgresException.InvariantSeverity), null);

info.AddValue(nameof(PostgresException.SqlState), sqlState);

info.AddValue(nameof(PostgresException.MessageText), null);

info.AddValue(nameof(PostgresException.Detail), null);

info.AddValue(nameof(PostgresException.Hint), null);

info.AddValue(nameof(PostgresException.Position), 0);

info.AddValue(nameof(PostgresException.InternalPosition), 0);

info.AddValue(nameof(PostgresException.InternalQuery), null);

info.AddValue(nameof(PostgresException.Where), null);

info.AddValue(nameof(PostgresException.SchemaName), null);

info.AddValue(nameof(PostgresException.TableName), null);

info.AddValue(nameof(PostgresException.ColumnName), null);

info.AddValue(nameof(PostgresException.DataTypeName), null);

info.AddValue(nameof(PostgresException.ConstraintName), null);

info.AddValue(nameof(PostgresException.File), null);

info.AddValue(nameof(PostgresException.Line), null);

info.AddValue(nameof(PostgresException.Routine), null);

return new PostgresException(info, default);

}

}

[Test]

public void Serialization()

{

var info = CreateSerializationInfo();

info.AddValue(nameof(PostgresException.Severity), "high");

info.AddValue(nameof(PostgresException.InvariantSeverity), "high2");

info.AddValue(nameof(PostgresException.SqlState), "53300");

info.AddValue(nameof(PostgresException.MessageText), "message");

info.AddValue(nameof(PostgresException.Detail), "detail");

info.AddValue(nameof(PostgresException.Hint), "hint");

info.AddValue(nameof(PostgresException.Position), 18);

info.AddValue(nameof(PostgresException.InternalPosition), 42);

info.AddValue(nameof(PostgresException.InternalQuery), "query");

info.AddValue(nameof(PostgresException.Where), "where");

info.AddValue(nameof(PostgresException.SchemaName), "schema");

info.AddValue(nameof(PostgresException.TableName), "table");

info.AddValue(nameof(PostgresException.ColumnName), "column");

info.AddValue(nameof(PostgresException.DataTypeName), "type");

info.AddValue(nameof(PostgresException.ConstraintName), "constraint");

info.AddValue(nameof(PostgresException.File), "file");

info.AddValue(nameof(PostgresException.Line), "line");

info.AddValue(nameof(PostgresException.Routine), "routine");

var actual = new PostgresException(info, default);

var formatter = new BinaryFormatter();

var stream = new MemoryStream();

formatter.Serialize(stream, actual);

stream.Seek(0, SeekOrigin.Begin);

var expected = (PostgresException)formatter.Deserialize(stream);

Assert.That(expected.Severity, Is.EqualTo(actual.Severity));

Assert.That(expected.InvariantSeverity, Is.EqualTo(actual.InvariantSeverity));

Assert.That(expected.SqlState, Is.EqualTo(actual.SqlState));

Assert.That(expected.MessageText, Is.EqualTo(actual.MessageText));

Assert.That(expected.Detail, Is.EqualTo(actual.Detail));

Assert.That(expected.Hint, Is.EqualTo(actual.Hint));

Assert.That(expected.Position, Is.EqualTo(actual.Position));

Assert.That(expected.InternalPosition, Is.EqualTo(actual.InternalPosition));

Assert.That(expected.InternalQuery, Is.EqualTo(actual.InternalQuery));

Assert.That(expected.Where, Is.EqualTo(actual.Where));

Assert.That(expected.SchemaName, Is.EqualTo(actual.SchemaName));

Assert.That(expected.TableName, Is.EqualTo(actual.TableName));

Assert.That(expected.ColumnName, Is.EqualTo(actual.ColumnName));

Assert.That(expected.DataTypeName, Is.EqualTo(actual.DataTypeName));

Assert.That(expected.ConstraintName, Is.EqualTo(actual.ConstraintName));

Assert.That(expected.File, Is.EqualTo(actual.File));

Assert.That(expected.Line, Is.EqualTo(actual.Line));

Assert.That(expected.Routine, Is.EqualTo(actual.Routine));

}

SerializationInfo CreateSerializationInfo()

{

var info = new SerializationInfo(typeof(PostgresException), new FormatterConverter());

new Exception().GetObjectData(info, default);

return info;

}

}

}