Refactorings and more exception message tests

CaseyBurns · CaseyBurns · commit 63bbee22d198 · 2012-04-24T20:43:09.000+12:00
diff --git a/FluentAssertionsMvc.VisualState.xml b/FluentAssertionsMvc.VisualState.xml
@@ -1,18 +1,18 @@
 <?xml version="1.0" encoding="utf-8"?>
 <VisualState xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" ShowCheckBoxes="false">
   <TopNode>[0-1000]G:\Dev\FluentAssertions.MVC\FluentAssertionsMvc.nunit</TopNode>
-  <SelectedNode>[0-1074]FluentAssertions.Mvc3.Tests.RedirectToRoute_Tests.WithArea_GivenUnexpected_ShouldFail</SelectedNode>
+  <SelectedNode>[0-1065]FluentAssertions.Mvc3.Tests.RedirectResultAssertions_Tests.WithPermanent_GivenUnexpectedUrl_ShouldFail</SelectedNode>
   <ExcludeCategories>false</ExcludeCategories>
   <Nodes>
     <Node UniqueName="[0-1000]G:\Dev\FluentAssertions.MVC\FluentAssertionsMvc.nunit" Expanded="true" />
-    <Node UniqueName="[0-1075]G:\Dev\FluentAssertions.MVC\bin\Debug\Test\FluentAssertions.Mvc3.Tests.dll" Expanded="true" />
-    <Node UniqueName="[0-1076]FluentAssertions" Expanded="true" />
-    <Node UniqueName="[0-1077]FluentAssertions.Mvc3" Expanded="true" />
-    <Node UniqueName="[0-1078]FluentAssertions.Mvc3.Tests" Expanded="true" />
-    <Node UniqueName="[0-1049]FluentAssertions.Mvc3.Tests.ActionResultAssertions_Tests" Expanded="true" />
+    <Node UniqueName="[0-1079]G:\Dev\FluentAssertions.MVC\bin\Debug\Test\FluentAssertions.Mvc3.Tests.dll" Expanded="true" />
+    <Node UniqueName="[0-1080]FluentAssertions" Expanded="true" />
+    <Node UniqueName="[0-1081]FluentAssertions.Mvc3" Expanded="true" />
+    <Node UniqueName="[0-1082]FluentAssertions.Mvc3.Tests" Expanded="true" />
+    <Node UniqueName="[0-1066]FluentAssertions.Mvc3.Tests.ActionResultAssertions_Tests" Expanded="true" />
     <Node UniqueName="[0-1008]FluentAssertions.Mvc3.Tests.ContentResultAssertions_Tests" Expanded="true" />
-    <Node UniqueName="[0-1047]FluentAssertions.Mvc3.Tests.RedirectResultAssertions_Tests" Expanded="true" />
-    <Node UniqueName="[0-1062]FluentAssertions.Mvc3.Tests.RedirectToRoute_Tests" Expanded="true" />
+    <Node UniqueName="[0-1061]FluentAssertions.Mvc3.Tests.RedirectResultAssertions_Tests" Expanded="true" />
+    <Node UniqueName="[0-1048]FluentAssertions.Mvc3.Tests.RedirectToRoute_Tests" Expanded="true" />
     <Node UniqueName="[0-1033]FluentAssertions.Mvc3.Tests.RouteDataAssertions_Tests" Expanded="true" />
     <Node UniqueName="[0-1001]FluentAssertions.Mvc3.Tests.RouteValueDictionary_Extensions_Tests" Expanded="true" />
     <Node UniqueName="[0-1015]FluentAssertions.Mvc3.Tests.ViewResultAssertions_Tests" Expanded="true" />
