Introduce TransactionConfig parameter to query config

Neo4j.Driver/Neo4j.Driver.Tests.TestBackend/Protocol/DriverQuery/ExecuteQuery.cs

@@ -69,12 +69,19 @@ private QueryConfig BuildConfig()
             }
         }
 
+        var transactionConfig = new TransactionConfig
+        {
+            Timeout = data.config.timeout.HasValue ? TimeSpan.FromMilliseconds(data.config.timeout.Value) : null,
+            Metadata = data.config.txMeta != null ? CypherToNativeObject.ConvertDictionaryToNative(data.config.txMeta) : new Dictionary<string, object>()
+        };
+
         return new QueryConfig(
             routingControl,
             data.config.database,
             data.config.impersonatedUser,
             bookmarkManager,
-            enableBookmarkManager);
+            enableBookmarkManager,
+            transactionConfig);
     }
 
     public override string Respond()
@@ -117,5 +124,8 @@ public class ExecuteQueryConfigDto
         public string database { get; set; }
         public string impersonatedUser { get; set; }
         public string bookmarkManagerId { get; set; }
+        public int? timeout { get; set; }
+        [JsonConverter(typeof(QueryParameterConverter))]
+        public Dictionary<string, CypherToNativeObject> txMeta { get; set; }
     }
 }

Neo4j.Driver/Neo4j.Driver.Tests.TestBackend/Protocol/Session/BaseSessionType.cs

@@ -45,7 +45,7 @@ public TransactionConfigBuilder ConfigureTxTimeout(TransactionConfigBuilder conf
                 configBuilder.WithTimeout(timeout);
             }
         }
-        catch (ArgumentOutOfRangeException e) when ((timeout ?? 0) < 0 && e.ParamName == "value")
+        catch (ArgumentOutOfRangeException e) when ((timeout ?? 0) < 0 && e.ParamName == "timeout")
         {
             throw new DriverExceptionWrapper(e);
         }

Neo4j.Driver/Neo4j.Driver.Tests/AsyncSessionTests.cs

@@ -299,7 +299,7 @@ public async void PipelinedShouldBeginWithoutBlocking()
                     false,
                     false);
 
-                await session.PipelinedExecuteReadAsync(_ => Task.FromResult(null as EagerResult<IRecord[]>));
+                await session.PipelinedExecuteReadAsync(_ => Task.FromResult(null as EagerResult<IRecord[]>), new TransactionConfig());
 
                 mockProtocol.Verify(
                     x =>

Neo4j.Driver/Neo4j.Driver.Tests/Internal/MessageHandling/Messages/BeginMessageTests.cs

@@ -56,7 +56,7 @@ public void ShouldHandleSetValues(int major, int minor)
                 new BoltProtocolVersion(major, minor),
                 "neo4j",
                 bookmarks,
-                new TransactionConfig(txMeta, TimeSpan.FromSeconds(1)),
+                new TransactionConfig { Metadata = txMeta, Timeout = TimeSpan.FromSeconds(1) },
                 AccessMode.Read,
                 new SessionConfig("Douglas Fir"),
                 null);
@@ -89,7 +89,7 @@ public void ShouldIgnoreNotificationConfig(int major, int minor)
                 new BoltProtocolVersion(major, minor),
                 "neo4j",
                 bookmarks,
-                new TransactionConfig(txMeta, TimeSpan.FromSeconds(1)),
+                new TransactionConfig { Metadata = txMeta, Timeout = TimeSpan.FromSeconds(1) },
                 AccessMode.Read,
                 new SessionConfig("Douglas Fir"),
                 new NotificationsDisabledConfig());
@@ -122,7 +122,7 @@ public void ShouldHandleSetValuesWithNotifications(int major, int minor)
                 new BoltProtocolVersion(major, minor),
                 "neo4j",
                 bookmarks,
-                new TransactionConfig(txMeta, TimeSpan.FromSeconds(1)),
+                new TransactionConfig { Metadata = txMeta, Timeout = TimeSpan.FromSeconds(1) },
                 AccessMode.Read,
                 new SessionConfig("Douglas Fir"),
                 new NotificationsConfig(Severity.Warning, new[] { Category.Generic }));
@@ -153,12 +153,14 @@ public void ShouldThrowIfBoltVersionLessThan44()
                         BoltProtocolVersion.V4_3,
                         "neo4j",
                         new InternalBookmarks("bm:a"),
-                        new TransactionConfig(
-                            new Dictionary<string, object>
+                        new TransactionConfig
+                        {
+                            Metadata = new Dictionary<string, object>
                             {
                                 ["a"] = "b"
                             },
-                            TimeSpan.FromSeconds(1)),
+                            Timeout = TimeSpan.FromSeconds(1)
+                        },
                         AccessMode.Read,
                         new SessionConfig("Douglas Fir"),
                         null))

