Add test project and improve logging error handling

.github/workflows/dotnet-desktop.yml

@@ -28,9 +28,19 @@ jobs:
       - name: Restore dependencies
         run: dotnet restore
 
+      - name: Bump & push tag
+        if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+        uses: mathieudutour/github-tag-action@v6.2
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          tag_prefix: ""
+
       - name: Build
         run: dotnet build --configuration Release --no-restore
 
+      - name: Test
+        run: dotnet test --configuration Release --no-build
+
       - name: Publish Nuget
         shell: pwsh
         run: |

FluentLoggerExtensions.slnx

@@ -1,6 +1,8 @@
 <Solution>
   <Folder Name="/Solution Items/">
     <File Path=".github/workflows/dotnet-desktop.yml" />
+    <File Path="README.md" />
   </Folder>
-  <Project Path="FluentLoggerExtensions.csproj" />
+  <Project Path="src/FluentLoggerExtensions.csproj" />
+  <Project Path="tests/FluentLoggerExtensions.Tests/FluentLoggerExtensions.Tests.csproj" Id="2c496e42-1236-4580-a854-98ce3e6cce11" />
 </Solution>

CallerLogContextExtensions.cs → src/CallerLogContextExtensions.cs

@@ -15,8 +15,22 @@ public static class CallerLogContextExtensions
     /// <param name="args">The arguments for the message.</param>
     public static void LogInformation(this CallerLogContext context, string message, params object?[] args)
     {
-        string? fileName = Path.GetFileName(context.File);
-        context.Logger.LogInformation("[{File}:{Member}:{Line}] " + message, PrependCallerArgs(fileName, context.Member, context.Line, args));
+        string fileName = Path.GetFileName(context.File);
+
+        try
+        {
+            context.Logger.LogInformation(
+                "[{File}:{Member}:{Line}] " + message,
+                PrependCallerArgs(fileName, context.Member, context.Line, args));
+        }
+        catch (Exception ex)
+        {
+            // Fall back to a safe message; don't rethrow
+            context.Logger.LogError(
+                ex,
+                "[{File}:{Member}:{Line}] Logging failed for template. Template={Template}",
+                fileName, context.Member, context.Line, message);
+        }
     }
 
     /// <summary>
