refs and cleanup

Author: SimonCropp

src/global.json global.jsonsrc/global.json renamed to global.json

@@ -1,4 +1,4 @@
-{
+{
   "sdk": {
     "version": "10.0.103",
     "allowPrerelease": true,

src/Directory.Packages.props

@@ -14,6 +14,6 @@
     <PackageVersion Include="NServiceBus.Extensions.Hosting" Version="4.0.0" />
     <PackageVersion Include="ProjectDefaults" Version="1.0.172" />
     <PackageVersion Include="System.ServiceProcess.ServiceController" Version="10.0.3" />
-    <PackageVersion Include="xunit.v3" Version="3.2.2" />
+    <PackageVersion Include="TUnit" Version="1.15.11" />
   </ItemGroup>
 </Project>

src/Tests/DeferredLoggerFactoryTests.cs

@@ -1,93 +1,94 @@
 using NServiceBus.Logging;
+using System.Threading.Tasks;
 
 /// <summary>
 /// Tests for the DeferredLoggerFactory pattern using a local test implementation.
 /// This tests the deferred logging pattern used for capturing logs before endpoint startup.
 /// </summary>
 public class DeferredLoggerFactoryTests
 {
-    [Fact]
-    public void GetLogger_with_type_returns_NamedLogger()
+    [Test]
+    public async Task GetLogger_with_type_returns_NamedLogger()
     {
         var factory = new TestDeferredLoggerFactory(LogLevel.Debug);
 
         var log = factory.GetLogger(typeof(DeferredLoggerFactoryTests));
 
-        Assert.NotNull(log);
-        Assert.IsType<TestNamedLogger>(log);
+        await Assert.That(log).IsNotNull();
+        await Assert.That(log).IsTypeOf<TestNamedLogger>();
     }
 
-    [Fact]
-    public void GetLogger_with_string_returns_NamedLogger()
+    [Test]
+    public async Task GetLogger_with_string_returns_NamedLogger()
     {
         var factory = new TestDeferredLoggerFactory(LogLevel.Debug);
 
         var log = factory.GetLogger("TestLogger");
 
-        Assert.NotNull(log);
-        Assert.IsType<TestNamedLogger>(log);
+        await Assert.That(log).IsNotNull();
+        await Assert.That(log).IsTypeOf<TestNamedLogger>();
     }
 
-    [Fact]
-    public void Write_adds_message_to_deferred_logs()
+    [Test]
+    public async Task Write_adds_message_to_deferred_logs()
     {
         var factory = new TestDeferredLoggerFactory(LogLevel.Debug);
 
         factory.Write("TestLogger", LogLevel.Info, "test message");
 
-        Assert.Single(factory.DeferredLogs);
-        Assert.True(factory.DeferredLogs.ContainsKey("TestLogger"));
-        Assert.Single(factory.DeferredLogs["TestLogger"]);
+        await Assert.That(factory.DeferredLogs).HasSingleItem();
+        await Assert.That(factory.DeferredLogs.ContainsKey("TestLogger")).IsTrue();
+        await Assert.That(factory.DeferredLogs["TestLogger"]).HasSingleItem();
         var (level, message) = factory.DeferredLogs["TestLogger"].First();
-        Assert.Equal(LogLevel.Info, level);
-        Assert.Equal("test message", message);
+        await Assert.That(level).IsEqualTo(LogLevel.Info);
+        await Assert.That(message).IsEqualTo("test message");
     }
 
-    [Fact]
-    public void Write_filters_messages_below_configured_level()
+    [Test]
+    public async Task Write_filters_messages_below_configured_level()
     {
         var factory = new TestDeferredLoggerFactory(LogLevel.Warn);
 
         factory.Write("TestLogger", LogLevel.Debug, "debug message");
         factory.Write("TestLogger", LogLevel.Info, "info message");
 
-        Assert.Empty(factory.DeferredLogs);
+        await Assert.That(factory.DeferredLogs).IsEmpty();
     }
 
-    [Fact]
-    public void Write_accepts_messages_at_or_above_configured_level()
+    [Test]
+    public async Task Write_accepts_messages_at_or_above_configured_level()
     {
         var factory = new TestDeferredLoggerFactory(LogLevel.Warn);
 
         factory.Write("TestLogger", LogLevel.Warn, "warn message");
         factory.Write("TestLogger", LogLevel.Error, "error message");
         factory.Write("TestLogger", LogLevel.Fatal, "fatal message");
 
-        Assert.Single(factory.DeferredLogs);
-        Assert.Equal(3, factory.DeferredLogs["TestLogger"].Count);
+        await Assert.That(factory.DeferredLogs).HasSingleItem();
+        await Assert.That(factory.DeferredLogs["TestLogger"].Count).IsEqualTo(3);
     }
 
-    [Fact]
-    public void Write_groups_messages_by_logger_name()
+    [Test]
+    public async Task Write_groups_messages_by_logger_name()
     {
         var factory = new TestDeferredLoggerFactory(LogLevel.Debug);
 
         factory.Write("Logger1", LogLevel.Info, "message 1");
         factory.Write("Logger2", LogLevel.Info, "message 2");
         factory.Write("Logger1", LogLevel.Info, "message 3");
 
-        Assert.Equal(2, factory.DeferredLogs.Count);
-        Assert.Equal(2, factory.DeferredLogs["Logger1"].Count);
-        Assert.Single(factory.DeferredLogs["Logger2"]);
+        await Assert.That(factory.DeferredLogs.Count).IsEqualTo(2);
+        await Assert.That(factory.DeferredLogs["Logger1"].Count).IsEqualTo(2);
+        await Assert.That(factory.DeferredLogs["Logger2"]).HasSingleItem();
     }
 
-    [Theory]
-    [InlineData(LogLevel.Debug, true, true, true, true, true)]
-    [InlineData(LogLevel.Info, false, true, true, true, true)]
-    [InlineData(LogLevel.Warn, false, false, true, true, true)]
-    [InlineData(LogLevel.Error, false, false, false, true, true)]
-    [InlineData(LogLevel.Fatal, false, false, false, false, true)]
-    public void GetLogger_sets_enabled_levels_correctly(
+    [Test]
+    [Arguments(LogLevel.Debug, true, true, true, true, true)]
+    [Arguments(LogLevel.Info, false, true, true, true, true)]
+    [Arguments(LogLevel.Warn, false, false, true, true, true)]
+    [Arguments(LogLevel.Error, false, false, false, true, true)]
+    [Arguments(LogLevel.Fatal, false, false, false, false, true)]
+    public async Task GetLogger_sets_enabled_levels_correctly(
         LogLevel configuredLevel,
         bool expectedDebug,
         bool expectedInfo,
@@ -99,24 +100,24 @@ public void GetLogger_sets_enabled_levels_correctly(
 
         var log = factory.GetLogger("TestLogger");
 
-        Assert.Equal(expectedDebug, log.IsDebugEnabled);
-        Assert.Equal(expectedInfo, log.IsInfoEnabled);
-        Assert.Equal(expectedWarn, log.IsWarnEnabled);
-        Assert.Equal(expectedError, log.IsErrorEnabled);
-        Assert.Equal(expectedFatal, log.IsFatalEnabled);
+        await Assert.That(log.IsDebugEnabled).IsEqualTo(expectedDebug);
+        await Assert.That(log.IsInfoEnabled).IsEqualTo(expectedInfo);
+        await Assert.That(log.IsWarnEnabled).IsEqualTo(expectedWarn);
+        await Assert.That(log.IsErrorEnabled).IsEqualTo(expectedError);
+        await Assert.That(log.IsFatalEnabled).IsEqualTo(expectedFatal);
     }
 
-    [Fact]
-    public void Logger_writes_through_factory()
+    [Test]
+    public async Task Logger_writes_through_factory()
     {
         var factory = new TestDeferredLoggerFactory(LogLevel.Debug);
         var logger = factory.GetLogger("TestLogger");
 
         logger.Info("test info message");
         logger.Error("test error message");
 
-        Assert.Single(factory.DeferredLogs);
-        Assert.Equal(2, factory.DeferredLogs["TestLogger"].Count);
+        await Assert.That(factory.DeferredLogs).HasSingleItem();
+        await Assert.That(factory.DeferredLogs["TestLogger"].Count).IsEqualTo(2);
     }
 }
 
@@ -214,4 +215,4 @@ public void Fatal(string? message, Exception? exception) =>
 
     public void FatalFormat(string format, params object?[] args) =>
         factory.Write(name, LogLevel.Fatal, string.Format(format, args));
-}
+}

src/Tests/IntegrationTests.cs

@@ -2,10 +2,11 @@
 using Microsoft.Extensions.Hosting;
 using NServiceBus.Logging;
 using Microsoft.Extensions.Logging;
+using System.Threading.Tasks;
 
 public class IntegrationTests
 {
-    [Fact]
+    [Test]
     public async Task Ensure_log_messages_are_redirected()
     {
         var msLoggerFactory = new LoggerFactory();
@@ -26,15 +27,15 @@ public async Task Ensure_log_messages_are_redirected()
         };
         await endpoint.SendLocal(message, cancellationToken: cancel);
         await Task.Delay(500, cancel);
-        Assert.NotEmpty(LogMessageCapture.LoggingEvents);
+        await Assert.That(LogMessageCapture.LoggingEvents).IsNotEmpty();
         await endpoint.Stop(cancel);
     }
 
-    [Fact]
+    [Test]
     public Task Ensure_log_messages_are_redirected_in_Hosting_deferred() =>
         RunWithHost(true);
 
-    [Fact]
+    [Test]
     public Task Ensure_log_messages_are_redirected_in_Hosting_not_deferred() =>
         RunWithHost(false);
 
@@ -74,7 +75,7 @@ static async Task RunWithHost(bool deferLogging)
         await messageSession.SendLocal(message);
         await Task.Delay(500);
 
-        Assert.NotEmpty(LogMessageCapture.LoggingEvents);
+        await Assert.That(LogMessageCapture.LoggingEvents).IsNotEmpty();
         await host.StopAsync();
     }
 

src/Tests/LoggerFactoryTests.cs

@@ -1,12 +1,13 @@
 using NServiceBus.Logging;
+using System.Threading.Tasks;
 
 /// <summary>
 /// Tests for the LoggerFactory class through the public MicrosoftLogFactory API.
 /// </summary>
 public class LoggerFactoryTests
 {
-    [Fact]
-    public void GetLogger_with_type_returns_ILog_implementation()
+    [Test]
+    public async Task GetLogger_with_type_returns_ILog_implementation()
     {
         var mockFactory = new MockMsLoggerFactory();
         var factory = new MicrosoftLogFactory();
@@ -16,12 +17,12 @@ public void GetLogger_with_type_returns_ILog_implementation()
         var loggerFactory = GetLoggingFactory(factory);
         var log = loggerFactory.GetLogger(typeof(LoggerFactoryTests));
 
-        Assert.NotNull(log);
-        Assert.IsAssignableFrom<ILog>(log);
+        await Assert.That(log).IsNotNull();
+        await Assert.That(log).IsAssignableTo<ILog>();
     }
 
-    [Fact]
-    public void GetLogger_with_string_returns_ILog_implementation()
+    [Test]
+    public async Task GetLogger_with_string_returns_ILog_implementation()
     {
         var mockFactory = new MockMsLoggerFactory();
         var factory = new MicrosoftLogFactory();
@@ -30,12 +31,12 @@ public void GetLogger_with_string_returns_ILog_implementation()
         var loggerFactory = GetLoggingFactory(factory);
         var log = loggerFactory.GetLogger("MyCustomLogger");
 
-        Assert.NotNull(log);
-        Assert.IsAssignableFrom<ILog>(log);
+        await Assert.That(log).IsNotNull();
+        await Assert.That(log).IsAssignableTo<ILog>();
     }
 
-    [Fact]
-    public void GetLogger_with_type_creates_logger_with_type_name()
+    [Test]
+    public async Task GetLogger_with_type_creates_logger_with_type_name()
     {
         var mockFactory = new MockMsLoggerFactory();
         var factory = new MicrosoftLogFactory();
@@ -44,12 +45,12 @@ public void GetLogger_with_type_creates_logger_with_type_name()
         var loggerFactory = GetLoggingFactory(factory);
         loggerFactory.GetLogger(typeof(LoggerFactoryTests));
 
-        Assert.Single(mockFactory.Loggers);
-        Assert.True(mockFactory.Loggers.ContainsKey(typeof(LoggerFactoryTests).FullName!));
+        await Assert.That(mockFactory.Loggers).HasSingleItem();
+        await Assert.That(mockFactory.Loggers.ContainsKey(typeof(LoggerFactoryTests).FullName!)).IsTrue();
     }
 
-    [Fact]
-    public void GetLogger_with_string_creates_logger_with_given_name()
+    [Test]
+    public async Task GetLogger_with_string_creates_logger_with_given_name()
     {
         var mockFactory = new MockMsLoggerFactory();
         var factory = new MicrosoftLogFactory();
@@ -58,12 +59,12 @@ public void GetLogger_with_string_creates_logger_with_given_name()
         var loggerFactory = GetLoggingFactory(factory);
         loggerFactory.GetLogger("MyCustomLogger");
 
-        Assert.Single(mockFactory.Loggers);
-        Assert.True(mockFactory.Loggers.ContainsKey("MyCustomLogger"));
+        await Assert.That(mockFactory.Loggers).HasSingleItem();
+        await Assert.That(mockFactory.Loggers.ContainsKey("MyCustomLogger")).IsTrue();
     }
 
-    [Fact]
-    public void GetLogger_with_type_logs_to_correct_logger()
+    [Test]
+    public async Task GetLogger_with_type_logs_to_correct_logger()
     {
         var mockFactory = new MockMsLoggerFactory();
         var factory = new MicrosoftLogFactory();
@@ -74,12 +75,12 @@ public void GetLogger_with_type_logs_to_correct_logger()
         log.Info("test message");
 
         var mockLogger = mockFactory.Loggers[typeof(LoggerFactoryTests).FullName!];
-        Assert.Single(mockLogger.LogEntries);
-        Assert.Equal("test message", mockLogger.LogEntries[0].Message);
+        await Assert.That(mockLogger.LogEntries).HasSingleItem();
+        await Assert.That(mockLogger.LogEntries[0].Message).IsEqualTo("test message");
     }
 
-    [Fact]
-    public void GetLogger_with_string_logs_to_correct_logger()
+    [Test]
+    public async Task GetLogger_with_string_logs_to_correct_logger()
     {
         var mockFactory = new MockMsLoggerFactory();
         var factory = new MicrosoftLogFactory();
@@ -90,12 +91,12 @@ public void GetLogger_with_string_logs_to_correct_logger()
         log.Warn("warning message");
 
         var mockLogger = mockFactory.Loggers["CustomLogger"];
-        Assert.Single(mockLogger.LogEntries);
-        Assert.Equal("warning message", mockLogger.LogEntries[0].Message);
+        await Assert.That(mockLogger.LogEntries).HasSingleItem();
+        await Assert.That(mockLogger.LogEntries[0].Message).IsEqualTo("warning message");
     }
 
-    [Fact]
-    public void GetLogger_called_multiple_times_with_same_type_returns_separate_wrapper_instances()
+    [Test]
+    public async Task GetLogger_called_multiple_times_with_same_type_returns_separate_wrapper_instances()
     {
         var mockFactory = new MockMsLoggerFactory();
         var factory = new MicrosoftLogFactory();
@@ -105,11 +106,11 @@ public void GetLogger_called_multiple_times_with_same_type_returns_separate_wrap
         var log1 = loggerFactory.GetLogger(typeof(LoggerFactoryTests));
         var log2 = loggerFactory.GetLogger(typeof(LoggerFactoryTests));
 
-        Assert.NotSame(log1, log2);
+        await Assert.That(log2).IsNotSameReferenceAs(log1);
     }
 
-    [Fact]
-    public void GetLogger_called_multiple_times_with_different_types_creates_different_loggers()
+    [Test]
+    public async Task GetLogger_called_multiple_times_with_different_types_creates_different_loggers()
     {
         var mockFactory = new MockMsLoggerFactory();
         var factory = new MicrosoftLogFactory();
@@ -119,7 +120,7 @@ public void GetLogger_called_multiple_times_with_different_types_creates_differe
         loggerFactory.GetLogger(typeof(LoggerFactoryTests));
         loggerFactory.GetLogger(typeof(string));
 
-        Assert.Equal(2, mockFactory.Loggers.Count);
+        await Assert.That(mockFactory.Loggers.Count).IsEqualTo(2);
     }
 
     // Helper to invoke protected GetLoggingFactory method
@@ -137,4 +138,4 @@ static ILoggerFactory GetLoggingFactory(MicrosoftLogFactory factory)
             throw exception.InnerException!;
         }
     }
-}
+}