SNOW-902610 Min pool size

Snowflake.Data.Tests/IntegrationTests/ConnectionMultiplePoolsAsyncIT.cs

@@ -0,0 +1,49 @@
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Snowflake.Data.Client;
+using Snowflake.Data.Core.Session;
+using Snowflake.Data.Tests.Util;
+
+namespace Snowflake.Data.Tests.IntegrationTests
+{
+    [TestFixture]
+    [NonParallelizable]
+    public class ConnectionMultiplePoolsAsyncIT: SFBaseTestAsync
+    {
+        private readonly PoolConfig _previousPoolConfig = new PoolConfig();
+
+        [SetUp]
+        public new void BeforeTest()
+        {
+            SnowflakeDbConnectionPool.SetConnectionPoolVersion(ConnectionPoolType.MultipleConnectionPool);
+            SnowflakeDbConnectionPool.ClearAllPools();
+            SnowflakeDbConnectionPool.SetPooling(true);
+        }
+
+        [TearDown]
+        public new void AfterTest()
+        {
+            _previousPoolConfig.Reset();
+        }
+
+        [Test]
+        public async Task TestMinPoolSizeAsync()
+        {
+            // arrange
+            var connection = new SnowflakeDbConnection();
+            connection.ConnectionString = ConnectionString + "application=TestMinPoolSizeAsync;minPoolSize=3";
+
+            // act
+            await connection.OpenAsync().ConfigureAwait(false);
+            Thread.Sleep(3000);            
+
+            // assert
+            var pool = SnowflakeDbConnectionPool.GetPool(connection.ConnectionString);
+            Assert.AreEqual(3, pool.GetCurrentPoolSize());
+
+            // cleanup
+            await connection.CloseAsync(CancellationToken.None).ConfigureAwait(false);
+        }
+    }
+}

Snowflake.Data.Tests/IntegrationTests/ConnectionMultiplePoolsIT.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Data;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using Snowflake.Data.Client;
@@ -35,40 +36,54 @@ public static void AfterAllTests()
             SnowflakeDbConnectionPool.ClearAllPools();
         }
 
+        [Test]
+        public void TestBasicConnectionPool()
+        {
+            var connectingString = ConnectionString + "maxPoolSize=1;minPoolSize=1";
+            var conn1 = new SnowflakeDbConnection(connectingString);
+            conn1.Open();
+            Assert.AreEqual(ConnectionState.Open, conn1.State);
+            conn1.Close();
+
+            Assert.AreEqual(ConnectionState.Closed, conn1.State);
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(connectingString).GetCurrentPoolSize());
+        }
+
         [Test]
         public void TestReuseSessionInConnectionPool() // old name: TestConnectionPool
         {
-            var conn1 = new SnowflakeDbConnection(ConnectionString);
+            var connectionString = ConnectionString + "minPoolSize=1";
+            var conn1 = new SnowflakeDbConnection(connectionString);
             conn1.Open();
             Assert.AreEqual(ConnectionState.Open, conn1.State);
             conn1.Close();
-            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(connectionString).GetCurrentPoolSize());
 
             var conn2 = new SnowflakeDbConnection();
-            conn2.ConnectionString = ConnectionString;
+            conn2.ConnectionString = connectionString;
             conn2.Open();
             Assert.AreEqual(ConnectionState.Open, conn2.State);
-            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(connectionString).GetCurrentPoolSize());
 
             conn2.Close();
