Added attributes and filters

Author: Jennifer Deigendesch

ASPNETCoreExample/Attributes/ValidateModelAttribute.cs

@@ -0,0 +1,24 @@
+namespace AspNetCoreExample.Attributes
+{
+   using System;
+
+   using Microsoft.AspNetCore.Mvc;
+   using Microsoft.AspNetCore.Mvc.Filters;
+
+   [AttributeUsage(AttributeTargets.Method)]
+   public class ValidateModelAttribute : ActionFilterAttribute
+   {
+      public override void OnActionExecuting(ActionExecutingContext context)
+      {
+         if (context.ActionArguments.Values.Contains(null))
+         {
+            context.Result = new BadRequestResult();
+         }
+
+         if (!context.ModelState.IsValid)
+         {
+            context.Result = new BadRequestObjectResult(context.ModelState);
+         }
+      }
+   }
+}

ASPNETCoreExample/Attributes/ValidateUserExistsAttribute.cs

@@ -0,0 +1,20 @@
+namespace AspNetCoreExample.Attributes
+{
+   using System;
+
+   using AspNetCoreExample.Filters;
+
+   using Microsoft.AspNetCore.Mvc;
+
+   /// <summary>
+   /// Attribute that validates if the user exists for the given id.
+   /// </summary>
+   [AttributeUsage(AttributeTargets.Method)]
+   public class ValidateUserExistsAttribute : TypeFilterAttribute
+   {
+      public ValidateUserExistsAttribute()
+         : base(typeof(ValidateUserExistsFilter))
+      {
+      }
+   }
+}

ASPNETCoreExample/Controllers/UserController.cs

@@ -3,6 +3,7 @@
    using System;
    using System.Threading.Tasks;
 
+   using AspNetCoreExample.Attributes;
    using AspNetCoreExample.Repositories;
 
    using DataDAL.Tables;
@@ -33,6 +34,7 @@ public UserController(IUserRepository repository, ILogger<UserController> logger
       [HttpGet("{id}")]
       [ProducesResponseType(typeof(User), 200)]
       [ProducesResponseType(typeof(string), 400)]
+      [ValidateUserExists]
       public async Task<IActionResult> GetUserAsync(string id)
       {
          try
@@ -47,5 +49,28 @@ public async Task<IActionResult> GetUserAsync(string id)
             return this.BadRequest(errorMessage);
          }
       }
+
+      /// <summary>
+      /// Add the given user.
+      /// </summary>
+      /// <param name="user">User to add.</param>
+      /// <response code="400">If adding the user failed.</response>
+      [HttpPost]
+      [ProducesResponseType(typeof(string), 400)]
+      [ValidateModel]
+      public async Task<IActionResult> SetUserAsync([FromBody] User user)
+      {
+         try
+         {
+            await this.repository.SetUserAsync(user);
+            return this.Ok();
+         }
+         catch (Exception e)
+         {
+            string errorMessage = $"Error while adding the user: {e.InnerException?.Message ?? e.Message}";
+            this.logger.LogError(errorMessage);
+            return this.BadRequest(errorMessage);
+         }
+      }
    }
 }

ASPNETCoreExample/Filters/ValidateUserExistsFilter.cs

@@ -0,0 +1,46 @@
+namespace AspNetCoreExample.Filters
+{
+   using System.Threading.Tasks;
+
+   using DataDAL;
+
+   using Microsoft.AspNetCore.Mvc;
+   using Microsoft.AspNetCore.Mvc.Filters;
+   using Microsoft.EntityFrameworkCore;
+
+   public class ValidateUserExistsFilter : IAsyncActionFilter
+   {
+      private const string UserIdKey = "id";
+
+      private readonly DataDAL dataDal;
+
+      public ValidateUserExistsFilter(DataDAL dataDal)
+      {
+         this.dataDal = dataDal;
+      }
+
+      public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+      {
+         if (!context.ActionArguments.ContainsKey(UserIdKey))
+         {
+            context.Result = new BadRequestResult();
+            return;
+         }
+
+         if (!await this.UserExists(context))
+         {
+            context.Result = new ForbidResult();
+            return;
+         }
+
+         await next();
+      }
+
+      private async Task<bool> UserExists(ActionExecutingContext context)
+      {
+         string userId = context.ActionArguments[UserIdKey]
+            .ToString();
+         return await this.dataDal.User.CountAsync(item => item.Id == userId) > 0;
+      }
+   }
+}

ASPNETCoreExample/Repositories/IUserRepository.cs

@@ -7,5 +7,7 @@
    public interface IUserRepository
    {
       Task<User> GetUserAsync(string id);
+
+      Task SetUserAsync(User user);
    }
 }

ASPNETCoreExample/Repositories/UserRepository.cs

@@ -22,5 +22,11 @@ public async Task<User> GetUserAsync(string id)
          return await this.dataDal.User.Where(item => item.Id == id)
                    .FirstAsync();
       }
+
+      public async Task SetUserAsync(User user)
+      {
+         var newUser = await this.dataDal.User.AddAsync(user);
+         await newUser.Context.SaveChangesAsync();
+      }
    }
 }

Tests/AttributeTests/AttributeTestBase.cs

