Fix RedirectResultAssertions, RedirectToActionResultAssertions, RedirectToRouteAssertions messages.

Author: faddiv

src/FluentAssertions.AspNetCore.Mvc/RedirectResultAssertions.cs

@@ -33,7 +33,8 @@ public RedirectResultAssertions WithUrl(string expectedUrl, string reason = "",
             Execute.Assertion
                    .ForCondition(string.Equals(actualUrl, expectedUrl, StringComparison.OrdinalIgnoreCase))
                    .BecauseOf(reason, reasonArgs)
-                   .FailWith("Expected RedirectResult.Url to be {0}{reason} but was {1}", expectedUrl, actualUrl);
+                   .WithDefaultIdentifier("RedirectResult.Url")
+                   .FailWith(FailureMessages.CommonFailMessage2, expectedUrl, actualUrl);
 
             return this;
         }
@@ -56,7 +57,8 @@ public RedirectResultAssertions WithPermanent(bool expectedPermanent, string rea
             Execute.Assertion
                     .ForCondition(expectedPermanent == actualPermanent)
                     .BecauseOf(reason, reasonArgs)
-                    .FailWith("Expected RedirectResult.Permanent to be {0}{reason} but was {1}", expectedPermanent, actualPermanent);
+                    .WithDefaultIdentifier("RedirectResult.Permanent")
+                    .FailWith(FailureMessages.CommonFailMessage2, expectedPermanent, actualPermanent);
 
             return this;
         }

src/FluentAssertions.AspNetCore.Mvc/RedirectToActionResultAssertions.cs

@@ -33,7 +33,8 @@ public RedirectToActionResultAssertions WithActionName(string expectedActionName
             Execute.Assertion
                    .ForCondition(string.Equals(actualActionName, expectedActionName, StringComparison.OrdinalIgnoreCase))
                    .BecauseOf(reason, reasonArgs)
-                   .FailWith("Expected RedirectToActionResult.ActionName to be {0}{reason} but was {1}", expectedActionName, actualActionName);
+                   .WithDefaultIdentifier("RedirectToActionResult.ActionName")
+                   .FailWith(FailureMessages.CommonFailMessage2, expectedActionName, actualActionName);
 
             return this;
         }
@@ -56,7 +57,8 @@ public RedirectToActionResultAssertions WithControllerName(string expectedContro
             Execute.Assertion
                 .ForCondition(string.Equals(actualControllerName, expectedControllerName, StringComparison.OrdinalIgnoreCase))
                 .BecauseOf(reason, reasonArgs)
-                .FailWith("Expected RedirectToActionResult.ControllerName to be {0}{reason} but was {1}", expectedControllerName, actualControllerName);
+                .WithDefaultIdentifier("RedirectToActionResult.ControllerName")
+                .FailWith(FailureMessages.CommonFailMessage2, expectedControllerName, actualControllerName);
 
             return this;
         }
@@ -79,7 +81,8 @@ public RedirectToActionResultAssertions WithFragment(string expectedFragment, st
             Execute.Assertion
                 .ForCondition(string.Equals(actualFragment, expectedFragment, StringComparison.OrdinalIgnoreCase))
                 .BecauseOf(reason, reasonArgs)
-                .FailWith("Expected RedirectToActionResult.Fragment to be {0}{reason} but was {1}", expectedFragment, actualFragment);
+                .WithDefaultIdentifier("RedirectToActionResult.Fragment")
+                .FailWith(FailureMessages.CommonFailMessage2, expectedFragment, actualFragment);
 
             return this;
         }
@@ -102,7 +105,8 @@ public RedirectToActionResultAssertions WithPermanent(bool expectedPermanent, st
             Execute.Assertion
                     .ForCondition(expectedPermanent == actualPermanent)
                     .BecauseOf(reason, reasonArgs)
-                    .FailWith("Expected RedirectToActionResult.Permanent to be {0}{reason} but was {1}", expectedPermanent, actualPermanent);
+                    .WithDefaultIdentifier("RedirectToActionResult.Permanent")
+                    .FailWith(FailureMessages.CommonFailMessage2, expectedPermanent, actualPermanent);
 
             return this;
         }
