BadRequest result made chainable with IAndTestBuilder

Author: ivaylokenov

MyWebApi/Builders/Actions/ShouldReturnBadRequest.cs

@@ -16,22 +16,25 @@ public partial class ActionResultTestBuilder<TActionResult>
         /// Tests whether action result is BadRequestResult, InvalidModelStateResult or BadRequestErrorMessageResult.
         /// </summary>
         /// <returns>Bad request test builder.</returns>
-        public IBadRequestTestBuilder ShouldReturnBadRequest()
+        public IBadRequestTestBuilder<TActionResult> ShouldReturnBadRequest()
         {
             if (this.ActionResult as BadRequestResult != null)
             {
-                return this.ReturnBadRequestTestBuilder<BadRequestResult>();
+                return this.ReturnBadRequestTestBuilder<BadRequestResult>()
+                    as IBadRequestTestBuilder<TActionResult>;
             }
 
             if (this.ActionResult as InvalidModelStateResult != null)
             {
-                return this.ReturnBadRequestTestBuilder<InvalidModelStateResult>();
+                return this.ReturnBadRequestTestBuilder<InvalidModelStateResult>()
+                    as IBadRequestTestBuilder<TActionResult>;
             }
 
-            return this.ReturnBadRequestTestBuilder<BadRequestErrorMessageResult>();
+            return this.ReturnBadRequestTestBuilder<BadRequestErrorMessageResult>()
+                as IBadRequestTestBuilder<TActionResult>;
         }
 
