SNOW-1406763 Test special chars in password

.github/workflows/main.yml

@@ -3,9 +3,9 @@ name: DotNet Build and Test
 # Triggers the workflow on push or pull request events but only for the master branch
 on:
   push:
-    branches: [ master ]
+    branches: [ master, pool/SNOW-860872-connection-pool ]
   pull_request:
-    branches: [ master ]
+    branches: [ master, pool/SNOW-860872-connection-pool ]
   workflow_dispatch:
     inputs:
       logLevel:
@@ -61,7 +61,7 @@ jobs:
         run: |
           cd Snowflake.Data.Tests
           dotnet restore
-          dotnet build -f ${{ matrix.dotnet }}
+          dotnet build -f ${{ matrix.dotnet }} '-p:DefineAdditionalConstants=SF_PUBLIC_ENVIRONMENT'
       - name: Run Tests
         run: |
           cd Snowflake.Data.Tests
@@ -118,7 +118,7 @@ jobs:
       - name: Build Driver
         run: |
           dotnet restore
-          dotnet build
+          dotnet build '-p:DefineAdditionalConstants=SF_PUBLIC_ENVIRONMENT'
       - name: Run Tests
         run: |
           cd Snowflake.Data.Tests
@@ -175,7 +175,7 @@ jobs:
       - name: Build Driver
         run: |
           dotnet restore
-          dotnet build
+          dotnet build '-p:DefineAdditionalConstants=SF_PUBLIC_ENVIRONMENT'
       - name: Run Tests
         run: |
           cd Snowflake.Data.Tests

CodingConventions.md

@@ -85,6 +85,18 @@ public class ExampleClass
 }
 ```
 
+#### Property
+
+Use PascalCase, eg. `SomeProperty`.
+
+```csharp
+public ExampleProperty
+{
+    get;
+    set;
+}
+```
+
 ### Local variables
 
 Use camelCase, eg. `someVariable`.

README.md

@@ -168,6 +168,12 @@ The following table lists all valid connection properties:
 | CLIENT_CONFIG_FILE             | No       | The location of the client configuration json file. In this file you can configure easy logging feature.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | ALLOWUNDERSCORESINHOST         | No       | Specifies whether to allow underscores in account names. This impacts PrivateLink customers whose account names contain underscores. In this situation, you must override the default value by setting allowUnderscoresInHost to true.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | QUERY_TAG                      | No       | Optional string that can be used to tag queries and other SQL statements executed within a connection. The tags are displayed in the output of the QUERY_HISTORY , QUERY_HISTORY_BY_* functions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| MAXPOOLSIZE                    | No       | Maximum number of connections in a pool. Default value is 10. `maxPoolSize` value cannot be lower than `minPoolSize` value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| MINPOOLSIZE                    | No       | Expected minimum number of connections in pool. When you get a connection from the pool, more connections might be initialised in background to increase the pool size to `minPoolSize`. If you specify 0 or 1 there will be no attempts to create extra initialisations in background. The default value is 2. `maxPoolSize` value cannot be lower than `minPoolSize` value. The parameter is used only in a new version of connection pool.                                                                                                                                                                                                                                                                             |
+| CHANGEDSESSION                 | No       | Specifies what should happen with a closed connection when some of its session variables are altered (e. g. you used `ALTER SESSION SET SCHEMA` to change the databese schema). The default behaviour is `OriginalPool` which means the session stays in the original pool. Currently no other option is possible. Parameter used only in a new version of connection pool.                                                                                                                                                                                                                                                                                                                                               |
+| WAITINGFORIDLESESSIONTIMEOUT   | No       | Timeout for waiting for an idle session when pool is full. It happens when there is no idle session and we cannot create a new one because of reaching `maxPoolSize`. The default value is 30 seconds. Usage of units possible and allowed are: e. g. `1000ms` (milliseconds), `15s` (seconds), `2m` (minutes) where seconds are default for a skipped postfix. Special values: `0` - immediate fail for new connection to open when session is full. You cannot specify infinite value.                                                                                                                                                                                                                                  |
+| EXPIRATIONTIMEOUT              | No       | Timeout for using each connection. Connections which last more than specified timeout are considered to be expired and are being removed from the pool. The default is 1 hour. Usage of units possible and allowed are: e. g. `360000ms` (milliseconds), `3600s` (seconds), `60m` (minutes) where seconds are default for a skipped postfix. Special values: `0` - immediate expiration of the connection just after its creation. Expiration timeout cannot be set to infinity.                                                                                                                                                                                                                                          |
+| POOLINGENABLED                 | No       | Boolean flag indicating if the connection should be a part of a pool. The default value is `true`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 
 <br />
 
@@ -822,6 +828,11 @@ CancellationTokenSource cancellationTokenSource  = new CancellationTokenSource()
 ((SnowflakeDbConnection)conn).CloseAsync(cancellationTokenSource.Token);
 ```
 