@@ -125,7 +129,8 @@ public RedirectToActionResultAssertions WithPreserveMethod(bool expectedPreserve
             Execute.Assertion
                 .ForCondition(expectedPreserveMethod == actualPreserveMethod)
                 .BecauseOf(reason, reasonArgs)
-                .FailWith("Expected RedirectToActionResult.PreserveMethod to be {0}{reason} but was {1}", expectedPreserveMethod, actualPreserveMethod);
+                .WithDefaultIdentifier("RedirectToActionResult.PreserveMethod")
+                .FailWith(FailureMessages.CommonFailMessage2, expectedPreserveMethod, actualPreserveMethod);
 
             return this;
         }
@@ -146,17 +151,7 @@ public RedirectToActionResultAssertions WithRouteValue(string key, object expect
         {
             var subjectTyped = Subject as RedirectToActionResult;
 
-            Execute.Assertion
-                .ForCondition(subjectTyped != null && subjectTyped.RouteValues.ContainsKey(key))
-                .BecauseOf(reason, reasonArgs)
-                .FailWith(FailureMessages.RedirectToActionResult_RouteValues_ContainsKey, key);
-
-            var actualValue = subjectTyped.RouteValues[key];
-
-            Execute.Assertion
-                .ForCondition(expectedValue.Equals(actualValue))
-                .BecauseOf(reason, reasonArgs)
-                .FailWith(FailureMessages.RedirectToActionResult_RouteValues_HaveValue, key, expectedValue, actualValue);
+            AssertionHelpers.AssertStringObjectDictionary(subjectTyped.RouteValues, "RedirectToActionResult.RouteValues", key, expectedValue, reason, reasonArgs);
 
             return this;
         }

src/FluentAssertions.AspNetCore.Mvc/RedirectToRouteAssertions.cs

@@ -50,7 +50,8 @@ public RedirectToRouteAssertions WithPermanent(bool expectedPermanent, string re
             Execute.Assertion
                     .BecauseOf(reason, reasonArgs)
                     .ForCondition(expectedPermanent == Subject.Permanent)
-                    .FailWith("Expected RedirectToRoute.Permanent to be {0}{reason}, but found {1}", expectedPermanent, Subject.Permanent);
+                    .WithDefaultIdentifier("RedirectToRoute.Permanent")
+                    .FailWith(FailureMessages.CommonFailMessage2, expectedPermanent, Subject.Permanent);
             return this;
         }
 
@@ -70,7 +71,8 @@ public RedirectToRouteAssertions WithRouteName(string expectedRouteName, string
             Execute.Assertion
                    .BecauseOf(reason, reasonArgs)
                    .ForCondition(string.Equals(expectedRouteName, Subject.RouteName, StringComparison.OrdinalIgnoreCase))
-                   .FailWith("Expected RedirectToRoute.RouteName to be {0}{reason}, but found {1}", expectedRouteName, Subject.RouteName);
+                   .WithDefaultIdentifier("RedirectToRoute.RouteName")
+                   .FailWith(FailureMessages.CommonFailMessage2, expectedRouteName, Subject.RouteName);
 
             return this;
         }
@@ -90,7 +92,10 @@ public RedirectToRouteAssertions WithRouteName(string expectedRouteName, string
         [CustomAssertion]
         public RedirectToRouteAssertions WithRouteValue(string key, object expectedValue, string reason = "", params object[] reasonArgs)
         {
-            Subject.RouteValues.Should().Contain(new KeyValuePair<string, object>(key, expectedValue), reason, reasonArgs);
+            var routeValues = Subject.RouteValues;
+
+            AssertionHelpers.AssertStringObjectDictionary(routeValues, "RedirectToRouteResult.RouteValues", key, expectedValue, reason, reasonArgs);
+
             return this;
         }
 

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

@@ -1,4 +1,5 @@
-using Microsoft.AspNetCore.Mvc;
+using FluentAssertions.Mvc.Tests.Helpers;
+using Microsoft.AspNetCore.Mvc;
 using System;
 using Xunit;
 
@@ -22,9 +23,9 @@ public void WithUrl_GivenUnexpectedUrl_ShouldFail()
             ActionResult result = new RedirectResult("/abc");
 
             Action a = () => result.Should().BeRedirectResult()
-                .WithUrl("/xyz");
+                .WithUrl("/xyz", "it is {0}", 10);
             a.Should().Throw<Exception>()
-                .WithMessage("Expected RedirectResult.Url to be \"/xyz\" but was \"/abc\"");
+                .WithMessage(FailureMessageHelper.ExpectedContextToBeXButY("RedirectResult.Url", "/xyz", "/abc"));
         }
 
         [Fact]
@@ -42,9 +43,10 @@ public void WithPermanent_GivenUnexpectedUrl_ShouldFail()
             ActionResult result = new RedirectResult("/abc", true);
 
             Action a = () => result.Should().BeRedirectResult()
-                .WithPermanent(false);
+                .WithPermanent(false, "it is {0}", 10);
+
             a.Should().Throw<Exception>()
-                .WithMessage("Expected RedirectResult.Permanent to be False but was True");
+                .WithMessage(FailureMessageHelper.ExpectedContextToBeXButY("RedirectResult.Permanent", false, true));
         }
     }
 }

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

