From a8de6cd15d9e7d193b3be8b7a57417f356b9bc04 Mon Sep 17 00:00:00 2001
From: Alex Macocian <amacocian@yahoo.com>
Date: Thu, 22 Aug 2024 13:21:45 +0200
Subject: [PATCH] ScopedLogger with implicit member name Include NetStandard in
 NetCore

---
 .../Extensions/LoggingExtensions.cs           |  17 ++
 .../SystemExtensions.NetCore.csproj           |  17 +-
 .../Logging/CoreScopedLoggerTests.cs          | 260 ++++++++++++++++++
 .../SystemExtensions.NetStandard.Tests.csproj |   6 +-
 4 files changed, 292 insertions(+), 8 deletions(-)
 create mode 100644 SystemExtensions.NetCore/Extensions/LoggingExtensions.cs
 create mode 100644 SystemExtensions.Tests/Logging/CoreScopedLoggerTests.cs

diff --git a/SystemExtensions.NetCore/Extensions/LoggingExtensions.cs b/SystemExtensions.NetCore/Extensions/LoggingExtensions.cs
new file mode 100644
index 0000000..d1ea41f
--- /dev/null
+++ b/SystemExtensions.NetCore/Extensions/LoggingExtensions.cs
@@ -0,0 +1,17 @@
+using Microsoft.Extensions.Logging;
+using System.Logging;
+using System.Runtime.CompilerServices;
+
+namespace System.Extensions.Core;
+public static class LoggingExtensions
+{
+    public static ScopedLogger<T> CreateScopedLogger<T>(this ILogger<T> logger, string flowIdentifier, [CallerMemberName] string? methodName = default)
+    {
+        return ScopedLogger<T>.Create(logger, methodName ?? string.Empty, flowIdentifier);
+    }
+
+    public static ScopedLogger<T> CreateScopedLogger<T>(this ILogger<T> logger, [CallerMemberName] string? methodName = default)
+    {
+        return ScopedLogger<T>.Create(logger, methodName ?? string.Empty, string.Empty);
+    }
+}
diff --git a/SystemExtensions.NetCore/SystemExtensions.NetCore.csproj b/SystemExtensions.NetCore/SystemExtensions.NetCore.csproj
index 0c2a7da..b0f0035 100644
--- a/SystemExtensions.NetCore/SystemExtensions.NetCore.csproj
+++ b/SystemExtensions.NetCore/SystemExtensions.NetCore.csproj
@@ -3,15 +3,15 @@
   <PropertyGroup>
     <TargetFramework>net6.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
-	<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+	  <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <Nullable>enable</Nullable>
     <RootNamespace>System</RootNamespace>
-	<PackageLicenseFile>LICENSE</PackageLicenseFile>
-	<PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
-	<Version>1.0.1</Version>
-	<Authors>Alexandru Macocian</Authors>
-	<RepositoryUrl>https://github.com/AlexMacocian/SystemExtensions</RepositoryUrl>
-	<Description>Extensions for the System namespace</Description>
+	  <PackageLicenseFile>LICENSE</PackageLicenseFile>
+	  <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+	  <Version>1.6.5</Version>
+	  <Authors>Alexandru Macocian</Authors>
+	  <RepositoryUrl>https://github.com/AlexMacocian/SystemExtensions</RepositoryUrl>
+	  <Description>Extensions for the System namespace</Description>
   </PropertyGroup>
 
   <ItemGroup>
@@ -21,4 +21,7 @@
 	</None>
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\SystemExtensions.NetStandard\SystemExtensions.NetStandard.csproj" />
+  </ItemGroup>
 </Project>