@@ -0,0 +1,37 @@
+namespace Tests.AttributeTests
+{
+   using System.Collections.Generic;
+
+   using AspNetCoreExample.Controllers;
+
+   using Microsoft.AspNetCore.Http;
+   using Microsoft.AspNetCore.Mvc;
+   using Microsoft.AspNetCore.Mvc.Abstractions;
+   using Microsoft.AspNetCore.Mvc.Filters;
+   using Microsoft.AspNetCore.Routing;
+   using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+   using Moq;
+
+   public class AttributeTestBase
+   {
+      protected UserController Controller { get; private set; }
+
+      [TestInitialize]
+      public virtual void SetUp()
+      {
+         this.Controller = new UserController(null, null);
+      }
+
+      protected ActionExecutingContext CreateActionExecutingContext(object controller, IDictionary<string, object> requestParameters)
+      {
+         var httpContextMock = new Mock<HttpContext>();
+         var routeDataMock = new Mock<RouteData>();
+         var actionDescriptorMock = new Mock<ActionDescriptor>();
+         var actionContext = new ActionContext(httpContextMock.Object, routeDataMock.Object, actionDescriptorMock.Object);
+
+         var filters = new List<IFilterMetadata>();
+         return new ActionExecutingContext(actionContext, filters, requestParameters, controller);
+      }
+   }
+}

Tests/AttributeTests/ValidateModelTests.cs

@@ -0,0 +1,79 @@
+namespace Tests.AttributeTests
+{
+   using System.Collections.Generic;
+
+   using AspNetCoreExample.Attributes;
+
+   using DataDAL.Tables;
+
+   using Microsoft.AspNetCore.Mvc;
+   using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+   [TestClass]
+   public class ValidateModelTests : AttributeTestBase
+   {
+      private const string ModelKey = "Model";
+
+      private ValidateModelAttribute attributeToTest;
+
+      [TestInitialize]
+      public override void SetUp()
+      {
+         base.SetUp();
+         this.attributeToTest = new ValidateModelAttribute();
+      }
+
+      [TestMethod]
+      public void ShouldReturnOkIfModelIsValid()
+      {
+         // Arrange
+         var model = new User();
+         var requestParameter = this.GetValidateModelAttributeRequestParameters(model);
+         var actionExecutingContext = this.CreateActionExecutingContext(this.Controller, requestParameter);
+
+         // Test
+         this.attributeToTest.OnActionExecuting(actionExecutingContext);
+
+         // Assert
+         Assert.IsNull(actionExecutingContext.Result);
+      }
+
+      [TestMethod]
+      public void ShouldReturnBadRequestIfModelIsInvalid()
+      {
+         // Arrange
+         const string InvalidModel = "test";
+         var requestParameter = this.GetValidateModelAttributeRequestParameters(InvalidModel);
+         var actionExecutingContext = this.CreateActionExecutingContext(this.Controller, requestParameter);
+         actionExecutingContext.ModelState.AddModelError(ModelKey, "Invalid Model");
+
+         // Test
+         this.attributeToTest.OnActionExecuting(actionExecutingContext);
+
+         // Assert
+         Assert.IsNotNull(actionExecutingContext.Result);
+         Assert.IsInstanceOfType(actionExecutingContext.Result, typeof(BadRequestObjectResult));
+      }
+
+      [TestMethod]
+      public void ShouldReturnBadRequestIfModelIsNotAvailable()
+      {
+         // Arrange
+         const string NotAvailableModel = null;
+         var requestParameter = this.GetValidateModelAttributeRequestParameters(NotAvailableModel);
+         var actionExecutingContext = this.CreateActionExecutingContext(this.Controller, requestParameter);
+
+         // Test
+         this.attributeToTest.OnActionExecuting(actionExecutingContext);
+
+         // Assert
+         Assert.IsNotNull(actionExecutingContext.Result);
+         Assert.IsInstanceOfType(actionExecutingContext.Result, typeof(BadRequestResult));
+      }
+
+      private IDictionary<string, object> GetValidateModelAttributeRequestParameters(object model)
+      {
+         return new Dictionary<string, object> { { ModelKey, model } };
+      }
+   }
+}

Tests/FilterTests/FilterTestBase.cs

@@ -0,0 +1,44 @@
+namespace Tests.FilterTests
+{
+   using System.Collections.Generic;
+
+   using AspNetCoreExample.Controllers;
+
+   using Microsoft.AspNetCore.Http;
+   using Microsoft.AspNetCore.Mvc;
+   using Microsoft.AspNetCore.Mvc.Abstractions;
+   using Microsoft.AspNetCore.Mvc.Filters;
+   using Microsoft.AspNetCore.Routing;
+   using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+   using Moq;
+
+   using Tests.RepositoryTests;
+
+   public class FilterTestBase : TestBase
+   {
+      protected ActionExecutionDelegate DelegateMock { get; private set; }
+
+      protected UserController Controller { get; private set; }
+
+      [TestInitialize]
+      public override void SetUp()
+      {
+         base.SetUp();
+
+         this.DelegateMock = new Mock<ActionExecutionDelegate>().Object;
+         this.Controller = new UserController(null, null);
+      }
+
+      protected ActionExecutingContext CreateActionExecutingContext(object controller, IDictionary<string, object> requestParameters)
+      {
+         var httpContextMock = new Mock<HttpContext>();
+         var routeDataMock = new Mock<RouteData>();
+         var actionDescriptorMock = new Mock<ActionDescriptor>();
+         var actionContext = new ActionContext(httpContextMock.Object, routeDataMock.Object, actionDescriptorMock.Object);
+
+         var filters = new List<IFilterMetadata>();
+         return new ActionExecutingContext(actionContext, filters, requestParameters, controller);
+      }
+   }
+}