Remove dependency to FluentAssertions.

Author: GillesTourreau

README.md

@@ -270,7 +270,7 @@ logger.SetupSequence()
 ```
 
 > Here we use the FluentAssertions library to check the arguments values of the log message template, but of course you can use your
-favorite assertion framework to check it.
+favorite assertion library to check it.
 
 The second way allows also to check the arguments of the log template message by there index (*it is not what I recommand,
 because if the trainee developper in your team change the name of the arguments name in the log message template, you will not
@@ -476,13 +476,3 @@ Both usage offers the same fluent assertion methods.
 and the version 2.0.0 of the [Microsoft.Extensions.Logging.Abstractions](https://www.nuget.org/packages/Microsoft.Extensions.Logging.Abstractions) NuGet package. So this library can be used with
 different .NET architecture projects (.NET Framework, .NET Core, Xamarin,...) and also with old versions of the
 [Microsoft.Extensions.Logging.Abstractions](https://www.nuget.org/packages/Microsoft.Extensions.Logging.Abstractions) NuGet package.
-
-- The [PosInformatique.Logging.Assertions](https://www.nuget.org/packages/PosInformatique.Logging.Assertions/) library
-depends of the [FluentAssertions](https://github.com/fluentassertions/fluentassertions) library
-for internal assertions which is more pretty to read in the exceptions message. It is use the version 6.0.0 and of course it is compatible
-with the earlier version of it.
-
-- Also, the [PosInformatique.Logging.Assertions](https://www.nuget.org/packages/PosInformatique.Logging.Assertions/) library
-use the internal [FluentAssertions](https://github.com/fluentassertions/fluentassertions) unit test
-provider engine detection to throw an exception (when an assertion is false) depending of the engine used to execute
-the unit test. For example, `XunitException` if the unit test engine used is `Xunit`.

src/Logging.Assertions/AssertionHelper.cs

@@ -0,0 +1,81 @@
+//-----------------------------------------------------------------------
+// <copyright file="AssertionHelper.cs" company="P.O.S Informatique">
+//     Copyright (c) P.O.S Informatique. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace PosInformatique.Logging.Assertions
+{
+    internal static class AssertionHelper
+    {
+        public static string ToString(object? @object)
+        {
+            if (@object is null)
+            {
+                return "null";
+            }
+
+            return @object.ToString();
+        }
+
+        public static void BeEquivalentTo(object actual, object expected)
+        {
+            if (!Equals(actual, expected))
+            {
+                throw new LoggingAssertionFailedException($"Expected value: {ToString(expected)}{Environment.NewLine}Actual value: {ToString(actual)}");
+            }
+        }
+
+        public static void BeEquivalentTo(IDictionary<string, object> actual, IDictionary<string, object> expected)
+        {
+            if (actual.Count != expected.Count)
+            {
+                if (expected.Count > actual.Count)
+                {
+                    var missingKeys = new List<string>();
+
+                    foreach (var expectedKey in expected.Keys)
+                    {
+                        if (!actual.ContainsKey(expectedKey))
+                        {
+                            missingKeys.Add(expectedKey);
+                        }
+                    }
+
+                    var missingKeysList = string.Join(", ", missingKeys.Select(k => "\"" + k + "\""));
+
+                    throw new LoggingAssertionFailedException($"Expected state to be a dictionary with {expected.Count} item(s), but it misses key(s) {{{missingKeysList}}}");
+                }
+                else
+                {
+                    var additionalKeys = new List<string>();
+
+                    foreach (var actualKey in actual.Keys)
+                    {
+                        if (!expected.ContainsKey(actualKey))
+                        {
+                            additionalKeys.Add(actualKey);
+                        }
+                    }
+
+                    var additionalKeysList = string.Join(", ", additionalKeys.Select(k => "\"" + k + "\""));
+
+                    throw new LoggingAssertionFailedException($"Expected state to be a dictionary with {expected.Count} item(s), but has additional key(s) {{{additionalKeysList}}}");
+                }
+            }
+        }
+
+        public static void BeSameAs(Exception actual, Exception expected)
+        {
+            if (actual.GetType() != expected.GetType())
+            {
+                throw new LoggingAssertionFailedException($"Expected exception to refer to {expected.GetType().FullName} with message \"{expected.Message}\", but found {actual.GetType().FullName} with message \"{actual.Message}\".");
+            }
+
+            if (!actual.Message.Equals(expected.Message, StringComparison.InvariantCulture))
+            {
+                throw new LoggingAssertionFailedException($"Expected exception to refer to {expected.GetType().FullName} with message \"{expected.Message}\", but found {actual.GetType().FullName} with message \"{actual.Message}\".");
+            }
+        }
+    }
+}

src/Logging.Assertions/ILoggerMockSetupSequenceError.cs

@@ -6,7 +6,6 @@
 
 namespace PosInformatique.Logging.Assertions
 {
-    using FluentAssertions;
     using Microsoft.Extensions.Logging;
 
     /// <summary>

src/Logging.Assertions/LoggerMock.cs

@@ -7,8 +7,6 @@
 namespace PosInformatique.Logging.Assertions
 {
     using System.Globalization;
-    using FluentAssertions;
-    using FluentAssertions.Common;
     using Microsoft.Extensions.Logging;
 
     /// <summary>
@@ -64,7 +62,7 @@ public void VerifyLogs()
                 var missingCalls = this.expectedLogActions.Skip(this.expectedLogActionsIndex).Select(m => "- " + m.ExceptionDisplayMessage);
                 var missingCallsString = string.Join(Environment.NewLine, missingCalls);
 
-                Services.ThrowException($"Logger has been called few times (Expected: {this.expectedLogActions.Count} calls, Actual: {this.expectedLogActionsIndex} calls).{Environment.NewLine}{missingCallsString}");
+                throw new LoggingAssertionFailedException($"Logger has been called few times (Expected: {this.expectedLogActions.Count} calls, Actual: {this.expectedLogActionsIndex} calls).{Environment.NewLine}{missingCallsString}");
             }
         }
 
@@ -177,14 +175,14 @@ private TLogAction GetCurrentExpectedLogAction<TLogAction>(string methodCall)
             {
                 if (this.mock.expectedLogActionsIndex >= this.mock.expectedLogActions.Count)
                 {
-                    Services.ThrowException($"The ILogger has been called too many times (Expected: {this.mock.expectedLogActions.Count} calls)");
+                    throw new LoggingAssertionFailedException($"The ILogger has been called too many times (Expected: {this.mock.expectedLogActions.Count} calls)");
                 }
 
                 var expectedLogAction = this.mock.expectedLogActions[this.mock.expectedLogActionsIndex];
 
                 if (expectedLogAction is not TLogAction expectedLogActionTyped)
                 {
-                    Services.ThrowException($"The '{methodCall}' method has been called but expected other action (Expected: {expectedLogAction.Name})");
+                    throw new LoggingAssertionFailedException($"The '{methodCall}' method has been called but expected other action (Expected: {expectedLogAction.Name})");
                     throw new NotImplementedException("Must not be called.");
                 }
 
@@ -248,7 +246,7 @@ public void Assert<TState>(LogLevel logLevel, TState state, Exception? exception
             {
                 if (logLevel != this.logLevel)
                 {
-                    Services.ThrowException($"Wrong log level for the Log() method call. (Expected: {this.logLevel}, Actual: {logLevel})");
+                    throw new LoggingAssertionFailedException($"Wrong log level for the Log() method call. (Expected: {this.logLevel}, Actual: {logLevel})");
                 }
 
                 if (this.arguments != null)
@@ -259,12 +257,12 @@ public void Assert<TState>(LogLevel logLevel, TState state, Exception? exception
 
                     if (originalMessage != this.message)
                     {
-                        Services.ThrowException($"Wrong log message for the Log({logLevel}) method call. (Expected: '{this.message}', Actual: '{originalMessage}')");
+                        throw new LoggingAssertionFailedException($"Wrong log message for the Log({logLevel}) method call. (Expected: '{this.message}', Actual: '{originalMessage}')");
                     }
 
                     if (stateAsList.Count - 1 != this.arguments.Count)
                     {
-                        Services.ThrowException($"Incorrect template message argument count for the '{originalMessage}' template message. (Expected: '{this.arguments.Count}', Actual: '{stateAsList.Count - 1}')");
+                        throw new LoggingAssertionFailedException($"Incorrect template message argument count for the '{originalMessage}' template message. (Expected: '{this.arguments.Count}', Actual: '{stateAsList.Count - 1}')");
                     }
 
                     var messageArguments = new LogMessageTemplateArguments(
@@ -278,15 +276,15 @@ public void Assert<TState>(LogLevel logLevel, TState state, Exception? exception
 
                     if (message != this.message)
                     {
-                        Services.ThrowException($"Wrong log message for the Log({logLevel}) method call. (Expected: '{this.message}', Actual: '{message}')");
+                        throw new LoggingAssertionFailedException($"Wrong log message for the Log({logLevel}) method call. (Expected: '{this.message}', Actual: '{message}')");
                     }
                 }
 
                 if (this.exception != null)
                 {
                     if (exception is null)
                     {
-                        Services.ThrowException($"Expected an exception but no exeception has been thrown.");
+                        throw new LoggingAssertionFailedException($"Expected an exception but no exeception has been thrown.");
                     }
                     else
                     {
@@ -327,7 +325,7 @@ public override void Assert<TState>(TState state)
                 }
                 else
                 {
-                    Services.ThrowException($"The 'BeginScope()' has been called with a wrong state argument type (Expected: {typeof(TExpectedState).Name}, Actual: {typeof(TState).Name}).");
+                    throw new LoggingAssertionFailedException($"The 'BeginScope()' has been called with a wrong state argument type (Expected: {typeof(TExpectedState).Name}, Actual: {typeof(TState).Name}).");
                 }
             }
         }
@@ -381,7 +379,7 @@ public void Assert(LogLevel logLevel)
             {
                 if (this.expectedLogLevel != logLevel)
                 {
-                    Services.ThrowException($"The 'IsEnabled()' has been called with a wrong log level (Expected: {this.expectedLogLevel}, Actual: {logLevel}).");
+                    throw new LoggingAssertionFailedException($"The 'IsEnabled()' has been called with a wrong log level (Expected: {this.expectedLogLevel}, Actual: {logLevel}).");
                 }
             }
         }

src/Logging.Assertions/LoggerMockSetupSequenceExtensions.cs

@@ -7,7 +7,6 @@
 namespace PosInformatique.Logging.Assertions
 {
     using System.Collections.Generic;
-    using FluentAssertions;
     using Microsoft.Extensions.Logging;
 
     /// <summary>
@@ -24,7 +23,7 @@ public static class LoggerMockSetupSequenceExtensions
         /// <returns>The current <see cref="ILoggerMockSetupSequence"/> which allows to continue the setup of the <see cref="ILogger"/> method calls.</returns>
         public static ILoggerMockSetupSequence BeginScope(this ILoggerMockSetupSequence sequence, object state)
         {
-            return sequence.BeginScope<object>(expectedState => state.Should().BeEquivalentTo(expectedState));
+            return sequence.BeginScope<object>(expectedState => AssertionHelper.BeEquivalentTo(ToDictionary(state), ToDictionary(expectedState)));
         }
 
         /// <summary>
@@ -39,17 +38,7 @@ public static ILoggerMockSetupSequence BeginScope(this ILoggerMockSetupSequence
         /// <returns>The current <see cref="ILoggerMockSetupSequence"/> which allows to continue the setup of the <see cref="ILogger"/> method calls.</returns>
         public static ILoggerMockSetupSequence BeginScopeAsDictionary(this ILoggerMockSetupSequence sequence, object state)
         {
-            return sequence.BeginScope<IDictionary<string, object>>(expectedState =>
-            {
-                var actualState = new Dictionary<string, object>();
-
-                foreach (var property in state.GetType().GetProperties())
-                {
-                    actualState.Add(property.Name, property.GetValue(state));
-                }
-
-                actualState.Should().BeEquivalentTo(expectedState);
-            });
+            return sequence.BeginScope<IDictionary<string, object>>(expectedState => AssertionHelper.BeEquivalentTo(ToDictionary(state), expectedState));
         }
 
         /// <summary>
@@ -108,7 +97,7 @@ public static ILoggerMockSetupSequenceLog LogWarning(this ILoggerMockSetupSequen
         /// <returns>An instance of <see cref="ILoggerMockSetupSequence"/> which allows to continue the setup of the method calls.</returns>
         public static ILoggerMockSetupSequenceLog WithException(this ILoggerMockSetupSequenceError sequence, Exception expectedException)
         {
-            return sequence.WithException(actualException => actualException.Should().BeSameAs(expectedException));
+            return sequence.WithException(actualException => AssertionHelper.BeSameAs(actualException, expectedException));
         }
 
         /// <summary>
@@ -123,9 +112,25 @@ public static ILoggerMockSetupSequence WithArguments(this ILoggerMockSetupSequen
             {
                 for (int i = 0; i < expectedArguments.Length; i++)
                 {
-                    actualArguments[i].Should().Be(expectedArguments[i]);
+                    if (!Equals(actualArguments[i], expectedArguments[i]))
+                    {
+                        throw new LoggingAssertionFailedException(
+                            $"Log message arguments at the index {i} is different.{Environment.NewLine}Expected: {AssertionHelper.ToString(expectedArguments[i])}{Environment.NewLine}Actual: {AssertionHelper.ToString(actualArguments[i])}");
+                    }
                 }
             });
         }
+
+        private static IDictionary<string, object> ToDictionary(object @object)
+        {
+            var dictionary = new Dictionary<string, object>();
+
+            foreach (var property in @object.GetType().GetProperties())
+            {
+                dictionary.Add(property.Name, property.GetValue(@object));
+            }
+
+            return dictionary;
+        }
     }
 }

src/Logging.Assertions/Logging.Assertions.csproj

@@ -10,6 +10,9 @@
     <PackageProjectUrl>https://github.com/PosInformatique/PosInformatique.Logging.Assertions</PackageProjectUrl>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageReleaseNotes>
+      1.6.0
+      - Removing dependency to FluentAssertions library.
+
       1.5.1
       - Fix a bug to check the log messages when using message templates assertions.
 
@@ -57,7 +60,6 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="6.0.0" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.0.0" />
   </ItemGroup>
 

src/Logging.Assertions/LoggingAssertionFailedException.cs

@@ -0,0 +1,43 @@
+//-----------------------------------------------------------------------
+// <copyright file="LoggingAssertionFailedException.cs" company="P.O.S Informatique">
+//     Copyright (c) P.O.S Informatique. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace PosInformatique.Logging.Assertions
+{
+    /// <summary>
+    /// Occurs when a logging assertion has been failed.
+    /// </summary>
+    public class LoggingAssertionFailedException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LoggingAssertionFailedException"/> class.
+        /// </summary>
+        public LoggingAssertionFailedException()
+            : base()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LoggingAssertionFailedException"/> class
+        /// with the specified <paramref name="message"/>.
+        /// </summary>
+        /// <param name="message">Message of the exception.</param>
+        public LoggingAssertionFailedException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LoggingAssertionFailedException"/> class
+        /// with the specified <paramref name="message"/> and the <paramref name="innerException"/>.
+        /// </summary>
+        /// <param name="message">Message of the exception.</param>
+        /// <param name="innerException">Inner exception related to the <see cref="LoggingAssertionFailedException"/> to create.</param>
+        public LoggingAssertionFailedException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}