Added route tests to the sample (#132)

Author: ivaylokenov

samples/MusicStore/MusicStore.Test/Routes/CheckoutRouteTest.cs

@@ -0,0 +1,79 @@
+namespace MusicStore.Test.Routes
+{
+    using System.Threading;
+    using Models;
+    using MusicStore.Controllers;
+    using MyTested.AspNetCore.Mvc;
+    using Xunit;
+
+    public class CheckoutRouteTest
+    {
+        [Fact]
+        public void GetAddressAndPaymentShouldBeRoutedCorrectly()
+        {
+            MyMvc
+                .Routes()
+                .ShouldMap("/Checkout/AddressAndPayment")
+                .To<CheckoutController>(c => c.AddressAndPayment());
+        }
+
+        [Fact]
+        public void PostAddressAndPaymentShouldBeRoutedCorrectly()
+        {
+            var firstName = "FirstNameTest";
+            var lastName = "LastNameTest";
+            var address = "AddressTest";
+            var city = "CityTest";
+            var state = "StateTest";
+            var postalCode = "PostalTest";
+            var country = "CountryTest";
+            var phone = "PhoneTest";
+            var email = "[email protected]";
+
+            MyMvc
+                .Routes()
+                .ShouldMap(request => request
+                    .WithMethod(HttpMethod.Post)
+                    .WithLocation("/Checkout/AddressAndPayment")
+                    .WithFormFields(new
+                    {
+                        FirstName = firstName,
+                        LastName = lastName,
+                        Address = address,
+                        City = city,
+                        State = state,
+                        PostalCode = postalCode,
+                        Country = country,
+                        Phone = phone,
+                        Email = email,
+                    })
+                    .WithAntiForgeryToken())
+                .To<CheckoutController>(c => c.AddressAndPayment(
+                    With.Any<MusicStoreContext>(),
+                    new Order
+                    {
+                        FirstName = firstName,
+                        LastName = lastName,
+                        Address = address,
+                        City = city,
+                        State = state,
+                        PostalCode = postalCode,
+                        Country = country,
+                        Phone = phone,
+                        Email = email
+                    },
+                    With.Any<CancellationToken>()))
+                .AndAlso()
+                .ToValidModelState();
+        }
+
+        [Fact]
+        public void GetCompleteShouldBeRoutedCorrectly()
+        {
+            MyMvc
+                .Routes()
+                .ShouldMap("/Checkout/Complete/1")
+                .To<CheckoutController>(c => c.Complete(With.Any<MusicStoreContext>(), 1));
+        }
+    }
+}

samples/MusicStore/MusicStore.Test/Routes/HomeRouteTest.cs

@@ -9,7 +9,7 @@
     public class HomeRouteTest
     {
         [Fact]
-        public void IndexShouldBeRoutedCorrectly()
+        public void GetIndexShouldBeRoutedCorrectly()
         {
             MyMvc
                 .Routes()
@@ -20,12 +20,30 @@ public void IndexShouldBeRoutedCorrectly()
         }
 
         [Fact]
-        public void ErrorShouldBeRoutedCorrectly()
+        public void GetErrorShouldBeRoutedCorrectly()
         {
             MyMvc
                 .Routes()
                 .ShouldMap("/Home/Error")
                 .To<HomeController>(c => c.Error());
         }
+
+        [Fact]
+        public void GetStatusCodeShouldBeRoutedCorrectly()
+        {
+            MyMvc
+                .Routes()
+                .ShouldMap("/Home/StatusCodePage")
+                .To<HomeController>(c => c.StatusCodePage());
+        }
+
+        [Fact]
+        public void GetAccessDeniedShouldBeRoutedCorrectly()
+        {
+            MyMvc
+                .Routes()
+                .ShouldMap("/Home/AccessDenied")
+                .To<HomeController>(c => c.AccessDenied());
+        }
     }
 }

samples/MusicStore/MusicStore.Test/Routes/ShoppingCartRouteTest.cs