diff --git a/src/FluentAssertions.Mvc3/ContentResultAssertions.cs b/src/FluentAssertions.Mvc3/ContentResultAssertions.cs
@@ -7,16 +7,15 @@
 
 namespace FluentAssertions.Mvc3
 {
-    public class ContentResultAssertions : ReferenceTypeAssertions<ContentResult, ContentResultAssertions>
+    public class ContentResultAssertions : ObjectAssertions
     {
         class Constants
         {
             public const string CommonFailMessage = "Expect {0} to be '{1}' but was '{2}'";
         }
 
-        public ContentResultAssertions(ContentResult subject)
+        public ContentResultAssertions(ContentResult subject) : base(subject)
         {
-            Subject = subject;
         }
 
         public ContentResultAssertions WithContent(string expectedContent)
@@ -27,10 +26,12 @@ public ContentResultAssertions WithContent(string expectedContent)
 
         public ContentResultAssertions WithContent(string expectedContent, string reason, params object[] reasonArgs)
         {
+            string actualContent = (Subject as ContentResult).Content;
+
             Execute.Verification
-                    .ForCondition(string.Equals(Subject.Content, expectedContent, StringComparison.InvariantCultureIgnoreCase))
+                    .ForCondition(string.Equals(actualContent, expectedContent, StringComparison.InvariantCultureIgnoreCase))
                     .BecauseOf(reason, reasonArgs)
-                    .FailWith(string.Format(Constants.CommonFailMessage, "ContentResult.Content", expectedContent, Subject.Content));
+                    .FailWith(string.Format(Constants.CommonFailMessage, "ContentResult.Content", expectedContent, actualContent));
 
             return this;
         }
@@ -43,10 +44,12 @@ public ContentResultAssertions WithContentType(string expectedContent)
 
         public ContentResultAssertions WithContentType(string expectedContent, string reason, params object[] reasonArgs)
         {
+            string actualContentType = (Subject as ContentResult).ContentType;
+
             Execute.Verification
-                    .ForCondition(string.Equals(expectedContent, Subject.ContentType, StringComparison.InvariantCultureIgnoreCase))
+                    .ForCondition(string.Equals(expectedContent, actualContentType, StringComparison.InvariantCultureIgnoreCase))
                     .BecauseOf(reason, reasonArgs)
-                    .FailWith(Constants.CommonFailMessage, "ContentResult.ContentType", expectedContent, Subject.ContentType);
+                    .FailWith(Constants.CommonFailMessage, "ContentResult.ContentType", expectedContent, actualContentType);
 
             return this;
         }
@@ -59,10 +62,12 @@ public ContentResultAssertions WithContentEncoding(Encoding expectedEncoding)
 
         public ContentResultAssertions WithContentEncoding(Encoding expectedEncoding, string reason, params object[] reasonArgs)
         {
+            Encoding actualContentEncoding = (Subject as ContentResult).ContentEncoding;
+
             Execute.Verification
-                    .ForCondition(expectedEncoding == Subject.ContentEncoding)
+                    .ForCondition(expectedEncoding == actualContentEncoding)
                     .BecauseOf(reason, reasonArgs)
-                    .FailWith(Constants.CommonFailMessage, "ContentResult.ContentType", expectedEncoding.ToString(), Subject.ContentEncoding.ToString());
+                    .FailWith(Constants.CommonFailMessage, "ContentResult.ContentType", expectedEncoding.ToString(), actualContentEncoding.ToString());
 
             return this;
         }
diff --git a/src/FluentAssertions.Mvc3/PartialViewResultAssertions.cs b/src/FluentAssertions.Mvc3/PartialViewResultAssertions.cs
@@ -4,11 +4,12 @@
 using System.Text;
 using System.Web.Mvc;
 using System.Diagnostics;
+using FluentAssertions.Assertions;
 
 namespace FluentAssertions.Mvc3
 {
     [DebuggerNonUserCode]
-    public class PartialViewResultAssertions : ViewResultBaseAssertions<PartialViewResult>
+    public class PartialViewResultAssertions : ObjectAssertions
     {
         public PartialViewResultAssertions(PartialViewResult viewResult) : base(viewResult) { }
     }
diff --git a/src/FluentAssertions.Mvc3/ViewResultAssertions.cs b/src/FluentAssertions.Mvc3/ViewResultAssertions.cs
@@ -18,10 +18,12 @@ public ViewResultAssertions WithMasterName(string expectedMasterName)
 
         public ViewResultAssertions WithMasterName(string expectedMasterName, string reason, params object[] reasonArgs)
         {
+            string actualMasterName = (Subject as ViewResult).MasterName;
+
             Execute.Verification
-                    .ForCondition(string.Equals(expectedMasterName, Subject.MasterName, StringComparison.InvariantCultureIgnoreCase))
+                    .ForCondition(string.Equals(expectedMasterName, actualMasterName, StringComparison.InvariantCultureIgnoreCase))
                     .BecauseOf(reason, reasonArgs)
-                    .FailWith("Expected MasterName to be '{0}' but was '{1}'", expectedMasterName, Subject.MasterName);
+                    .FailWith("Expected MasterName to be '{0}' but was '{1}'", expectedMasterName, actualMasterName);
             return this;
         }
 	}
diff --git a/src/FluentAssertions.Mvc3/ViewResultBaseAssertions.cs b/src/FluentAssertions.Mvc3/ViewResultBaseAssertions.cs
@@ -9,10 +9,10 @@
 namespace FluentAssertions.Mvc3
 {
     [DebuggerNonUserCode]
-    public abstract class ViewResultBaseAssertions<T> : ReferenceTypeAssertions<T, ViewResultBaseAssertions<T>>
+    public abstract class ViewResultBaseAssertions<T> : ObjectAssertions
         where T : ViewResultBase
     {
-        public ViewResultBaseAssertions(ViewResultBase subject)
+        public ViewResultBaseAssertions(ViewResultBase subject) : base(subject)
         {
             Subject = (T)subject;
         }
@@ -25,10 +25,12 @@ public ViewResultBaseAssertions<T> WithViewName(string expectedViewName)
 
         public ViewResultBaseAssertions<T> WithViewName(string expectedViewName, string reason, params object[] reasonArgs)
         {
+            string actualViewName = (Subject as ViewResultBase).ViewName;
+
             Execute.Verification
-                    .ForCondition(string.Equals(expectedViewName, Subject.ViewName, StringComparison.InvariantCultureIgnoreCase))
+                    .ForCondition(string.Equals(expectedViewName, actualViewName, StringComparison.InvariantCultureIgnoreCase))
                     .BecauseOf(reason, reasonArgs)
-                    .FailWith("Expected ViewName to be '{0}' but was '{1}'", expectedViewName, Subject.ViewName);
+                    .FailWith("Expected ViewName to be '{0}' but was '{1}'", expectedViewName, actualViewName);
             return this;
         }
 
@@ -40,12 +42,14 @@ public ViewResultBaseAssertions<T> WithViewData(string key, object expectedValue
 
         public ViewResultBaseAssertions<T> WithViewData(string key, object expectedValue, string reason, params object[] reasonArgs)
         {
+            ViewDataDictionary actualViewData = (Subject as ViewResultBase).ViewData;
+
             Execute.Verification
-                    .ForCondition(Subject.ViewData.ContainsKey(key))
+                    .ForCondition(actualViewData.ContainsKey(key))
                     .BecauseOf(reason, reasonArgs)
                     .FailWith("ViewData does not contain key of '{0}'", key);
 
-            Subject.ViewData[key].Should().Be(expectedValue);
+            actualViewData[key].Should().Be(expectedValue);
 
             return this;
         }
@@ -58,12 +62,14 @@ public ViewResultBaseAssertions<T> WithTempData(string key, object expectedValue
 
         public ViewResultBaseAssertions<T> WithTempData(string key, object expectedValue, string reason, params object[] reasonArgs)
         {
+            TempDataDictionary actualTempData = (Subject as ViewResultBase).TempData;
+
             Execute.Verification
-                    .ForCondition(Subject.TempData.ContainsKey(key))
+                    .ForCondition(actualTempData.ContainsKey(key))
                     .BecauseOf(reason, reasonArgs)
                     .FailWith("TempData does not contain key of '{0}'", key);
 
-            Subject.TempData[key].Should().Be(expectedValue);
+            actualTempData[key].Should().Be(expectedValue);
 
             return this;
         }
@@ -72,17 +78,20 @@ public object Model
         {
             get
             {
-                return Subject.Model;
+                var model = (Subject as ViewResult).Model;
+                return model;
             }
         }
 
         public TModel ModelAs<TModel>()
         {
+            object model = (Subject as ViewResultBase).Model;
+
             Execute.Verification
-                    .ForCondition(Subject.Model is TModel)
-                    .FailWith("Expected Model to be of type '{0}' but was '{1}'", typeof(TModel).Name, Subject.Model.GetType().Name);
+                    .ForCondition(model is TModel)
+                    .FailWith("Expected Model to be of type '{0}' but was '{1}'", typeof(TModel).Name, model.GetType().Name);
 
-            return (TModel)Subject.Model;
+            return (TModel)model;
         }
     }
 }
diff --git a/tests/FluentAssertions.Mvc3.Tests/ContentResultAssertions_Tests.cs b/tests/FluentAssertions.Mvc3.Tests/ContentResultAssertions_Tests.cs
@@ -22,7 +22,8 @@ public void WithContent_GivenUnexpected_ShouldFail()
         {
             ActionResult result = new ContentResult { Content = "content" };
             Action a = () => result.Should().BeContent().WithContent("xyz");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -37,7 +38,8 @@ public void WithContentType_GivenUnexpected_ShouldFail()
         {
             ActionResult result = new ContentResult { ContentType = "text/html" };
             Action a = () => result.Should().BeContent().WithContentType("xyz");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -52,7 +54,8 @@ public void WithContentEncoding_GivenUnexpected_ShouldFail()
         {
             ActionResult result = new ContentResult { ContentEncoding = Encoding.ASCII };
             Action a = () => result.Should().BeContent().WithContentEncoding(Encoding.Unicode);
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
     }
 }
diff --git a/tests/FluentAssertions.Mvc3.Tests/RouteDataAssertions_Tests.cs b/tests/FluentAssertions.Mvc3.Tests/RouteDataAssertions_Tests.cs
@@ -40,7 +40,8 @@ public void HaveValue_GivenKeyDoesExist_ShouldFail()
         {
             var routeData = _routes.GetRouteDataForUrl("/accounts/check");
             Action a = () => routeData.Should().HaveValue("xyz", "");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -55,7 +56,8 @@ public void HaveValue_GivenUnexpectedController_ShouldFail()
         {
             var routeData = _routes.GetRouteDataForUrl("/accounts/check");
             Action a = () => routeData.Should().HaveValue("controller", "xyz");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
         
         [Test]
@@ -77,7 +79,8 @@ public void HaveValue_GivenUnexpectedId_ShouldFail()
         {
             var routeData = _routes.GetRouteDataForUrl("/accounts/check/44");
             Action a = () => routeData.Should().HaveValue("id", "999");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -92,7 +95,8 @@ public void HaveController_GivenUnexpectedValue_ShouldFail()
         {
             var routeData = _routes.GetRouteDataForUrl("/accounts/check/44");
             Action a = () => routeData.Should().HaveController("xyz");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -107,15 +111,17 @@ public void HaveAction_GivenUnexpectedValue_ShouldFail()
         {
             var routeData = _routes.GetRouteDataForUrl("/accounts/check/44");
             Action a = () => routeData.Should().HaveAction("xyz");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
         public void HaveDataToken_GivenKeyDoesExist_ShouldFail()
         {
             var routeData = _routes.GetRouteDataForUrl("/accounts/check");
             Action a = () => routeData.Should().HaveDataToken("xyz", "");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -130,7 +136,8 @@ public void HaveDataToken_GivenUnexpectedArea_ShouldFail()
         {
             var routeData = _routes.GetRouteDataForUrl("/accounts/check");
             Action a = () => routeData.Should().HaveDataToken("area", "xyz");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
     }
 }
diff --git a/tests/FluentAssertions.Mvc3.Tests/ViewResultAssertions_Tests.cs b/tests/FluentAssertions.Mvc3.Tests/ViewResultAssertions_Tests.cs
@@ -34,7 +34,8 @@ public void WithMasterName_GivenUnexpectedValue_ShouldFail()
             };
 
             Action action = () => result.Should().BeView().WithMasterName("xyz");
-            action.ShouldThrow<Exception>();
+            action.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -57,7 +58,8 @@ public void WithViewName_GivenUnexpectedValue_ShouldFail()
             };
 
             Action action = () => result.Should().BeView().WithViewName("xyz");
-            action.ShouldThrow<Exception>();
+            action.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -149,7 +151,8 @@ public void WithViewData_GivenUnexpectedValue_ShouldFail()
             };
 
             Action a = () => result.Should().BeView().WithViewData("key1", "xyz");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -161,7 +164,8 @@ public void WithViewData_GivenUnexpectedKey_ShouldFail()
             };
 
             Action a = () => result.Should().BeView().WithViewData("xyz", "value1");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -184,7 +188,8 @@ public void Model_GivenUnexpectedValue_ShouldFail()
             };
 
             Action a = () => result.Should().BeView().Model.Should().Be("xyx");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -207,7 +212,8 @@ public void ModelAs_GivenUnexpectedValue_ShouldFail()
             };
 
             Action a = () => result.Should().BeView().ModelAs<string>().Should().Be("xyx");
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
 
         [Test]
@@ -219,7 +225,8 @@ public void ModelAs_GivenWrongType_ShouldFail()
             };
 
             Action a = () => result.Should().BeView().ModelAs<int>().Should().Be(2);
-            a.ShouldThrow<Exception>();
+            a.ShouldThrow<Exception>()
+                    .WithMessage("");
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -7,16 +7,15 @@`
`7`	`7`
`8`	`8`	`namespace FluentAssertions.Mvc3`
`9`	`9`	`{`
`10`		`- public class ContentResultAssertions : ReferenceTypeAssertions<ContentResult, ContentResultAssertions>`
	`10`	`+ public class ContentResultAssertions : ObjectAssertions`
`11`	`11`	`{`
`12`	`12`	`class Constants`
`13`	`13`	`{`
`14`	`14`	`public const string CommonFailMessage = "Expect {0} to be '{1}' but was '{2}'";`
`15`	`15`	`}`
`16`	`16`
`17`		`- public ContentResultAssertions(ContentResult subject)`
	`17`	`+ public ContentResultAssertions(ContentResult subject) : base(subject)`
`18`	`18`	`{`
`19`		`- Subject = subject;`
`20`	`19`	`}`
`21`	`20`
`22`	`21`	`public ContentResultAssertions WithContent(string expectedContent)`
`@@ -27,10 +26,12 @@ public ContentResultAssertions WithContent(string expectedContent)`
`27`	`26`
`28`	`27`	`public ContentResultAssertions WithContent(string expectedContent, string reason, params object[] reasonArgs)`
`29`	`28`	`{`
	`29`	`+ string actualContent = (Subject as ContentResult).Content;`
	`30`	`+`
`30`	`31`	`Execute.Verification`
`31`		`- .ForCondition(string.Equals(Subject.Content, expectedContent, StringComparison.InvariantCultureIgnoreCase))`
	`32`	`+ .ForCondition(string.Equals(actualContent, expectedContent, StringComparison.InvariantCultureIgnoreCase))`
`32`	`33`	`.BecauseOf(reason, reasonArgs)`
`33`		`- .FailWith(string.Format(Constants.CommonFailMessage, "ContentResult.Content", expectedContent, Subject.Content));`
	`34`	`+ .FailWith(string.Format(Constants.CommonFailMessage, "ContentResult.Content", expectedContent, actualContent));`
`34`	`35`
`35`	`36`	`return this;`
`36`	`37`	`}`
`@@ -43,10 +44,12 @@ public ContentResultAssertions WithContentType(string expectedContent)`
`43`	`44`
`44`	`45`	`public ContentResultAssertions WithContentType(string expectedContent, string reason, params object[] reasonArgs)`
`45`	`46`	`{`
	`47`	`+ string actualContentType = (Subject as ContentResult).ContentType;`
	`48`	`+`
`46`	`49`	`Execute.Verification`
`47`		`- .ForCondition(string.Equals(expectedContent, Subject.ContentType, StringComparison.InvariantCultureIgnoreCase))`
	`50`	`+ .ForCondition(string.Equals(expectedContent, actualContentType, StringComparison.InvariantCultureIgnoreCase))`
`48`	`51`	`.BecauseOf(reason, reasonArgs)`
`49`		`- .FailWith(Constants.CommonFailMessage, "ContentResult.ContentType", expectedContent, Subject.ContentType);`
	`52`	`+ .FailWith(Constants.CommonFailMessage, "ContentResult.ContentType", expectedContent, actualContentType);`
`50`	`53`
`51`	`54`	`return this;`
`52`	`55`	`}`
`@@ -59,10 +62,12 @@ public ContentResultAssertions WithContentEncoding(Encoding expectedEncoding)`
`59`	`62`
`60`	`63`	`public ContentResultAssertions WithContentEncoding(Encoding expectedEncoding, string reason, params object[] reasonArgs)`
`61`	`64`	`{`
	`65`	`+ Encoding actualContentEncoding = (Subject as ContentResult).ContentEncoding;`
	`66`	`+`
`62`	`67`	`Execute.Verification`
`63`		`- .ForCondition(expectedEncoding == Subject.ContentEncoding)`
	`68`	`+ .ForCondition(expectedEncoding == actualContentEncoding)`
`64`	`69`	`.BecauseOf(reason, reasonArgs)`
`65`		`- .FailWith(Constants.CommonFailMessage, "ContentResult.ContentType", expectedEncoding.ToString(), Subject.ContentEncoding.ToString());`
	`70`	`+ .FailWith(Constants.CommonFailMessage, "ContentResult.ContentType", expectedEncoding.ToString(), actualContentEncoding.ToString());`
`66`	`71`
`67`	`72`	`return this;`
`68`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,12 @@`
`4`	`4`	`using System.Text;`
`5`	`5`	`using System.Web.Mvc;`
`6`	`6`	`using System.Diagnostics;`
	`7`	`+using FluentAssertions.Assertions;`
`7`	`8`
`8`	`9`	`namespace FluentAssertions.Mvc3`
`9`	`10`	`{`
`10`	`11`	`[DebuggerNonUserCode]`
`11`		`- public class PartialViewResultAssertions : ViewResultBaseAssertions<PartialViewResult>`
	`12`	`+ public class PartialViewResultAssertions : ObjectAssertions`
`12`	`13`	`{`
`13`	`14`	`public PartialViewResultAssertions(PartialViewResult viewResult) : base(viewResult) { }`
`14`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,10 +18,12 @@ public ViewResultAssertions WithMasterName(string expectedMasterName)`
`18`	`18`
`19`	`19`	`public ViewResultAssertions WithMasterName(string expectedMasterName, string reason, params object[] reasonArgs)`
`20`	`20`	`{`
	`21`	`+ string actualMasterName = (Subject as ViewResult).MasterName;`
	`22`	`+`
`21`	`23`	`Execute.Verification`
`22`		`- .ForCondition(string.Equals(expectedMasterName, Subject.MasterName, StringComparison.InvariantCultureIgnoreCase))`
	`24`	`+ .ForCondition(string.Equals(expectedMasterName, actualMasterName, StringComparison.InvariantCultureIgnoreCase))`
`23`	`25`	`.BecauseOf(reason, reasonArgs)`
`24`		`- .FailWith("Expected MasterName to be '{0}' but was '{1}'", expectedMasterName, Subject.MasterName);`
	`26`	`+ .FailWith("Expected MasterName to be '{0}' but was '{1}'", expectedMasterName, actualMasterName);`
`25`	`27`	`return this;`
`26`	`28`	`}`
`27`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,10 +9,10 @@`
`9`	`9`	`namespace FluentAssertions.Mvc3`
`10`	`10`	`{`
`11`	`11`	`[DebuggerNonUserCode]`
`12`		`- public abstract class ViewResultBaseAssertions<T> : ReferenceTypeAssertions<T, ViewResultBaseAssertions<T>>`
	`12`	`+ public abstract class ViewResultBaseAssertions<T> : ObjectAssertions`
`13`	`13`	`where T : ViewResultBase`
`14`	`14`	`{`
`15`		`- public ViewResultBaseAssertions(ViewResultBase subject)`
	`15`	`+ public ViewResultBaseAssertions(ViewResultBase subject) : base(subject)`
`16`	`16`	`{`
`17`	`17`	`Subject = (T)subject;`
`18`	`18`	`}`
`@@ -25,10 +25,12 @@ public ViewResultBaseAssertions<T> WithViewName(string expectedViewName)`
`25`	`25`
`26`	`26`	`public ViewResultBaseAssertions<T> WithViewName(string expectedViewName, string reason, params object[] reasonArgs)`
`27`	`27`	`{`
	`28`	`+ string actualViewName = (Subject as ViewResultBase).ViewName;`
	`29`	`+`
`28`	`30`	`Execute.Verification`
`29`		`- .ForCondition(string.Equals(expectedViewName, Subject.ViewName, StringComparison.InvariantCultureIgnoreCase))`
	`31`	`+ .ForCondition(string.Equals(expectedViewName, actualViewName, StringComparison.InvariantCultureIgnoreCase))`
`30`	`32`	`.BecauseOf(reason, reasonArgs)`
`31`		`- .FailWith("Expected ViewName to be '{0}' but was '{1}'", expectedViewName, Subject.ViewName);`
	`33`	`+ .FailWith("Expected ViewName to be '{0}' but was '{1}'", expectedViewName, actualViewName);`
`32`	`34`	`return this;`
`33`	`35`	`}`
`34`	`36`
`@@ -40,12 +42,14 @@ public ViewResultBaseAssertions<T> WithViewData(string key, object expectedValue`
`40`	`42`
`41`	`43`	`public ViewResultBaseAssertions<T> WithViewData(string key, object expectedValue, string reason, params object[] reasonArgs)`
`42`	`44`	`{`
	`45`	`+ ViewDataDictionary actualViewData = (Subject as ViewResultBase).ViewData;`
	`46`	`+`
`43`	`47`	`Execute.Verification`
`44`		`- .ForCondition(Subject.ViewData.ContainsKey(key))`
	`48`	`+ .ForCondition(actualViewData.ContainsKey(key))`
`45`	`49`	`.BecauseOf(reason, reasonArgs)`
`46`	`50`	`.FailWith("ViewData does not contain key of '{0}'", key);`
`47`	`51`
`48`		`- Subject.ViewData[key].Should().Be(expectedValue);`
	`52`	`+ actualViewData[key].Should().Be(expectedValue);`
`49`	`53`
`50`	`54`	`return this;`
`51`	`55`	`}`
`@@ -58,12 +62,14 @@ public ViewResultBaseAssertions<T> WithTempData(string key, object expectedValue`
`58`	`62`
`59`	`63`	`public ViewResultBaseAssertions<T> WithTempData(string key, object expectedValue, string reason, params object[] reasonArgs)`
`60`	`64`	`{`
	`65`	`+ TempDataDictionary actualTempData = (Subject as ViewResultBase).TempData;`
	`66`	`+`
`61`	`67`	`Execute.Verification`
`62`		`- .ForCondition(Subject.TempData.ContainsKey(key))`
	`68`	`+ .ForCondition(actualTempData.ContainsKey(key))`
`63`	`69`	`.BecauseOf(reason, reasonArgs)`
`64`	`70`	`.FailWith("TempData does not contain key of '{0}'", key);`
`65`	`71`
`66`		`- Subject.TempData[key].Should().Be(expectedValue);`
	`72`	`+ actualTempData[key].Should().Be(expectedValue);`
`67`	`73`
`68`	`74`	`return this;`
`69`	`75`	`}`
`@@ -72,17 +78,20 @@ public object Model`
`72`	`78`	`{`
`73`	`79`	`get`
`74`	`80`	`{`
`75`		`- return Subject.Model;`
	`81`	`+ var model = (Subject as ViewResult).Model;`
	`82`	`+ return model;`
`76`	`83`	`}`
`77`	`84`	`}`
`78`	`85`
`79`	`86`	`public TModel ModelAs<TModel>()`
`80`	`87`	`{`
	`88`	`+ object model = (Subject as ViewResultBase).Model;`
	`89`	`+`
`81`	`90`	`Execute.Verification`
`82`		`- .ForCondition(Subject.Model is TModel)`
`83`		`- .FailWith("Expected Model to be of type '{0}' but was '{1}'", typeof(TModel).Name, Subject.Model.GetType().Name);`
	`91`	`+ .ForCondition(model is TModel)`
	`92`	`+ .FailWith("Expected Model to be of type '{0}' but was '{1}'", typeof(TModel).Name, model.GetType().Name);`
`84`	`93`
`85`		`- return (TModel)Subject.Model;`
	`94`	`+ return (TModel)model;`
`86`	`95`	`}`
`87`	`96`	`}`
`88`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,8 @@ public void WithContent_GivenUnexpected_ShouldFail()`
`22`	`22`	`{`
`23`	`23`	`ActionResult result = new ContentResult { Content = "content" };`
`24`	`24`	`Action a = () => result.Should().BeContent().WithContent("xyz");`
`25`		`- a.ShouldThrow<Exception>();`
	`25`	`+ a.ShouldThrow<Exception>()`
	`26`	`+ .WithMessage("");`
`26`	`27`	`}`
`27`	`28`
`28`	`29`	`[Test]`
`@@ -37,7 +38,8 @@ public void WithContentType_GivenUnexpected_ShouldFail()`
`37`	`38`	`{`
`38`	`39`	`ActionResult result = new ContentResult { ContentType = "text/html" };`
`39`	`40`	`Action a = () => result.Should().BeContent().WithContentType("xyz");`
`40`		`- a.ShouldThrow<Exception>();`
	`41`	`+ a.ShouldThrow<Exception>()`
	`42`	`+ .WithMessage("");`
`41`	`43`	`}`
`42`	`44`
`43`	`45`	`[Test]`
`@@ -52,7 +54,8 @@ public void WithContentEncoding_GivenUnexpected_ShouldFail()`
`52`	`54`	`{`
`53`	`55`	`ActionResult result = new ContentResult { ContentEncoding = Encoding.ASCII };`
`54`	`56`	`Action a = () => result.Should().BeContent().WithContentEncoding(Encoding.Unicode);`
`55`		`- a.ShouldThrow<Exception>();`
	`57`	`+ a.ShouldThrow<Exception>()`
	`58`	`+ .WithMessage("");`
`56`	`59`	`}`
`57`	`60`	`}`
`58`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,8 @@ public void HaveValue_GivenKeyDoesExist_ShouldFail()`
`40`	`40`	`{`
`41`	`41`	`var routeData = _routes.GetRouteDataForUrl("/accounts/check");`
`42`	`42`	`Action a = () => routeData.Should().HaveValue("xyz", "");`
`43`		`- a.ShouldThrow<Exception>();`
	`43`	`+ a.ShouldThrow<Exception>()`
	`44`	`+ .WithMessage("");`
`44`	`45`	`}`
`45`	`46`
`46`	`47`	`[Test]`
`@@ -55,7 +56,8 @@ public void HaveValue_GivenUnexpectedController_ShouldFail()`
`55`	`56`	`{`
`56`	`57`	`var routeData = _routes.GetRouteDataForUrl("/accounts/check");`
`57`	`58`	`Action a = () => routeData.Should().HaveValue("controller", "xyz");`
`58`		`- a.ShouldThrow<Exception>();`
	`59`	`+ a.ShouldThrow<Exception>()`
	`60`	`+ .WithMessage("");`
`59`	`61`	`}`
`60`	`62`
`61`	`63`	`[Test]`
`@@ -77,7 +79,8 @@ public void HaveValue_GivenUnexpectedId_ShouldFail()`
`77`	`79`	`{`
`78`	`80`	`var routeData = _routes.GetRouteDataForUrl("/accounts/check/44");`
`79`	`81`	`Action a = () => routeData.Should().HaveValue("id", "999");`
`80`		`- a.ShouldThrow<Exception>();`
	`82`	`+ a.ShouldThrow<Exception>()`
	`83`	`+ .WithMessage("");`
`81`	`84`	`}`
`82`	`85`
`83`	`86`	`[Test]`
`@@ -92,7 +95,8 @@ public void HaveController_GivenUnexpectedValue_ShouldFail()`
`92`	`95`	`{`
`93`	`96`	`var routeData = _routes.GetRouteDataForUrl("/accounts/check/44");`
`94`	`97`	`Action a = () => routeData.Should().HaveController("xyz");`
`95`		`- a.ShouldThrow<Exception>();`
	`98`	`+ a.ShouldThrow<Exception>()`
	`99`	`+ .WithMessage("");`
`96`	`100`	`}`
`97`	`101`
`98`	`102`	`[Test]`
`@@ -107,15 +111,17 @@ public void HaveAction_GivenUnexpectedValue_ShouldFail()`
`107`	`111`	`{`
`108`	`112`	`var routeData = _routes.GetRouteDataForUrl("/accounts/check/44");`
`109`	`113`	`Action a = () => routeData.Should().HaveAction("xyz");`
`110`		`- a.ShouldThrow<Exception>();`
	`114`	`+ a.ShouldThrow<Exception>()`
	`115`	`+ .WithMessage("");`
`111`	`116`	`}`
`112`	`117`
`113`	`118`	`[Test]`
`114`	`119`	`public void HaveDataToken_GivenKeyDoesExist_ShouldFail()`
`115`	`120`	`{`
`116`	`121`	`var routeData = _routes.GetRouteDataForUrl("/accounts/check");`
`117`	`122`	`Action a = () => routeData.Should().HaveDataToken("xyz", "");`
`118`		`- a.ShouldThrow<Exception>();`
	`123`	`+ a.ShouldThrow<Exception>()`
	`124`	`+ .WithMessage("");`
`119`	`125`	`}`
`120`	`126`
`121`	`127`	`[Test]`
`@@ -130,7 +136,8 @@ public void HaveDataToken_GivenUnexpectedArea_ShouldFail()`
`130`	`136`	`{`
`131`	`137`	`var routeData = _routes.GetRouteDataForUrl("/accounts/check");`
`132`	`138`	`Action a = () => routeData.Should().HaveDataToken("area", "xyz");`
`133`		`- a.ShouldThrow<Exception>();`
	`139`	`+ a.ShouldThrow<Exception>()`
	`140`	`+ .WithMessage("");`
`134`	`141`	`}`
`135`	`142`	`}`
`136`	`143`	`}`