chore: Added first tests

dailydevops · May 19, 2024 · 5b6ece0 · 5b6ece0
1 parent 77e3c5a
commit 5b6ece0
Show file tree

Hide file tree

Showing 11 changed files with 127 additions and 128 deletions.
diff --git a/src/NetEvolve.Logging.XUnit/LoggedMessage.cs b/src/NetEvolve.Logging.XUnit/LoggedMessage.cs
diff --git a/src/NetEvolve.Logging.XUnit/NetEvolve.Logging.XUnit.csproj b/src/NetEvolve.Logging.XUnit/NetEvolve.Logging.XUnit.csproj
@@ -10,8 +10,8 @@
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Logging.Configuration" />
     <PackageReference Include="NetEvolve.Arguments" />
+    <PackageReference Include="NetEvolve.Logging.Abstractions" />
     <PackageReference Include="xunit.extensibility.core" />
-    <PackageReference Include="xunit.extensibility.execution" />
   </ItemGroup>
 
 </Project>
diff --git a/src/NetEvolve.Logging.XUnit/XUnitLogger.cs b/src/NetEvolve.Logging.XUnit/XUnitLogger.cs
@@ -4,10 +4,10 @@
 using System.Globalization;
 using System.Text;
 using Microsoft.Extensions.Logging;
+using NetEvolve.Logging.Abstractions;
 using Xunit.Abstractions;
-using Xunit.Sdk;
 
