Merge branch 'master' into mcepiga/overflow-num

Author: sfc-gh-mcepiga

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 # Changelog
 - v5.8.0
+  -  Reduced synchronization context capture in library, minimizing the risk of deadlock occurrence across different code path executions.
   -  Replaced NUnit tests with Xunit in order to modernize and stabilize existing CI/CD setup.
   -  Added `AllowNumberOverflowAsString` connection property. When set to `true`, numeric values that exceed the range of `System.Decimal` (or a narrower integer type) are returned as strings from `GetValue()` instead of throwing `OverflowException`.
   -  Improved handling of certificates serial number matching and performance of CRL checkup.

Snowflake.Data.Tests/IntegrationTests/ConnectionMultiplePoolsAsyncIT.cs

@@ -98,9 +98,9 @@ public async Task TestConnectionPoolWithInvalidOpenAsync()
 
                 try
                 {
-                    using (var reader = await command.ExecuteReaderAsync())
+                    using (var reader = await command.ExecuteReaderAsync().ConfigureAwait(false))
                     {
-                        while (await reader.ReadAsync())
+                        while (await reader.ReadAsync().ConfigureAwait(false))
                         {
                             for (int i = 0; i < reader.FieldCount; i++)
                             {
@@ -167,7 +167,7 @@ public async Task TestReleaseConnectionWhenRollbackFailsAsync()
             var connection = new TestSnowflakeDbConnection(mockDbProviderFactory.Object);
             connection.ConnectionString = connectionString;
             await connection.OpenAsync(CancellationToken.None).ConfigureAwait(false);
-            await connection.BeginTransactionAsync();
+            await connection.BeginTransactionAsync().ConfigureAwait(false);
             Assert.True(connection.HasActiveExplicitTransaction());
 
             // act
@@ -183,7 +183,7 @@ public async Task TestConcurrentConnectionPoolingAsync()
             // add test case name in connection string to make in unique for each test case
             // set short expiration timeout to cover the case that connection expired
             string connStr = _fixture.ConnectionString + ";application=TestConcurrentConnectionPoolingAsync2;ExpirationTimeout=3;poolingEnabled=true";
-            await ConnectionSinglePoolCacheAsyncIT.ConcurrentPoolingAsyncHelper(connStr, true, 5, 5, 3);
+            await ConnectionSinglePoolCacheAsyncIT.ConcurrentPoolingAsyncHelper(connStr, true, 5, 5, 3).ConfigureAwait(false);
         }
 
         [SFFact(DisplayName = "test connection pooling with concurrent connection and using async calls no close call for connection. Connection is closed when Dispose() is called by framework.")]
@@ -193,17 +193,17 @@ public async Task TestConcurrentConnectionPoolingDisposeAsync()
             // set short expiration timeout to cover the case that connection expired
             string connStr = _fixture.ConnectionString +
                              ";application=TestConcurrentConnectionPoolingDisposeAsync2;ExpirationTimeout=3;poolingEnabled=true";
-            await ConnectionSinglePoolCacheAsyncIT.ConcurrentPoolingAsyncHelper(connStr, false, 5, 5, 3);
+            await ConnectionSinglePoolCacheAsyncIT.ConcurrentPoolingAsyncHelper(connStr, false, 5, 5, 3).ConfigureAwait(false);
         }
 
         [SFFact]
         public async Task TestBasicConnectionPool()
         {
             var connectionString = _fixture.ConnectionString + "minPoolSize=0;maxPoolSize=1;poolingEnabled=true";
             var conn1 = new SnowflakeDbConnection(connectionString);
-            await conn1.OpenAsync(CancellationToken.None);
+            await conn1.OpenAsync(CancellationToken.None).ConfigureAwait(false);
             Assert.Equal(ConnectionState.Open, conn1.State);
-            await conn1.CloseAsync();
+            await conn1.CloseAsync().ConfigureAwait(false);
 
             // assert
             Assert.Equal(ConnectionState.Closed, conn1.State);
@@ -216,18 +216,18 @@ public async Task TestReuseSessionInConnectionPool() // old name: TestConnection
         {
             var connectionString = _fixture.ConnectionString + "minPoolSize=1;poolingEnabled=true";
             var conn1 = new SnowflakeDbConnection(connectionString);
-            await conn1.OpenAsync(CancellationToken);
+            await conn1.OpenAsync(CancellationToken).ConfigureAwait(false);
             Assert.Equal(ConnectionState.Open, conn1.State);
-            await conn1.CloseAsync();
+            await conn1.CloseAsync().ConfigureAwait(false);
             Assert.Equal(1, SnowflakeDbConnectionPool.GetPool(connectionString).GetCurrentPoolSize());
 
             var conn2 = new SnowflakeDbConnection();
             conn2.ConnectionString = connectionString;
-            await conn2.OpenAsync(CancellationToken);
+            await conn2.OpenAsync(CancellationToken).ConfigureAwait(false);
             Assert.Equal(ConnectionState.Open, conn2.State);
             Assert.Equal(1, SnowflakeDbConnectionPool.GetPool(connectionString).GetCurrentPoolSize());
 
-            await conn2.CloseAsync();
+            await conn2.CloseAsync().ConfigureAwait(false);
             Assert.Equal(1, SnowflakeDbConnectionPool.GetPool(connectionString).GetCurrentPoolSize());
             Assert.Equal(ConnectionState.Closed, conn1.State);
             Assert.Equal(ConnectionState.Closed, conn2.State);
@@ -241,32 +241,32 @@ public async Task TestReuseSessionInConnectionPoolReachingMaxConnections() // ol
 
             var conn1 = new SnowflakeDbConnection();
             conn1.ConnectionString = connectionString;
-            await conn1.OpenAsync(CancellationToken);
+            await conn1.OpenAsync(CancellationToken).ConfigureAwait(false);
             Assert.Equal(ConnectionState.Open, conn1.State);
 
             var conn2 = new SnowflakeDbConnection();
             conn2.ConnectionString = connectionString;
-            await conn2.OpenAsync(CancellationToken);
+            await conn2.OpenAsync(CancellationToken).ConfigureAwait(false);
             Assert.Equal(ConnectionState.Open, conn2.State);
 
             Assert.Equal(2, pool.GetCurrentPoolSize());
-            await conn1.CloseAsync();
-            await conn2.CloseAsync();
+            await conn1.CloseAsync().ConfigureAwait(false);
+            await conn2.CloseAsync().ConfigureAwait(false);
             Assert.Equal(2, pool.GetCurrentPoolSize());
 
             var conn3 = new SnowflakeDbConnection();
             conn3.ConnectionString = connectionString;
-            await conn3.OpenAsync(CancellationToken);
+            await conn3.OpenAsync(CancellationToken).ConfigureAwait(false);
             Assert.Equal(ConnectionState.Open, conn3.State);
 
             var conn4 = new SnowflakeDbConnection();
             conn4.ConnectionString = connectionString;
-            await conn4.OpenAsync(CancellationToken);
+            await conn4.OpenAsync(CancellationToken).ConfigureAwait(false);
             Assert.Equal(ConnectionState.Open, conn4.State);
 
-            await conn3.CloseAsync();
+            await conn3.CloseAsync().ConfigureAwait(false);
             Assert.Equal(2, pool.GetCurrentPoolSize());
-            await conn4.CloseAsync();
+            await conn4.CloseAsync().ConfigureAwait(false);
             Assert.Equal(2, pool.GetCurrentPoolSize());
 
             Assert.Equal(ConnectionState.Closed, conn1.State);
@@ -283,8 +283,8 @@ public async Task TestWaitForTheIdleConnectionWhenExceedingMaxConnectionsLimitAs
                                    "application=TestWaitForMaxSize2;waitingForIdleSessionTimeout=1s;maxPoolSize=2;minPoolSize=1;poolingEnabled=true";
             var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
             Assert.Equal(0, pool.GetCurrentPoolSize());
-            var conn1 = await OpenConnectionAsync(connectionString);
-            var conn2 = await OpenConnectionAsync(connectionString);
+            var conn1 = await OpenConnectionAsync(connectionString).ConfigureAwait(false);
+            var conn2 = await OpenConnectionAsync(connectionString).ConfigureAwait(false);
             var watch = new StopWatch();
 
             // act
@@ -315,13 +315,13 @@ public async Task TestBusyAndIdleConnectionsCountedInPoolSize()
             connection.ConnectionString = connectionString;
 
             // act
-            await connection.OpenAsync(CancellationToken);
+            await connection.OpenAsync(CancellationToken).ConfigureAwait(false);
 
             // assert
             Assert.Equal(1, pool.GetCurrentPoolSize());
 
             // act
-            await connection.CloseAsync();
+            await connection.CloseAsync().ConfigureAwait(false);
 
             // assert
             Assert.Equal(1, pool.GetCurrentPoolSize());
@@ -336,14 +336,14 @@ public async Task TestConnectionPoolDisable()
             conn1.ConnectionString = _fixture.ConnectionString;
 
             // act
-            await conn1.OpenAsync(CancellationToken);
+            await conn1.OpenAsync(CancellationToken).ConfigureAwait(false);
 
             // assert
             Assert.Equal(ConnectionState.Open, conn1.State);
             Assert.Equal(0, pool.GetCurrentPoolSize());
 
             // act
-            await conn1.CloseAsync();
+            await conn1.CloseAsync().ConfigureAwait(false);
 
             // assert
             Assert.Equal(ConnectionState.Closed, conn1.State);
@@ -394,16 +394,16 @@ public async Task TestConnectionPoolExpirationWorks()
             Assert.Equal(0, pool.GetCurrentPoolSize());
 
             // act
-            var conn1 = await OpenConnectionAsync(connectionString);
-            var conn2 = await OpenConnectionAsync(connectionString);
-            var conn3 = await OpenConnectionAsync(connectionString);
-            var conn4 = await OpenConnectionAsync(connectionString);
+            var conn1 = await OpenConnectionAsync(connectionString).ConfigureAwait(false);
+            var conn2 = await OpenConnectionAsync(connectionString).ConfigureAwait(false);
+            var conn3 = await OpenConnectionAsync(connectionString).ConfigureAwait(false);
+            var conn4 = await OpenConnectionAsync(connectionString).ConfigureAwait(false);
 
             // assert
             Assert.Equal(4, pool.GetCurrentPoolSize());
 
             // act
-            await WaitUntilAllSessionsCreatedOrTimeout(pool);
+            await WaitUntilAllSessionsCreatedOrTimeout(pool).ConfigureAwait(false);
             var beforeSleepMillis = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
             await Task.Delay(TimeSpan.FromSeconds(ExpirationTimeoutInSeconds)).ConfigureAwait(false);
             await conn1.CloseAsync(CancellationToken.None).ConfigureAwait(false);
@@ -415,9 +415,9 @@ public async Task TestConnectionPoolExpirationWorks()
             Assert.Equal(2, pool.GetCurrentPoolSize()); // 2 idle sessions, but expired because close doesn't remove expired sessions
 
             // act
-            await WaitUntilAllSessionsCreatedOrTimeout(pool);
-            var conn5 = await OpenConnectionAsync(connectionString);
-            await WaitUntilAllSessionsCreatedOrTimeout(pool);
+            await WaitUntilAllSessionsCreatedOrTimeout(pool).ConfigureAwait(false);
+            var conn5 = await OpenConnectionAsync(connectionString).ConfigureAwait(false);
+            await WaitUntilAllSessionsCreatedOrTimeout(pool).ConfigureAwait(false);
 
             // assert
             Assert.Equal(2, pool.GetCurrentPoolSize()); // 1 idle session and 1 busy
@@ -430,7 +430,7 @@ public async Task TestConnectionPoolExpirationWorks()
         private static async Task WaitUntilAllSessionsCreatedOrTimeout(SessionPool pool)
         {
             var expectingToWaitAtMostForSessionCreations = TimeSpan.FromSeconds(15);
-            await Awaiter.WaitUntilConditionOrTimeout(() => pool.OngoingSessionCreationsCount() == 0, expectingToWaitAtMostForSessionCreations);
+            await Awaiter.WaitUntilConditionOrTimeout(() => pool.OngoingSessionCreationsCount() == 0, expectingToWaitAtMostForSessionCreations).ConfigureAwait(false);
         }
 
         private async Task<SnowflakeDbConnection> OpenConnectionAsync(string connectionString)

Snowflake.Data.Tests/IntegrationTests/ConnectionMultiplePoolsIT.cs

@@ -38,8 +38,8 @@ public async Task TestWaitForTheIdleConnectionWhenExceedingMaxConnectionsLimit()
             var connectionString = _fixture.ConnectionString + "application=TestWaitForMaxSize1;waitingForIdleSessionTimeout=1s;maxPoolSize=2;minPoolSize=1;poolingEnabled=true";
             var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
             Assert.Equal(0, pool.GetCurrentPoolSize());
-            var conn1 = await OpenConnectionAsync(connectionString);
-            var conn2 = await OpenConnectionAsync(connectionString);
+            var conn1 = await OpenConnectionAsync(connectionString).ConfigureAwait(false);
+            var conn2 = await OpenConnectionAsync(connectionString).ConfigureAwait(false);
             var watch = new StopWatch();
 
             // act
@@ -53,8 +53,8 @@ public async Task TestWaitForTheIdleConnectionWhenExceedingMaxConnectionsLimit()
             Assert.Equal(2, pool.GetCurrentPoolSize());
 
             // cleanup
-            await conn1.CloseAsync(CancellationToken.None);
-            await conn2.CloseAsync(CancellationToken.None);
+            await conn1.CloseAsync(CancellationToken.None).ConfigureAwait(false);
+            await conn2.CloseAsync(CancellationToken.None).ConfigureAwait(false);
         }
 
         [SFFact(RetriesCount = RetriesCount.Thrice)]
@@ -138,15 +138,15 @@ public async Task TestMinPoolSize()
             Assert.Equal(3, pool.GetCurrentPoolSize());
 
             // cleanup
-            await connection.CloseAsync(CancellationToken.None);
+            await connection.CloseAsync(CancellationToken.None).ConfigureAwait(false);
         }
 
         [SFFact]
         public async Task TestPreventConnectionFromReturningToPool()
         {
             // arrange
             var connectionString = _fixture.ConnectionString + "minPoolSize=0;poolingEnabled=true";
-            var connection = await OpenConnectionAsync(connectionString);
+            var connection = await OpenConnectionAsync(connectionString).ConfigureAwait(false);
             var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
             Assert.Equal(1, pool.GetCurrentPoolSize());
 
@@ -170,8 +170,8 @@ public async Task TestReleaseConnectionWhenRollbackFails()
             Assert.Equal(0, pool.GetCurrentPoolSize());
             var connection = new TestSnowflakeDbConnection(mockDbProviderFactory.Object);
             connection.ConnectionString = connectionString;
-            await connection.OpenAsync(CancellationToken.None);
-            await connection.BeginTransactionAsync();
+            await connection.OpenAsync(CancellationToken.None).ConfigureAwait(false);
+            await connection.BeginTransactionAsync().ConfigureAwait(false);
             Assert.True(connection.HasActiveExplicitTransaction());
 
             // act
@@ -200,11 +200,11 @@ public async Task TestReturningCancelledSessionsToThePool(bool cancelAsync)
             {
                 using (var connection = new SnowflakeDbConnection(connectionString))
                 {
-                    await connection.OpenAsync(cts.Token);
+                    await connection.OpenAsync(cts.Token).ConfigureAwait(false);
                     using (var command = connection.CreateCommand())
                     {
                         command.CommandText = $"SELECT SYSTEM$WAIT(20)";
-                        await command.ExecuteNonQueryAsync(cts.Token);
+                        await command.ExecuteNonQueryAsync(cts.Token).ConfigureAwait(false);
                     }
                 }
             }, CancellationToken.None);
@@ -213,23 +213,23 @@ await Awaiter.WaitUntilConditionOrTimeout(() =>
             {
                 var state = pool.GetCurrentState();
                 return state.IdleSessionsCount == 0 && state.BusySessionsCount == 1;
-            }, TimeSpan.FromMilliseconds(10000));
+            }, TimeSpan.FromMilliseconds(10000)).ConfigureAwait(false);
 
             // one busy session
             Assert.Equal(0, pool.GetCurrentState().IdleSessionsCount);
             Assert.Equal(1, pool.GetCurrentState().BusySessionsCount);
 
             if (cancelAsync)
 #if NET8_0_OR_GREATER
-                await cts.CancelAsync();
+                await cts.CancelAsync().ConfigureAwait(false);
 #else
                 cts.Cancel();
 #endif
             else
                 cts.Cancel();
 
             // operation canceled properly
-            await Assert.ThrowsAnyAsync<OperationCanceledException>(() => task);
+            await Assert.ThrowsAnyAsync<OperationCanceledException>(() => task).ConfigureAwait(false);
 
             // one idle session
             Assert.Equal(1, pool.GetCurrentState().IdleSessionsCount);