test: repoint relational unit tests to new read/purge semantics

The initial commit removed the EnableHistory guard from the relational
read/purge handlers but missed four unit tests in
DotNetWorkQueue.Transport.RelationalDatabase.Tests that still asserted
the old behavior ("factory.DidNotReceive().Create()" when
EnableHistory=false). Convert them to assert the new behavior: when the
history table does not exist (simulated via DbException), the handlers
return empty / null / 0 gracefully.

- Get_When_Disabled_Returns_Empty_List -> Get_When_History_Table_Missing_Returns_Empty_List
- GetByQueueId_When_Disabled_Returns_Null -> GetByQueueId_When_History_Table_Missing_Returns_Null
- GetCount_When_Disabled_Returns_Zero -> GetCount_When_History_Table_Missing_Returns_Zero
- Purge_When_Disabled_Returns_Zero -> Purge_When_History_Table_Missing_Returns_Zero

216/216 tests pass locally.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: blehnen

Source/DotNetWorkQueue.Transport.RelationalDatabase.Tests/Basic/PurgeMessageHistoryHandlerTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Data;
+using System.Data.Common;
 using DotNetWorkQueue.Transport.RelationalDatabase.Basic;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using NSubstitute;
@@ -10,12 +11,18 @@ namespace DotNetWorkQueue.Transport.RelationalDatabase.Tests.Basic
     public class PurgeMessageHistoryHandlerTests
     {
         [TestMethod]
-        public void Purge_When_Disabled_Returns_Zero()
+        public void Purge_When_History_Table_Missing_Returns_Zero()
         {
-            var (handler, factory, _) = Create(enabled: false);
+            // After the EnableHistory read-path guard was removed, Purge relies on a
+            // DbException catch to handle the case where the history table was never
+            // created. Simulate that with a thrown DbException from ExecuteNonQuery.
+            var (handler, factory, _) = Create(enabled: true);
+            var (_, command) = SetupConnection(factory);
+            command.When(c => c.ExecuteNonQuery()).Do(_ => throw new FakeDbException());
+
             var result = handler.Purge(DateTime.UtcNow.AddDays(-30));
+
             Assert.AreEqual(0L, result);
-            factory.DidNotReceive().Create();
         }
 
         [TestMethod]
@@ -68,5 +75,10 @@ private static (IDbConnection connection, IDbCommand command) SetupConnection(ID
             factory.Create().Returns(connection);
             return (connection, command);
         }
+
+        private sealed class FakeDbException : DbException
+        {
+            public FakeDbException() : base("simulated: history table does not exist") { }
+        }
     }
 }

Source/DotNetWorkQueue.Transport.RelationalDatabase.Tests/Basic/QueryMessageHistoryHandlerTests.cs

@@ -1,4 +1,5 @@
 using System.Data;
+using System.Data.Common;
 using DotNetWorkQueue.Configuration;
 using DotNetWorkQueue.Transport.RelationalDatabase.Basic;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -9,31 +10,44 @@ namespace DotNetWorkQueue.Transport.RelationalDatabase.Tests.Basic
     [TestClass]
     public class QueryMessageHistoryHandlerTests
     {
+        // After the EnableHistory read-path guard was removed, these methods rely on a
+        // DbException catch to handle the case where the history table was never created.
+        // We simulate that by throwing DbException from ExecuteReader / ExecuteScalar.
+
         [TestMethod]
-        public void Get_When_Disabled_Returns_Empty_List()
+        public void Get_When_History_Table_Missing_Returns_Empty_List()
         {
-            var (handler, factory, _) = Create(enabled: false);
+            var (handler, factory, _) = Create(enabled: true);
+            var (_, command) = SetupConnection(factory);
+            command.When(c => c.ExecuteReader()).Do(_ => throw new FakeDbException());
+
             var result = handler.Get(0, 10, null);
+
             Assert.AreEqual(0, result.Count);
-            factory.DidNotReceive().Create();
         }
 
         [TestMethod]
-        public void GetByQueueId_When_Disabled_Returns_Null()
+        public void GetByQueueId_When_History_Table_Missing_Returns_Null()
         {
-            var (handler, factory, _) = Create(enabled: false);
+            var (handler, factory, _) = Create(enabled: true);
+            var (_, command) = SetupConnection(factory);
+            command.When(c => c.ExecuteReader()).Do(_ => throw new FakeDbException());
+
             var result = handler.GetByQueueId("q1");
+
             Assert.IsNull(result);
-            factory.DidNotReceive().Create();
         }
 
         [TestMethod]
-        public void GetCount_When_Disabled_Returns_Zero()
+        public void GetCount_When_History_Table_Missing_Returns_Zero()
         {
-            var (handler, factory, _) = Create(enabled: false);
+            var (handler, factory, _) = Create(enabled: true);
+            var (_, command) = SetupConnection(factory);
+            command.When(c => c.ExecuteScalar()).Do(_ => throw new FakeDbException());
+
             var result = handler.GetCount(null);
+
             Assert.AreEqual(0L, result);
-            factory.DidNotReceive().Create();
         }
 
         [TestMethod]
@@ -122,5 +136,10 @@ private static (IDbConnection connection, IDbCommand command) SetupConnection(ID
             factory.Create().Returns(connection);
             return (connection, command);
         }
+
+        private sealed class FakeDbException : DbException
+        {
+            public FakeDbException() : base("simulated: history table does not exist") { }
+        }
     }
 }