public void ChangeDatabaseInvalidName()
{
var csb = AppConfig.CreateConnectionStringBuilder();
using (var connection = new MySqlConnection(csb.ConnectionString))
{
connection.Open();
Assert.Throws <MySqlException>(() => connection.ChangeDatabase($"not_a_real_database_1234"));
Assert.Equal(ConnectionState.Open, connection.State);
Assert.Equal(csb.Database, connection.Database);
Assert.Equal(csb.Database, QueryCurrentDatabase(connection));
}
}
public async Task ChangeDatabase()
{
var csb = AppConfig.CreateConnectionStringBuilder();
using var connection = new MySqlConnection(csb.ConnectionString);
await connection.OpenAsync();
Assert.Equal(csb.Database, connection.Database);
Assert.Equal(csb.Database, await QueryCurrentDatabaseAsync(connection));
await connection.ChangeDatabaseAsync(AppConfig.SecondaryDatabase);
Assert.Equal(AppConfig.SecondaryDatabase, connection.Database);
Assert.Equal(AppConfig.SecondaryDatabase, await QueryCurrentDatabaseAsync(connection));
}
public void ConnectNoPassword()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.UserID = AppConfig.PasswordlessUser;
csb.Password = "";
csb.Database = "";
using (var connection = new MySqlConnection(csb.ConnectionString))
{
Assert.Equal(ConnectionState.Closed, connection.State);
connection.Open();
Assert.Equal(ConnectionState.Open, connection.State);
}
}
public async Task ConnectSslBadCaCertificate()
{
var csb = AppConfig.CreateConnectionStringBuilder();
#if !BASELINE
csb.CertificateFile = Path.Combine(AppConfig.CertsPath, "ssl-client.pfx");
#else
csb.SslCert = Path.Combine(AppConfig.CertsPath, "ssl-client-cert.pem");
csb.SslKey = Path.Combine(AppConfig.CertsPath, "ssl-client-key.pem");
#endif
csb.SslMode = MySqlSslMode.VerifyCA;
csb.SslCa = Path.Combine(AppConfig.CertsPath, "non-ca-client-cert.pem");
using var connection = new MySqlConnection(csb.ConnectionString);
await Assert.ThrowsAsync <MySqlException>(async() => await connection.OpenAsync());
}
public void ChangeDatabase()
{
var csb = AppConfig.CreateConnectionStringBuilder();
using var connection = new MySqlConnection(csb.ConnectionString);
connection.Open();
Assert.Equal(csb.Database, connection.Database);
Assert.Equal(csb.Database, QueryCurrentDatabase(connection));
connection.ChangeDatabase(AppConfig.SecondaryDatabase);
Assert.Equal(AppConfig.SecondaryDatabase, connection.Database);
Assert.Equal(AppConfig.SecondaryDatabase, QueryCurrentDatabase(connection));
}
public async Task CharacterSet()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.Pooling = true;
csb.MinimumPoolSize = 0;
csb.MaximumPoolSize = 21; // use a uniqe pool size to create a unique connection string to force a unique pool to be created
#if BASELINE
csb.CharacterSet = "utf8mb4";
#endif
// verify that connection charset is the same when retrieving a connection from the pool
await CheckCharacterSetAsync(csb.ConnectionString).ConfigureAwait(false);
await CheckCharacterSetAsync(csb.ConnectionString).ConfigureAwait(false);
await CheckCharacterSetAsync(csb.ConnectionString).ConfigureAwait(false);
}
public async Task ConnectSslBadClientCertificate()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.CertificateFile = Path.Combine(AppConfig.CertsPath, "non-ca-client.pfx");
csb.CertificatePassword = "";
using (var connection = new MySqlConnection(csb.ConnectionString))
{
#if BASELINE
var exType = typeof(IOException);
#else
var exType = typeof(MySqlException);
#endif
await Assert.ThrowsAsync(exType, async() => await connection.OpenAsync());
}
}
public void ConnectBadPassword()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.Password = "******";
using var connection = new MySqlConnection(csb.ConnectionString);
var ex = Assert.Throws <MySqlException>(connection.Open);
#if !BASELINE // https://bugs.mysql.com/bug.php?id=78426
if (AppConfig.SupportedFeatures.HasFlag(ServerFeatures.ErrorCodes) || ex.Number != 0)
{
Assert.Equal((int)MySqlErrorCode.AccessDenied, ex.Number);
}
#endif
Assert.Equal(ConnectionState.Closed, connection.State);
}
public void ConnectBadDatabase()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.Database = "wrong_database";
using var connection = new MySqlConnection(csb.ConnectionString);
var ex = Assert.Throws <MySqlException>(connection.Open);
#if !BASELINE // https://bugs.mysql.com/bug.php?id=78426
if (AppConfig.SupportedFeatures.HasFlag(ServerFeatures.ErrorCodes) || ex.ErrorCode != default)
{
Assert.Equal(MySqlErrorCode.UnknownDatabase, ex.ErrorCode);
}
#endif
Assert.Equal(ConnectionState.Closed, connection.State);
}
public void ChangeConnectionStringAfterClose()
{
var csb = AppConfig.CreateConnectionStringBuilder();
using var connection = new MySqlConnection(csb.ConnectionString);
connection.Open();
Assert.Equal(csb.Database, connection.Database);
connection.Close();
csb.Database = AppConfig.SecondaryDatabase;
connection.ConnectionString = csb.ConnectionString;
connection.Open();
Assert.Equal(csb.Database, connection.Database);
connection.Close();
}
public async Task ConnectNoPassword()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.UserID = AppConfig.PasswordlessUser;
csb.Password = "";
csb.Database = "";
using (var connection = new MySqlConnection(csb.ConnectionString))
{
Assert.Equal(ConnectionState.Closed, connection.State);
await connection.OpenAsync().ConfigureAwait(false);
Assert.Equal(ConnectionState.Open, connection.State);
}
}
public void GetIntForTinyInt1(bool treatTinyAsBoolean, bool prepare)
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.TreatTinyAsBoolean = treatTinyAsBoolean;
csb.IgnorePrepare = false;
using var connection = new MySqlConnection(csb.ConnectionString);
connection.Open();
connection.Execute(@"drop table if exists datatypes_tinyint1;
create table datatypes_tinyint1(value tinyint(1));
insert into datatypes_tinyint1(value) values(0), (1), (2), (-1), (-128), (127);");
using var command = new MySqlCommand("select value from datatypes_tinyint1;", connection);
if (prepare)
{
command.Prepare();
}
using var reader = command.ExecuteReader();
int[] expected = { 0, 1, 2, -1, -128, 127 };
if (treatTinyAsBoolean)
{
expected = expected.Select(x => x == 0 ? 0 : 1).ToArray();
}
for (int i = 0; i < expected.Length; i++)
{
Assert.True(reader.Read());
#if !BASELINE
// https://bugs.mysql.com/bug.php?id=99091
Assert.Equal((sbyte)expected[i], reader.GetSByte(0));
if (treatTinyAsBoolean)
{
Assert.Equal((byte)expected[i], reader.GetByte(0));
}
#endif
Assert.Equal((short)expected[i], reader.GetInt16(0));
Assert.Equal(expected[i], reader.GetInt32(0));
Assert.Equal((long)expected[i], reader.GetInt64(0));
#if !BASELINE
// https://bugs.mysql.com/bug.php?id=99091
Assert.Equal(expected[i], reader.GetFieldValue <int>(0));
#endif
}
Assert.False(reader.Read());
}
public async Task InsertLargeBlobAsync(string column, int size)
{
// NOTE: MySQL Server will reset the connection when it receives an oversize packet, so we need to create a test-specific connection here
using (var connection = new MySqlConnection(AppConfig.CreateConnectionStringBuilder().ConnectionString))
{
await connection.OpenAsync();
var transaction = await connection.BeginTransactionAsync();
// verify that this amount of data can be sent to MySQL successfully
var maxAllowedPacket = (await connection.QueryAsync <int>("select @@max_allowed_packet").ConfigureAwait(false)).Single();
var shouldFail = maxAllowedPacket < size + 100;
var data = CreateByteArray(size);
long lastInsertId;
using (var cmd = new MySqlCommand(Invariant($"insert into datatypes_blobs(`{column}`) values(?)"), connection, transaction)
{
Parameters = { new MySqlParameter {
Value = data
} }
})
{
try
{
await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);
lastInsertId = cmd.LastInsertedId;
Assert.False(shouldFail);
}
catch (MySqlException ex)
{
lastInsertId = -1;
Assert.True(shouldFail);
Assert.Contains("packet", ex.Message);
}
}
if (!shouldFail)
{
var queryResult = (await connection.QueryAsync <byte[]>(Invariant($"select `{column}` from datatypes_blobs where rowid = {lastInsertId}")).ConfigureAwait(false)).Single();
TestUtilities.AssertEqual(data, queryResult);
await connection.ExecuteAsync(Invariant($"delete from datatypes_blobs where rowid = {lastInsertId}")).ConfigureAwait(false);
}
}
}
public void LeakConnections()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.Pooling = true;
csb.MinimumPoolSize = 0;
csb.MaximumPoolSize = 6;
csb.ConnectionTimeout = 3u;
for (int i = 0; i < csb.MaximumPoolSize + 2; i++)
{
var connection = new MySqlConnection(csb.ConnectionString);
connection.Open();
// have to GC for leaked connections to be removed from the pool
GC.Collect();
}
}
public DatabaseFixture()
{
var csb = AppConfig.CreateConnectionStringBuilder();
var connectionString = csb.ConnectionString;
var database = csb.Database;
csb.Database = "";
using (var db = new MySqlConnection(csb.ConnectionString))
{
db.Open();
var cmd = db.CreateCommand();
cmd.CommandText = "create schema if not exists " + database;
cmd.ExecuteNonQuery();
db.Close();
}
Connection = new MySqlConnection(connectionString);
}
public void ChangeConnectionStringWhenOpen()
{
var csb = AppConfig.CreateConnectionStringBuilder();
using var connection = new MySqlConnection(csb.ConnectionString);
connection.Open();
Assert.Equal(csb.Database, connection.Database);
csb.Database = AppConfig.SecondaryDatabase;
#if BASELINE
Assert.Throws <MySqlException>(() =>
#else
Assert.Throws <InvalidOperationException>(() =>
#endif
{
connection.ConnectionString = csb.ConnectionString;
});
}
public async Task RequireTls13()
{
if (AppConfig.SupportedFeatures.HasFlag(ServerFeatures.Tls13))
{
return;
}
var csb = AppConfig.CreateConnectionStringBuilder();
csb.TlsVersion = "TLS 1.3";
using var connection = new MySqlConnection(csb.ConnectionString);
#if !BASELINE
await Assert.ThrowsAsync <MySqlException>(async() => await connection.OpenAsync());
#else
await Assert.ThrowsAsync <Win32Exception>(async() => await connection.OpenAsync());
#endif
}
public async Task ResetConnectionClearsUserVariables()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.AllowUserVariables = true;
using var connection = new MySqlConnection(csb.ConnectionString);
await connection.OpenAsync();
connection.Execute("set @temp_var = 1;");
var tempVar = connection.ExecuteScalar <int?>("select @temp_var;");
Assert.Equal(1, tempVar);
await connection.ResetConnectionAsync();
tempVar = connection.ExecuteScalar <int?>("select @temp_var;");
Assert.Null(tempVar);
}
public async Task InsertLargeBlobAsync(string column, int size)
{
// NOTE: MySQL Server will reset the connection when it receives an oversize packet, so we need to create a test-specific connection here
using (var connection = new MySqlConnection(AppConfig.CreateConnectionStringBuilder().ConnectionString))
{
await connection.OpenAsync();
var transaction = await connection.BeginTransactionAsync();
var data = CreateByteArray(size);
var isSupported = size < 1048576 || AppConfig.SupportedFeatures.HasFlag(ServerFeatures.LargePackets);
long lastInsertId;
using (var cmd = new MySqlCommand(Invariant($"insert into datatypes_blobs(`{column}`) values(?)"), connection, transaction)
{
Parameters = { new MySqlParameter {
Value = data
} }
})
{
try
{
await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);
lastInsertId = cmd.LastInsertedId;
Assert.True(isSupported);
}
catch (MySqlException ex)
{
lastInsertId = -1;
Assert.False(isSupported);
Assert.True(ex.Message.IndexOf("packet") >= 0 || ex.Message.IndexOf("innodb_log_file_size") >= 0);
}
}
if (isSupported)
{
var queryResult = (await connection.QueryAsync <byte[]>(Invariant($"select `{column}` from datatypes_blobs where rowid = {lastInsertId}")).ConfigureAwait(false)).Single();
TestUtilities.AssertEqual(data, queryResult);
await connection.ExecuteAsync(Invariant($"delete from datatypes_blobs where rowid = {lastInsertId}")).ConfigureAwait(false);
}
}
}
public async Task WaitTimeout()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.Pooling = true;
csb.MinimumPoolSize = 0;
csb.MaximumPoolSize = 1;
#if !BASELINE
csb.DeferConnectionReset = true;
#endif
int serverThread;
using (var connection = new MySqlConnection(csb.ConnectionString))
{
await connection.OpenAsync();
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = "SET @@session.wait_timeout=3";
await cmd.ExecuteNonQueryAsync();
}
serverThread = connection.ServerThread;
}
await Task.Delay(TimeSpan.FromSeconds(5));
using (var connection = new MySqlConnection(csb.ConnectionString))
{
#if !BASELINE
try
#endif
{
await connection.OpenAsync();
Assert.NotEqual(serverThread, connection.ServerThread);
}
#if !BASELINE
catch (MySqlProtocolException) when(csb.UseCompression)
{
// workaround for https://bugs.mysql.com/bug.php?id=103412
}
#endif
}
}
public async Task UseDatabase()
{
var csb = AppConfig.CreateConnectionStringBuilder();
using var connection = new MySqlConnection(csb.ConnectionString);
connection.Open();
Assert.Equal(csb.Database, connection.Database);
Assert.Equal(csb.Database, await QueryCurrentDatabaseAsync(connection));
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = $"USE {AppConfig.SecondaryDatabase};";
await cmd.ExecuteNonQueryAsync();
}
Assert.Equal(AppConfig.SecondaryDatabase, connection.Database);
Assert.Equal(AppConfig.SecondaryDatabase, await QueryCurrentDatabaseAsync(connection));
}
public void ConnectionPoolNoPassword()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.UserID = AppConfig.PasswordlessUser;
csb.Password = "";
csb.Database = "";
csb.Pooling = true;
csb.MinimumPoolSize = 0;
csb.MaximumPoolSize = 5;
for (int i = 0; i < 3; i++)
{
using var connection = new MySqlConnection(csb.ConnectionString);
Assert.Equal(ConnectionState.Closed, connection.State);
connection.Open();
Assert.Equal(ConnectionState.Open, connection.State);
}
}
public async Task ConnectSslClientCertificate()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.CertificateFile = Path.Combine(AppConfig.CertsPath, "ssl-client.pfx");
csb.CertificatePassword = "";
using (var connection = new MySqlConnection(csb.ConnectionString))
{
using (var cmd = connection.CreateCommand())
{
await connection.OpenAsync();
cmd.CommandText = "SHOW SESSION STATUS LIKE 'Ssl_version'";
var sslVersion = (string)await cmd.ExecuteScalarAsync();
Assert.False(string.IsNullOrWhiteSpace(sslVersion));
}
}
}
public async Task ExhaustConnectionPool()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.Pooling = true;
csb.MinimumPoolSize = 0;
csb.MaximumPoolSize = 3;
csb.ConnectionTimeout = 60;
var connections = new List <MySqlConnection>();
for (int i = 0; i < csb.MaximumPoolSize; i++)
{
var connection = new MySqlConnection(csb.ConnectionString);
await connection.OpenAsync().ConfigureAwait(false);
connections.Add(connection);
}
var closeTask = Task.Run(() =>
{
Thread.Sleep(5000);
connections[0].Dispose();
connections.RemoveAt(0);
});
using (var extraConnection = new MySqlConnection(csb.ConnectionString))
{
var stopwatch = Stopwatch.StartNew();
await extraConnection.OpenAsync().ConfigureAwait(false);
stopwatch.Stop();
Assert.InRange(stopwatch.ElapsedMilliseconds, 4500, 7500);
}
closeTask.Wait();
foreach (var connection in connections)
{
connection.Dispose();
}
}
public void ResetConnection(object connectionReset, int poolSize, long expected)
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.Pooling = true;
csb.MaximumPoolSize = (uint)poolSize; // use a different pool size to create a unique connection string to force a unique pool to be created
if (connectionReset != null)
{
csb.ConnectionReset = (bool)connectionReset;
}
using (var connection = new MySqlConnection(csb.ConnectionString))
{
connection.Open();
using (var command = connection.CreateCommand())
{
command.CommandText = "select @@autocommit;";
Assert.Equal(1L, command.ExecuteScalar());
}
}
using (var connection = new MySqlConnection(csb.ConnectionString))
{
connection.Open();
using (var command = connection.CreateCommand())
{
command.CommandText = "SET autocommit=0;";
command.ExecuteNonQuery();
}
}
using (var connection = new MySqlConnection(csb.ConnectionString))
{
connection.Open();
using (var command = connection.CreateCommand())
{
command.CommandText = "select @@autocommit;";
Assert.Equal(expected, command.ExecuteScalar());
}
}
}
public async Task ConnectSslPreferred()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.SslMode = MySqlSslMode.Preferred;
csb.CertificateFile = null;
csb.CertificatePassword = null;
using var connection = new MySqlConnection(csb.ConnectionString);
using var cmd = connection.CreateCommand();
await connection.OpenAsync();
Assert.True(connection.SslIsEncrypted);
Assert.True(connection.SslIsSigned);
Assert.True(connection.SslIsAuthenticated);
Assert.False(connection.SslIsMutuallyAuthenticated);
cmd.CommandText = "SHOW SESSION STATUS LIKE 'Ssl_version'";
var sslVersion = (string)await cmd.ExecuteScalarAsync();
Assert.False(string.IsNullOrWhiteSpace(sslVersion));
}
public void CollationConnection(bool reopenConnection)
{
var csb = AppConfig.CreateConnectionStringBuilder();
#if BASELINE
csb.CharacterSet = "utf8mb4";
#endif
using var connection = new MySqlConnection(csb.ConnectionString);
connection.Open();
if (reopenConnection)
{
connection.Close();
connection.Open();
}
var collation = connection.Query <string>(@"select @@collation_connection;").Single();
var expected = connection.ServerVersion.StartsWith("8.0") ? "utf8mb4_0900_ai_ci" : "utf8mb4_general_ci";
Assert.Equal(expected, collation);
}
public void NoBackslashEscapes()
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.NoBackslashEscapes = true;
using var connection = new MySqlConnection(csb.ConnectionString);
connection.Open();
connection.Execute("SET @@sql_mode = CONCAT(@@sql_mode, ',NO_BACKSLASH_ESCAPES');");
var value = "\\'\"";
using var cmd = new MySqlCommand("SELECT @param;", connection)
{
Parameters =
{
new("@param", value),
},
};
var result = cmd.ExecuteScalar();
Assert.Equal(value, result);
}
public void UseDatabase()
{
var csb = AppConfig.CreateConnectionStringBuilder();
using (var connection = new MySqlConnection(csb.ConnectionString))
{
connection.Open();
Assert.Equal(csb.Database, connection.Database);
Assert.Equal(csb.Database, QueryCurrentDatabase(connection));
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = $"USE {AppConfig.SecondaryDatabase};";
cmd.ExecuteNonQuery();
}
Assert.Equal(AppConfig.SecondaryDatabase, connection.Database);
Assert.Equal(AppConfig.SecondaryDatabase, QueryCurrentDatabase(connection));
}
}
public void PersistSecurityInfo(bool persistSecurityInfo)
{
var csb = AppConfig.CreateConnectionStringBuilder();
csb.PersistSecurityInfo = persistSecurityInfo;
var connectionStringWithoutPassword = Regex.Replace(csb.ConnectionString, @"(?i)password='******'?;?", "");
using (var connection = new MySqlConnection(csb.ConnectionString))
{
Assert.Equal(csb.ConnectionString, connection.ConnectionString);
connection.Open();
if (persistSecurityInfo)
{
Assert.Equal(csb.ConnectionString, connection.ConnectionString);
}
else
{
Assert.Equal(connectionStringWithoutPassword, connection.ConnectionString);
}
}
}