@@ -0,0 +1,40 @@
+namespace MusicStore.Test.Routes
+{
+    using MusicStore.Controllers;
+    using MyTested.AspNetCore.Mvc;
+    using System.Threading;
+    using Xunit;
+
+    public class ShoppingCartRouteTest
+    {
+        [Fact]
+        public void IndexShouldBeRoutedCorrectly()
+        {
+            MyMvc
+                .Routes()
+                .ShouldMap("/ShoppingCart/Index")
+                .To<ShoppingCartController>(c => c.Index());
+        }
+        
+        [Fact]
+        public void AddToCartShouldBeRoutedCorrectly()
+        {
+            MyMvc
+                .Routes()
+                .ShouldMap("/ShoppingCart/AddToCart/1")
+                .To<ShoppingCartController>(c => c.AddToCart(1, With.Any<CancellationToken>()));
+        }
+
+        [Fact]
+        public void RemoveFromCartShouldBeRoutedCorrectly()
+        {
+            MyMvc
+                .Routes()
+                .ShouldMap(request => request
+                    .WithMethod(HttpMethod.Post)
+                    .WithLocation("/ShoppingCart/RemoveFromCart/1")
+                    .WithAntiForgeryToken())
+                .To<ShoppingCartController>(c => c.RemoveFromCart(1, With.Any<CancellationToken>()));
+        }
+    }
+}

samples/MusicStore/MusicStore.Test/Routes/StoreRouteTests.cs

@@ -0,0 +1,37 @@
+namespace MusicStore.Test.Routes
+{
+    using Microsoft.Extensions.Caching.Memory;
+    using MusicStore.Controllers;
+    using MyTested.AspNetCore.Mvc;
+    using Xunit;
+
+    public class StoreRouteTests
+    {
+        [Fact]
+        public void IndexShouldBeRoutedCorrectly()
+        {
+            MyMvc
+                .Routes()
+                .ShouldMap("/Store/Index")
+                .To<StoreController>(c => c.Index());
+        }
+
+        [Fact]
+        public void BrowseShouldBeRoutedCorrectly()
+        {
+            MyMvc
+                .Routes()
+                .ShouldMap("/Store/Browse?genre=Disco")
+                .To<StoreController>(c => c.Browse("Disco"));
+        }
+
+        [Fact]
+        public void DetailsShouldBeRoutedCorrectly()
+        {
+            MyMvc
+                .Routes()
+                .ShouldMap("/Store/Details/1")
+                .To<StoreController>(c => c.Details(With.Any<IMemoryCache>(), 1)); ;
+        }
+    }
+}

src/MyTested.AspNetCore.Mvc.Core/Builders/Controllers/ControllerHttpBuilder.cs

