Fix AcceptedAtRouteResultAssertions tests.

Author: faddiv

src/FluentAssertions.AspNetCore.Mvc/AcceptedAtRouteResultAssertions.cs

@@ -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;
         }
@@ -56,17 +57,8 @@ public AcceptedAtRouteResultAssertions WithRouteValue(string key, object expecte
         {
             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;
         }

tests/FluentAssertions.AspNetCore.Mvc.Tests/AcceptedAtRouteResultAssertions_Tests.cs

@@ -8,6 +8,8 @@ namespace FluentAssertions.AspNetCore.Mvc.Tests
 
     public class AcceptedAtRouteResultAssertions_Tests
     {
+        public const string Reason = FailureMessageHelper.Reason;
+        public readonly static object[] ReasonArgs = FailureMessageHelper.ReasonArgs;
         private const string TestValue = "testValue";
 
         [Fact]
@@ -22,21 +24,25 @@ public void WithRouteName_GivenExpectedRouteName_ShouldPass()
         public void WithRouteName_GivenUnexpectedRouteName_ShouldFail()
         {
             var result = new AcceptedAtRouteResult("someOtherRoute", null, null);
-            Action a = () => result.Should().BeAcceptedAtRouteResult().WithRouteName("expectedRoute");
-            var failureMessage = FailureMessageHelper.Format(FailureMessages.CommonFailMessage, "AcceptedAtRouteResult.RouteName", "expectedRoute", "someOtherRoute");
+            var failureMessage = FailureMessageHelper.ExpectedContextToBeXButY(
+                "AcceptedAtRouteResult.RouteName", "expectedRoute", "someOtherRoute");
+
+            Action a = () => result.Should().BeAcceptedAtRouteResult().WithRouteName("expectedRoute", Reason, ReasonArgs);
+
             a.Should().Throw<Exception>().WithMessage(failureMessage);
         }
 
         [Fact]
         public void WithRouteValue_GivenKeyDoesntExist_ShouldFail()
         {
             var expectedKey = "expectedKey";
-            var failureMessage = FailureMessageHelper.Format(FailureMessages.AcceptedAtRouteResult_RouteValues_ContainsKey, expectedKey);
-
             var routeValues = new {myKey = "MyValue"};
             var result = new AcceptedAtRouteResult(string.Empty, routeValues, null);
+            var failureMessage = FailureMessageHelper.ExpectedContextContainValueAtKeyButKeyNotFound(
+                "AcceptedAtRouteResult.RouteValues", "Val", expectedKey);
+
+            Action a = () => result.Should().BeAcceptedAtRouteResult().WithRouteValue(expectedKey, "Val", Reason, ReasonArgs);
 
-            Action a = () => result.Should().BeAcceptedAtRouteResult().WithRouteValue(expectedKey, "");
             a.Should().Throw<Exception>().WithMessage(failureMessage);
         }
 
@@ -48,6 +54,7 @@ public void WithRouteValue_GivenExpectedKeyValuePair_ShouldPass()
             var routeValues = new {expectedKey = expectedValue};
 
             var result = new AcceptedAtRouteResult(string.Empty, routeValues, null);
+
             result.Should().BeAcceptedAtRouteResult().WithRouteValue(expectedKey, expectedValue);
         }
 
@@ -57,42 +64,44 @@ public void HaveValue_GivenUnexpectedKeyValuePair_ShouldFail()
             var expectedKey = "expectedKey";
             var expectedValue = "expectedValue";
             var routeValues = new { expectedKey = "someOtherValue" };
-            var failureMessage = FailureMessageHelper.Format(FailureMessages.AcceptedAtRouteResult_RouteValues_HaveValue, expectedKey, expectedValue, "someOtherValue");
-
+            var failureMessage = FailureMessageHelper.ExpectedAtKeyValueXButFoundY(
+                "AcceptedAtRouteResult.RouteValues", expectedKey, expectedValue, "someOtherValue");
             var result = new AcceptedAtRouteResult(string.Empty, routeValues, null);
-            Action a = () => result.Should().BeAcceptedAtRouteResult().WithRouteValue(expectedKey, expectedValue);
+
+            Action a = () => result.Should().BeAcceptedAtRouteResult().WithRouteValue(expectedKey, expectedValue, Reason, ReasonArgs);
+
             a.Should().Throw<Exception>().WithMessage(failureMessage);
         }
 
         [Fact]
         public void ValueAs_GivenExpectedValue_ShouldPass()
         {
             var result = new TestController().AcceptedAtRoute(string.Empty, null, TestValue);
-            result.Should().BeAcceptedAtRouteResult().ValueAs<string>().Should().Be(TestValue);
-        }
 
-        [Fact]
-        public void ValueAs_GivenUnexpectedValue_ShouldFail()
-        {
-            var result = new TestController().AcceptedAtRoute(string.Empty, null, TestValue);
-            Action a = () => result.Should().BeAcceptedAtRouteResult().ValueAs<string>().Should().Be("xyx");
-            a.Should().Throw<Exception>();
+            result.Should().BeAcceptedAtRouteResult().ValueAs<string>().Should().BeSameAs(TestValue);
         }
 
         [Fact]
         public void ValueAs_GivenWrongType_ShouldFail()
         {
             var result = new TestController().AcceptedAtRoute(string.Empty, null, TestValue);
-            Action a = () => result.Should().BeAcceptedAtRouteResult().ValueAs<int>().Should().Be(2);
-            a.Should().Throw<Exception>();
+            var failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundY(
+                "AcceptedAtRouteResult.Value", typeof(int), typeof(string));
+
+            Action a = () => result.Should().BeAcceptedAtRouteResult().ValueAs<int>();
+
+            a.Should().Throw<Exception>().WithMessage(failureMessage);
         }
 
         [Fact]
         public void ValueAs_Null_ShouldFail()
         {
             ActionResult result = new AcceptedAtRouteResult(string.Empty, null, null);
-            var failureMessage = FailureMessageHelper.Format(FailureMessages.CommonNullWasSuppliedFailMessage, "AcceptedAtRouteResult.Value", typeof(object).Name);
+            var failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundNull(
+                "AcceptedAtRouteResult.Value", typeof(object));
+
             Action a = () => result.Should().BeAcceptedAtRouteResult().ValueAs<object>();
+
             a.Should().Throw<Exception>().WithMessage(failureMessage);
         }
     }