@@ -24,10 +24,10 @@ public void WithActionName_GivenUnexpectedActionName_ShouldFail()
             RedirectToActionResult result = new RedirectToActionResult("someOtherAction", string.Empty, null);
 
             Action a = () => result.Should().BeRedirectToActionResult()
-                .WithActionName("expectedAction");
+                .WithActionName("expectedAction", "it is {0}", 10);
 
             a.Should().Throw<Exception>()
-                .WithMessage("Expected RedirectToActionResult.ActionName to be \"expectedAction\" but was \"someOtherAction\"");
+                .WithMessage(FailureMessageHelper.ExpectedContextToBeXButY("RedirectToActionResult.ActionName", "expectedAction", "someOtherAction"));
         }
 
         [Fact]
@@ -46,10 +46,10 @@ public void WithControllerName_GivenUnexpectedControllerName_ShouldFail()
             RedirectToActionResult result = new RedirectToActionResult(string.Empty, "someOtherController", null);
 
             Action a = () => result.Should().BeRedirectToActionResult()
-                .WithControllerName("expectedController");
+                .WithControllerName("expectedController", "it is {0}", 10);
 
             a.Should().Throw<Exception>()
-                .WithMessage("Expected RedirectToActionResult.ControllerName to be \"expectedController\" but was \"someOtherController\"");
+                .WithMessage(FailureMessageHelper.ExpectedContextToBeXButY("RedirectToActionResult.ControllerName", "expectedController", "someOtherController"));
         }
 
         [Fact]
@@ -68,10 +68,10 @@ public void WithFragment_GivenUnexpectedFragment_ShouldFail()
             RedirectToActionResult result = new RedirectToActionResult(string.Empty, string.Empty, null, false, "someOtherFragment");
 
             Action a = () => result.Should().BeRedirectToActionResult()
-                .WithFragment("expectedFragment");
+                .WithFragment("expectedFragment", "it is {0}", 10);
 
             a.Should().Throw<Exception>()
-                .WithMessage("Expected RedirectToActionResult.Fragment to be \"expectedFragment\" but was \"someOtherFragment\"");
+                .WithMessage(FailureMessageHelper.ExpectedContextToBeXButY("RedirectToActionResult.Fragment", "expectedFragment", "someOtherFragment"));
         }
 
         [Fact]
@@ -89,10 +89,10 @@ public void WithPermanent_GivenUnexpectedValue_ShouldFail()
             RedirectToActionResult result = new RedirectToActionResult(string.Empty, string.Empty, null, true);
 
             Action a = () => result.Should().BeRedirectToActionResult()
