Fix AcceptedAtActionResultAssertions tests.

Author: faddiv

src/FluentAssertions.AspNetCore.Mvc/AcceptedAtActionResultAssertions.cs

@@ -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;
         }
@@ -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;
         }
@@ -79,17 +81,8 @@ public AcceptedAtActionResultAssertions WithRouteValue(string key, object expect
         {
             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;
         }

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

@@ -5,53 +5,66 @@
 
 namespace FluentAssertions.AspNetCore.Mvc.Tests
 {
-    
+
     public class AcceptedAtActionResultAssertions_Tests
     {
+        public const string Reason = FailureMessageHelper.Reason;
+        public readonly static object[] ReasonArgs = FailureMessageHelper.ReasonArgs;
         private const string TestValue = "testValue";
 
         [Fact]
         public void WithActionName_GivenExpectedActionName_ShouldPass()
         {
             var expectedActionName = "expectedAction";
             var result = new AcceptedAtActionResult(expectedActionName, string.Empty, null, null);
+
             result.Should().BeAcceptedAtActionResult().WithActionName(expectedActionName);
         }
 
         [Fact]
         public void WithActionName_GivenUnexpectedActionName_ShouldFail()
         {
             var result = new AcceptedAtActionResult("someOtherAction", string.Empty, null, null);
-            Action a = () => result.Should().BeAcceptedAtActionResult().WithActionName("expectedAction");
-            a.Should().Throw<Exception>().WithMessage("Expected AcceptedAtActionResult.ActionName to be \"expectedAction\" but was \"someOtherAction\"");
+            var failureMessage = FailureMessageHelper.ExpectedContextToBeXButY(
+                "AcceptedAtActionResult.ActionName", "expectedAction", "someOtherAction");
+
+            Action a = () => result.Should().BeAcceptedAtActionResult().WithActionName("expectedAction", Reason, ReasonArgs);
+
+            a.Should().Throw<Exception>().WithMessage(failureMessage);
         }
 
         [Fact]
         public void WithControllerName_GivenExpectedControllerName_ShouldPass()
         {
             var expectedControllerName = "expectedController";
             var result = new AcceptedAtActionResult(string.Empty, expectedControllerName, null, null);
+
             result.Should().BeAcceptedAtActionResult().WithControllerName(expectedControllerName);
         }
 
         [Fact]
         public void WithControllerName_GivenUnexpectedControllerName_ShouldFail()
         {
             var result = new AcceptedAtActionResult(string.Empty, "someOtherController", null, null);
-            Action a = () => result.Should().BeAcceptedAtActionResult().WithControllerName("expectedController");
-            a.Should().Throw<Exception>().WithMessage("Expected AcceptedAtActionResult.ControllerName to be \"expectedController\" but was \"someOtherController\"");
+            var failureMessage = FailureMessageHelper.ExpectedContextToBeXButY(
+                "AcceptedAtActionResult.ControllerName", "expectedController", "someOtherController");
+
+            Action a = () => result.Should().BeAcceptedAtActionResult().WithControllerName("expectedController", Reason, ReasonArgs);
+
+            a.Should().Throw<Exception>().WithMessage(failureMessage);
         }
 
         [Fact]
         public void WithRouteValue_GivenKeyDoesntExist_ShouldFail()
         {
             var expectedKey = "expectedKey";
-            var failureMessage = FailureMessageHelper.Format(FailureMessages.AcceptedAtActionResult_RouteValues_ContainsKey, expectedKey);
-
-            var routeValues = new {myKey = "MyValue"};
+            var failureMessage = FailureMessageHelper.ExpectedContextContainValueAtKeyButKeyNotFound
+                ("AcceptedAtActionResult.RouteValues", "MyValue", expectedKey);
+            var routeValues = new { myKey = "MyValue" };
             var result = new AcceptedAtActionResult(string.Empty, string.Empty, routeValues, null);
 
-            Action a = () => result.Should().BeAcceptedAtActionResult().WithRouteValue(expectedKey, "");
+            Action a = () => result.Should().BeAcceptedAtActionResult().WithRouteValue(expectedKey, "MyValue", Reason, ReasonArgs);
+
             a.Should().Throw<Exception>().WithMessage(failureMessage);
         }
 
@@ -60,9 +73,9 @@ public void WithRouteValue_GivenExpectedKeyValuePair_ShouldPass()
         {
             var expectedKey = "expectedKey";
             var expectedValue = "expectedValue";
-            var routeValues = new {expectedKey = expectedValue};
-
+            var routeValues = new { expectedKey = expectedValue };
             var result = new AcceptedAtActionResult(string.Empty, string.Empty, routeValues, null);
+
             result.Should().BeAcceptedAtActionResult().WithRouteValue(expectedKey, expectedValue);
         }
 
@@ -72,42 +85,43 @@ public void HaveValue_GivenUnexpectedKeyValuePair_ShouldFail()
             var expectedKey = "expectedKey";
             var expectedValue = "expectedValue";
             var routeValues = new { expectedKey = "someOtherValue" };
-            var failureMessage = FailureMessageHelper.Format(FailureMessages.AcceptedAtActionResult_RouteValues_HaveValue, expectedKey, expectedValue, "someOtherValue");
-
+            var failureMessage = FailureMessageHelper.ExpectedAtKeyValueXButFoundY(
+                "AcceptedAtActionResult.RouteValues", expectedKey, expectedValue, "someOtherValue");
             var result = new AcceptedAtActionResult(string.Empty, string.Empty, routeValues, null);
-            Action a = () => result.Should().BeAcceptedAtActionResult().WithRouteValue(expectedKey, expectedValue);
+
+            Action a = () => result.Should().BeAcceptedAtActionResult().WithRouteValue(expectedKey, expectedValue, Reason, ReasonArgs);
+
             a.Should().Throw<Exception>().WithMessage(failureMessage);
         }
 
         [Fact]
         public void ValueAs_GivenExpectedValue_ShouldPass()
         {
             var result = new TestController().AcceptedAtAction(string.Empty, string.Empty, null, TestValue);
-            result.Should().BeAcceptedAtActionResult().ValueAs<string>().Should().Be(TestValue);
-        }
-
-        [Fact]
-        public void ValueAs_GivenUnexpectedValue_ShouldFail()
-        {
-            var result = new TestController().AcceptedAtAction(string.Empty, string.Empty, null, TestValue);
-            Action a = () => result.Should().BeAcceptedAtActionResult().ValueAs<string>().Should().Be("xyx");
-            a.Should().Throw<Exception>();
+            result.Should().BeAcceptedAtActionResult().ValueAs<string>().Should().BeSameAs(TestValue);
         }
 
         [Fact]
         public void ValueAs_GivenWrongType_ShouldFail()
         {
             var result = new TestController().AcceptedAtAction(string.Empty, string.Empty, null, TestValue);
-            Action a = () => result.Should().BeAcceptedAtActionResult().ValueAs<int>().Should().Be(2);
+            var failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundY(
+                "AcceptedAtActionResult.Value", typeof(int), typeof(string));
+
+            Action a = () => result.Should().BeAcceptedAtActionResult().ValueAs<int>();
+
             a.Should().Throw<Exception>();
         }
 
         [Fact]
         public void ValueAs_Null_ShouldFail()
         {
             ActionResult result = new AcceptedAtActionResult(string.Empty, string.Empty, null, null);
-            var failureMessage = FailureMessageHelper.Format(FailureMessages.CommonNullWasSuppliedFailMessage, "AcceptedAtActionResult.Value", typeof(object).Name);
+            var failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundNull(
+                "AcceptedAtActionResult.Value", typeof(object));
+
             Action a = () => result.Should().BeAcceptedAtActionResult().ValueAs<object>();
+
             a.Should().Throw<Exception>().WithMessage(failureMessage);
         }
     }