Pool/SNOW-937188 changed session behavior

Snowflake.Data.Tests/IntegrationTests/ConnectionMultiplePoolsAsyncIT.cs

@@ -50,7 +50,7 @@ public async Task TestAddToPoolOnOpenAsync()
         }
 
         [Test]
-        public async Task TestDoNotAddToPoolInvalidConnectionAsync()
+        public async Task TestFailForInvalidConnectionAsync()
         {
             // arrange
             var invalidConnectionString = ";connection_timeout=123";
@@ -63,15 +63,10 @@ public async Task TestDoNotAddToPoolInvalidConnectionAsync()
                 Assert.Fail("OpenAsync should fail for invalid connection string");
             }
             catch {}
+            var thrown = Assert.Throws<SnowflakeDbException>(() => SnowflakeDbConnectionPool.GetPool(connection.ConnectionString));
 
             // assert
-            var pool = SnowflakeDbConnectionPool.GetPool(connection.ConnectionString);
-            var poolState = pool.GetCurrentState();
-            logger.Warn($"Pool state: {poolState}");
-            Assert.Less(pool.GetCurrentPoolSize(), SFSessionHttpClientProperties.DefaultMinPoolSize); // for invalid connection string it is used default min pool size
-
-            // cleanup
-            await connection.CloseAsync(CancellationToken.None).ConfigureAwait(false);
+            Assert.That(thrown.Message, Does.Contain("Required property ACCOUNT is not provided"));
         }
 
         [Test]

Snowflake.Data.Tests/IntegrationTests/ConnectionMultiplePoolsIT.cs

@@ -50,6 +50,7 @@ public void TestBasicConnectionPool()
             // assert
             Assert.AreEqual(ConnectionState.Closed, conn1.State);
             Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(connectionString).GetCurrentPoolSize());
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(connectionString, null).GetCurrentPoolSize());
         }
 
         [Test]
