Fix red tests due to connectionLifeTime check enabled after change its value from infinite to 1h

Author: Zhen

Neo4j.Driver/Neo4j.Driver.Tests/ConnectionPoolTests.cs

@@ -35,6 +35,19 @@ namespace Neo4j.Driver.Tests
 {
     public class ConnectionPoolTests
     {
+        internal static ConnectionPool NewConnectionPoolWithNoConnectionTimeoutValidation(
+            IConnection connection,
+            BlockingCollection<IPooledConnection> availableConnections = null,
+            ConcurrentSet<IPooledConnection> inUseConnections = null)
+        {
+            var testConfigWithIdleTimeoutAndLifetimeCheckDisabled = new Config
+            {
+                MaxConnectionLifetime = Config.InfiniteInterval,
+                ConnectionIdleTimeout = Config.InfiniteInterval
+            };
+            return new ConnectionPool(connection, availableConnections, inUseConnections,
+                poolSettings: new ConnectionPoolSettings(testConfigWithIdleTimeoutAndLifetimeCheckDisabled));
+        }
         public class AcquireMethod
         {
             private readonly ITestOutputHelper _output;
@@ -45,6 +58,17 @@ private IConnection MockedConnection
                 {
                     var mock = new Mock<IPooledConnection>();
                     mock.Setup(x => x.IsOpen).Returns(true);
+                    mock.Setup(x => x.IdleTimer).Returns(MockedTimer);
+                    mock.Setup(x => x.LifetimeTimer).Returns(MockedTimer);
+                    return mock.Object;
+                }
+            }
+
+            private ITimer MockedTimer
+            {
+                get {
+                    var mock = new Mock<ITimer>();
+                    mock.Setup(t => t.ElapsedMilliseconds).Returns(0);
                     return mock.Object;
                 }
             }
@@ -211,6 +235,8 @@ public void ShouldReuseWhenOpenConnectionInQueue()
                 var conns = new BlockingCollection<IPooledConnection>();
                 var mock = new Mock<IPooledConnection>();
                 mock.Setup(x => x.IsOpen).Returns(true);
+                mock.Setup(x => x.IdleTimer).Returns(MockedTimer);
+                mock.Setup(x => x.LifetimeTimer).Returns(MockedTimer);
 
                 conns.Add(mock.Object);
                 var pool = new ConnectionPool(MockedConnection, conns);
@@ -237,7 +263,7 @@ public void ShouldReuseOpenConnectionWhenOpenAndClosedConnectionsInQueue()
 
                 conns.Add(unhealthyMock.Object);
                 conns.Add(healthyMock.Object);
-                var pool = new ConnectionPool(MockedConnection, conns);
+                var pool = NewConnectionPoolWithNoConnectionTimeoutValidation(MockedConnection, conns);
 
                 pool.NumberOfAvailableConnections.Should().Be(2);
                 pool.NumberOfInUseConnections.Should().Be(0);
@@ -301,7 +327,11 @@ public void ShouldReuseIdleNotTooLongConn()
                 conns.Add(mock.Object);
                 var enableIdleTooLongTest = TimeSpan.FromMilliseconds(100);
                 var poolSettings = new ConnectionPoolSettings(
-                    new Config {MaxIdleConnectionPoolSize = 2, ConnectionIdleTimeout = enableIdleTooLongTest});
+                    new Config {
+                        MaxIdleConnectionPoolSize = 2,
+                        ConnectionIdleTimeout = enableIdleTooLongTest,
+                        MaxConnectionLifetime = Config.InfiniteInterval, // disable life time check
+                    });
                 var pool = new ConnectionPool(MockedConnection, conns, poolSettings: poolSettings);
 
                 pool.NumberOfAvailableConnections.Should().Be(1);
@@ -343,7 +373,7 @@ public void ShouldAcquireNewWhenBeingUsedConcurrentlyBy(int numberOfThreads)
                     mockConns.Enqueue(mock);
                 }
 
-                var pool = new ConnectionPool(MockedConnection, conns);
+                var pool = NewConnectionPoolWithNoConnectionTimeoutValidation(MockedConnection, conns);
 
                 pool.NumberOfAvailableConnections.Should().Be(numberOfThreads);
                 pool.NumberOfInUseConnections.Should().Be(0);
@@ -407,7 +437,7 @@ public void ShouldCloseAcquiredConnectionIfPoolDisposeStarted()
                 // Given
                 var conns = new BlockingCollection<IPooledConnection>();
                 var healthyMock = new Mock<IPooledConnection>();
-                var pool = new ConnectionPool(MockedConnection, conns);
+                var pool = NewConnectionPoolWithNoConnectionTimeoutValidation(MockedConnection, conns);
 
                 pool.NumberOfAvailableConnections.Should().Be(0);
                 pool.NumberOfInUseConnections.Should().Be(0);
@@ -453,6 +483,7 @@ public void ShouldTimeoutAfterAcquireTimeoutIfPoolIsFull()
             public void ShouldTimeoutAfterAcquireTimeoutWhenConnectionIsNotValidated()
             {
                 Config config = Config.Builder.WithConnectionAcquisitionTimeout(TimeSpan.FromSeconds(5))
+                    .WithConnectionTimeout(Config.InfiniteInterval)
                     .ToConfig();
 
                 var notValidConnection = new Mock<IPooledConnection>();