Error messages improvements

samples/FluentAssertions.AspNetCore.Mvc.Sample/Controllers/ApiController.cs

@@ -378,7 +378,7 @@ public IActionResult GetPhysicalFile(string physicalPath, string contentType, st
         [HttpGet]
         public IActionResult GetVirtualFileResult(string fileName, string contentType)
         {
-            return new VirtualFileResult(fileName, contentType);
+            return File(fileName, contentType);
         }
 
         [HttpGet]

src/FluentAssertions.AspNetCore.Mvc/AcceptedAtActionResultAssertions.cs

@@ -26,7 +26,7 @@ public AcceptedAtActionResultAssertions(AcceptedAtActionResult subject) : base(s
         /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
         /// </param>
         /// <param name="reasonArgs">
-        /// Zero or more objects to format using the placeholders in <see cref="reason" />.
+        /// Zero or more objects to format using the placeholders in <paramref name="reason"/>.
         /// </param>
         public AcceptedAtActionResultAssertions WithActionName(string expectedActionName, string reason = "", params object[] reasonArgs)
         {
@@ -35,7 +35,8 @@ public AcceptedAtActionResultAssertions WithActionName(string expectedActionName
             Execute.Assertion
                    .ForCondition(string.Equals(actualActionName, expectedActionName, StringComparison.OrdinalIgnoreCase))
                    .BecauseOf(reason, reasonArgs)
-                   .FailWith("Expected AcceptedAtActionResult.ActionName to be {0}{reason} but was {1}", expectedActionName, actualActionName);
+                   .WithDefaultIdentifier("AcceptedAtActionResult.ActionName")
+                   .FailWith(FailureMessages.CommonFailMessage, expectedActionName, actualActionName);
 
             return this;
         }
@@ -45,11 +46,11 @@ public AcceptedAtActionResultAssertions WithActionName(string expectedActionName
         /// </summary>
         /// <param name="expectedControllerName">The expected controller.</param>
         /// <param name="reason">
-        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion 
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
         /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
         /// </param>
         /// <param name="reasonArgs">
-        /// Zero or more objects to format using the placeholders in <see cref="reason" />.
+        /// Zero or more objects to format using the placeholders in <paramref name="reason"/>.
         /// </param>
         public AcceptedAtActionResultAssertions WithControllerName(string expectedControllerName, string reason = "", params object[] reasonArgs)
         {
@@ -58,7 +59,8 @@ public AcceptedAtActionResultAssertions WithControllerName(string expectedContro
             Execute.Assertion
                 .ForCondition(string.Equals(actualControllerName, expectedControllerName, StringComparison.OrdinalIgnoreCase))
                 .BecauseOf(reason, reasonArgs)
-                .FailWith("Expected AcceptedAtActionResult.ControllerName to be {0}{reason} but was {1}", expectedControllerName, actualControllerName);
+                .WithDefaultIdentifier("AcceptedAtActionResult.ControllerName")
+                .FailWith(FailureMessages.CommonFailMessage, expectedControllerName, actualControllerName);
 
             return this;
         }
@@ -69,27 +71,18 @@ public AcceptedAtActionResultAssertions WithControllerName(string expectedContro
         /// <param name="key">The expected key.</param>
         /// <param name="expectedValue">The expected value.</param>
         /// <param name="reason">
-        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion 
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
         /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
         /// </param>
         /// <param name="reasonArgs">
-        /// Zero or more objects to format using the placeholders in <see cref="reason" />.
+        /// Zero or more objects to format using the placeholders in <paramref name="reason"/>.
         /// </param>
         public AcceptedAtActionResultAssertions WithRouteValue(string key, object expectedValue, string reason = "", params object[] reasonArgs)
         {
             var subjectTyped = Subject as AcceptedAtActionResult;
 
-            Execute.Assertion
-                .ForCondition(subjectTyped != null && subjectTyped.RouteValues.ContainsKey(key))
-                .BecauseOf(reason, reasonArgs)
-                .FailWith(FailureMessages.AcceptedAtActionResult_RouteValues_ContainsKey, key);
-
-            var actualValue = subjectTyped.RouteValues[key];
-
-            Execute.Assertion
-                .ForCondition(expectedValue.Equals(actualValue))
-                .BecauseOf(reason, reasonArgs)
-                .FailWith(FailureMessages.AcceptedAtActionResult_RouteValues_HaveValue, key, expectedValue, actualValue);
+            AssertionHelpers.AssertStringObjectDictionary(subjectTyped.RouteValues,
+                "AcceptedAtActionResult.RouteValues", key, expectedValue, reason, reasonArgs);
 
             return this;
         }
@@ -105,11 +98,14 @@ public TValue ValueAs<TValue>()
             var value = subjectTyped.Value;
 
             if (value == null)
-                Execute.Assertion.FailWith(FailureMessages.CommonNullWasSuppliedFailMessage, "AcceptedAtActionResult.Value", typeof(TValue).Name);
+                Execute.Assertion
+                    .WithDefaultIdentifier("AcceptedAtActionResult.Value")
+                    .FailWith(FailureMessages.CommonNullWasSuppliedFailMessage, typeof(TValue));
 
             Execute.Assertion
                 .ForCondition(value is TValue)
-                .FailWith(FailureMessages.CommonTypeFailMessage, "AcceptedAtActionResult.Value", typeof(TValue).Name, value.GetType().Name);
+                .WithDefaultIdentifier("AcceptedAtActionResult.Value")
+                .FailWith(FailureMessages.CommonTypeFailMessage, typeof(TValue), value.GetType());
 
             return (TValue)value;
         }

src/FluentAssertions.AspNetCore.Mvc/AcceptedAtRouteResultAssertions.cs

@@ -26,7 +26,7 @@ public AcceptedAtRouteResultAssertions(AcceptedAtRouteResult subject) : base(sub
         /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
         /// </param>
         /// <param name="reasonArgs">
-        /// Zero or more objects to format using the placeholders in <see cref="reason" />.
+        /// Zero or more objects to format using the placeholders in <paramref name="reason"/>.
         /// </param>
         public AcceptedAtRouteResultAssertions WithRouteName(string expectedRouteName, string reason = "", params object[] reasonArgs)
         {
@@ -35,7 +35,8 @@ public AcceptedAtRouteResultAssertions WithRouteName(string expectedRouteName, s
             Execute.Assertion
                 .BecauseOf(reason, reasonArgs)
                 .ForCondition(string.Equals(expectedRouteName, subjectTyped.RouteName, StringComparison.OrdinalIgnoreCase))
-                .FailWith(FailureMessages.CommonFailMessage, "AcceptedAtRouteResult.RouteName", expectedRouteName, subjectTyped.RouteName);
+                .WithDefaultIdentifier("AcceptedAtRouteResult.RouteName")
+                .FailWith(FailureMessages.CommonFailMessage, expectedRouteName, subjectTyped.RouteName);
 
             return this;
         }
@@ -50,23 +51,14 @@ public AcceptedAtRouteResultAssertions WithRouteName(string expectedRouteName, s
         /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
         /// </param>
         /// <param name="reasonArgs">
-        /// Zero or more objects to format using the placeholders in <see cref="reason" />.
+        /// Zero or more objects to format using the placeholders in <paramref name="reason"/>.
         /// </param>
         public AcceptedAtRouteResultAssertions WithRouteValue(string key, object expectedValue, string reason = "", params object[] reasonArgs)
         {
             var subjectTyped = Subject as AcceptedAtRouteResult;
 
-            Execute.Assertion
-                .ForCondition(subjectTyped != null && subjectTyped.RouteValues.ContainsKey(key))
-                .BecauseOf(reason, reasonArgs)
-                .FailWith(FailureMessages.AcceptedAtRouteResult_RouteValues_ContainsKey, key);
-
-            var actualValue = subjectTyped.RouteValues[key];
-
-            Execute.Assertion
-                .ForCondition(expectedValue.Equals(actualValue))
-                .BecauseOf(reason, reasonArgs)
-                .FailWith(FailureMessages.AcceptedAtRouteResult_RouteValues_HaveValue, key, expectedValue, actualValue);
+            AssertionHelpers.AssertStringObjectDictionary(subjectTyped.RouteValues,
+                "AcceptedAtRouteResult.RouteValues", key, expectedValue, reason, reasonArgs);
 
             return this;
         }
@@ -82,11 +74,14 @@ public TValue ValueAs<TValue>()
             var value = subjectTyped.Value;
 
             if (value == null)
-                Execute.Assertion.FailWith(FailureMessages.CommonNullWasSuppliedFailMessage, "AcceptedAtRouteResult.Value", typeof(TValue).Name);
+                Execute.Assertion
+                    .WithDefaultIdentifier("AcceptedAtRouteResult.Value")
+                    .FailWith(FailureMessages.CommonNullWasSuppliedFailMessage, typeof(TValue));
 
             Execute.Assertion
                 .ForCondition(value is TValue)
-                .FailWith(FailureMessages.CommonTypeFailMessage, "AcceptedAtRouteResult.Value", typeof(TValue).Name, value.GetType().Name);
+                .WithDefaultIdentifier("AcceptedAtRouteResult.Value")
+                .FailWith(FailureMessages.CommonTypeFailMessage, typeof(TValue), value.GetType());
 
             return (TValue)value;
         }

src/FluentAssertions.AspNetCore.Mvc/AcceptedResultAssertions.cs

@@ -50,11 +50,14 @@ public TValue ValueAs<TValue>()
             var value = AcceptedResultSubject.Value;
 
             if (value == null)
-                Execute.Assertion.FailWith(FailureMessages.CommonNullWasSuppliedFailMessage, "AcceptedResultAssertions.Value", typeof(TValue).Name);
+                Execute.Assertion
+                    .WithDefaultIdentifier("AcceptedResultAssertions.Value")
+                    .FailWith(FailureMessages.CommonNullWasSuppliedFailMessage, typeof(TValue));
 
             Execute.Assertion
                 .ForCondition(value is TValue)
-                .FailWith(FailureMessages.CommonTypeFailMessage, "AcceptedResultAssertions.Value", typeof(TValue).Name, value.GetType().Name);
+                .WithDefaultIdentifier("AcceptedResultAssertions.Value")
+                .FailWith(FailureMessages.CommonTypeFailMessage, typeof(TValue), value.GetType());
 
             return (TValue)value;
         }
@@ -65,16 +68,23 @@ public TValue ValueAs<TValue>()
         /// <param name="uri">
         /// The Uri.
         /// </param>
+        /// <param name="reason">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion 
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="reasonArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="reason"/>.
+        /// </param>
         /// <returns>The typed value.</returns>
-        public AcceptedResultAssertions WithUri(Uri uri)
+        public AcceptedResultAssertions WithUri(Uri uri, string reason = "", params object[] reasonArgs)
         {
-            var expectedUri = !uri.IsAbsoluteUri 
-                ? uri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped) 
-                : uri.AbsoluteUri;
+            var expectedUri = AssertionHelpers.GetAbsoluteUri(uri);
 
             Execute.Assertion
+                .BecauseOf(reason, reasonArgs)
                 .ForCondition(expectedUri == Location)
-                .FailWith(FailureMessages.CommonFailMessage, "AcceptedResultAssertions.Uri", expectedUri, Location);
+                .WithDefaultIdentifier("AcceptedResultAssertions.Uri")
+                .FailWith(FailureMessages.CommonFailMessage, expectedUri, Location);
 
             return this;
         }
@@ -85,12 +95,21 @@ public AcceptedResultAssertions WithUri(Uri uri)
         /// <param name="uri">
         /// The Uri as string.
         /// </param>
+        /// <param name="reason">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="reasonArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="reason"/>.
+        /// </param>
         /// <returns>The typed value.</returns>
-        public AcceptedResultAssertions WithUri(string uri)
+        public AcceptedResultAssertions WithUri(string uri, string reason = "", params object[] reasonArgs)
         {
             Execute.Assertion
+                .BecauseOf(reason, reasonArgs)
                 .ForCondition(uri == Location)
-                .FailWith(FailureMessages.CommonFailMessage, "AcceptedResultAssertions.Uri", uri, Location);
+                .WithDefaultIdentifier("AcceptedResultAssertions.Uri")
+                .FailWith(FailureMessages.CommonFailMessage, uri, Location);
 
             return this;
         }