Neo4j.Driver/Neo4j.Driver.Tests/TransactionConfigTests.cs

@@ -16,92 +16,149 @@
 using System;
 using System.Collections.Generic;
 using FluentAssertions;
+using Neo4j.Driver.Internal.Logging;
 using Xunit;
 
-namespace Neo4j.Driver.Tests
+namespace Neo4j.Driver.Tests;
+
+public class TransactionConfigTests
 {
-    public class TransactionConfigTests
+    public class TimeoutField
+    {
+        public static IEnumerable<object[]> InvalidTimeSpanValues => new[]
+        {
+            new object[] { TimeSpan.FromSeconds(-1) },
+            new object[] { TimeSpan.FromHours(-2) }
+        };
+
+        public static IEnumerable<object[]> ValidTimeSpanValues => new[]
+        {
+            new object[] { null },
+            new object[] { (TimeSpan?)TimeSpan.Zero },
+            new object[] { (TimeSpan?)TimeSpan.FromMilliseconds(1) },
+            new object[] { (TimeSpan?)TimeSpan.FromMinutes(30) },
+            new object[] { (TimeSpan?)TimeSpan.MaxValue }
+        };
+
+        [Fact]
+        public void ShouldReturnDefaultValueAsNull()
+        {
+            var config = new TransactionConfig();
+
+            config.Timeout.Should().Be(null);
+        }
+
+        [Theory]
+        [MemberData(nameof(ValidTimeSpanValues))]
+        public void ShouldAllowToSetToNewValue(TimeSpan? input)
+        {
+            var builder = new TransactionConfigBuilder(null, TransactionConfig.Default);
+            builder.WithTimeout(input);
+
+            var config = builder.Build();
+
+            config.Timeout.Should().Be(input);
+        }
+
+        [Theory]
+        [MemberData(nameof(ValidTimeSpanValues))]
+        public void ShouldAllowToInitToNewValue(TimeSpan? input)
+        {
+            var config = new TransactionConfig { Timeout = input };
+            config.Timeout.Should().Be(input);
+        }
+
+        [Fact]
+        public void ShouldRoundUpWithBuilder()
+        {
+            var ts = TimeSpan.FromTicks(1);
+            var builder = new TransactionConfigBuilder(NullLogger.Instance, TransactionConfig.Default);
+            builder.WithTimeout(ts);
+
+            var config = builder.Build();
+
+            config.Timeout.Should().Be(TimeSpan.FromMilliseconds(1));
+        }
+
+        [Fact]
+        public void ShouldRoundUpWithInit()
+        {
+            var ts = TimeSpan.FromTicks(1);
+            var config = new TransactionConfig { Timeout = ts };
+            config.Timeout.Should().Be(TimeSpan.FromMilliseconds(1));
+        }
+
+        [Theory]
+        [MemberData(nameof(InvalidTimeSpanValues))]
+        public void ShouldThrowExceptionIfAssigningValueLessThanZero(TimeSpan input)
+        {
+            var error = Record.Exception(
+                () => new TransactionConfigBuilder(null, TransactionConfig.Default).WithTimeout(input));
+
+            error.Should().BeOfType<ArgumentOutOfRangeException>();
+            error.Message.Should().Contain("not be negative");
+        }
+
+        [Theory]
+        [MemberData(nameof(InvalidTimeSpanValues))]
+        public void ShouldThrowExceptionIfInitValueLessThanZero(TimeSpan input)
+        {
+            var error = Record.Exception(() => new TransactionConfig { Timeout = input });
+            error.Should().BeOfType<ArgumentOutOfRangeException>();
+            error.Message.Should().Contain("not be negative");
+        }
+    }
+
+    public class MetadataField
     {
-        public class TimeoutField
+        [Fact]
+        public void ShouldReturnDefaultValueEmptyDictionary()
+        {
+            var config = new TransactionConfig();
+
+            config.Metadata.Should().BeEmpty();
+        }
+
+        [Fact]
+        public void ShouldAllowToSetToNewValue()
+        {
+            var builder = new TransactionConfigBuilder(null, TransactionConfig.Default)
+                .WithMetadata(new Dictionary<string, object> { { "key", "value" } });
+
+            var config = builder.Build();
+
+            config.Metadata.Should()
+                .HaveCount(1)
+                .And.Contain(new KeyValuePair<string, object>("key", "value"));
+        }
+
+        [Fact]
+        public void ShouldThrowExceptionIfAssigningNull()
         {
-            public static IEnumerable<object[]> InvalidTimeSpanValues => new[]
-            {
-                new object[] { TimeSpan.FromSeconds(-1) },
-                new object[] { TimeSpan.FromHours(-2) }
-            };
-
-            public static IEnumerable<object[]> ValidTimeSpanValues => new[]
-            {
-                new object[] { null },
-                new object[] { (TimeSpan?)TimeSpan.Zero },
-                new object[] { (TimeSpan?)TimeSpan.FromMilliseconds(1) },
-                new object[] { (TimeSpan?)TimeSpan.FromMinutes(30) },
-                new object[] { (TimeSpan?)TimeSpan.MaxValue }
-            };
-
-            [Fact]
-            public void ShouldReturnDefaultValueAsNull()
-            {
-                var config = new TransactionConfig();
-
-                config.Timeout.Should().Be(null);
-            }
-
-            [Theory]
-            [MemberData(nameof(ValidTimeSpanValues))]
-            public void ShouldAllowToSetToNewValue(TimeSpan? input)
-            {
-                var builder = new TransactionConfigBuilder(null, TransactionConfig.Default);
-                builder.WithTimeout(input);
-
-                var config = builder.Build();
-
-                config.Timeout.Should().Be(input);
-            }
-
-            [Theory]
-            [MemberData(nameof(InvalidTimeSpanValues))]
-            public void ShouldThrowExceptionIfAssigningValueLessThanZero(TimeSpan input)
-            {
-                var error = Record.Exception(() => new TransactionConfigBuilder(null, TransactionConfig.Default).WithTimeout(input));
-
-                error.Should().BeOfType<ArgumentOutOfRangeException>();
-                error.Message.Should().Contain("not be negative");
-            }
+            var error = Record.Exception(
+                () => new TransactionConfigBuilder(null, TransactionConfig.Default).WithMetadata(null));
+
+            error.Should().BeOfType<ArgumentNullException>();
+            error.Message.Should().Contain("should not be null");
+        }
+
+        [Fact]
+        public void ShouldAllowToInitToNewValue()
+        {
+            var config = new TransactionConfig { Metadata = new Dictionary<string, object> { ["key"] = "value" } };
+
+            config.Metadata.Should()
+                .HaveCount(1)
+                .And.Contain(new KeyValuePair<string, object>("key", "value"));
         }
 
-        public class MetadataField
+        [Fact]
+        public void ShouldThrowExceptionIfInitNull()
         {
-            [Fact]
-            public void ShouldReturnDefaultValueEmptyDictionary()
-            {
-                var config = new TransactionConfig();
-
-                config.Metadata.Should().BeEmpty();
-            }
-
-            [Fact]
-            public void ShouldAllowToSetToNewValue()
-            {
-                var builder = new TransactionConfigBuilder(null, TransactionConfig.Default)
-                    .WithMetadata(new Dictionary<string, object> { { "key", "value" } });
-
-                var config = builder.Build();
-
-                config.Metadata.Should()
-                    .HaveCount(1)
-                    .And.Contain(new KeyValuePair<string, object>("key", "value"));
-            }
-
-            [Fact]
-            public void ShouldThrowExceptionIfAssigningNull()
-            {
-                var error = Record.Exception(
-                    () => new TransactionConfigBuilder(null, TransactionConfig.Default).WithMetadata(null));
-
-                error.Should().BeOfType<ArgumentNullException>();
-                error.Message.Should().Contain("should not be null");
-            }
+            var error = Record.Exception(() => new TransactionConfig { Metadata = null });
+
+            error.Should().BeOfType<ArgumentNullException>();
+            error.Message.Should().Contain("should not be null");
         }
     }
 }

