Added expected exception messages for all unit tests with expected exceptions

ivaylokenov · ivaylokenov · commit 618192794a79 · 2015-08-23T17:55:08.000+03:00
diff --git a/MyWebApi.Tests/BuildersTests/ActionsTests/ShouldReturnOkResultTests.cs b/MyWebApi.Tests/BuildersTests/ActionsTests/ShouldReturnOkResultTests.cs
@@ -19,7 +19,7 @@ public void ShouldReturnOkResultShouldNotThrowExceptionWithOkResult()
         [Test]
         [ExpectedException(
             typeof(HttpActionResultAssertionException),
-            ExpectedMessage = "When calling BadRequestAction action in WebApiController expected action result to be a OkNegotiatedContentResult<T>, but instead received a BadRequestResult.")]
+            ExpectedMessage = "When calling BadRequestAction action in WebApiController expected action result to be OkNegotiatedContentResult<T>, but instead received BadRequestResult.")]
         public void ShouldReturnOkResultShouldThrowExceptionWithOtherThanOkResult()
         {
             MyWebApi
diff --git a/MyWebApi.Tests/BuildersTests/ActionsTests/ShouldReturnTests.cs b/MyWebApi.Tests/BuildersTests/ActionsTests/ShouldReturnTests.cs
@@ -87,7 +87,7 @@ public void ShouldReturnShouldNotThrowExceptionWithClassGenericDefinitionTypesAn
         [Test]
         [ExpectedException(
             typeof(HttpActionResultAssertionException),
-            ExpectedMessage = "When calling GenericAction action in WebApiController expected action result to be a ResponseModel, but instead received a List<ResponseModel>.")]
+            ExpectedMessage = "When calling GenericAction action in WebApiController expected action result to be ResponseModel, but instead received List<ResponseModel>.")]
         public void ShouldReturnShouldThrowExceptionWithDifferentResult()
         {
             MyWebApi
@@ -99,7 +99,7 @@ public void ShouldReturnShouldThrowExceptionWithDifferentResult()
         [Test]
         [ExpectedException(
             typeof(HttpActionResultAssertionException),
-            ExpectedMessage = "When calling GenericAction action in WebApiController expected action result to be a ResponseModel, but instead received a List<ResponseModel>.")]
+            ExpectedMessage = "When calling GenericAction action in WebApiController expected action result to be ResponseModel, but instead received List<ResponseModel>.")]
         public void ShouldReturnShouldThrowExceptionWithDifferentResultAndTypeOf()
         {
             MyWebApi
@@ -111,7 +111,7 @@ public void ShouldReturnShouldThrowExceptionWithDifferentResultAndTypeOf()
         [Test]
         [ExpectedException(
             typeof(HttpActionResultAssertionException),
-            ExpectedMessage = "When calling GenericAction action in WebApiController expected action result to be a ICollection<Int32>, but instead received a List<ResponseModel>.")]
+            ExpectedMessage = "When calling GenericAction action in WebApiController expected action result to be ICollection<Int32>, but instead received List<ResponseModel>.")]
         public void ShouldReturnShouldThrowExceptionWithDifferentGenericResult()
         {
             MyWebApi
@@ -123,7 +123,7 @@ public void ShouldReturnShouldThrowExceptionWithDifferentGenericResult()
         [Test]
         [ExpectedException(
             typeof(HttpActionResultAssertionException),
-            ExpectedMessage = "When calling GenericAction action in WebApiController expected action result to be a ICollection<Int32>, but instead received a List<ResponseModel>.")]
+            ExpectedMessage = "When calling GenericAction action in WebApiController expected action result to be ICollection<Int32>, but instead received List<ResponseModel>.")]
         public void ShouldReturnShouldThrowExceptionWithDifferentGenericResultAndTypeOf()
         {
             MyWebApi
diff --git a/MyWebApi.Tests/BuildersTests/ResponseModelsTests/ResponseModelErrorDetailsTestBuilderTests.cs b/MyWebApi.Tests/BuildersTests/ResponseModelsTests/ResponseModelErrorDetailsTestBuilderTests.cs
@@ -19,11 +19,18 @@ public void ThatEqualsShouldNotThrowExceptionWhenProvidedMessageIsValid()
                 .ShouldHaveModelStateFor<RequestModel>()
                 .ContainingNoModelStateErrorFor(m => m.NonRequiredString)
                 .ContainingModelStateErrorFor(m => m.RequiredString).ThatEquals("The RequiredString field is required.")
-                .ContainingModelStateErrorFor(m => m.Integer).ThatEquals(string.Format("The field Integer must be between {0} and {1}.", 1, int.MaxValue));
+                .ContainingModelStateErrorFor(m => m.RequiredString)
+                .ContainingNoModelStateErrorFor(m => m.NotValidateInteger)
+                .ContainingModelStateError("RequiredString")
+                .ContainingModelStateErrorFor(m => m.Integer).ThatEquals(string.Format("The field Integer must be between {0} and {1}.", 1, int.MaxValue))
+                .ContainingModelStateError("RequiredString")
+                .ContainingModelStateError("Integer");
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelErrorAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelErrorAssertionException),
+            ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected error message for key RequiredString to be 'RequiredString field is required.', but instead found 'The RequiredString field is required.'.")]
         public void ThatEqualsShouldThrowExceptionWhenProvidedMessageIsValid()
         {
             var requestModelWithErrors = TestObjectFactory.GetRequestModelWithErrors();
@@ -52,7 +59,9 @@ public void BeginningWithShouldNotThrowExceptionWhenProvidedMessageIsValid()
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelErrorAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelErrorAssertionException),
+            ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected error message for key 'RequiredString' to start with 'RequiredString', but instead found 'The RequiredString field is required.'.")]
         public void BeginningWithShouldThrowExceptionWhenProvidedMessageIsValid()
         {
             var requestModelWithErrors = TestObjectFactory.GetRequestModelWithErrors();
@@ -81,7 +90,9 @@ public void EngingWithShouldNotThrowExceptionWhenProvidedMessageIsValid()
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelErrorAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelErrorAssertionException),
+            ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected error message for key 'RequiredString' to end with 'required!', but instead found 'The RequiredString field is required.'.")]
         public void EngingWithShouldThrowExceptionWhenProvidedMessageIsValid()
         {
             var requestModelWithErrors = TestObjectFactory.GetRequestModelWithErrors();
@@ -110,7 +121,9 @@ public void ContainingShouldNotThrowExceptionWhenProvidedMessageIsValid()
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelErrorAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelErrorAssertionException),
+            ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected error message for key 'RequiredString' to contain 'invalid', but instead found 'The RequiredString field is required.'.")]
         public void ContainingShouldThrowExceptionWhenProvidedMessageIsValid()
         {
             var requestModelWithErrors = TestObjectFactory.GetRequestModelWithErrors();
diff --git a/MyWebApi.Tests/BuildersTests/ResponseModelsTests/ResponseModelErrorTestBuilderTests.cs b/MyWebApi.Tests/BuildersTests/ResponseModelsTests/ResponseModelErrorTestBuilderTests.cs
@@ -4,6 +4,7 @@
     using Exceptions;
 
     using NUnit.Framework;
+
     using Setups;
     using Setups.Models;
 
@@ -24,7 +25,9 @@ public void ContainingNoErrorsShouldNotThrowExceptionWhenThereAreNoModelStateErr
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelErrorAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelErrorAssertionException),
+            ExpectedMessage = "When calling OkResultActionWithRequestBody action in WebApiController expected to have valid model state with no errors, but it had some.")]
         public void ContainingNoErrorsShouldThrowExceptionWhenThereAreModelStateErrors()
         {
             var requestBodyWithErrors = TestObjectFactory.GetRequestModelWithErrors();
@@ -51,7 +54,9 @@ public void AndModelStateErrorShouldNotThrowExceptionWhenTheProvidedModelStateEr
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelErrorAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelErrorAssertionException),
+            ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected to have a model error against key Name, but none found.")]
         public void AndModelStateErrorShouldThrowExceptionWhenTheProvidedModelStateErrorDoesNotExist()
         {
             var requestBody = TestObjectFactory.GetValidRequestModel();
@@ -78,7 +83,9 @@ public void AndModelStateErrorForShouldNotThrowExceptionWhenTheProvidedPropertyH
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelErrorAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelErrorAssertionException),
+            ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected to have a model error against key RequiredString, but none found.")]
         public void AndModelStateErrorForShouldThrowExceptionWhenTheProvidedPropertyDoesNotHaveErrors()
         {
             var requestBody = TestObjectFactory.GetValidRequestModel();
@@ -105,7 +112,9 @@ public void AndNoModelStateErrorForShouldNotThrowExceptionWhenTheProvidedPropert
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelErrorAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelErrorAssertionException),
+            ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected to have no model errors against key RequiredString, but found some.")]
         public void AndNoModelStateErrorForShouldThrowExceptionWhenTheProvidedPropertyHasErrors()
         {
             var requestBodyWithErrors = TestObjectFactory.GetRequestModelWithErrors();
@@ -133,7 +142,9 @@ public void AndNoModelStateErrorForShouldNotThrowExceptionWhenChainedWithValidMo
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelErrorAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelErrorAssertionException),
+            ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected to have no model errors against key Integer, but found some.")]
         public void AndNoModelStateErrorForShouldThrowExceptionWhenChainedWithInvalidModel()
         {
             var requestBodyWithErrors = TestObjectFactory.GetRequestModelWithErrors();
diff --git a/MyWebApi.Tests/BuildersTests/ResponseModelsTests/ResponseModelTestBuilderTests.cs b/MyWebApi.Tests/BuildersTests/ResponseModelsTests/ResponseModelTestBuilderTests.cs
@@ -32,7 +32,9 @@ public void WithResponseModelShouldNotThrowExceptionWithIncorrectInheritedTypeAr
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelAssertionException),
+            ExpectedMessage = "When calling OkResultWithResponse action in WebApiController expected response model to be a ResponseModel, but instead received a ICollection<ResponseModel>.")]
         public void WithResponseModelShouldThrowExceptionWithIncorrectResponseModel()
         {
             MyWebApi
@@ -43,7 +45,9 @@ public void WithResponseModelShouldThrowExceptionWithIncorrectResponseModel()
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelAssertionException),
+            ExpectedMessage = "When calling OkResultWithResponse action in WebApiController expected response model to be a ICollection<Int32>, but instead received a ICollection<ResponseModel>.")]
         public void WithResponseModelShouldThrowExceptionWithIncorrectGenericTypeArgument()
         {
             MyWebApi
@@ -66,7 +70,9 @@ public void WithResponseModelShouldNotThrowExceptionWithCorrectPassedExpectedObj
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelAssertionException),
+            ExpectedMessage = "When calling OkResultWithResponse action in WebApiController expected response model ICollection<ResponseModel> to be the given model, but in fact it was a different model.")]
         public void WithResponceModelShouldThrowExceptionWithDifferentPassedExpectedObject()
         {
             var controller = new WebApiController();
@@ -93,7 +99,8 @@ public void WithResponseModelShouldNotThrowExceptionWithCorrectAssertions()
         }
 
         [Test]