-                .WithPermanent(false);
+                .WithPermanent(false, "it is {0}", 10);
 
             a.Should().Throw<Exception>()
-                .WithMessage("Expected RedirectToActionResult.Permanent to be False but was True");
+                .WithMessage(FailureMessageHelper.ExpectedContextToBeXButY("RedirectToActionResult.Permanent", false, true));
         }
 
         [Fact]
@@ -110,22 +110,22 @@ public void WithPreserveMethod_GivenUnexpectedValue_ShouldFail()
             RedirectToActionResult result = new RedirectToActionResult(string.Empty, string.Empty, null, false, true);
 
             Action a = () => result.Should().BeRedirectToActionResult()
-                .WithPreserveMethod(false);
+                .WithPreserveMethod(false, "it is {0}", 10);
 
             a.Should().Throw<Exception>()
-                .WithMessage("Expected RedirectToActionResult.PreserveMethod to be False but was True");
+                .WithMessage(FailureMessageHelper.ExpectedContextToBeXButY("RedirectToActionResult.PreserveMethod", false, true));
         }
 
         [Fact]
         public void WithRouteValue_GivenKeyDoesntExist_ShouldFail()
         {
             var expectedKey = "expectedKey";
-            var failureMessage = FailureMessageHelper.Format(FailureMessages.RedirectToActionResult_RouteValues_ContainsKey, expectedKey);
+            var failureMessage = FailureMessageHelper.ExpectedKeyButNotFound("RedirectToActionResult.RouteValues", expectedKey, "Val");
 
             var routeValues = new {myKey = "MyValue"};
             RedirectToActionResult result = new RedirectToActionResult(string.Empty, string.Empty, routeValues);
 
-            Action a = () => result.Should().BeRedirectToActionResult().WithRouteValue(expectedKey, "");
+            Action a = () => result.Should().BeRedirectToActionResult().WithRouteValue(expectedKey, "Val", "it is {0}", 10);
 
             a.Should().Throw<Exception>()
                 .WithMessage(failureMessage);
@@ -149,10 +149,10 @@ public void HaveValue_GivenUnexpectedKeyValuePair_ShouldFail()
             var expectedKey = "expectedKey";
             var expectedValue = "expectedValue";
             var routeValues = new { expectedKey = "someOtherValue" };
-            var failureMessage = FailureMessageHelper.Format(FailureMessages.RedirectToActionResult_RouteValues_HaveValue, expectedKey, expectedValue, "someOtherValue");
+            var failureMessage = FailureMessageHelper.ExpectedAtKeyValueXButFoundY("RedirectToActionResult.RouteValues", expectedKey, expectedValue, "someOtherValue");
 
             RedirectToActionResult result = new RedirectToActionResult(string.Empty, string.Empty, routeValues);
-            Action a = () => result.Should().BeRedirectToActionResult().WithRouteValue(expectedKey, expectedValue);
+            Action a = () => result.Should().BeRedirectToActionResult().WithRouteValue(expectedKey, expectedValue, "it is {0}", 10);
 
             a.Should().Throw<Exception>()
                 .WithMessage(failureMessage);

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

@@ -1,4 +1,5 @@
-using Microsoft.AspNetCore.Mvc;
+using FluentAssertions.Mvc.Tests.Helpers;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Routing;
 using System;
 using Xunit;
@@ -24,9 +25,9 @@ public void WithPermanent_GivenUnExpected_ShouldFail()
             ActionResult result = new RedirectToRouteResult("", null, true);
             Action a = () => result.Should()
                 .BeRedirectToRouteResult()
-                .WithPermanent(false);
+                .WithPermanent(false, "it is {0}", 10);
             a.Should().Throw<Exception>()
-                .WithMessage("Expected RedirectToRoute.Permanent to be False, but found True");
+                .WithMessage(FailureMessageHelper.ExpectedContextToBeXButY("RedirectToRoute.Permanent", false, true));
         }
 
         [Fact]
