Improved SimulatedDbCommand similarity to SqlCommand.

Author: RyanLamansky

SqlServerSimulator.Tests/CommandTests.cs

@@ -0,0 +1,107 @@
+using System.Data;
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+[TestClass]
+public class CommandTests
+{
+    private static DbCommand CreateCommand() => new Simulation().CreateDbConnection().CreateCommand();
+
+    private static DbCommand CreateCommand(string? commandText) => new Simulation().CreateCommand(commandText);
+
+    private static DbConnection CreateOpenConnection() => new Simulation().CreateOpenConnection();
+
+    [TestMethod]
+    public void DbConnectionPassThrough()
+    {
+        using var connection = new Simulation().CreateDbConnection();
+        using var command = connection.CreateCommand();
+        AreSame(connection, command.Connection);
+    }
+
+    [TestMethod]
+    public void CreateCommandIsNotNull() => IsNotNull(CreateCommand());
+
+    [TestMethod]
+    public void CommandTypeDefaultsText() => AreEqual(System.Data.CommandType.Text, CreateCommand().CommandType);
+
+    [TestMethod]
+    public void CreateCommandWithCommandText()
+    {
+        const string commandText = "select 1";
+        using var command = CreateCommand(commandText);
+        AreEqual(commandText, command.CommandText);
+    }
+
+    [TestMethod]
+    public void NullCommandTextConvertedToEmptyString() => AreSame(string.Empty, CreateCommand("").CommandText);
+
+    [TestMethod]
+    public void CommandTimeoutRangeCheck()
+    {
+        using var command = CreateCommand();
+        AreEqual(30, command.CommandTimeout);
+        var exception = ThrowsExactly<ArgumentException>(() => command.CommandTimeout = -1);
+        AreEqual(nameof(command.CommandTimeout), exception.ParamName);
+
+        command.CommandTimeout = 5;
+        AreEqual(5, command.CommandTimeout);
+    }
+
+    [TestMethod]
+    public void DesignTimeVisibleBehavior()
+    {
+        using var command = CreateCommand();
+        IsTrue(command.DesignTimeVisible);
+        command.DesignTimeVisible = false;
+        IsFalse(command.DesignTimeVisible);
+        command.DesignTimeVisible = true;
+        IsTrue(command.DesignTimeVisible);
+    }
+
+    [TestMethod]
+    public void TransactionPassThrough()
+    {
+        using var connection = CreateOpenConnection();
+        using var transaction = connection.BeginTransaction();
+        AreSame(transaction.Connection, connection);
+        using var command = connection.CreateCommand();
+        IsNull(command.Transaction);
+
+        command.Transaction = transaction;
+        AreSame(transaction, command.Transaction);
+        command.Transaction = null;
+        IsNull(command.Transaction);
+    }
+
+    sealed class TestTransaction : DbTransaction
+    {
+        public override IsolationLevel IsolationLevel => throw new NotImplementedException();
+        protected override DbConnection? DbConnection => throw new NotImplementedException();
+        public override void Commit() => throw new NotImplementedException();
+        public override void Rollback() => throw new NotImplementedException();
+    }
+
+    [TestMethod]
+    public void TransactionRestrictions()
+    {
+        var simulation = new Simulation();
+        using var connection = simulation.CreateOpenConnection();
+        using (var sim1con2 = simulation.CreateOpenConnection())
+        {
+            using var otherConnectionTransaction = sim1con2.BeginTransaction();
+
+            using var doomedCommand = connection.CreateCommand();
+
+            _ = Throws<Exception>(() => doomedCommand.Transaction = otherConnectionTransaction);
+        }
+
+        using var connection2 = CreateOpenConnection();
+        using var transaction = connection.BeginTransaction();
+        using var command2 = connection2.CreateCommand();
+        _ = Throws<Exception>(() => command2.Transaction = transaction);
+        _ = Throws<Exception>(() => command2.Transaction = new TestTransaction());
+    }
+}

SqlServerSimulator/SimulatedDbCommand.cs

@@ -6,47 +6,61 @@ namespace SqlServerSimulator;
 
 sealed class SimulatedDbCommand : DbCommand
 {
-    internal Simulation simulation;
-    internal SimulatedDbConnection connection;
-    internal SimulatedDbTransaction? transaction;
-    private string commandText = string.Empty;
+    internal readonly Simulation simulation;
 
     public SimulatedDbCommand(Simulation simulation, SimulatedDbConnection connection)
     {
         this.simulation = simulation;
-        this.connection = connection;
-    }
-
-    public SimulatedDbCommand(Simulation simulation, SimulatedDbConnection connection, SimulatedDbTransaction transaction)
-    {
-        this.simulation = simulation;
-        this.connection = connection;
-        this.transaction = transaction;
+        this.Connection = connection;
     }
 
     [AllowNull]
     public override string CommandText
     {
-        get => commandText;
-        set => commandText = value ?? string.Empty;
-    }
+        get;
+        set => field = value ?? string.Empty;
+    } = string.Empty;
+
+    public override int CommandTimeout
+    {
+        get;
+        set => field = value >= 0 ?
+            value :
+            throw new ArgumentException($"Invalid {nameof(CommandTimeout)} value {value}; the value must be >= 0.", nameof(CommandTimeout));
+        // ArgumentOutOfRangeException would be more appropriate but the official SQL Client uses ArgumentException, so this is more consistent.
+    } = 30;
+
+    public override CommandType CommandType
+    {
+        get;
+        set => throw (Enum.IsDefined(value) ? new NotSupportedException() : new ArgumentOutOfRangeException(nameof(CommandType), value, null));
+    } = CommandType.Text;
 
-    public override int CommandTimeout { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-    public override CommandType CommandType { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-    public override bool DesignTimeVisible { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-    public override UpdateRowSource UpdatedRowSource { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-    protected override DbConnection? DbConnection { get => this.connection; set => throw new NotImplementedException(); }
+    public override bool DesignTimeVisible { get; set; } = true;
+
+    public override UpdateRowSource UpdatedRowSource { get; set; } = UpdateRowSource.Both;
+
+    protected override DbConnection? DbConnection
+    {
+        get;
+        set
+        {
+            if (field is not null) // Set by the constructor.
+                throw new NotSupportedException("Simulated DbCommands cannot switch to different connections.");
+            field = value;
+        }
+    }
 
     protected override DbParameterCollection DbParameterCollection { get; } = new SimulatedDbParameterCollection();
 
     protected override DbTransaction? DbTransaction
     {
-        get => this.transaction;
+        get;
         set
         {
             if (value == null)
             {
-                this.transaction = null;
+                field = null;
                 return;
             }
 
@@ -56,10 +70,10 @@ protected override DbTransaction? DbTransaction
             if (transaction.simulation != this.simulation)
                 throw new NotSupportedException("Simulated DbCommands cannot switch to different simulations.");
 
-            if (transaction.connection != this.connection)
+            if (transaction.connection != this.Connection)
                 throw new NotSupportedException("Simulated DbCommands cannot switch to different connections.");
 
-            this.transaction = transaction;
+            field = transaction;
         }
     }