@@ -27,8 +41,22 @@ public static void LogInformation(this CallerLogContext context, string message,
     /// <param name="args">The arguments for the message.</param>
     public static void LogError(this CallerLogContext context, string message, params object?[] args)
     {
-        string? fileName = Path.GetFileName(context.File);
-        context.Logger.LogError("[{File}:{Member}:{Line}] " + message, PrependCallerArgs(fileName, context.Member, context.Line, args));
+        string fileName = Path.GetFileName(context.File);
+
+        try
+        {
+            context.Logger.LogError(
+                "[{File}:{Member}:{Line}] " + message,
+                PrependCallerArgs(fileName, context.Member, context.Line, args));
+        }
+        catch (Exception ex)
+        {
+            // Fall back to a safe message; don't rethrow
+            context.Logger.LogError(
+                ex,
+                "[{File}:{Member}:{Line}] Logging failed for template. Template={Template}",
+                fileName, context.Member, context.Line, message);
+        }
     }
 
     /// <summary>
@@ -39,8 +67,22 @@ public static void LogError(this CallerLogContext context, string message, param
     /// <param name="args">The arguments for the message.</param>
     public static void LogDebug(this CallerLogContext context, string message, params object?[] args)
     {
-        string? fileName = Path.GetFileName(context.File);
-        context.Logger.LogDebug("[{File}:{Member}:{Line}] " + message, PrependCallerArgs(fileName, context.Member, context.Line, args));
+        string fileName = Path.GetFileName(context.File);
+
+        try
+        {
+            context.Logger.LogDebug(
+                "[{File}:{Member}:{Line}] " + message,
+                PrependCallerArgs(fileName, context.Member, context.Line, args));
+        }
+        catch (Exception ex)
+        {
+            // Fall back to a safe message; don't rethrow
+            context.Logger.LogDebug(
+                ex,
+                "[{File}:{Member}:{Line}] Logging failed for template. Template={Template}",
+                fileName, context.Member, context.Line, message);
+        }
     }
 
     /// <summary>
@@ -51,8 +93,22 @@ public static void LogDebug(this CallerLogContext context, string message, param
     /// <param name="args">The arguments for the message.</param>
     public static void LogWarning(this CallerLogContext context, string message, params object?[] args)
     {
-        string? fileName = Path.GetFileName(context.File);
-        context.Logger.LogWarning("[{File}:{Member}:{Line}] " + message, PrependCallerArgs(fileName, context.Member, context.Line, args));
+        string fileName = Path.GetFileName(context.File);
+
+        try
+        {
+            context.Logger.LogWarning(
+                "[{File}:{Member}:{Line}] " + message,
+                PrependCallerArgs(fileName, context.Member, context.Line, args));
+        }
+        catch (Exception ex)
+        {
+            // Fall back to a safe message; don't rethrow
+            context.Logger.LogWarning(
+                ex,
+                "[{File}:{Member}:{Line}] Logging failed for template. Template={Template}",
+                fileName, context.Member, context.Line, message);
+        }
     }
 
     /// <summary>

FluentLoggerExtensions.csproj → src/FluentLoggerExtensions.csproj

@@ -13,6 +13,7 @@
 		<PackageLicenseExpression>MIT</PackageLicenseExpression>
 		<IncludeSymbols>true</IncludeSymbols>
 		<SymbolPackageFormat>snupkg</SymbolPackageFormat>
+		<PackageReadmeFile>README.md</PackageReadmeFile>
 	</PropertyGroup>
 
 	<ItemGroup>
@@ -23,4 +24,8 @@
 		</PackageReference>
 	</ItemGroup>
 
+	<ItemGroup>
+		<None Include="..\README.md" Pack="true" PackagePath="\" />
+	</ItemGroup>
+
 </Project>

tests/FluentLoggerExtensions.Tests/CallerLogContextLogDebugTests.cs

@@ -0,0 +1,73 @@
+using FluentLogger;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace FluentLoggerExtensions.Tests;
+
+public class CallerLogContextLogDebugTests
+{
+    [Theory]
+    [InlineData("This is a test log message")]
+    [InlineData("This is another test log message")]
+    [InlineData("This is a really log test message")]
+    public void LogDebug_WithPlainMessage_DoesNotThrow(string message)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogDebug(message);
+        logger.VerifyLogContains(message, LogLevel.Debug);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogDebug_WithInterpolatedString_DoesNotThrow(string id)
+    {
+        Mock<ILogger> logger = new();
+
+        logger.Object.WithCaller().LogDebug($"{id}");
+    }
+
+    [Theory]
+    [InlineData("hello", "there")]
+    public void LogDebug_WithMatchingPlaceholdersAndArguments_DoesNotThrow(string id, string id2)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogDebug("{FirstWord} {SecondWord}", id, id2);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogDebug_WithMissingArguments_DoesNotThrowUntilStateIsEnumerated(string id)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogDebug("{FirstWord} {SecondWord}", id);
+    }
+
+    [Fact]
+    public void Mismatched_placeholders_throw_when_state_is_enumerated()
+    {
+        var logger = new Mock<ILogger>();
+
+        logger
+            .Setup(l => l.Log(
+                It.IsAny<LogLevel>(),
+                It.IsAny<EventId>(),
+                It.IsAny<It.IsAnyType>(),
+                It.IsAny<Exception?>(),
+                (Func<It.IsAnyType, Exception?, string>)It.IsAny<object>()))
+            .Callback(new InvocationAction(invocation =>
+            {
+                // state is argument #2
+                var state = invocation.Arguments[2];
+
+                // This is what Serilog does internally: enumerate structured values
+                foreach (var _ in (IEnumerable<KeyValuePair<string, object?>>)state)
+                {
+                    // enumeration triggers LogValuesFormatter.GetValue(...)
+                }
+            }));
+
+        // 2 placeholders, 1 arg -> will throw once enumerated
+        logger.Object.WithCaller().LogDebug("{FirstWord} {SecondWord}", "hello");
+    }
+
+}

tests/FluentLoggerExtensions.Tests/CallerLogContextLogErrorTests.cs

@@ -0,0 +1,73 @@
+using FluentLogger;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace FluentLoggerExtensions.Tests;
+
+public class CallerLogContextLogErrorTests
+{
+    [Theory]
+    [InlineData("This is a test log message")]
+    [InlineData("This is another test log message")]
+    [InlineData("This is a really log test message")]
+    public void LogError_WithPlainMessage_DoesNotThrow(string message)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogError(message);
+        logger.VerifyLogContains(message, LogLevel.Error);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogError_WithInterpolatedString_DoesNotThrow(string id)
+    {
+        Mock<ILogger> logger = new();
+
+        logger.Object.WithCaller().LogError($"{id}");
+    }
+
+    [Theory]
+    [InlineData("hello", "there")]
+    public void LogError_WithMatchingPlaceholdersAndArguments_DoesNotThrow(string id, string id2)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogError("{FirstWord} {SecondWord}", id, id2);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogError_WithMissingArguments_DoesNotThrowUntilStateIsEnumerated(string id)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogError("{FirstWord} {SecondWord}", id);
+    }
+
+    [Fact]
+    public void Mismatched_placeholders_throw_when_state_is_enumerated()
+    {
+        var logger = new Mock<ILogger>();
+
+        logger
+            .Setup(l => l.Log(
+                It.IsAny<LogLevel>(),
+                It.IsAny<EventId>(),
+                It.IsAny<It.IsAnyType>(),
+                It.IsAny<Exception?>(),
+                (Func<It.IsAnyType, Exception?, string>)It.IsAny<object>()))
+            .Callback(new InvocationAction(invocation =>
+            {
+                // state is argument #2
+                var state = invocation.Arguments[2];
+
+                // This is what Serilog does internally: enumerate structured values
+                foreach (var _ in (IEnumerable<KeyValuePair<string, object?>>)state)
+                {
+                    // enumeration triggers LogValuesFormatter.GetValue(...)
+                }
+            }));
+
+        // 2 placeholders, 1 arg -> will throw once enumerated
+        logger.Object.WithCaller().LogError("{FirstWord} {SecondWord}", "hello");
+    }
+
+}

tests/FluentLoggerExtensions.Tests/CallerLogContextLogInformationTests.cs

@@ -0,0 +1,73 @@
+using FluentLogger;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace FluentLoggerExtensions.Tests;
+
+public class CallerLogContextLogInformationTests
+{
+    [Theory]
+    [InlineData("This is a test log message")]
+    [InlineData("This is another test log message")]
+    [InlineData("This is a really log test message")]
+    public void LogInformation_WithPlainMessage_DoesNotThrow(string message)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogInformation(message);
+        logger.VerifyLogContains(message);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogInformation_WithInterpolatedString_DoesNotThrow(string id)
+    {
+        Mock<ILogger> logger = new();
+
+        logger.Object.WithCaller().LogInformation($"{id}");
+    }
+
+    [Theory]
+    [InlineData("hello", "there")]
+    public void LogInformation_WithMatchingPlaceholdersAndArguments_DoesNotThrow(string id, string id2)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogInformation("{FirstWord} {SecondWord}", id, id2);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogInformation_WithMissingArguments_DoesNotThrowUntilStateIsEnumerated(string id)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogInformation("{FirstWord} {SecondWord}", id);
+    }
+
+    [Fact]
+    public void Mismatched_placeholders_throw_when_state_is_enumerated()
+    {
+        var logger = new Mock<ILogger>();
+
+        logger
+            .Setup(l => l.Log(
+                It.IsAny<LogLevel>(),
+                It.IsAny<EventId>(),
+                It.IsAny<It.IsAnyType>(),
+                It.IsAny<Exception?>(),
+                (Func<It.IsAnyType, Exception?, string>)It.IsAny<object>()))
+            .Callback(new InvocationAction(invocation =>
+            {
+                // state is argument #2
+                var state = invocation.Arguments[2];
+
+                // This is what Serilog does internally: enumerate structured values
+                foreach (var _ in (IEnumerable<KeyValuePair<string, object?>>)state)
+                {
+                    // enumeration triggers LogValuesFormatter.GetValue(...)
+                }
+            }));
+
+        // 2 placeholders, 1 arg -> will throw once enumerated
+        logger.Object.WithCaller().LogInformation("{FirstWord} {SecondWord}", "hello");
+    }
+
+}