diff --git a/SystemExtensions.Tests/Logging/CoreScopedLoggerTests.cs b/SystemExtensions.Tests/Logging/CoreScopedLoggerTests.cs
new file mode 100644
index 0000000..150ef87
--- /dev/null
+++ b/SystemExtensions.Tests/Logging/CoreScopedLoggerTests.cs
@@ -0,0 +1,260 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SystemExtensions.NetStandard.Tests.Logging.Models;
+using System.Extensions.Core;
+using FluentAssertions;
+using System.Linq;
+
+namespace System.Logging.Core.Tests;
+
+[TestClass]
+public class CoreScopedLoggerTests
+{
+    private const string Flow = "Flow";
+    private const string Message = "Some message";
+    private readonly CachingLogger<CoreScopedLoggerTests> cachingLogger = new();
+
+    [TestMethod]
+    public void CreateLogger_CreatesNewLogger()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: Flow);
+        scopedLogger.Should().BeOfType<ScopedLogger<CoreScopedLoggerTests>>();
+    }
+
+    [TestMethod]
+    public void CreateLogger_NullFlow_ReturnsScopedLogger()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: null);
+        scopedLogger.Should().NotBeNull();
+    }
+
+    [TestMethod]
+    public void LogInformation_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: Flow);
+        var expectedMessage = $"[{Flow}] {nameof(this.LogInformation_LogsExpected)}: {Message}";
+
+        scopedLogger.LogInformation(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogInformation_EmptyFlow_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: string.Empty);
+        var expectedMessage = $"{nameof(this.LogInformation_EmptyFlow_LogsExpected)}: {Message}";
+
+        scopedLogger.LogInformation(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogInformation_WhitespaceFlow_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: "  ");
+        var expectedMessage = $"{nameof(this.LogInformation_WhitespaceFlow_LogsExpected)}: {Message}";
+
+        scopedLogger.LogInformation(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogDebug_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: Flow);
+        var expectedMessage = $"[{Flow}] {nameof(this.LogDebug_LogsExpected)}: {Message}";
+
+        scopedLogger.LogDebug(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogDebug_EmptyFlow_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: string.Empty);
+        var expectedMessage = $"{nameof(this.LogDebug_EmptyFlow_LogsExpected)}: {Message}";
+
+        scopedLogger.LogDebug(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogDebug_WhitespaceFlow_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: "  ");
+        var expectedMessage = $"{nameof(this.LogDebug_WhitespaceFlow_LogsExpected)}: {Message}";
+
+        scopedLogger.LogDebug(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogWarning_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: Flow);
+        var expectedMessage = $"[{Flow}] {nameof(this.LogWarning_LogsExpected)}: {Message}";
+
+        scopedLogger.LogWarning(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogWarning_EmptyFlow_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: string.Empty);
+        var expectedMessage = $"{nameof(this.LogWarning_EmptyFlow_LogsExpected)}: {Message}";
+
+        scopedLogger.LogWarning(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogWarning_WhitespaceFlow_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: "  ");
+        var expectedMessage = $"{nameof(this.LogWarning_WhitespaceFlow_LogsExpected)}: {Message}";
+
+        scopedLogger.LogWarning(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogError_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: Flow);
+        var expectedMessage = $"[{Flow}] {nameof(this.LogError_LogsExpected)}: {Message}";
+
+        scopedLogger.LogError(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogError_EmptyFlow_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: string.Empty);
+        var expectedMessage = $"{nameof(this.LogError_EmptyFlow_LogsExpected)}: {Message}";
+
+        scopedLogger.LogError(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogError_WhitespaceFlow_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: "  ");
+        var expectedMessage = $"{nameof(this.LogError_WhitespaceFlow_LogsExpected)}: {Message}";
+
+        scopedLogger.LogError(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogCritical_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: Flow);
+        var expectedMessage = $"[{Flow}] {nameof(this.LogCritical_LogsExpected)}: {Message}";
+
+        scopedLogger.LogCritical(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogCritical_EmptyFlow_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: string.Empty);
+        var expectedMessage = $"{nameof(this.LogCritical_EmptyFlow_LogsExpected)}: {Message}";
+
+        scopedLogger.LogCritical(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogCritical_WhitespaceFlow_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: "  ");
+        var expectedMessage = $"{nameof(this.LogCritical_WhitespaceFlow_LogsExpected)}: {Message}";
+
+        scopedLogger.LogCritical(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogWarning_WithException_LogsExpected()
+    {
+        var exception = new Exception();
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: Flow);
+        var expectedMessage = $"[{Flow}] {nameof(this.LogWarning_WithException_LogsExpected)}: {Message}";
+
+        scopedLogger.LogWarning(exception, Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogError_WithException_LogsExpected()
+    {
+        var exception = new Exception();
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: Flow);
+        var expectedMessage = $"[{Flow}] {nameof(this.LogError_WithException_LogsExpected)}: {Message}";
+
+        scopedLogger.LogError(exception, Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void LogCritical_WithException_LogsExpected()
+    {
+        var exception = new Exception();
+        var scopedLogger = this.cachingLogger.CreateScopedLogger(flowIdentifier: Flow);
+        var expectedMessage = $"[{Flow}] {nameof(this.LogCritical_WithException_LogsExpected)}: {Message}";
+
+        scopedLogger.LogCritical(exception, Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+
+    [TestMethod]
+    public void Log_WithImplicitMethodName_LogsExpected()
+    {
+        var scopedLogger = this.cachingLogger.CreateScopedLogger();
+        var expectedMessage = $"{nameof(this.Log_WithImplicitMethodName_LogsExpected)}: {Message}";
+
+        scopedLogger.LogInformation(Message);
+
+        this.cachingLogger.LogCache.Should().HaveCount(1);
+        this.cachingLogger.LogCache.First().Should().Be(expectedMessage);
+    }
+}
diff --git a/SystemExtensions.Tests/SystemExtensions.NetStandard.Tests.csproj b/SystemExtensions.Tests/SystemExtensions.NetStandard.Tests.csproj
index 77387a8..d87a21f 100644
--- a/SystemExtensions.Tests/SystemExtensions.NetStandard.Tests.csproj
+++ b/SystemExtensions.Tests/SystemExtensions.NetStandard.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net6.0</TargetFramework>
@@ -6,6 +6,10 @@
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <None Remove="Logging\CoreScopedLoggerTests.cs~RF2747aada.TMP" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="FluentAssertions" Version="6.12.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />