Fixes issue with wildcards used in string interpolations

or other methods calls

Author: adrianiftode

src/Moq.ILogger/VerifyLogExtensions.cs

@@ -617,7 +617,7 @@ Expression<Func<object, Type, bool>> CreateCompareLambdaFrom(Expression methodCa
                 var verifyLogConstantExpression = Expression.Constant(verifyLogExpression, typeof(VerifyLogExpression));
 
                 var compareMessagesCallExpression = Expression.Call(typeof(VerifyLogExtensions), nameof(CompareMessages), null,
-                    vParamToStringExpression, verifyLogConstantExpression, methodCallExpression);
+                    methodCallExpression, verifyLogConstantExpression, vParamToStringExpression);
                 compareExpression = Expression.Lambda<Func<object, Type, bool>>(compareMessagesCallExpression, vParam, tParam);
                 return compareExpression;
             }

tests/Moq.ILogger.Tests/Samples/SomeClassTests.cs

@@ -16,6 +16,9 @@ public void LoggingInformation()
         public void LoggingWarning(string name)
             => _logger.LogWarning(new ArgumentException("The given name is not ok", nameof(name)), "This operation failed, but let's log an warning only");
 
+        public void LoggingError(string name)
+            => _logger.LogError(new ArgumentException("The given name is not ok", nameof(name)), $"This operation failed for name {name}");
+
         public void SemanticLogging()
         {
             var position = new { Latitude = 25, Longitude = 134 };
@@ -45,7 +48,7 @@ public void Verify_log_information_with_a_message()
             sut.LoggingInformation();
 
             loggerMock.VerifyLog(logger => logger.LogInformation("This operation is successful."));
-            loggerMock.VerifyLog(logger => logger.LogInformation((EventId)0,"This operation is successful."));
+            loggerMock.VerifyLog(logger => logger.LogInformation((EventId)0, "This operation is successful."));
             loggerMock.VerifyLog(logger => logger.LogInformation("This * is successful."));
             loggerMock.VerifyLog(logger => logger.LogInformation(It.Is<string>(msg => msg.Length > 5)));
             loggerMock.VerifyLog(logger => logger.LogInformation(It.IsAny<string>()));
@@ -70,6 +73,18 @@ public void Verify_errors()
             loggerMock.VerifyLog(logger => logger.LogWarning(It.IsAny<EventId>(), new ArgumentException("The given name is not ok", "name"), "*failed*"));
         }
 
+        [Fact]
+        public void Verify_exceptions_logged_as_errors()
+        {
+            var name = "Adrian";
+            var loggerMock = new Mock<ILogger<SomeClass>>();
+            var sut = new SomeClass(loggerMock.Object);
+
+            sut.LoggingError(name);
+
+            loggerMock.VerifyLog(logger => logger.LogError(It.Is<ArgumentException>(ex => ex.ParamName == "name"), $"*{name}*"));
+        }
+
         [Fact]
         public void Verify_semantic_logging()
         {

tests/Moq.ILogger.Tests/VerifyLogExtensionsTests.cs

@@ -299,6 +299,32 @@ public void Verify_a_structured_message_using_wildcards_with_parameters_names_an
                 .WithMessage("*.LogInformation*");
         }
 
