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); } } }