-        [ExpectedException(typeof(AssertionException))]
+        [ExpectedException(
+            typeof(AssertionException))]
         public void WithResponseModelShouldThrowExceptionWithIncorrectAssertions()
         {
             MyWebApi
@@ -118,7 +125,9 @@ public void WithResponseModelShouldNotThrowExceptionWithCorrectPredicate()
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelAssertionException),
+            ExpectedMessage = "When calling OkResultWithResponse action in WebApiController expected response model IList<ResponseModel> to pass the given condition, but it failed.")]
         public void WithResponseModelShouldThrowExceptionWithWrongPredicate()
         {
             MyWebApi
@@ -139,7 +148,9 @@ public void WithNoResponseModelShouldNotThrowExceptionWhenNoResponseModel()
         }
 
         [Test]
-        [ExpectedException(typeof(ResponseModelAssertionException))]
+        [ExpectedException(
+            typeof(ResponseModelAssertionException),
+            ExpectedMessage = "When calling OkResultWithResponse action in WebApiController expected to not have response model but in fact response model was found.")]
         public void WithNoResponseModelShouldThrowExceptionWhenResponseModelExists()
         {
             MyWebApi
diff --git a/MyWebApi.Tests/Setups/Models/RequestModel.cs b/MyWebApi.Tests/Setups/Models/RequestModel.cs
@@ -11,5 +11,7 @@ public class RequestModel
         public string RequiredString { get; set; }
 
         public string NonRequiredString { get; set; }
+
+        public int NotValidateInteger { get; set; }
     }
 }