Neo4j.Driver/Neo4j.Driver/ExecuteQuery/QueryConfig.cs

@@ -40,14 +40,18 @@ public QueryConfig(
         string database = null,
         string impersonatedUser = null,
         IBookmarkManager bookmarkManager = null,
-        bool enableBookmarkManager = true)
+        bool enableBookmarkManager = true,
+        TransactionConfig transactionConfig = null)
     {
         Routing = routing;
         Database = database;
         ImpersonatedUser = impersonatedUser;
         BookmarkManager = bookmarkManager;
         EnableBookmarkManager = enableBookmarkManager;
+        TransactionConfig = transactionConfig ?? TransactionConfig.Default;
     }
+    /// <summary>Config for the transaction that will be used to execute the query.</summary>
+    public TransactionConfig TransactionConfig { get; }
 
     /// <summary>Members of the cluster the query can be processed by.</summary>
     public RoutingControl Routing { get; }
@@ -94,8 +98,9 @@ public QueryConfig(
         string database = null,
         string impersonatedUser = null,
         IBookmarkManager bookmarkManager = null,
-        bool enableBookmarkManager = true)
-        : base(routing, database, impersonatedUser, bookmarkManager, enableBookmarkManager)
+        bool enableBookmarkManager = true,
+        TransactionConfig transactionConfig = null)
+        : base(routing, database, impersonatedUser, bookmarkManager, enableBookmarkManager, transactionConfig)
     {
         CursorProcessor = cursorProcessor ?? throw new ArgumentNullException(nameof(cursorProcessor));
     }