+## Evict the Connection
+
+For the open connection, call the `PreventPooling()` to mark the connection to be removed on close instead being still pooled.
+The busy sessions counter will be decreased when the connection is closed.
+
 ## Logging
 
 The Snowflake Connector for .NET uses [log4net](http://logging.apache.org/log4net/) as the logging framework.
@@ -980,7 +991,7 @@ dotnet-coverage collect "dotnet test --framework net472 --no-build -l console;ve
 
 ## Notice
 
-1.  CVE-2019-0820 -  
+1.  CVE-2019-0820 -
     This CVE has been reported in systems.text.regularexpressions.dll which is used by the regular expressions packages - systems.text.regularexpressions.4.3.1.nupkg. This vulnerability manifests itself ONLY when the following .NET runtime environments are being used:
 
         * v1.0 branch: 1.0 - 1.0.16 (exclusive)
@@ -990,7 +1001,7 @@ dotnet-coverage collect "dotnet test --framework net472 --no-build -l console;ve
 
         In order to mitigate this vulnerability, we recommend to update to higher Runtime versions. If you're already running on a .NET Runtime version higher than the ones listed above, you're not going to be affected by this vulnerability.
 
-2.  Logging -  
+2.  Logging -
     Snowflake has identified an issue on Feb 20, 2020, with our logging code for the .NET drivers in which we write Master and Session tokens in the clear to the debug logs. The debug logs are collected locally on the drive where your programs are running. This issue impacts only those instances where the programs are run with debug flags enabled, i.e. setting the log level value= "Debug” or “All" in the log4Net config
 
     Under normal conditions, the Master and Session tokens captured in the log files are short-lived for about 4 and 1 hours, respectively. They will expire after the 4-hour window unless explicitly refreshed, in which case they could be refreshed indefinitely.
@@ -1003,8 +1014,8 @@ dotnet-coverage collect "dotnet test --framework net472 --no-build -l console;ve
     - If you cannot upgrade for any reason, please ensure all debugging is disabled
     - If you are concerned about a potential compromise, contact Snowflake Customer Support for assistance with invalidating all active sessions/tokens.
 
-3.  Global HTTP connection settings -  
-    Snowflake has identified an issue where the driver is globally enforcing TLS 1.2 and certificate revocation checks with the .NET Driver v1.2.1 and earlier versions.  
+3.  Global HTTP connection settings -
+    Snowflake has identified an issue where the driver is globally enforcing TLS 1.2 and certificate revocation checks with the .NET Driver v1.2.1 and earlier versions.
     Starting with v2.0.0, the driver will set these locally.
 
 Note that the driver is now targeting .NET 6.0. When upgrading, you might also need to run “Update-Package -reinstall” to update the dependencies.

Snowflake.Data.Tests/IntegrationTests/ConnectionMultiplePoolsAsyncIT.cs

@@ -0,0 +1,197 @@
+using System.Data.Common;
+using System.Threading;
+using System.Threading.Tasks;
+using Moq;
+using NUnit.Framework;
+using Snowflake.Data.Client;
+using Snowflake.Data.Core;
+using Snowflake.Data.Core.Session;
+using Snowflake.Data.Log;
+using Snowflake.Data.Tests.Mock;
+using Snowflake.Data.Tests.Util;
+
+namespace Snowflake.Data.Tests.IntegrationTests
+{
+    [TestFixture]
+    [NonParallelizable]
+    public class ConnectionMultiplePoolsAsyncIT: SFBaseTestAsync
+    {
+        private readonly PoolConfig _previousPoolConfig = new PoolConfig();
+        private readonly SFLogger logger = SFLoggerFactory.GetLogger<SFConnectionIT>();
+
+        [SetUp]
+        public new void BeforeTest()
+        {
+            SnowflakeDbConnectionPool.SetConnectionPoolVersion(ConnectionPoolType.MultipleConnectionPool);
+            SnowflakeDbConnectionPool.ClearAllPools();
+        }
+
+        [TearDown]
+        public new void AfterTest()
+        {
+            _previousPoolConfig.Reset();
+        }
+
+        [Test]
+        public async Task TestAddToPoolOnOpenAsync()
+        {
+            // arrange
+            var connection = new SnowflakeDbConnection(ConnectionString + "minPoolSize=1");
+
+            // act
+            await connection.OpenAsync().ConfigureAwait(false);
+
+            // assert
+            var pool = SnowflakeDbConnectionPool.GetPool(connection.ConnectionString);
+            Assert.AreEqual(1, pool.GetCurrentPoolSize());
+
+            // cleanup
+            await connection.CloseAsync(CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Test]
+        public async Task TestFailForInvalidConnectionAsync()
+        {
+            // arrange
+            var invalidConnectionString = ";connection_timeout=123";
+            var connection = new SnowflakeDbConnection(invalidConnectionString);
+
+            // act
+            try
+            {
+                await connection.OpenAsync().ConfigureAwait(false);
+                Assert.Fail("OpenAsync should fail for invalid connection string");
+            }
+            catch {}
+            var thrown = Assert.Throws<SnowflakeDbException>(() => SnowflakeDbConnectionPool.GetPool(connection.ConnectionString));
+
+            // assert
+            Assert.That(thrown.Message, Does.Contain("Required property ACCOUNT is not provided"));
+        }
+
+        [Test]
+        public void TestConnectionPoolWithInvalidOpenAsync()
+        {
+            // make the connection string unique so it won't pick up connection
+            // pooled by other test cases.
+            string connStr = ConnectionString + "minPoolSize=0;maxPoolSize=10;application=conn_pool_test_invalid_openasync2";
+            using (var connection = new SnowflakeDbConnection())
+            {
+                connection.ConnectionString = connStr;
+                // call openAsync but do not wait and destroy it direct
+                // so the session is initialized with empty token
+                connection.OpenAsync();
+            }
+
+            // use the same connection string to make a new connection
+            // to ensure the invalid connection made previously is not pooled
+            using (var connection1 = new SnowflakeDbConnection())
+            {
+                connection1.ConnectionString = connStr;
+                // this will not open a new session but get the invalid connection from pool
+                connection1.Open();
+                // Now run query with connection1
+                var command = connection1.CreateCommand();
+                command.CommandText = "select 1, 2, 3";
+
+                try
+                {
+                    using (var reader = command.ExecuteReader())
+                    {
+                        while (reader.Read())
+                        {
+                            for (int i = 0; i < reader.FieldCount; i++)
+                            {
+                                // Process each column as appropriate
+                                reader.GetFieldValue<object>(i);
+                            }
+                        }
+                    }
+                }
+                catch (SnowflakeDbException)
+                {
+                    // fail the test case if anything wrong.
+                    Assert.Fail();
+                }
+            }
+        }
+
+        [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);
+        }
+
+        [Test]
+        public async Task TestPreventConnectionFromReturningToPool()
+        {
+            // arrange
+            var connectionString = ConnectionString + "minPoolSize=0";
+            var connection = new SnowflakeDbConnection(connectionString);
+            await connection.OpenAsync().ConfigureAwait(false);
+            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
+            Assert.AreEqual(1, pool.GetCurrentPoolSize());
+
+            // act
+            connection.PreventPooling();
+            await connection.CloseAsync(CancellationToken.None).ConfigureAwait(false);
+
+            // assert
+            Assert.AreEqual(0, pool.GetCurrentPoolSize());
+        }
+
+        [Test]
+        public async Task TestReleaseConnectionWhenRollbackFailsAsync()
+        {
+            // arrange
+            var connectionString = ConnectionString + "minPoolSize=0";
+            var pool = SnowflakeDbConnectionPool.GetPool(connectionString);
+            var commandThrowingExceptionOnlyForRollback = MockHelper.CommandThrowingExceptionOnlyForRollback();
+            var mockDbProviderFactory = new Mock<DbProviderFactory>();
+            mockDbProviderFactory.Setup(p => p.CreateCommand()).Returns(commandThrowingExceptionOnlyForRollback.Object);
+            Assert.AreEqual(0, pool.GetCurrentPoolSize());
+            var connection = new TestSnowflakeDbConnection(mockDbProviderFactory.Object);
+            connection.ConnectionString = connectionString;
+            await connection.OpenAsync().ConfigureAwait(false);
+            connection.BeginTransaction(); // not using async version because it is not available on .net framework
+            Assert.AreEqual(true, connection.HasActiveExplicitTransaction());
+
+            // act
+            await connection.CloseAsync(CancellationToken.None).ConfigureAwait(false);
+
+            // assert
+            Assert.AreEqual(0, pool.GetCurrentPoolSize(), "Should not return connection to the pool");
+        }
+
+        [Test(Description = "test connection pooling with concurrent connection using async calls")]
+        public void 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 = ConnectionString + ";application=TestConcurrentConnectionPoolingAsync2;ExpirationTimeout=3";
+            ConnectionSinglePoolCacheAsyncIT.ConcurrentPoolingAsyncHelper(connStr, true, 7, 100, 2);
+        }
+
+        [Test(Description = "test connection pooling with concurrent connection and using async calls no close call for connection. Connection is closed when Dispose() is called by framework.")]
+        public void TestConcurrentConnectionPoolingDisposeAsync()
+        {
+            // 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 = ConnectionString + ";application=TestConcurrentConnectionPoolingDisposeAsync2;ExpirationTimeout=3";
+            ConnectionSinglePoolCacheAsyncIT.ConcurrentPoolingAsyncHelper(connStr, false, 7, 100, 2);
+        }
+    }
+}