diff --git a/MyWebApi.Tests/UtilitiesTests/ExpressionParserTests.cs b/MyWebApi.Tests/UtilitiesTests/ExpressionParserTests.cs
@@ -24,7 +24,7 @@ public void GetMethodNameShouldReturnCorrectMethodNameWithValidMethodCallExpress
         }
 
         [Test]
-        [ExpectedException(typeof(ArgumentException))]
+        [ExpectedException(typeof(ArgumentException), ExpectedMessage = "Provided expression is not a valid method call.")]
         public void GetMethodNameShouldThrowArgumentExceptionWithInvalidMethodCallExpression()
         {
             Expression<Func<int>> expression = () => 0;
@@ -65,7 +65,7 @@ public void ResolveMethodArgumentsShouldReturnEmptyCollectionIfMethoDoesNotHaveA
         }
 
         [Test]
-        [ExpectedException(typeof(ArgumentException))]
+        [ExpectedException(typeof(ArgumentException), ExpectedMessage = "Provided expression is not a valid method call.")]
         public void ResolveMethodArgumentsShouldThrowArgumentExceptionWithInvalidMethodCallExpression()
         {
             Expression<Func<int>> expression = () => 0;
@@ -82,7 +82,7 @@ public void GetPropertyNameShouldReturnProperMemberNameWithValidExpression()
         }
 
         [Test]
