SNOW-902610 Min pool size

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,23 +36,37 @@ 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);
         }
@@ -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);
 
@@ -324,6 +339,25 @@ public void TestConnectionPoolExpirationWorks()
             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)
         {
             var connection = new SnowflakeDbConnection();

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()

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

Snowflake.Data/Core/Session/SessionOrCreationTokens.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Snowflake.Data.Core.Session
+{
+    internal class SessionOrCreationTokens
+    {
+        private static readonly List<SessionCreationToken> s_emptySessionCreationTokenList = new List<SessionCreationToken>();
+
+        public SFSession Session { get; }
+        public List<SessionCreationToken> SessionCreationTokens { get; }
+
+        public SessionOrCreationTokens(SFSession session)
+        {
+            Session = session ?? throw new Exception("Internal error: missing session");
+            SessionCreationTokens = s_emptySessionCreationTokenList;
+        }
+
+        public SessionOrCreationTokens(List<SessionCreationToken> sessionCreationTokens)
+        {
+            Session = null;
+            if (sessionCreationTokens == null || sessionCreationTokens.Count == 0)
+            {
+                throw new Exception("Internal error: missing session creation token");
+            }
+            SessionCreationTokens = sessionCreationTokens;
+        }
+
+        public List<SessionCreationToken> BackgroundSessionCreationTokens()
+        {
+            if (Session == null)
+            {
+                return SessionCreationTokens.Skip(1).ToList();
+            }
+            return SessionCreationTokens;
+        }
+
+        public SessionCreationToken SessionCreationToken() => SessionCreationTokens.First();
+    }
+}