-public class XUnitLogger : ILogger
+public class XUnitLogger : ILogger, ISupportExternalScope
 {
     private readonly string? _categoryName;
     private readonly XUnitLoggerOptions _options;
@@ -20,9 +20,9 @@ public class XUnitLogger : ILogger
     [ThreadStatic]
     private static StringBuilder? _builder;
 
-    public IReadOnlyList<LoggedMessage> LoggedMessages => _loggedMessages.AsReadOnly();
+    public IExternalScopeProvider ScopeProvider { get; private set; }
 
-    internal IExternalScopeProvider? ScopeProvider { get; set; }
+    public IReadOnlyList<LoggedMessage> LoggedMessages => _loggedMessages.AsReadOnly();
 
     public static XUnitLogger CreateLogger(
         ITestOutputHelper testOutputHelper,
@@ -40,40 +40,24 @@ public static XUnitLogger<T> CreateLogger<T>(
     internal XUnitLogger(
         ITestOutputHelper testOutputHelper,
         IExternalScopeProvider? scopeProvider,
-        string? categoryName,
+        string? name,
         XUnitLoggerOptions? options
     )
     {
         ArgumentNullException.ThrowIfNull(testOutputHelper);
+        ArgumentNullException.ThrowIfNull(name);
 
         _writeToLogger = testOutputHelper.WriteLine;
-        ScopeProvider = scopeProvider;
-        _categoryName = categoryName;
-        _options = options ?? XUnitLoggerOptions.Default;
-
-        _loggedMessages = [];
-    }
-
-    internal XUnitLogger(
-        IMessageSink messageSink,
-        IExternalScopeProvider? scopeProvider,
-        string? categoryName,
-        XUnitLoggerOptions? options
-    )
-    {
-        ArgumentNullException.ThrowIfNull(messageSink);
-
-        _writeToLogger = message => messageSink.OnMessage(new DiagnosticMessage(message));
-        ScopeProvider = scopeProvider;
-        _categoryName = categoryName;
+        ScopeProvider = scopeProvider ?? NullExternalScopeProvider.Instance;
+        _categoryName = name;
         _options = options ?? XUnitLoggerOptions.Default;
 
         _loggedMessages = [];
     }
 
     /// <inheritdoc cref="ILogger.BeginScope{TState}(TState)"/>
     public IDisposable? BeginScope<TState>(TState state)
-        where TState : notnull => ScopeProvider?.Push(state);
+        where TState : notnull => ScopeProvider.Push(state);
 
     /// <inheritdoc cref="ILogger.IsEnabled(LogLevel)"/>
     public bool IsEnabled(LogLevel logLevel) => logLevel != LogLevel.None;
@@ -170,7 +154,7 @@ DateTimeOffset now
             }
         }
 
-        ScopeProvider?.ForEachScope(
+        ScopeProvider.ForEachScope(
             (scope, state) =>
             {
                 scopes.Add(scope);
@@ -230,4 +214,12 @@ private static string LogLevelToString(LogLevel logLevel) =>
             LogLevel.None => "NONE",
             _ => throw new ArgumentOutOfRangeException(nameof(logLevel))
         };
+
+    /// <inheritdoc/>
+    public void SetScopeProvider(IExternalScopeProvider scopeProvider)
+    {
+        ArgumentNullException.ThrowIfNull(scopeProvider);
+
+        ScopeProvider = scopeProvider;
+    }
 }
diff --git a/src/NetEvolve.Logging.XUnit/XUnitLoggerOfT.cs b/src/NetEvolve.Logging.XUnit/XUnitLoggerOfT.cs
diff --git a/src/NetEvolve.Logging.XUnit/XUnitLoggerProvider.cs b/src/NetEvolve.Logging.XUnit/XUnitLoggerProvider.cs
@@ -2,78 +2,54 @@
 
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Immutable;
 using Microsoft.Extensions.Logging;
 using NetEvolve.Arguments;
+using NetEvolve.Logging.Abstractions;
 using Xunit.Abstractions;
 
 internal sealed class XUnitLoggerProvider : ILoggerProvider, ISupportExternalScope
 {
-    private readonly ITestOutputHelper? _testOutputHelper;
-    private readonly IMessageSink? _messageSink;
-    private readonly IExternalScopeProvider _scopeProvider; // = NullExternalScopeProvider.Instance;
+    private readonly ITestOutputHelper _testOutputHelper;
+    private readonly IExternalScopeProvider _scopeProvider = NullExternalScopeProvider.Instance;
     private readonly XUnitLoggerOptions _options;
     private readonly ConcurrentDictionary<string, XUnitLogger> _loggers;
 
+    internal ImmutableList<XUnitLogger> Loggers => _loggers.Values.ToImmutableList();
+
     public XUnitLoggerProvider(
         ITestOutputHelper testOutputHelper,
         IExternalScopeProvider? scopeProvider = null,
         XUnitLoggerOptions? options = null
     )
-        : this(scopeProvider, options)
     {
         ArgumentNullException.ThrowIfNull(testOutputHelper);
 
-        _testOutputHelper = testOutputHelper;
-    }
-
-    public XUnitLoggerProvider(
-        IMessageSink messageSink,
-        IExternalScopeProvider? scopeProvider = null,
-        XUnitLoggerOptions? options = null
-    )
-        : this(scopeProvider, options)
-    {
-        ArgumentNullException.ThrowIfNull(messageSink);
-
-        _messageSink = messageSink;
-    }
-
-    private XUnitLoggerProvider(
-        IExternalScopeProvider? scopeProvider = null,
-        XUnitLoggerOptions? options = null
-    )
-    {
         _scopeProvider = scopeProvider ?? new LoggerExternalScopeProvider();
         _options = options ?? new XUnitLoggerOptions();
 
         _loggers = new ConcurrentDictionary<string, XUnitLogger>(StringComparer.Ordinal);
+        _testOutputHelper = testOutputHelper;
     }
 
     /// <inheritdoc cref="ILoggerProvider.CreateLogger(string)"/>
     public ILogger CreateLogger(string categoryName)
     {
         Argument.ThrowIfNullOrWhiteSpace(categoryName);
 
-        return _loggers.GetOrAdd(categoryName, CreateLoggerInternal);
+        return _loggers.GetOrAdd(
+            categoryName,
+            name => new XUnitLogger(_testOutputHelper, _scopeProvider, name, _options)
+        );
     }
 
     /// <inheritdoc cref="ILoggerProvider.CreateLogger(string)"/>
     public ILogger CreateLogger<T>()
-        where T : notnull => _loggers.GetOrAdd(typeof(T).FullName!, CreateLoggerInternal);
-
-    private XUnitLogger CreateLoggerInternal(string name)
-    {
-        if (_testOutputHelper is not null)
-        {
-            return new XUnitLogger(_testOutputHelper, _scopeProvider, name, _options);
-        }
-        else if (_messageSink is not null)
-        {
-            return new XUnitLogger(_messageSink, _scopeProvider, name, _options);
-        }
-
-        throw new InvalidOperationException("No output destination was provided.");
-    }
+        where T : notnull =>
+        _loggers.GetOrAdd(
+            typeof(T).FullName!,
+            _ => new XUnitLogger<T>(_testOutputHelper, _scopeProvider, _options)
+        );
 
     /// <inheritdoc cref="ISupportExternalScope.SetScopeProvider(IExternalScopeProvider)"/>
     public void SetScopeProvider(IExternalScopeProvider scopeProvider)
@@ -87,7 +63,7 @@ public void SetScopeProvider(IExternalScopeProvider scopeProvider)
 
         foreach (var logger in _loggers.Values)
         {
-            logger.ScopeProvider = scopeProvider;
+            logger.SetScopeProvider(scopeProvider);
         }
     }
 

diff --git a/src/NetEvolve.Logging.XUnit/XUnitLogger`T.cs b/src/NetEvolve.Logging.XUnit/XUnitLogger`T.cs
@@ -11,11 +11,4 @@ internal XUnitLogger(
         XUnitLoggerOptions? options
     )
         : base(testOutputHelper, scopeProvider, typeof(T).FullName, options) { }
-
-    internal XUnitLogger(
-        IMessageSink messageSink,
-        IExternalScopeProvider? scopeProvider,
-        XUnitLoggerOptions? options
-    )
-        : base(messageSink, scopeProvider, typeof(T).FullName, options) { }
 }
diff --git a/tests/NetEvolve.Logging.XUnit.Tests.Integration/GlobalUsings.cs b/tests/NetEvolve.Logging.XUnit.Tests.Integration/GlobalUsings.cs
diff --git a/tests/NetEvolve.Logging.XUnit.Tests.Integration/UnitTest1.cs b/tests/NetEvolve.Logging.XUnit.Tests.Integration/UnitTest1.cs
@@ -1,4 +1,6 @@
-namespace NetEvolve.Logging.XUnit.Tests.Integration;
+namespace NetEvolve.Logging.XUnit.Tests.Integration;
+
+using Xunit;
 
 public class UnitTest1
 {

diff --git a/tests/NetEvolve.Logging.XUnit.Tests.Unit/GlobalUsings.cs b/tests/NetEvolve.Logging.XUnit.Tests.Unit/GlobalUsings.cs
diff --git a/tests/NetEvolve.Logging.XUnit.Tests.Unit/UnitTest1.cs b/tests/NetEvolve.Logging.XUnit.Tests.Unit/UnitTest1.cs
diff --git a/tests/NetEvolve.Logging.XUnit.Tests.Unit/XUnitLoggerProviderTests.cs b/tests/NetEvolve.Logging.XUnit.Tests.Unit/XUnitLoggerProviderTests.cs
@@ -0,0 +1,88 @@
+namespace NetEvolve.Logging.XUnit.Tests.Unit;
+
+using System;
+using Microsoft.Extensions.Logging;
+using NetEvolve.Logging.Abstractions;
+using Xunit;
+using Xunit.Abstractions;
+
+public class XUnitLoggerProviderTests
+{
+    private readonly ITestOutputHelper _testOutputHelper;
+
+    public XUnitLoggerProviderTests(ITestOutputHelper testOutputHelper) =>
+        _testOutputHelper = testOutputHelper;
+
+    [Fact]
+    public void CreateLogger_WithTestOutputHelper()
+    {
+        // Arrange
+        using var provider = new XUnitLoggerProvider(_testOutputHelper);
+
+        // Act
+        var logger = provider.CreateLogger(nameof(XUnitLoggerProviderTests));
+
+        // Assert
+        Assert.NotNull(logger);
+        _ = Assert.IsType<XUnitLogger>(logger);
+    }
+
+    [Fact]
+    public void CreateLoggerGeneric_WithTestOutputHelper()
+    {
+        // Arrange
+        using var provider = new XUnitLoggerProvider(_testOutputHelper);
+
+        // Act
+        var logger = provider.CreateLogger<XUnitLoggerProviderTests>();
+
+        // Assert
+        Assert.NotNull(logger);
+        _ = Assert.IsType<XUnitLogger<XUnitLoggerProviderTests>>(logger);
+    }
+
+    [Fact]
+    public void SetScopeProvider_Null_ThrowArgumentNullException()
+    {
+        // Arrange
+        using var provider = new XUnitLoggerProvider(_testOutputHelper);
+
+        // Act
+        void Act() => provider.SetScopeProvider(null!);
+
+        // Assert
+        _ = Assert.Throws<ArgumentNullException>("scopeProvider", Act);
+    }
+
+    [Fact]
+    public void SetScopeProvider_WithNullScopeProvider_NoExceptionThrown()
+    {
+        // Arrange
+        using var provider = new XUnitLoggerProvider(_testOutputHelper);
+
+        // Act
+        var ex = Record.Exception(
+            () => provider.SetScopeProvider(NullExternalScopeProvider.Instance)
+        );
+
+        // Assert
+        Assert.Null(ex);
+    }
+
+    [Fact]
+    public void SetScopeProvider_WithScopeProvider_Expected()
+    {
+        // Arrange
+        using var provider = new XUnitLoggerProvider(_testOutputHelper);
+        var scopeProvider = new LoggerExternalScopeProvider();
+
+        // Act
+        provider.SetScopeProvider(scopeProvider);
+
+        // Assert
+        foreach (var logger in provider.Loggers)
+        {
+            Assert.Same(scopeProvider, logger.ScopeProvider);
+        }
+    }
+}