-        [ExpectedException(typeof(ArgumentException))]
+        [ExpectedException(typeof(ArgumentException), ExpectedMessage = "Provided expression is not a valid member expression.")]
         public void GetPropertyNameShouldThrowExceptionWithInvalidMemberExpression()
         {
             Expression<Func<WebApiController, object>> expression = c => c.OkResultWithResponse();
diff --git a/MyWebApi.Tests/UtilitiesTests/ValidatorTests.cs b/MyWebApi.Tests/UtilitiesTests/ValidatorTests.cs
@@ -26,27 +26,27 @@ public void CheckForNullReferenceShouldNotThrowExceptionWithNotNullObject()
         [ExpectedException(typeof(ArgumentNullException))]
         public void CheckForNotEmptyStringShouldThrowArgumentNullExceptionWithNullString()
         {
-            Validator.CheckForNotEmptyString(null);
+            Validator.CheckForNotWhiteSpaceString(null);
         }
 
         [Test]
         [ExpectedException(typeof(ArgumentNullException))]
         public void CheckForNotEmptyStringShouldThrowArgumentNullExceptionWithEmptyString()
         {
-            Validator.CheckForNotEmptyString(string.Empty);
+            Validator.CheckForNotWhiteSpaceString(string.Empty);
         }
 
         [Test]
         [ExpectedException(typeof(ArgumentNullException))]
         public void CheckForNotEmptyStringShouldThrowArgumentNullExceptionWithWhiteSpace()
         {
-            Validator.CheckForNotEmptyString("      ");
+            Validator.CheckForNotWhiteSpaceString("      ");
         }
 
         [Test]
         public void CheckForNotEmptyStringShouldNotThrowExceptionWithNormalString()
         {
-            Validator.CheckForNotEmptyString(new string('a', 10));
+            Validator.CheckForNotWhiteSpaceString(new string('a', 10));
         }
     }
 }