-        private IBadRequestTestBuilder ReturnBadRequestTestBuilder<TBadRequestResult>()
+        private IBadRequestTestBuilder<TBadRequestResult> ReturnBadRequestTestBuilder<TBadRequestResult>()
             where TBadRequestResult : class
         {
             var badRequestResult = this.GetReturnObject<TBadRequestResult>();

MyWebApi/Builders/BadRequests/BadRequestErrorMessageTestBuilder.cs

@@ -1,27 +1,33 @@
 namespace MyWebApi.Builders.BadRequests
 {
     using System.Web.Http;
-
+    using System.Web.Http.Results;
     using Base;
     using Common.Extensions;
+    using Contracts.And;
     using Contracts.BadRequests;
     using Exceptions;
 
     /// <summary>
     /// Used for testing specific bad request error messages.
     /// </summary>
-    public class BadRequestErrorMessageTestBuilder : BaseTestBuilder, IBadRequestErrorMessageTestBuilder
+    public class BadRequestErrorMessageTestBuilder<TBadRequestResult>
+        : BaseTestBuilderWithActionResult<TBadRequestResult>, IBadRequestErrorMessageTestBuilder<TBadRequestResult>
     {
         private readonly string actualMessage;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="BadRequestErrorMessageTestBuilder" /> class.
+        /// Initializes a new instance of the <see cref="BadRequestErrorMessageTestBuilder{TBadRequestResult}" /> class.
         /// </summary>
         /// <param name="controller">Controller on which the action will be tested.</param>
         /// <param name="actionName">Name of the tested action.</param>
         /// <param name="actualMessage">Actual error message received from bad request result.</param>
-        public BadRequestErrorMessageTestBuilder(ApiController controller, string actionName, string actualMessage)
-            : base(controller, actionName)
+        public BadRequestErrorMessageTestBuilder(
+            ApiController controller,
+            string actionName,
+            TBadRequestResult actionResult,
+            string actualMessage)
+            : base(controller, actionName, actionResult)
         {
             this.actualMessage = actualMessage;
         }
@@ -30,56 +36,64 @@ public BadRequestErrorMessageTestBuilder(ApiController controller, string action
         /// Tests whether particular error message is equal to given message.
         /// </summary>
         /// <param name="errorMessage">Expected error message for particular key.</param>
-        public void ThatEquals(string errorMessage)
+        public IAndTestBuilder<TBadRequestResult> ThatEquals(string errorMessage)
         {
             if (this.actualMessage != errorMessage)
             {
                 this.ThrowNewBadRequestResultAssertionException(
                     "When calling {0} action in {1} expected bad request error message to be '{2}', but instead found '{3}'.",
                     errorMessage);
             }
+
+            return this.NewAndTestBuilder();
         }
 
         /// <summary>
         /// Tests whether particular error message begins with given message.
         /// </summary>
         /// <param name="beginMessage">Expected beginning for particular error message.</param>
-        public void BeginningWith(string beginMessage)
+        public IAndTestBuilder<TBadRequestResult> BeginningWith(string beginMessage)
         {
             if (!this.actualMessage.StartsWith(beginMessage))
             {
                 this.ThrowNewBadRequestResultAssertionException(
                     "When calling {0} action in {1} expected bad request error message to begin with '{2}', but instead found '{3}'.",
                     beginMessage);
             }
+
+            return this.NewAndTestBuilder();
         }
 
         /// <summary>
         /// Tests whether particular error message ends with given message.
         /// </summary>
         /// <param name="endMessage">Expected ending for particular error message.</param>
-        public void EndingWith(string endMessage)
+        public IAndTestBuilder<TBadRequestResult> EndingWith(string endMessage)
         {
             if (!this.actualMessage.EndsWith(endMessage))
             {
                 this.ThrowNewBadRequestResultAssertionException(
                     "When calling {0} action in {1} expected bad request error message to end with '{2}', but instead found '{3}'.",
                     endMessage);
             }
+
+            return this.NewAndTestBuilder();
         }
 
         /// <summary>
         /// Tests whether particular error message contains given message.
         /// </summary>
         /// <param name="containsMessage">Expected containing string for particular error message.</param>
-        public void Containing(string containsMessage)
+        public IAndTestBuilder<TBadRequestResult> Containing(string containsMessage)
         {
             if (!this.actualMessage.Contains(containsMessage))
             {
                 this.ThrowNewBadRequestResultAssertionException(
                     "When calling {0} action in {1} expected bad request error message to contain '{2}', but instead found '{3}'.",
                     containsMessage);
             }
+
+            return this.NewAndTestBuilder();
         }
 
         private void ThrowNewBadRequestResultAssertionException(string messageFormat, string operation)

MyWebApi/Builders/BadRequests/BadRequestTestBuilder.cs

@@ -8,6 +8,7 @@
 
     using Base;
     using Common.Extensions;
+    using Contracts.And;
     using Contracts.BadRequests;
     using Contracts.Models;
     using Exceptions;
@@ -18,7 +19,7 @@
     /// </summary>
     /// <typeparam name="TBadRequestResult">Type of bad request result - BadRequestResult, InvalidModelStateResult, BadRequestErrorMessageResult.</typeparam>
     public class BadRequestTestBuilder<TBadRequestResult> : BaseTestBuilderWithActionResult<TBadRequestResult>,
-        IBadRequestTestBuilder
+        IBadRequestTestBuilder<TBadRequestResult>
     {
         private const string ErrorMessage = "error message";
         private const string ModelStateDictionary = "model state dictionary";
@@ -41,28 +42,30 @@ public BadRequestTestBuilder(
         /// Tests bad request result with specific error message using test builder.
         /// </summary>
         /// <returns>Bad request with error message test builder.</returns>
-        public IBadRequestErrorMessageTestBuilder WithErrorMessage()
+        public IBadRequestErrorMessageTestBuilder<TBadRequestResult> WithErrorMessage()
         {
             var badRequestErrorMessageResult = this.GetBadRequestResult<BadRequestErrorMessageResult>(ErrorMessage);
-            return new BadRequestErrorMessageTestBuilder(this.Controller, this.ActionName, badRequestErrorMessageResult.Message);
+            return new BadRequestErrorMessageTestBuilder<TBadRequestResult>(this.Controller, this.ActionName, this.ActionResult, badRequestErrorMessageResult.Message);
         }
 
         /// <summary>
         /// Tests bad request result with specific error message provided by string.
         /// </summary>
         /// <param name="message">Expected error message from bad request result.</param>
-        public void WithErrorMessage(string message)
+        public IAndTestBuilder<TBadRequestResult> WithErrorMessage(string message)
         {
             var badRequestErrorMessageResult = this.GetBadRequestResult<BadRequestErrorMessageResult>(ErrorMessage);
             var actualMessage = badRequestErrorMessageResult.Message;
             this.ValidateErrorMessage(message, actualMessage);
+
+            return this.NewAndTestBuilder();
         }
 
         /// <summary>
         /// Tests bad request result with specific model state dictionary.
         /// </summary>
         /// <param name="modelState">Model state dictionary to deeply compare to the actual one.</param>
-        public void WithModelState(ModelStateDictionary modelState)
+        public IAndTestBuilder<TBadRequestResult> WithModelState(ModelStateDictionary modelState)
         {
             var invalidModelStateResult = this.GetBadRequestResult<InvalidModelStateResult>(ModelStateDictionary);
             var actualModelState = invalidModelStateResult.ModelState;
@@ -115,6 +118,8 @@ public void WithModelState(ModelStateDictionary modelState)
                     this.ValidateErrorMessage(expectedError, actualError);
                 }
             }
+
+            return this.NewAndTestBuilder();
         }
 
         /// <summary>

MyWebApi/Builders/Base/BaseTestBuilder.cs

@@ -1,9 +1,7 @@
 namespace MyWebApi.Builders.Base
 {
     using System.Web.Http;
-
     using Common.Extensions;
-    using Contracts;
     using Contracts.Base;
     using Exceptions;
     using Utilities;

MyWebApi/Builders/Contracts/Actions/IActionResultTestBuilder.cs

@@ -58,7 +58,7 @@ public interface IActionResultTestBuilder<out TActionResult> : IBaseTestBuilderW
         /// Tests whether action result is BadRequestResult, InvalidModelStateResult or BadRequestErrorMessageResult.
         /// </summary>
         /// <returns>Bad request test builder.</returns>
-        IBadRequestTestBuilder ShouldReturnBadRequest();
+        IBadRequestTestBuilder<TActionResult> ShouldReturnBadRequest();
 
         /// <summary>
         /// Tests whether action result is UnauthorizedResult.

MyWebApi/Builders/Contracts/BadRequests/IBadRequestErrorMessageTestBuilder.cs

@@ -1,32 +1,34 @@
 namespace MyWebApi.Builders.Contracts.BadRequests
 {
+    using And;
+
     /// <summary>
     /// Used for testing specific bad request error messages.
     /// </summary>
-    public interface IBadRequestErrorMessageTestBuilder
+    public interface IBadRequestErrorMessageTestBuilder<out TBadRequestResult>
     {
         /// <summary>
         /// Tests whether particular error message is equal to given message.
         /// </summary>
         /// <param name="errorMessage">Expected error message for particular key.</param>
-        void ThatEquals(string errorMessage);
+        IAndTestBuilder<TBadRequestResult> ThatEquals(string errorMessage);
 
         /// <summary>
         /// Tests whether particular error message begins with given message.
         /// </summary>
         /// <param name="beginMessage">Expected beginning for particular error message.</param>
-        void BeginningWith(string beginMessage);
+        IAndTestBuilder<TBadRequestResult> BeginningWith(string beginMessage);
 
         /// <summary>
         /// Tests whether particular error message ends with given message.
         /// </summary>
         /// <param name="endMessage">Expected ending for particular error message.</param>
-        void EndingWith(string endMessage);
+        IAndTestBuilder<TBadRequestResult> EndingWith(string endMessage);
 
         /// <summary>
         /// Tests whether particular error message contains given message.
         /// </summary>
         /// <param name="containsMessage">Expected containing string for particular error message.</param>
-        void Containing(string containsMessage);
+        IAndTestBuilder<TBadRequestResult> Containing(string containsMessage);
     }
 }

MyWebApi/Builders/Contracts/BadRequests/IBadRequestTestBuilder.cs

@@ -1,31 +1,31 @@
 namespace MyWebApi.Builders.Contracts.BadRequests
 {
     using System.Web.Http.ModelBinding;
-
+    using And;
     using Models;
 
     /// <summary>
     /// Used for testing bad request results.
     /// </summary>
-    public interface IBadRequestTestBuilder
+    public interface IBadRequestTestBuilder<out TBadRequestResult>
     {
         /// <summary>
         /// Tests bad request result with specific error message using test builder.
         /// </summary>
         /// <returns>Bad request with error message test builder.</returns>
-        IBadRequestErrorMessageTestBuilder WithErrorMessage();
+        IBadRequestErrorMessageTestBuilder<TBadRequestResult> WithErrorMessage();
 
         /// <summary>
         /// Tests bad request result with specific error message provided by string.
         /// </summary>
         /// <param name="message">Expected error message from bad request result.</param>
-        void WithErrorMessage(string message);
+        IAndTestBuilder<TBadRequestResult> WithErrorMessage(string message);
 
         /// <summary>
         /// Tests bad request result with specific model state dictionary.
         /// </summary>
         /// <param name="modelState">Model state dictionary to deeply compare to the actual one.</param>
-        void WithModelState(ModelStateDictionary modelState);
+        IAndTestBuilder<TBadRequestResult> WithModelState(ModelStateDictionary modelState);
 
         /// <summary>
         /// Tests bad request result for model state errors using test builder.