+        [Fact]
+        public void Verify_a_message_using_wildcards_with_interpolated_message_it_verifies()
+        {
+            var loggerMock = new Mock<ILogger<object>>();
+            var interpolatedMessageArg = "Arg";
+            loggerMock.Object.LogInformation($"Test message {interpolatedMessageArg}");
+
+            Action act = () => loggerMock.VerifyLog(c => c.LogInformation($"*{interpolatedMessageArg}*"));
+
+            act.Should().NotThrow();
+        }
+
+        [Fact]
+        public void Verify_a_message_using_wildcards_with_interpolated_message_it_throws()
+        {
+            var loggerMock = new Mock<ILogger<object>>();
+            var interpolatedMessageArg1 = "Arg 1";
+            var interpolatedMessageArg2 = "Arg 2";
+            loggerMock.Object.LogInformation($"Test message {interpolatedMessageArg1}");
+
+            Action act = () => loggerMock.VerifyLog(c => c.LogInformation($"*{interpolatedMessageArg2}*"));
+
+            act.Should().ThrowExactly<VerifyLogException>()
+                .WithMessage("*.LogInformation*");
+        }
+
         [Fact]
         public void Verify_a_structured_message_when_parameters_differ_it_throws()
         {
@@ -390,10 +416,36 @@ public void Verify_a_message_with_a_different_one_from_a_method_call_it_throws()
 
             act.Should().ThrowExactly<VerifyLogException>()
                 .WithMessage("*.LogInformation(VerifyLogExtensionsTests.GetNotAMessage(), new[] {  })*")
-                .Which.InnerException!.Message.Should().Match("*logger => logger.Log<It.IsAnyType>(LogLevel.Information, It.IsAny<EventId>(), It.Is<It.IsAnyType>((v, t) => VerifyLogExtensions.CompareMessages(v.ToString(), VerifyLogExpression, \"Not a test message\")), It.IsAny<Exception>(), (Func<It.IsAnyType, Exception, string>)It.IsAny<object>())*");
+                .Which.InnerException!.Message.Should().Match("*logger => logger.Log<It.IsAnyType>(LogLevel.Information, It.IsAny<EventId>(), It.Is<It.IsAnyType>((v, t) => VerifyLogExtensions.CompareMessages(\"Not a test message\", VerifyLogExpression, v.ToString())), It.IsAny<Exception>(), (Func<It.IsAnyType, Exception, string>)It.IsAny<object>())*");
         }
         string GetNotAMessage() => "Not a test message";
 
+        [Fact]
+        public void Verify_a_wildcard_message_with_method_call_it_verifies()
+        {
+            var loggerMock = new Mock<ILogger<object>>();
+            loggerMock.Object.LogInformation("Test message");
+
+            Action act = () => loggerMock.VerifyLog(c => c.LogInformation(GetWildcardMessage()));
+
+            act.Should().NotThrow();
+        }
+        string GetWildcardMessage() => "*message*";
+
+        [Fact]
+        public void Verify_a_wildcard_message_with_a_different_one_from_a_method_call_it_throws()
+        {
+            var loggerMock = new Mock<ILogger<object>>();
+            loggerMock.Object.LogInformation("Test message");
+
+            Action act = () => loggerMock.VerifyLog(c => c.LogInformation(GetWildcardNotAMessage()));
+
+            act.Should().ThrowExactly<VerifyLogException>()
+                .WithMessage("*.LogInformation(VerifyLogExtensionsTests.GetWildcardNotAMessage(), new[] {  })*")
+                .Which.InnerException!.Message.Should().Match("*logger => logger.Log<It.IsAnyType>(LogLevel.Information, It.IsAny<EventId>(), It.Is<It.IsAnyType>((v, t) => VerifyLogExtensions.CompareMessages(\"*no match*\", VerifyLogExpression, v.ToString())), It.IsAny<Exception>(), (Func<It.IsAnyType, Exception, string>)It.IsAny<object>())*");
+        }
+        string GetWildcardNotAMessage() => "*no match*";
+
         [Fact]
         public void Verify_a_message_one_constructed_call_it_throws()
         {
@@ -404,7 +456,7 @@ public void Verify_a_message_one_constructed_call_it_throws()
 
             act.Should().ThrowExactly<VerifyLogException>()
                 .WithMessage("*.LogInformation(new string(new[] { a }), new[] {  })*")
-                .Which.InnerException!.Message.Should().Match("*logger => logger.Log<It.IsAnyType>(LogLevel.Information, It.IsAny<EventId>(), It.Is<It.IsAnyType>((v, t) => VerifyLogExtensions.CompareMessages(v.ToString(), VerifyLogExpression, \"a\")), It.IsAny<Exception>(), (Func<It.IsAnyType, Exception, string>)It.IsAny<object>())*");
+                .Which.InnerException!.Message.Should().Match("*logger => logger.Log<It.IsAnyType>(LogLevel.Information, It.IsAny<EventId>(), It.Is<It.IsAnyType>((v, t) => VerifyLogExtensions.CompareMessages(\"a\", VerifyLogExpression, v.ToString())), It.IsAny<Exception>(), (Func<It.IsAnyType, Exception, string>)It.IsAny<object>())*");
         }
 
         [Fact]