@@ -177,7 +178,7 @@ public void TestWaitInAQueueForAnIdleSession()
         {
             // arrange
             var connectionString = ConnectionString + "application=TestWaitForMaxSize3;waitingForIdleSessionTimeout=3s;maxPoolSize=2;minPoolSize=0";
-            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
+            var pool = SnowflakeDbConnectionPool.GetPoolInternal(connectionString);
             Assert.AreEqual(0, pool.GetCurrentPoolSize(), "the pool is expected to be empty");
             const long ADelay = 0;
             const long BDelay = 400;
@@ -262,8 +263,7 @@ public void TestConnectionPoolNotPossibleToDisableForAllPools()
         public void TestConnectionPoolDisable()
         {
             // arrange
-            var pool = SnowflakeDbConnectionPool.GetPool(ConnectionString);
-            pool.SetPooling(false);
+            var pool = SnowflakeDbConnectionPool.GetPool(ConnectionString + ";poolingEnabled=false");
             var conn1 = new SnowflakeDbConnection();
             conn1.ConnectionString = ConnectionString;
 
@@ -322,7 +322,7 @@ public void TestConnectionPoolExpirationWorks()
             // arrange
             const int ExpirationTimeoutInSeconds = 10;
             var connectionString = ConnectionString + $"expirationTimeout={ExpirationTimeoutInSeconds};maxPoolSize=4;minPoolSize=2";
-            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
+            var pool = SnowflakeDbConnectionPool.GetPoolInternal(connectionString);
             Assert.AreEqual(0, pool.GetCurrentPoolSize());
 
             // act

Snowflake.Data.Tests/IntegrationTests/ConnectionPoolChangedSessionIT.cs

@@ -0,0 +1,216 @@
+using NUnit.Framework;
+using Snowflake.Data.Client;
+using Snowflake.Data.Core;
+using Snowflake.Data.Core.Session;
+using Snowflake.Data.Tests.Util;
+
+namespace Snowflake.Data.Tests.IntegrationTests
+{
+    [TestFixture]
+    [NonParallelizable]
+    public class ConnectionPoolChangedSessionIT : SFBaseTest
+    {
+        private readonly QueryExecResponseData _queryExecResponseChangedRole = new()
+        {
+            finalDatabaseName = TestEnvironment.TestConfig.database,
+            finalSchemaName = TestEnvironment.TestConfig.schema,
+            finalRoleName = "role change",
+            finalWarehouseName = TestEnvironment.TestConfig.warehouse
+        };
+
+        private readonly QueryExecResponseData _queryExecResponseChangedDatabase = new()
+        {
+            finalDatabaseName = "database changed",
+            finalSchemaName = TestEnvironment.TestConfig.schema,
+            finalRoleName = TestEnvironment.TestConfig.role,
+            finalWarehouseName = TestEnvironment.TestConfig.warehouse
+        };
+
+        private readonly QueryExecResponseData _queryExecResponseChangedSchema = new()
+        {
+            finalDatabaseName = TestEnvironment.TestConfig.database,
+            finalSchemaName = "schema changed",
+            finalRoleName = TestEnvironment.TestConfig.role,
+            finalWarehouseName = TestEnvironment.TestConfig.warehouse
+        };
+
+        private readonly QueryExecResponseData _queryExecResponseChangedWarehouse = new()
+        {
+            finalDatabaseName = TestEnvironment.TestConfig.database,
+            finalSchemaName = TestEnvironment.TestConfig.schema,
+            finalRoleName = TestEnvironment.TestConfig.role,
+            finalWarehouseName = "warehouse changed"
+        };
+
+        private static PoolConfig s_previousPoolConfigRestorer;
+
+        [OneTimeSetUp]
+        public static void BeforeAllTests()
+        {
+            s_previousPoolConfigRestorer = new PoolConfig();
+            SnowflakeDbConnectionPool.SetConnectionPoolVersion(ConnectionPoolType.MultipleConnectionPool);
+        }
+
+        [SetUp]
+        public new void BeforeTest()
+        {
+            SnowflakeDbConnectionPool.ClearAllPools();
+        }
+
+        [TearDown]
+        public new void AfterTest()
+        {
+            SnowflakeDbConnectionPool.ClearAllPools();
+        }
+
+        [OneTimeTearDown]
+        public static void AfterAllTests()
+        {
+            s_previousPoolConfigRestorer.Reset();
+        }
+
+        [Test]
+        public void TestPoolDestroysConnectionWhenChangedSessionProperties()
+        {
+            var connectionString = ConnectionString + "application=Destroy;ChangedSession=Destroy;minPoolSize=0;maxPoolSize=3";
+            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
+
+            var connection = new SnowflakeDbConnection(connectionString);
+            connection.Open();
+            connection.SfSession.UpdateSessionProperties(_queryExecResponseChangedDatabase);
+            connection.Close();
+
+            Assert.AreEqual(0, pool.GetCurrentPoolSize());
+        }
+
+        [Test]
+        public void TestPoolingWhenSessionPropertiesUnchanged()
+        {
+            var connectionString = ConnectionString + "application=NoSessionChanges;ChangedSession=Destroy;minPoolSize=0;maxPoolSize=3";
+            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
+
+            var connection = new SnowflakeDbConnection(connectionString);
+            connection.Open();
+            connection.Close();
+
+            Assert.AreEqual(1, pool.GetCurrentPoolSize());
+        }
+
+        [Test]
+        public void TestPoolingWhenConnectionPropertiesChangedForOriginalPoolMode()
+        {
+            var connectionString = ConnectionString + "application=OriginalPoolMode;ChangedSession=OriginalPool;minPoolSize=0;maxPoolSize=3";
+            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
+
+            var connection = new SnowflakeDbConnection(connectionString);
+            connection.Open();
+            connection.SfSession.UpdateSessionProperties(_queryExecResponseChangedWarehouse);
+            var sessionId = connection.SfSession.sessionId;
+            connection.Close();
+
+            Assert.AreEqual(1, pool.GetCurrentPoolSize());
+            connection.Close();
+
+            var connection2 = new SnowflakeDbConnection(connectionString);
+            connection2.Open();
+            Assert.AreEqual(sessionId, connection2.SfSession.sessionId);
+            connection2.Close();
+        }
+
+        [Test]
+        public void TestPoolingWhenConnectionPropertiesChangedForDefaultPoolMode()
+        {
+            var connectionString = ConnectionString + "application=DefaultPoolMode;minPoolSize=0;maxPoolSize=3";
+            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
+
+            var connection = new SnowflakeDbConnection(connectionString);
+            connection.Open();
+            connection.SfSession.UpdateSessionProperties(_queryExecResponseChangedRole);
+            var sessionId = connection.SfSession.sessionId;
+            connection.Close();
+
+            Assert.AreEqual(0, pool.GetCurrentPoolSize());
+
+            var connection2 = new SnowflakeDbConnection(connectionString);
+            connection2.Open();
+            Assert.AreNotEqual(sessionId, connection2.SfSession.sessionId);
+            connection2.Close();
+        }
+
+        [Test]
+        public void TestPoolDestroysAndRecreatesConnection()
+        {
+            var connectionString = ConnectionString + "application=DestroyRecreateSession;ChangedSession=Destroy;minPoolSize=1;maxPoolSize=3";
+
+            var connection = new SnowflakeDbConnection(connectionString);
+            connection.Open();
+            var sessionId = connection.SfSession.sessionId;
+            connection.SfSession.UpdateSessionProperties(_queryExecResponseChangedSchema);
+            connection.Close();
+
+            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
+            Assert.AreEqual(1, pool.GetCurrentPoolSize());
+
+            var connection2 = new SnowflakeDbConnection(connectionString);
+            connection2.Open();
+            Assert.AreNotEqual(sessionId, connection2.SfSession.sessionId);
+            connection2.Close();
+        }
+
+        [Test]
+        public void TestCompareSessionChangesCaseInsensitiveWhenUnquoted()
+        {
+            var connectionString = ConnectionString + "application=CompareCaseInsensitive;ChangedSession=Destroy;minPoolSize=1;maxPoolSize=3";
+
+            var responseData = new QueryExecResponseData()
+            {
+                finalDatabaseName = TestEnvironment.TestConfig.database.ToLower(),
+                finalSchemaName = TestEnvironment.TestConfig.schema.ToUpper(),
+                finalRoleName = $"{char.ToUpper(TestEnvironment.TestConfig.role[0])}{TestEnvironment.TestConfig.role.Substring(1).ToLower()}",
+                finalWarehouseName = TestEnvironment.TestConfig.warehouse.ToLower()
+            };
+
+            var connection = new SnowflakeDbConnection(connectionString);
+            connection.Open();
+            var sessionId = connection.SfSession.sessionId;
+            connection.SfSession.UpdateSessionProperties(responseData);
+            connection.Close();
+
+            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
+            Assert.AreEqual(1, pool.GetCurrentPoolSize());
+
+            var connection2 = new SnowflakeDbConnection(connectionString);
+            connection2.Open();
+            Assert.AreEqual(sessionId, connection2.SfSession.sessionId);
+            connection2.Close();
+        }
+
+        [Test]
+        public void TestCompareSessionChangesCaseSensitiveWhenQuoted()
+        {
+            var connectionString = ConnectionString + "application=CompareCaseSensitive;ChangedSession=Destroy;minPoolSize=1;maxPoolSize=3";
+
+            var responseData = new QueryExecResponseData()
+            {
+                finalDatabaseName = TestEnvironment.TestConfig.database,
+                finalSchemaName = TestEnvironment.TestConfig.schema,
+                finalRoleName = $"\\\"SomeQuotedValue\\\"",
+                finalWarehouseName = TestEnvironment.TestConfig.warehouse.ToLower()
+            };
+
+            var connection = new SnowflakeDbConnection(connectionString);
+            connection.Open();
+            var sessionId = connection.SfSession.sessionId;
+            connection.SfSession.UpdateSessionProperties(responseData);
+            connection.Close();
+
+            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
+            Assert.AreEqual(1, pool.GetCurrentPoolSize());
+
+            var connection2 = new SnowflakeDbConnection(connectionString);
+            connection2.Open();
+            Assert.AreNotEqual(sessionId, connection2.SfSession.sessionId);
+            connection2.Close();
+        }
+    }
+}

Snowflake.Data.Tests/IntegrationTests/ConnectionPoolCommonIT.cs

@@ -103,10 +103,17 @@ public void TestConnectionPoolWithDispose()
             conn1.ConnectionString = "bad connection string";
             Assert.Throws<SnowflakeDbException>(() => conn1.Open());
             conn1.Close();
-            Thread.Sleep(3000); // minPoolSize = 2 causes that another thread has been started. We sleep to make that thread finish.
 
             Assert.AreEqual(ConnectionState.Closed, conn1.State);
-            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetPool(conn1.ConnectionString).GetCurrentPoolSize());
+            if (_connectionPoolTypeUnderTest == ConnectionPoolType.SingleConnectionCache)
+            {
+                Assert.AreEqual(0, SnowflakeDbConnectionPool.GetPool(conn1.ConnectionString).GetCurrentPoolSize());
+            }
+            else
+            {
+                var thrown = Assert.Throws<SnowflakeDbException>(() => SnowflakeDbConnectionPool.GetPool(conn1.ConnectionString));
+                Assert.That(thrown.Message, Does.Contain("Connection string is invalid"));
+            }
         }
 
         [Test]

Snowflake.Data.Tests/IntegrationTests/ConnectionSinglePoolCacheIT.cs

@@ -223,7 +223,7 @@ public void TestConnectionPoolDisable()
         {
             // arrange
             var pool = SnowflakeDbConnectionPool.GetPool(ConnectionString);
-            pool.SetPooling(false);
+            SnowflakeDbConnectionPool.SetPooling(false);
             var conn1 = new SnowflakeDbConnection();
             conn1.ConnectionString = ConnectionString;