-            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(connectionString).GetCurrentPoolSize());
             Assert.AreEqual(ConnectionState.Closed, conn1.State);
             Assert.AreEqual(ConnectionState.Closed, conn2.State);
         }
 
         [Test]
         public void TestReuseSessionInConnectionPoolReachingMaxConnections() // old name: TestConnectionPoolFull
         {
-            var pool = SnowflakeDbConnectionPool.GetPool(ConnectionString);
-            pool.SetMaxPoolSize(2);
+            var connectionString = ConnectionString + "maxPoolSize=2;minPoolSize=1";
+            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
 
             var conn1 = new SnowflakeDbConnection();
-            conn1.ConnectionString = ConnectionString;
+            conn1.ConnectionString = connectionString;
             conn1.Open();
             Assert.AreEqual(ConnectionState.Open, conn1.State);
 
             var conn2 = new SnowflakeDbConnection();
-            conn2.ConnectionString = ConnectionString;
+            conn2.ConnectionString = connectionString;
             conn2.Open();
             Assert.AreEqual(ConnectionState.Open, conn2.State);
 
@@ -78,12 +93,12 @@ public void TestReuseSessionInConnectionPoolReachingMaxConnections() // old name
             Assert.AreEqual(2, pool.GetCurrentPoolSize());
 
             var conn3 = new SnowflakeDbConnection();
-            conn3.ConnectionString = ConnectionString;
+            conn3.ConnectionString = connectionString;
             conn3.Open();
             Assert.AreEqual(ConnectionState.Open, conn3.State);
 
             var conn4 = new SnowflakeDbConnection();
-            conn4.ConnectionString = ConnectionString;
+            conn4.ConnectionString = connectionString;
             conn4.Open();
             Assert.AreEqual(ConnectionState.Open, conn4.State);
 
@@ -102,7 +117,7 @@ public void TestReuseSessionInConnectionPoolReachingMaxConnections() // old name
         public void TestWaitForTheIdleConnectionWhenExceedingMaxConnectionsLimit()
         {
             // arrange
-            var connectionString = ConnectionString + "application=TestWaitForMaxSize1;waitingForIdleSessionTimeout=1s;maxPoolSize=2";
+            var connectionString = ConnectionString + "application=TestWaitForMaxSize1;waitingForIdleSessionTimeout=1s;maxPoolSize=2;minPoolSize=1";
             var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
             Assert.AreEqual(0, pool.GetCurrentPoolSize(), "expecting pool to be empty");
             var conn1 = OpenedConnection(connectionString);
@@ -128,7 +143,7 @@ public void TestWaitForTheIdleConnectionWhenExceedingMaxConnectionsLimit()
         public void TestWaitForTheIdleConnectionWhenExceedingMaxConnectionsLimitAsync()
         {
             // arrange
-            var connectionString = ConnectionString + "application=TestWaitForMaxSize2;waitingForIdleSessionTimeout=1s;maxPoolSize=2";
+            var connectionString = ConnectionString + "application=TestWaitForMaxSize2;waitingForIdleSessionTimeout=1s;maxPoolSize=2;minPoolSize=1";
             var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
             Assert.AreEqual(0, pool.GetCurrentPoolSize(), "expecting pool to be empty");
             var conn1 = OpenedConnection(connectionString);
@@ -211,10 +226,10 @@ public void TestWaitInAQueueForAnIdleSession()
         public void TestBusyAndIdleConnectionsCountedInPoolSize()
         {
             // arrange
-            var pool = SnowflakeDbConnectionPool.GetPool(ConnectionString);
-            pool.SetMaxPoolSize(2);
+            var connectionString = ConnectionString + "maxPoolSize=2;minPoolSize=1";
+            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
             var connection = new SnowflakeDbConnection();
-            connection.ConnectionString = ConnectionString;
+            connection.ConnectionString = connectionString;
 
             // act
             connection.Open();
@@ -267,19 +282,19 @@ public void TestConnectionPoolDisable()
         [Test]
         public void TestNewConnectionPoolClean()
         {
-            SnowflakeDbConnectionPool.SetMaxPoolSize(2);
+            var connectionString = ConnectionString + "maxPoolSize=2;minPoolSize=1;";
             var conn1 = new SnowflakeDbConnection();
-            conn1.ConnectionString = ConnectionString;
+            conn1.ConnectionString = connectionString;
             conn1.Open();
             Assert.AreEqual(ConnectionState.Open, conn1.State);
 
             var conn2 = new SnowflakeDbConnection();
-            conn2.ConnectionString = ConnectionString + " retryCount=1";
+            conn2.ConnectionString = connectionString + "retryCount=1";
             conn2.Open();
             Assert.AreEqual(ConnectionState.Open, conn2.State);
 
             var conn3 = new SnowflakeDbConnection();
-            conn3.ConnectionString = ConnectionString + "  retryCount=2";
+            conn3.ConnectionString = connectionString + "retryCount=2";
             conn3.Open();
             Assert.AreEqual(ConnectionState.Open, conn3.State);
 
@@ -301,27 +316,47 @@ public void TestNewConnectionPoolClean()
         [Test]
         public void TestConnectionPoolExpirationWorks()
         {
+            var connectionString = ConnectionString + "minPoolSize=1";
             var conn1 = new SnowflakeDbConnection();
-            conn1.ConnectionString = ConnectionString;
+            conn1.ConnectionString = connectionString;
             conn1.Open();
             conn1.Close();
             SnowflakeDbConnectionPool.SetTimeout(0);
             SnowflakeDbConnectionPool.SetMaxPoolSize(2);
 
             var conn2 = new SnowflakeDbConnection();
-            conn2.ConnectionString = ConnectionString;
+            conn2.ConnectionString = connectionString;
             conn2.Open();
             conn2.Close();
 
             var conn3 = new SnowflakeDbConnection();
-            conn3.ConnectionString = ConnectionString;
+            conn3.ConnectionString = connectionString;
             conn3.Open();
             conn3.Close();
 
             // The pooling timeout should apply to all connections being pooled,
             // not just the connections created after the new setting,
             // so expected result should be 0
-            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
+            Assert.AreEqual(0, SnowflakeDbConnectionPool.GetPool(connectionString).GetCurrentPoolSize());
+        }
+
+        [Test]
+        public void TestMinPoolSize()
+        {
+            // arrange
+            var connection = new SnowflakeDbConnection();
+            connection.ConnectionString = ConnectionString + "application=TestMinPoolSize;minPoolSize=3";
+
+            // act
+            connection.Open();
+            Thread.Sleep(3000);
+
+            // assert
+            var pool = SnowflakeDbConnectionPool.GetPool(connection.ConnectionString);
+            Assert.AreEqual(3, pool.GetCurrentPoolSize());
+
+            // cleanup
+            connection.Close();
         }
 
         private SnowflakeDbConnection OpenedConnection(string connectionString)

Snowflake.Data.Tests/IntegrationTests/ConnectionPoolCommonIT.cs

@@ -49,20 +49,6 @@ public static void AfterAllTests()
         {
             SnowflakeDbConnectionPool.ClearAllPools();
         }
-
-        [Test]
-        public void TestBasicConnectionPool()
-        {
-            SnowflakeDbConnectionPool.SetMaxPoolSize(1);
-
-            var conn1 = new SnowflakeDbConnection(ConnectionString);
-            conn1.Open();
-            Assert.AreEqual(ConnectionState.Open, conn1.State);
-            conn1.Close();
-
-            Assert.AreEqual(ConnectionState.Closed, conn1.State);
-            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
-        }
 
         [Test]
         public void TestConnectionPoolMultiThreading()
@@ -114,6 +100,7 @@ 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());

Snowflake.Data.Tests/IntegrationTests/ConnectionSinglePoolCacheIT.cs

@@ -35,6 +35,20 @@ public static void AfterAllTests()
             SnowflakeDbConnectionPool.ClearAllPools();
         }        
 
+        [Test]
+        public void TestBasicConnectionPool()
+        {
+            SnowflakeDbConnectionPool.SetMaxPoolSize(1);
+
+            var conn1 = new SnowflakeDbConnection(ConnectionString);
+            conn1.Open();
+            Assert.AreEqual(ConnectionState.Open, conn1.State);
+            conn1.Close();
+
+            Assert.AreEqual(ConnectionState.Closed, conn1.State);
+            Assert.AreEqual(1, SnowflakeDbConnectionPool.GetPool(ConnectionString).GetCurrentPoolSize());
+        }
+
         [Test]
         public void TestConcurrentConnectionPooling()
         {

Snowflake.Data.Tests/UnitTests/ConnectionPoolManagerTest.cs

@@ -19,8 +19,8 @@ namespace Snowflake.Data.Tests.UnitTests
     class ConnectionPoolManagerTest
     {
         private readonly ConnectionPoolManager _connectionPoolManager = new ConnectionPoolManager();
-        private const string ConnectionString1 = "database=D1;warehouse=W1;account=A1;user=U1;password=P1;role=R1;";
-        private const string ConnectionString2 = "database=D2;warehouse=W2;account=A2;user=U2;password=P2;role=R2;";
+        private const string ConnectionString1 = "database=D1;warehouse=W1;account=A1;user=U1;password=P1;role=R1;minPoolSize=1;";
+        private const string ConnectionString2 = "database=D2;warehouse=W2;account=A2;user=U2;password=P2;role=R2;minPoolSize=1;";
         private readonly SecureString _password = new SecureString();
         private static PoolConfig s_poolConfig;
 

Snowflake.Data.Tests/UnitTests/Session/SessionOrCreationTokensTest.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Linq;
+using NUnit.Framework;
+using Snowflake.Data.Core;
+using Snowflake.Data.Core.Session;
+
+namespace Snowflake.Data.Tests.UnitTests.Session
+{
+    [TestFixture]
+    public class SessionOrCreationTokensTest
+    {
+        private SFSession _session = new SFSession("account=test;user=test;password=test", null);
+
+        [Test]
+        public void TestNoBackgroundSessionsToCreateWhenInitialisedWithSession()
+        {
+            // arrange
+            var sessionOrTokens = new SessionOrCreationTokens(_session);
+
+            // act
+            var backgroundCreationTokens = sessionOrTokens.BackgroundSessionCreationTokens();
+
+            Assert.AreEqual(0, backgroundCreationTokens.Count);
+        }
+
+        [Test]
+        public void TestReturnFirstCreationToken()
+        {
+            // arrange
+            var sessionCreationTokenCounter = new SessionCreationTokenCounter(TimeSpan.FromSeconds(10));
+            var tokens = Enumerable.Range(1, 3)
+                .Select(_ => sessionCreationTokenCounter.NewToken())
+                .ToList();
+            var sessionOrTokens = new SessionOrCreationTokens(tokens);
+
+            // act
+            var token = sessionOrTokens.SessionCreationToken();
+
+            // assert
+            Assert.AreSame(tokens[0], token);
+        }
+
+        [Test]
+        public void TestReturnCreationTokensFromTheSecondOneForBackgroundExecution()
+        {
+            // arrange
+            var sessionCreationTokenCounter = new SessionCreationTokenCounter(TimeSpan.FromSeconds(10));
+            var tokens = Enumerable.Range(1, 3)
+                .Select(_ => sessionCreationTokenCounter.NewToken())
+                .ToList();
+            var sessionOrTokens = new SessionOrCreationTokens(tokens);
+
+            // act
+            var backgroundTokens = sessionOrTokens.BackgroundSessionCreationTokens();
+
+            // assert
+            Assert.AreEqual(2, backgroundTokens.Count);
+            Assert.AreSame(tokens[1], backgroundTokens[0]);
+            Assert.AreSame(tokens[2], backgroundTokens[1]);
+        }
+    }
+}