@@ -43,7 +43,7 @@ public IAndControllerBuilder<TController> WithHttpRequest(HttpRequest httpReques
         /// <inheritdoc />
         public IAndControllerBuilder<TController> WithHttpRequest(Action<IHttpRequestBuilder> httpRequestBuilder)
         {
-            var newHttpRequestBuilder = new HttpRequestBuilder();
+            var newHttpRequestBuilder = new HttpRequestBuilder(this.HttpContext);
             httpRequestBuilder(newHttpRequestBuilder);
             newHttpRequestBuilder.ApplyTo(this.HttpRequest);
             return this;

src/MyTested.AspNetCore.Mvc.Core/Builders/Http/HttpRequestBuilder.cs

@@ -28,15 +28,19 @@ public class HttpRequestBuilder : IAndHttpRequestBuilder
         /// <summary>
         /// Initializes a new instance of the <see cref="HttpRequestBuilder"/> class.
         /// </summary>
-        public HttpRequestBuilder()
+        public HttpRequestBuilder(HttpContext httpContext)
         {
-            this.request = new MockedHttpRequest
+            CommonValidator.CheckForNullReference(httpContext, nameof(HttpContext));
+
+            this.request = new MockedHttpRequest(httpContext)
             {
                 Scheme = HttpScheme.Http,
                 Path = "/"
             };
         }
 
+        public HttpContext HttpContext => this.request.HttpContext;
+
         /// <inheritdoc />
         public IAndHttpRequestBuilder WithBody(Stream body)
         {

src/MyTested.AspNetCore.Mvc.Core/Builders/Routes/RouteTestBuilder.cs

@@ -50,7 +50,7 @@ public IShouldMapTestBuilder ShouldMap(HttpRequest request)
         /// <inheritdoc />
         public IShouldMapTestBuilder ShouldMap(Action<IHttpRequestBuilder> httpRequestBuilder)
         {
-            var httpBuilder = new HttpRequestBuilder();
+            var httpBuilder = new HttpRequestBuilder(this.HttpContext);
             httpRequestBuilder(httpBuilder);
             httpBuilder.ApplyTo(this.HttpContext.Request);
             return this.ShouldMap(this.HttpContext);

src/MyTested.AspNetCore.Mvc.Core/From.cs

@@ -12,6 +12,6 @@ public static class From
         /// </summary>
         /// <typeparam name="TService">Type of service.</typeparam>
         /// <returns>Service implementation.</returns>
-        public static TService Services<TService>() => TestServiceProvider.GetService<TService>();
+        public static TService Services<TService>() => TestServiceProvider.GetRequiredService<TService>();
     }
 }

src/MyTested.AspNetCore.Mvc.Core/Internal/Http/MockedAuthenticationHandler.cs

@@ -0,0 +1,44 @@
+namespace MyTested.AspNetCore.Mvc.Internal.Http
+{
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using Builders.Authentication;
+    using Microsoft.AspNetCore.Http.Features.Authentication;
+    using Microsoft.AspNetCore.Mvc.Internal;
+
+    public class MockedAuthenticationHandler : IAuthenticationHandler
+    {
+        public Task AuthenticateAsync(AuthenticateContext context)
+        {
+            context.Authenticated(
+                ClaimsPrincipalBuilder.DefaultAuthenticated,
+                new Dictionary<string, string>(),
+                new Dictionary<string, object>());
+
+            return TaskCache.CompletedTask;
+        }
+
+        public Task ChallengeAsync(ChallengeContext context)
+        {
+            context.Accept();
+            return TaskCache.CompletedTask;
+        }
+
+        public void GetDescriptions(DescribeSchemesContext context)
+        { 
+            // intentionally does nothing
+        }
+
+        public Task SignInAsync(SignInContext context)
+        {
+            context.Accept();
+            return TaskCache.CompletedTask;
+        }
+
+        public Task SignOutAsync(SignOutContext context)
+        {
+            context.Accept();
+            return TaskCache.CompletedTask;
+        }
+    }
+}

src/MyTested.AspNetCore.Mvc.Core/Internal/Http/MockedHttpRequest.cs

@@ -8,12 +8,14 @@
     using Microsoft.AspNetCore.Http.Features;
     using Microsoft.AspNetCore.Http.Internal;
     using Microsoft.Extensions.Primitives;
+    using Utilities.Validators;
 
     /// <summary>
     /// Mocked HTTP request object.
     /// </summary>
     public class MockedHttpRequest : HttpRequest
     {
+        private readonly HttpContext httpContext;
         private readonly IHeaderDictionary headerDictionary;
         private readonly FormFileCollection formFiles;
         private readonly Dictionary<string, string> cookieValues;
@@ -25,8 +27,11 @@ public class MockedHttpRequest : HttpRequest
         /// <summary>
         /// Initializes a new instance of the <see cref="MockedHttpRequest"/> class.
         /// </summary>
-        public MockedHttpRequest()
+        public MockedHttpRequest(HttpContext httpContext)
         {
+            CommonValidator.CheckForNullReference(httpContext, nameof(HttpContext));
+
+            this.httpContext = httpContext;
             this.headerDictionary = new HeaderDictionary();
             this.formFiles = new FormFileCollection();
             this.cookieValues = new Dictionary<string, string>();
@@ -83,10 +88,10 @@ public MockedHttpRequest()
         public override HostString Host { get; set; }
 
         /// <summary>
-        /// Gets the HttpContext for this request. Not used. Always returns null.
+        /// Gets the <see cref="Microsoft.AspNetCore.Http.HttpContext"/> for this request.
         /// </summary>
         /// <value>The HTTP request HTTP context.</value>
-        public override HttpContext HttpContext => null;
+        public override HttpContext HttpContext => this.httpContext;
 
         /// <summary>
         /// Returns true if the Scheme is 'https'.