diff --git a/MyWebApi/Builders/Actions/ActionResultTestBuilder.cs b/MyWebApi/Builders/Actions/ActionResultTestBuilder.cs
@@ -58,7 +58,7 @@ private void ValidateActionReturnType(Type typeOfExpectedReturnValue, bool canBe
             if (invalid)
             {
                 throw new HttpActionResultAssertionException(string.Format(
-                    "When calling {0} action in {1} expected action result to be a {2}, but instead received a {3}.",
+                    "When calling {0} action in {1} expected action result to be {2}, but instead received {3}.",
                     this.ActionName,
                     this.Controller.GetType().ToFriendlyGenericTypeName(),
                     typeOfExpectedReturnValue.ToFriendlyGenericTypeName(),
diff --git a/MyWebApi/Builders/Base/BaseTestBuilder.cs b/MyWebApi/Builders/Base/BaseTestBuilder.cs
@@ -56,7 +56,7 @@ public string ActionName
 
             private set
             {
-                Validator.CheckForNotEmptyString(value, errorMessageName: "ActionName");
+                Validator.CheckForNotWhiteSpaceString(value, errorMessageName: "ActionName");
                 this.actionName = value;
             }
         }
diff --git a/MyWebApi/Builders/ResponseModels/ResponseModelTestBuilder.cs b/MyWebApi/Builders/ResponseModels/ResponseModelTestBuilder.cs
@@ -36,7 +36,7 @@ public void WithNoResponseModel()
             if (actualResult == null)
             {
                 throw new ResponseModelAssertionException(string.Format(
-                        "When calling {0} action in {1} expected to not have response model but in fact response model was found",
+                        "When calling {0} action in {1} expected to not have response model but in fact response model was found.",
                         this.ActionName,
                         this.Controller.GetType().ToFriendlyGenericTypeName()));
             }
diff --git a/MyWebApi/Utilities/ExpressionParser.cs b/MyWebApi/Utilities/ExpressionParser.cs
@@ -51,7 +51,7 @@ public static string GetPropertyName(LambdaExpression expression)
             var memberExpression = expression.Body as MemberExpression;
             if (memberExpression == null)
             {
-                throw new ArgumentException("Provided expression is not a valid member expression");
+                throw new ArgumentException("Provided expression is not a valid member expression.");
             }
 
             return memberExpression.Member.Name;
@@ -62,7 +62,7 @@ private static MethodCallExpression GetMethodCallExpresstion(LambdaExpression ex
             var methodCallExpression = expression.Body as MethodCallExpression;
             if (methodCallExpression == null)
             {
-                throw new ArgumentException("Provided expression is not a valid method call");
+                throw new ArgumentException("Provided expression is not a valid method call.");
             }
 
             return methodCallExpression;
diff --git a/MyWebApi/Utilities/Validator.cs b/MyWebApi/Utilities/Validator.cs

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public void ShouldReturnOkResultShouldNotThrowExceptionWithOkResult()`
`19`	`19`	`[Test]`
`20`	`20`	`[ExpectedException(`
`21`	`21`	`typeof(HttpActionResultAssertionException),`
`22`		`- ExpectedMessage = "When calling BadRequestAction action in WebApiController expected action result to be a OkNegotiatedContentResult<T>, but instead received a BadRequestResult.")]`
	`22`	`+ ExpectedMessage = "When calling BadRequestAction action in WebApiController expected action result to be OkNegotiatedContentResult<T>, but instead received BadRequestResult.")]`
`23`	`23`	`public void ShouldReturnOkResultShouldThrowExceptionWithOtherThanOkResult()`
`24`	`24`	`{`
`25`	`25`	`MyWebApi`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using Exceptions;`
`5`	`5`
`6`	`6`	`using NUnit.Framework;`
	`7`	`+`
`7`	`8`	`using Setups;`
`8`	`9`	`using Setups.Models;`
`9`	`10`
`@@ -24,7 +25,9 @@ public void ContainingNoErrorsShouldNotThrowExceptionWhenThereAreNoModelStateErr`
`24`	`25`	`}`
`25`	`26`
`26`	`27`	`[Test]`
`27`		`- [ExpectedException(typeof(ResponseModelErrorAssertionException))]`
	`28`	`+ [ExpectedException(`
	`29`	`+ typeof(ResponseModelErrorAssertionException),`
	`30`	`+ ExpectedMessage = "When calling OkResultActionWithRequestBody action in WebApiController expected to have valid model state with no errors, but it had some.")]`
`28`	`31`	`public void ContainingNoErrorsShouldThrowExceptionWhenThereAreModelStateErrors()`
`29`	`32`	`{`
`30`	`33`	`var requestBodyWithErrors = TestObjectFactory.GetRequestModelWithErrors();`
`@@ -51,7 +54,9 @@ public void AndModelStateErrorShouldNotThrowExceptionWhenTheProvidedModelStateEr`
`51`	`54`	`}`
`52`	`55`
`53`	`56`	`[Test]`
`54`		`- [ExpectedException(typeof(ResponseModelErrorAssertionException))]`
	`57`	`+ [ExpectedException(`
	`58`	`+ typeof(ResponseModelErrorAssertionException),`
	`59`	`+ ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected to have a model error against key Name, but none found.")]`
`55`	`60`	`public void AndModelStateErrorShouldThrowExceptionWhenTheProvidedModelStateErrorDoesNotExist()`
`56`	`61`	`{`
`57`	`62`	`var requestBody = TestObjectFactory.GetValidRequestModel();`
`@@ -78,7 +83,9 @@ public void AndModelStateErrorForShouldNotThrowExceptionWhenTheProvidedPropertyH`
`78`	`83`	`}`
`79`	`84`
`80`	`85`	`[Test]`
`81`		`- [ExpectedException(typeof(ResponseModelErrorAssertionException))]`
	`86`	`+ [ExpectedException(`
	`87`	`+ typeof(ResponseModelErrorAssertionException),`
	`88`	`+ ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected to have a model error against key RequiredString, but none found.")]`
`82`	`89`	`public void AndModelStateErrorForShouldThrowExceptionWhenTheProvidedPropertyDoesNotHaveErrors()`
`83`	`90`	`{`
`84`	`91`	`var requestBody = TestObjectFactory.GetValidRequestModel();`
`@@ -105,7 +112,9 @@ public void AndNoModelStateErrorForShouldNotThrowExceptionWhenTheProvidedPropert`
`105`	`112`	`}`
`106`	`113`
`107`	`114`	`[Test]`
`108`		`- [ExpectedException(typeof(ResponseModelErrorAssertionException))]`
	`115`	`+ [ExpectedException(`
	`116`	`+ typeof(ResponseModelErrorAssertionException),`
	`117`	`+ ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected to have no model errors against key RequiredString, but found some.")]`
`109`	`118`	`public void AndNoModelStateErrorForShouldThrowExceptionWhenTheProvidedPropertyHasErrors()`
`110`	`119`	`{`
`111`	`120`	`var requestBodyWithErrors = TestObjectFactory.GetRequestModelWithErrors();`
`@@ -133,7 +142,9 @@ public void AndNoModelStateErrorForShouldNotThrowExceptionWhenChainedWithValidMo`
`133`	`142`	`}`
`134`	`143`
`135`	`144`	`[Test]`
`136`		`- [ExpectedException(typeof(ResponseModelErrorAssertionException))]`
	`145`	`+ [ExpectedException(`
	`146`	`+ typeof(ResponseModelErrorAssertionException),`
	`147`	`+ ExpectedMessage = "When calling ModelStateCheck action in WebApiController expected to have no model errors against key Integer, but found some.")]`
`137`	`148`	`public void AndNoModelStateErrorForShouldThrowExceptionWhenChainedWithInvalidModel()`
`138`	`149`	`{`
`139`	`150`	`var requestBodyWithErrors = TestObjectFactory.GetRequestModelWithErrors();`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,9 @@ public void WithResponseModelShouldNotThrowExceptionWithIncorrectInheritedTypeAr`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`[Test]`
`35`		`- [ExpectedException(typeof(ResponseModelAssertionException))]`
	`35`	`+ [ExpectedException(`
	`36`	`+ typeof(ResponseModelAssertionException),`
	`37`	`+ ExpectedMessage = "When calling OkResultWithResponse action in WebApiController expected response model to be a ResponseModel, but instead received a ICollection<ResponseModel>.")]`
`36`	`38`	`public void WithResponseModelShouldThrowExceptionWithIncorrectResponseModel()`
`37`	`39`	`{`
`38`	`40`	`MyWebApi`
`@@ -43,7 +45,9 @@ public void WithResponseModelShouldThrowExceptionWithIncorrectResponseModel()`
`43`	`45`	`}`
`44`	`46`
`45`	`47`	`[Test]`
`46`		`- [ExpectedException(typeof(ResponseModelAssertionException))]`
	`48`	`+ [ExpectedException(`
	`49`	`+ typeof(ResponseModelAssertionException),`
	`50`	`+ ExpectedMessage = "When calling OkResultWithResponse action in WebApiController expected response model to be a ICollection<Int32>, but instead received a ICollection<ResponseModel>.")]`
`47`	`51`	`public void WithResponseModelShouldThrowExceptionWithIncorrectGenericTypeArgument()`
`48`	`52`	`{`
`49`	`53`	`MyWebApi`
`@@ -66,7 +70,9 @@ public void WithResponseModelShouldNotThrowExceptionWithCorrectPassedExpectedObj`
`66`	`70`	`}`
`67`	`71`
`68`	`72`	`[Test]`
`69`		`- [ExpectedException(typeof(ResponseModelAssertionException))]`
	`73`	`+ [ExpectedException(`
	`74`	`+ typeof(ResponseModelAssertionException),`
	`75`	`+ ExpectedMessage = "When calling OkResultWithResponse action in WebApiController expected response model ICollection<ResponseModel> to be the given model, but in fact it was a different model.")]`
`70`	`76`	`public void WithResponceModelShouldThrowExceptionWithDifferentPassedExpectedObject()`
`71`	`77`	`{`
`72`	`78`	`var controller = new WebApiController();`
`@@ -93,7 +99,8 @@ public void WithResponseModelShouldNotThrowExceptionWithCorrectAssertions()`
`93`	`99`	`}`
`94`	`100`
`95`	`101`	`[Test]`
`96`		`- [ExpectedException(typeof(AssertionException))]`
	`102`	`+ [ExpectedException(`
	`103`	`+ typeof(AssertionException))]`
`97`	`104`	`public void WithResponseModelShouldThrowExceptionWithIncorrectAssertions()`
`98`	`105`	`{`
`99`	`106`	`MyWebApi`
`@@ -118,7 +125,9 @@ public void WithResponseModelShouldNotThrowExceptionWithCorrectPredicate()`
`118`	`125`	`}`
`119`	`126`
`120`	`127`	`[Test]`
`121`		`- [ExpectedException(typeof(ResponseModelAssertionException))]`
	`128`	`+ [ExpectedException(`
	`129`	`+ typeof(ResponseModelAssertionException),`
	`130`	`+ ExpectedMessage = "When calling OkResultWithResponse action in WebApiController expected response model IList<ResponseModel> to pass the given condition, but it failed.")]`
`122`	`131`	`public void WithResponseModelShouldThrowExceptionWithWrongPredicate()`
`123`	`132`	`{`
`124`	`133`	`MyWebApi`
`@@ -139,7 +148,9 @@ public void WithNoResponseModelShouldNotThrowExceptionWhenNoResponseModel()`
`139`	`148`	`}`
`140`	`149`
`141`	`150`	`[Test]`
`142`		`- [ExpectedException(typeof(ResponseModelAssertionException))]`
	`151`	`+ [ExpectedException(`
	`152`	`+ typeof(ResponseModelAssertionException),`
	`153`	`+ ExpectedMessage = "When calling OkResultWithResponse action in WebApiController expected to not have response model but in fact response model was found.")]`
`143`	`154`	`public void WithNoResponseModelShouldThrowExceptionWhenResponseModelExists()`
`144`	`155`	`{`
`145`	`156`	`MyWebApi`
Original file line number	Diff line number	Diff line change
`@@ -11,5 +11,7 @@ public class RequestModel`
`11`	`11`	`public string RequiredString { get; set; }`
`12`	`12`
`13`	`13`	`public string NonRequiredString { get; set; }`
	`14`	`+`
	`15`	`+ public int NotValidateInteger { get; set; }`
`14`	`16`	`}`
`15`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public void GetMethodNameShouldReturnCorrectMethodNameWithValidMethodCallExpress`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`[Test]`
`27`		`- [ExpectedException(typeof(ArgumentException))]`
	`27`	`+ [ExpectedException(typeof(ArgumentException), ExpectedMessage = "Provided expression is not a valid method call.")]`
`28`	`28`	`public void GetMethodNameShouldThrowArgumentExceptionWithInvalidMethodCallExpression()`
`29`	`29`	`{`
`30`	`30`	`Expression<Func<int>> expression = () => 0;`
`@@ -65,7 +65,7 @@ public void ResolveMethodArgumentsShouldReturnEmptyCollectionIfMethoDoesNotHaveA`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`[Test]`
`68`		`- [ExpectedException(typeof(ArgumentException))]`
	`68`	`+ [ExpectedException(typeof(ArgumentException), ExpectedMessage = "Provided expression is not a valid method call.")]`
`69`	`69`	`public void ResolveMethodArgumentsShouldThrowArgumentExceptionWithInvalidMethodCallExpression()`
`70`	`70`	`{`
`71`	`71`	`Expression<Func<int>> expression = () => 0;`
`@@ -82,7 +82,7 @@ public void GetPropertyNameShouldReturnProperMemberNameWithValidExpression()`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`[Test]`
`85`		`- [ExpectedException(typeof(ArgumentException))]`
	`85`	`+ [ExpectedException(typeof(ArgumentException), ExpectedMessage = "Provided expression is not a valid member expression.")]`
`86`	`86`	`public void GetPropertyNameShouldThrowExceptionWithInvalidMemberExpression()`
`87`	`87`	`{`
`88`	`88`	`Expression<Func<WebApiController, object>> expression = c => c.OkResultWithResponse();`
Original file line number	Diff line number	Diff line change
`@@ -26,27 +26,27 @@ public void CheckForNullReferenceShouldNotThrowExceptionWithNotNullObject()`
`26`	`26`	`[ExpectedException(typeof(ArgumentNullException))]`
`27`	`27`	`public void CheckForNotEmptyStringShouldThrowArgumentNullExceptionWithNullString()`
`28`	`28`	`{`
`29`		`- Validator.CheckForNotEmptyString(null);`
	`29`	`+ Validator.CheckForNotWhiteSpaceString(null);`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`[Test]`
`33`	`33`	`[ExpectedException(typeof(ArgumentNullException))]`
`34`	`34`	`public void CheckForNotEmptyStringShouldThrowArgumentNullExceptionWithEmptyString()`
`35`	`35`	`{`
`36`		`- Validator.CheckForNotEmptyString(string.Empty);`
	`36`	`+ Validator.CheckForNotWhiteSpaceString(string.Empty);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`[Test]`
`40`	`40`	`[ExpectedException(typeof(ArgumentNullException))]`
`41`	`41`	`public void CheckForNotEmptyStringShouldThrowArgumentNullExceptionWithWhiteSpace()`
`42`	`42`	`{`
`43`		`- Validator.CheckForNotEmptyString(" ");`
	`43`	`+ Validator.CheckForNotWhiteSpaceString(" ");`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`[Test]`
`47`	`47`	`public void CheckForNotEmptyStringShouldNotThrowExceptionWithNormalString()`
`48`	`48`	`{`
`49`		`- Validator.CheckForNotEmptyString(new string('a', 10));`
	`49`	`+ Validator.CheckForNotWhiteSpaceString(new string('a', 10));`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ private void ValidateActionReturnType(Type typeOfExpectedReturnValue, bool canBe`
`58`	`58`	`if (invalid)`
`59`	`59`	`{`
`60`	`60`	`throw new HttpActionResultAssertionException(string.Format(`
`61`		`- "When calling {0} action in {1} expected action result to be a {2}, but instead received a {3}.",`
	`61`	`+ "When calling {0} action in {1} expected action result to be {2}, but instead received {3}.",`
`62`	`62`	`this.ActionName,`
`63`	`63`	`this.Controller.GetType().ToFriendlyGenericTypeName(),`
`64`	`64`	`typeOfExpectedReturnValue.ToFriendlyGenericTypeName(),`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ public string ActionName`
`56`	`56`
`57`	`57`	`private set`
`58`	`58`	`{`
`59`		`- Validator.CheckForNotEmptyString(value, errorMessageName: "ActionName");`
	`59`	`+ Validator.CheckForNotWhiteSpaceString(value, errorMessageName: "ActionName");`
`60`	`60`	`this.actionName = value;`
`61`	`61`	`}`
`62`	`62`	`}`