@@ -44,9 +45,9 @@ public void WithRouteName_GivenUnExpected_ShouldFail()
             ActionResult result = new RedirectToRouteResult("default", null);
             Action a = () => result.Should()
                 .BeRedirectToRouteResult()
-                .WithRouteName("xyz");
+                .WithRouteName("xyz", "it is {0}", 10);
             a.Should().Throw<Exception>()
-                .WithMessage("Expected RedirectToRoute.RouteName to be \"xyz\", but found \"default\"");
+                .WithMessage(FailureMessageHelper.ExpectedContextToBeXButY("RedirectToRoute.RouteName","xyz", "default"));
         }
 
         [Fact]
@@ -72,10 +73,27 @@ public void WithRouteValue_GivenUnexpected_ShouldFail()
 
             Action a = () => result.Should()
                 .BeRedirectToRouteResult()
-                .WithRouteValue("Id", "11");
+                .WithRouteValue("Id", "11", "it is {0}", 10);
 
             a.Should().Throw<Exception>()
-                .WithMessage("Expected result to contain value \"11\" at key \"Id\", but found \"22\".");
+                .WithMessage(FailureMessageHelper.ExpectedAtKeyValueXButFoundY("RedirectToRouteResult.RouteValues", "Id", "11", "22"));
+        }
+
+        [Fact]
+        public void WithRouteValue_GivenUnexpectedKey_ShouldFail()
+        {
+            ActionResult result = new RedirectToRouteResult("", new RouteValueDictionary(
+                new
+                {
+                    Id = "22"
+                }));
+
+            Action a = () => result.Should()
+                .BeRedirectToRouteResult()
+                .WithRouteValue("xyz", "22", "it is {0}", 10);
+
+            a.Should().Throw<Exception>()
+                .WithMessage(FailureMessageHelper.ExpectedKeyButNotFound("RedirectToRouteResult.RouteValues", "xyz", "22"));
         }
 
         [Fact]
@@ -101,9 +119,9 @@ public void WithController_GivenUnexpected_ShouldFail()
 
             Action a = () => result.Should()
                 .BeRedirectToRouteResult()
-                .WithController("xyz");
+                .WithController("xyz", "it is {0}", 10);
             a.Should().Throw<Exception>()
-                .WithMessage("Expected dictionary to contain value \"xyz\" at key \"Controller\", but found \"home\".");
+                .WithMessage(FailureMessageHelper.ExpectedAtKeyValueXButFoundY("RedirectToRouteResult.RouteValues", "Controller", "xyz", "home"));
         }
 
         [Fact]
@@ -129,10 +147,10 @@ public void WithAction_GivenUnexpected_ShouldFail()
 
             Action a = () => result.Should()
                 .BeRedirectToRouteResult()
-                .WithAction("xyz");
+                .WithAction("xyz", "it is {0}", 10);
 
             a.Should().Throw<Exception>()
-                .WithMessage("Expected dictionary to contain value \"xyz\" at key \"Action\", but found \"index\".");
+                .WithMessage(FailureMessageHelper.ExpectedAtKeyValueXButFoundY("RedirectToRouteResult.RouteValues", "Action", "xyz", "index"));
         }
 
         [Fact]
@@ -158,10 +176,10 @@ public void WithArea_GivenUnexpected_ShouldFail()
 
             Action a = () => result.Should()
                 .BeRedirectToRouteResult()
-                .WithArea("xyz");
+                .WithArea("xyz", "it is {0}", 10);
 
             a.Should().Throw<Exception>()
-                .WithMessage("Expected dictionary to contain value \"xyz\" at key \"Area\", but found \"accounts\".");
+                .WithMessage(FailureMessageHelper.ExpectedAtKeyValueXButFoundY("RedirectToRouteResult.RouteValues", "Area", "xyz", "accounts"));
         }
 
         #endregion Public Methods