feat: FIR-27628 implemented fake transaction

FireboltDotNetSdk.Tests/Unit/FireboltCommandTest.cs

@@ -315,7 +315,8 @@ public void SetTransaction()
             command.Transaction = null;
             Assert.That(command.Transaction, Is.EqualTo(null));
             Mock<DbTransaction> transaction = new();
-            Assert.Throws<NotSupportedException>(() => command.Transaction = transaction.Object);
+            command.Transaction = transaction.Object;
+            Assert.That(command.Transaction, Is.SameAs(transaction.Object));
         }
 
         [Test]

FireboltDotNetSdk.Tests/Unit/FireboltConnectionTest.cs

@@ -1,4 +1,5 @@
 using System.Data;
+using System.Data.Common;
 using System.Net;
 using FireboltDotNetSdk.Client;
 using FireboltDotNetSdk.Exception;
@@ -329,13 +330,27 @@ public void SetDifferentDatabaseAsync()
             That(cs.ClosedWithConnectionString, Is.EqualTo(connectionString2));
         }
 
+        [Test]
+        public void FakeTransaction()
+        {
+            const string connectionString = "clientid=testuser;clientsecret=testpwd;account=accountname;engine=diesel";
+            var cs = new FireboltConnection(connectionString);
+            DbTransaction transaction = cs.BeginTransaction();
+            NotNull(transaction);
+            False(transaction.SupportsSavepoints);
+            That(transaction.Connection, Is.SameAs(cs));
+            That(transaction.IsolationLevel, Is.EqualTo(IsolationLevel.Unspecified));
+            transaction.Commit();
+            Throws<NotImplementedException>(() => transaction.Rollback());
+        }
+
         [Test]
         public void NotImplementedMethods()
         {
             const string connectionString = "clientid=testuser;clientsecret=testpwd;account=accountname;engine=diesel";
             var cs = new FireboltConnection(connectionString);
-            Throws<NotImplementedException>(() => cs.BeginTransaction());
             Throws<NotSupportedException>(() => cs.EnlistTransaction(null));
+            Throws<NotSupportedException>(() => cs.EnlistTransaction(new Mock<System.Transactions.Transaction>().Object));
             Throws<NotImplementedException>(() => cs.GetSchema());
             Throws<NotImplementedException>(() => cs.GetSchema("collection"));
             Throws<NotImplementedException>(() => cs.GetSchema("collection", new string[0]));

FireboltNETSDK/Client/FireboltCommand.cs

@@ -103,23 +103,11 @@ protected override DbConnection? DbConnection
             set => _connection = value == null ? null : (FireboltConnection)value;
         }
 
-
         /// <summary>
-        /// Gets or sets the transaction within which the command executes. Always returns <b>null</b>.
+        /// Gets or sets the transaction within which the command executes. The transation is ignored.
         /// </summary>
-        /// <returns><b>null</b></returns>
         /// <exception cref="NotSupportedException">The value set is not <b>null</b>.</exception>
-        protected override DbTransaction? DbTransaction
-        {
-            get => null;
-            set
-            {
-                if (value != null)
-                {
-                    throw new NotSupportedException($"{nameof(DbTransaction)} is read only.'");
-                }
-            }
-        }
+        protected override DbTransaction? DbTransaction { get; set; }
 
         /// <summary>
         /// Gets the <see cref="FireboltParameterCollection"/>.

FireboltNETSDK/Client/FireboltConnection.cs

@@ -213,7 +213,7 @@ public override Task ChangeDatabaseAsync(string databaseName, CancellationToken
         }
 
         /// <summary>
-        /// Not supported. Transactions are not supported by the Firebolt server.
+        /// Not supported. Transactions are not supported by the Firebolt server but we ignore attempts to use them.
         /// </summary>
         /// <exception cref="NotSupportedException">Always throws <see cref="NotSupportedException"/>.</exception>
         public override void EnlistTransaction(Transaction? transaction)
@@ -392,7 +392,7 @@ public override void Open()
 
         protected override DbTransaction BeginDbTransaction(IsolationLevel isolationLevel)
         {
-            throw new NotImplementedException();
+            return new FireboltTransaction(this);
         }
 
         private string EditConnectionString(string orig, string name, string value)

FireboltNETSDK/FireboltTransaction.cs

@@ -0,0 +1,55 @@
+#region License Apache 2.0
+/* Copyright 2022 
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#endregion
+
+using System.Data.Common;
+using System.Runtime.CompilerServices;
+using IsolationLevel = System.Data.IsolationLevel;
+
+
+[assembly: InternalsVisibleTo("FireboltDotNetSdk.Tests")]
+namespace FireboltDotNetSdk.Client
+{
+    /// <summary>
+    /// Represents a connection to a Firebolt database. This class cannot be inherited.
+    /// </summary>
+    internal sealed class FireboltTransaction : DbTransaction
+    {
+        private DbConnection _dbConnection;
+        internal FireboltTransaction(DbConnection connection) : base()
+        {
+            _dbConnection = connection;
+        }
+
+        public override IsolationLevel IsolationLevel { get => IsolationLevel.Unspecified; }
+
+        protected override DbConnection? DbConnection { get => _dbConnection; }
+
+        /// <summary>
+        /// Empty NOP implementation - does nothing.
+        /// </summary>
+        public override void Commit() { }
+
+        /// <summary>
+        /// Throws NotImplementedException to indicate that rollback is not supported.
+        /// </summary>
+        public override void Rollback()
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+}