public async Task WriteFileAsync_WritesResponse_InChunksOfFourKilobytes()
{
// Arrange
var mockReadStream = new Mock<Stream>();
mockReadStream.SetupSequence(s => s.ReadAsync(It.IsAny<byte[]>(), 0, 0x1000, CancellationToken.None))
.Returns(Task.FromResult(0x1000))
.Returns(Task.FromResult(0x500))
.Returns(Task.FromResult(0));
var mockBodyStream = new Mock<Stream>();
mockBodyStream
.Setup(s => s.WriteAsync(It.IsAny<byte[]>(), 0, 0x1000, CancellationToken.None))
.Returns(Task.FromResult(0));
mockBodyStream
.Setup(s => s.WriteAsync(It.IsAny<byte[]>(), 0, 0x500, CancellationToken.None))
.Returns(Task.FromResult(0));
var result = new FileStreamResult(mockReadStream.Object, "text/plain");
var httpContext = new DefaultHttpContext();
httpContext.Response.Body = mockBodyStream.Object;
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
// Act
await result.ExecuteResultAsync(actionContext);
// Assert
mockReadStream.Verify();
mockBodyStream.Verify();
}
public async Task WriteFileAsync_CopiesProvidedStream_ToOutputStream()
{
// Arrange
// Generate an array of bytes with a predictable pattern
// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, 10, 11, 12, 13
var originalBytes = Enumerable.Range(0, 0x1234)
.Select(b => (byte)(b % 20)).ToArray();
var originalStream = new MemoryStream(originalBytes);
var httpContext = new DefaultHttpContext();
var outStream = new MemoryStream();
httpContext.Response.Body = outStream;
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var result = new FileStreamResult(originalStream, "text/plain");
// Act
await result.ExecuteResultAsync(actionContext);
// Assert
var outBytes = outStream.ToArray();
Assert.True(originalBytes.SequenceEqual(outBytes));
}
public Task ExpectedKeysAreAvailable()
{
var handler = new ClientHandler(env =>
{
var context = new DefaultHttpContext((IFeatureCollection)env);
// TODO: Assert.True(context.RequestAborted.CanBeCanceled);
Assert.Equal("HTTP/1.1", context.Request.Protocol);
Assert.Equal("GET", context.Request.Method);
Assert.Equal("https", context.Request.Scheme);
Assert.Equal("/A/Path", context.Request.PathBase.Value);
Assert.Equal("/and/file.txt", context.Request.Path.Value);
Assert.Equal("?and=query", context.Request.QueryString.Value);
Assert.NotNull(context.Request.Body);
Assert.NotNull(context.Request.Headers);
Assert.NotNull(context.Response.Headers);
Assert.NotNull(context.Response.Body);
Assert.Equal(200, context.Response.StatusCode);
Assert.Null(context.GetFeature<IHttpResponseFeature>().ReasonPhrase);
Assert.Equal("example.com", context.Request.Host.Value);
return Task.FromResult(0);
}, new PathString("/A/Path/"));
var httpClient = new HttpClient(handler);
return httpClient.GetAsync("https://example.com/A/Path/and/file.txt?and=query");
}
public async Task ReadFormAsync_SimpleData_ReturnsParsedFormCollection()
{
// Arrange
var formContent = Encoding.UTF8.GetBytes("foo=bar&baz=2");
var context = new DefaultHttpContext();
context.Request.ContentType = "application/x-www-form-urlencoded; charset=utf-8";
context.Request.Body = new MemoryStream(formContent);
// Not cached yet
var formFeature = context.GetFeature<IFormFeature>();
Assert.Null(formFeature);
// Act
var formCollection = await context.Request.ReadFormAsync();
// Assert
Assert.Equal("bar", formCollection["foo"]);
Assert.Equal("2", formCollection["baz"]);
// Cached
formFeature = context.GetFeature<IFormFeature>();
Assert.NotNull(formFeature);
Assert.NotNull(formFeature.Form);
Assert.Same(formFeature.Form, formCollection);
}
public async void Invoke_DoesNotLogWhenDisabledAndNotHandled()
{
// Arrange
var isHandled = false;
var sink = new TestSink(
TestSink.EnableWithTypeName<RouterMiddleware>,
TestSink.EnableWithTypeName<RouterMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: false);
var httpContext = new DefaultHttpContext();
httpContext.ApplicationServices = new ServiceProvider();
httpContext.RequestServices = httpContext.ApplicationServices;
RequestDelegate next = (c) =>
{
return Task.FromResult<object>(null);
};
var router = new TestRouter(isHandled);
var middleware = new RouterMiddleware(next, loggerFactory, router);
// Act
await middleware.Invoke(httpContext);
// Assert
Assert.Single(sink.Scopes);
var scope = sink.Scopes[0];
Assert.Equal(typeof(RouterMiddleware).FullName, scope.LoggerName);
Assert.Equal("RouterMiddleware.Invoke", scope.Scope);
Assert.Empty(sink.Writes);
}
public async Task ExecuteAsync_WritesOutputWithoutBOM()
{
// Arrange
var expected = new byte[] { 97, 98, 99, 100 };
var view = new Mock<IView>();
view.Setup(v => v.RenderAsync(It.IsAny<ViewContext>()))
.Callback((ViewContext v) =>
{
view.ToString();
v.Writer.Write("abcd");
})
.Returns(Task.FromResult(0));
var context = new DefaultHttpContext();
var memoryStream = new MemoryStream();
context.Response.Body = memoryStream;
var actionContext = new ActionContext(context,
new RouteData(),
new ActionDescriptor());
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider());
// Act
await ViewExecutor.ExecuteAsync(view.Object, actionContext, viewData, null, contentType: null);
// Assert
Assert.Equal(expected, memoryStream.ToArray());
Assert.Equal("text/html; charset=utf-8", context.Response.ContentType);
}
public void SelectResponseCharacterEncoding_SelectsEncoding(string acceptCharsetHeaders,
string requestEncoding,
string[] supportedEncodings,
string expectedEncoding)
{
// Arrange
var mockHttpContext = new Mock<HttpContext>();
var httpRequest = new DefaultHttpContext().Request;
httpRequest.Headers["Accept-Charset"] = acceptCharsetHeaders;
httpRequest.ContentType = "application/acceptCharset;charset=" + requestEncoding;
mockHttpContext.SetupGet(o => o.Request).Returns(httpRequest);
var actionContext = new ActionContext(mockHttpContext.Object, new RouteData(), new ActionDescriptor());
var formatter = new TestOutputFormatter();
foreach (string supportedEncoding in supportedEncodings)
{
formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding));
}
var formatterContext = new OutputFormatterContext()
{
Object = "someValue",
ActionContext = actionContext,
DeclaredType = typeof(string)
};
// Act
var actualEncoding = formatter.SelectCharacterEncoding(formatterContext);
// Assert
Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding);
}
public void CreateController_UsesControllerActivatorToInstantiateController()
{
// Arrange
var expected = new MyController();
var actionDescriptor = new ControllerActionDescriptor
{
ControllerTypeInfo = typeof(MyController).GetTypeInfo()
};
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = GetServices();
var actionContext = new ActionContext(httpContext,
new RouteData(),
actionDescriptor);
var activator = new Mock<IControllerActivator>();
activator.Setup(a => a.Create(actionContext, typeof(MyController)))
.Returns(expected)
.Verifiable();
var controllerFactory = new DefaultControllerFactory(activator.Object);
// Act
var result = controllerFactory.CreateController(actionContext);
// Assert
var controller = Assert.IsType<MyController>(result);
Assert.Same(expected, controller);
activator.Verify();
}
public void CreateResponse_DoingConneg_OnlyContent_RetrievesContentNegotiatorFromServices()
{
// Arrange
var context = new DefaultHttpContext();
var services = new Mock<IServiceProvider>();
services
.Setup(s => s.GetService(typeof(IContentNegotiator)))
.Returns(Mock.Of<IContentNegotiator>())
.Verifiable();
var options = new WebApiCompatShimOptions();
options.Formatters.AddRange(new MediaTypeFormatterCollection());
var optionsAccessor = new Mock<IOptions<WebApiCompatShimOptions>>();
optionsAccessor.SetupGet(o => o.Options).Returns(options);
services
.Setup(s => s.GetService(typeof(IOptions<WebApiCompatShimOptions>)))
.Returns(optionsAccessor.Object);
context.RequestServices = services.Object;
var request = CreateRequest(context);
// Act
request.CreateResponse(CreateValue());
// Assert
services.Verify();
}
public async Task Index_ReturnsNoCartItems_WhenNoItemsInCart()
{
// Arrange
var sessionFeature = new SessionFeature()
{
Session = CreateTestSession(),
};
var httpContext = new DefaultHttpContext();
httpContext.SetFeature<ISessionFeature>(sessionFeature);
httpContext.Session.SetString("Session", "CartId_A");
var controller = new ShoppingCartController()
{
DbContext = _serviceProvider.GetRequiredService<MusicStoreContext>(),
};
controller.ActionContext.HttpContext = httpContext;
// Act
var result = await controller.Index();
// Assert
var viewResult = Assert.IsType<ViewResult>(result);
Assert.NotNull(viewResult.ViewData);
Assert.Null(viewResult.ViewName);
var model = Assert.IsType<ShoppingCartViewModel>(viewResult.ViewData.Model);
Assert.Equal(0, model.CartItems.Count);
Assert.Equal(0, model.CartTotal);
}
public async Task ExecuteResultAsync_FallsBackToThePhysicalFileProvider_IfNoFileProviderIsPresent()
{
// Arrange
var path = Path.Combine("TestFiles", "FilePathResultTestFile.txt");
var result = new FilePathResult(path, "text/plain");
var appEnvironment = new Mock<IHostingEnvironment>();
appEnvironment.Setup(app => app.WebRootFileProvider)
.Returns(new PhysicalFileProvider(Directory.GetCurrentDirectory()));
var httpContext = new DefaultHttpContext();
httpContext.Response.Body = new MemoryStream();
httpContext.RequestServices = new ServiceCollection()
.AddInstance<IHostingEnvironment>(appEnvironment.Object)
.BuildServiceProvider();
var context = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
// Act
await result.ExecuteResultAsync(context);
httpContext.Response.Body.Position = 0;
// Assert
Assert.NotNull(httpContext.Response.Body);
var contents = await new StreamReader(httpContext.Response.Body).ReadToEndAsync();
Assert.Equal("FilePathResultTestFile contents", contents);
}
public async Task InvalidModelStateResult_WritesHttpError()
{
// Arrange
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = CreateServices();
var stream = new MemoryStream();
httpContext.Response.Body = stream;
var context = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var modelState = new ModelStateDictionary();
modelState.AddModelError("product.Name", "Name is required.");
var expected =
"{\"Message\":\"The request is invalid.\"," +
"\"ModelState\":{\"product.Name\":[\"Name is required.\"]}}";
var result = new InvalidModelStateResult(modelState, includeErrorDetail: false);
// Act
await result.ExecuteResultAsync(context);
// Assert
using (var reader = new StreamReader(stream))
{
stream.Seek(0, SeekOrigin.Begin);
var content = reader.ReadToEnd();
Assert.Equal(expected, content);
}
}
public async Task AddressAndPayment_RedirectToCompleteWhenSuccessful()
{
// Arrange
var httpContext = new DefaultHttpContext();
var orderId = 10;
var order = new Order()
{
OrderId = orderId,
};
// Session initialization
var cartId = "CartId_A";
var sessionFeature = new SessionFeature()
{
Session = CreateTestSession(),
};
httpContext.SetFeature<ISessionFeature>(sessionFeature);
httpContext.Session.SetString("Session", cartId);
// FormCollection initialization
httpContext.Request.Form =
new FormCollection(
new Dictionary<string, string[]>()
{ { "PromoCode", new string[] { "FREE" } } }
);
// UserName initialization
var claims = new List<Claim> { new Claim(ClaimTypes.Name, "TestUserName") };
httpContext.User = new ClaimsPrincipal(new ClaimsIdentity(claims));
// DbContext initialization
var dbContext = _serviceProvider.GetRequiredService<MusicStoreContext>();
var cartItems = CreateTestCartItems(
cartId,
itemPrice: 10,
numberOfItem: 1);
dbContext.AddRange(cartItems.Select(n => n.Album).Distinct());
dbContext.AddRange(cartItems);
dbContext.SaveChanges();
var controller = new CheckoutController()
{
DbContext = dbContext,
};
controller.ActionContext.HttpContext = httpContext;
// Act
var result = await controller.AddressAndPayment(order, CancellationToken.None);
// Assert
var redirectResult = Assert.IsType<RedirectToActionResult>(result);
Assert.Equal("Complete", redirectResult.ActionName);
Assert.Null(redirectResult.ControllerName);
Assert.NotNull(redirectResult.RouteValues);
Assert.Equal(orderId, redirectResult.RouteValues["Id"]);
}
public void AppendLargeCookie_Appended()
{
HttpContext context = new DefaultHttpContext();
string testString = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
new ChunkingCookieManager() { ChunkSize = null }.AppendResponseCookie(context, "TestCookie", testString, new CookieOptions());
IList<string> values = context.Response.Headers.GetValues("Set-Cookie");
Assert.Equal(1, values.Count);
Assert.Equal("TestCookie=" + testString + "; path=/", values[0]);
}
public Task SingleSlashNotMovedToPathBase()
{
var handler = new ClientHandler(env =>
{
var context = new DefaultHttpContext((IFeatureCollection)env);
Assert.Equal("", context.Request.PathBase.Value);
Assert.Equal("/", context.Request.Path.Value);
return Task.FromResult(0);
}, new PathString(""));
var httpClient = new HttpClient(handler);
return httpClient.GetAsync("https://example.com/");
}
public void HttpRequestMessage_CopiesRequestMethod()
{
// Arrange
var context = new DefaultHttpContext();
var feature = new HttpRequestMessageFeature(context);
context.Request.Method = "OPTIONS";
// Act
var request = feature.HttpRequestMessage;
// Assert
Assert.Equal(new HttpMethod("OPTIONS"), request.Method);
}
public void OnAuthorization_AllowsTheRequestIfItIsHttps()
{
// Arrange
var requestContext = new DefaultHttpContext();
requestContext.Request.Scheme = "https";
var authContext = CreateAuthorizationContext(requestContext);
var attr = new RequireHttpsAttribute();
// Act
attr.OnAuthorization(authContext);
// Assert
Assert.Null(authContext.Result);
}
public void HttpRequestMessage_CopiesContentHeader()
{
// Arrange
var context = new DefaultHttpContext();
var feature = new HttpRequestMessageFeature(context);
context.Request.Method = "OPTIONS";
context.Request.Headers.Add("Content-Type", new string[] { "text/plain" });
// Act
var request = feature.HttpRequestMessage;
// Assert
Assert.Equal("text/plain", request.Content.Headers.ContentType.ToString());
}
public void HttpRequestMessage_CopiesHeader()
{
// Arrange
var context = new DefaultHttpContext();
var feature = new HttpRequestMessageFeature(context);
context.Request.Method = "OPTIONS";
context.Request.Headers.Add("Host", new string[] { "contoso.com" });
// Act
var request = feature.HttpRequestMessage;
// Assert
Assert.Equal("contoso.com", request.Headers.Host);
}
public void HttpStatusCodeResult_ExecuteResultSetsResponseStatusCode()
{
// Arrange
var result = new HttpStatusCodeResult(StatusCodes.Status404NotFound);
var httpContext = new DefaultHttpContext();
var routeData = new RouteData();
var actionDescriptor = new ActionDescriptor();
var context = new ActionContext(httpContext, routeData, actionDescriptor);
// Act
result.ExecuteResult(context);
// Assert
Assert.Equal(StatusCodes.Status404NotFound, httpContext.Response.StatusCode);
}
public void AddingToAnonymousIdentityDoesNotKeepAnonymousIdentity()
{
HttpContext context = new DefaultHttpContext();
context.User.ShouldNotBe(null);
context.User.Identity.IsAuthenticated.ShouldBe(false);
SecurityHelper.AddUserPrincipal(context, new GenericPrincipal(new GenericIdentity("Test1", "Alpha"), new string[0]));
context.User.ShouldNotBe(null);
context.User.Identity.AuthenticationType.ShouldBe("Alpha");
context.User.Identity.Name.ShouldBe("Test1");
context.User.ShouldBeTypeOf<ClaimsPrincipal>();
context.User.Identity.ShouldBeTypeOf<ClaimsIdentity>();
((ClaimsPrincipal)context.User).Identities.Count().ShouldBe(1);
}
public void GetLargeChunkedCookie_Reassembled()
{
HttpContext context = new DefaultHttpContext();
context.Request.Headers.AppendValues("Cookie",
"TestCookie=chunks:7",
"TestCookieC1=abcdefghi",
"TestCookieC2=jklmnopqr",
"TestCookieC3=stuvwxyz0",
"TestCookieC4=123456789",
"TestCookieC5=ABCDEFGHI",
"TestCookieC6=JKLMNOPQR",
"TestCookieC7=STUVWXYZ");
string result = new ChunkingCookieManager().GetRequestCookie(context, "TestCookie");
string testString = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
Assert.Equal(testString, result);
}
public void GetCartId_ReturnsCartIdFromCookies()
{
// Arrange
var cartId = "cartId_A";
var httpContext = new DefaultHttpContext();
httpContext.SetFeature<IRequestCookiesFeature>(new CookiesFeature("Session=" + cartId));
var cart = new ShoppingCart(new MusicStoreContext());
// Act
var result = cart.GetCartId(httpContext);
// Assert
Assert.NotNull(result);
Assert.Equal(cartId, result);
}
public void CreateController_ThrowsIfActionDescriptorIsNotControllerActionDescriptor()
{
// Arrange
var expected = "The action descriptor must be of type 'Microsoft.AspNet.Mvc.ControllerActionDescriptor'." +
Environment.NewLine + "Parameter name: actionContext";
var actionDescriptor = new ActionDescriptor();
var controllerFactory = new DefaultControllerFactory(Mock.Of<IControllerActivator>());
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext(httpContext,
new RouteData(),
actionDescriptor);
// Act and Assert
var ex = Assert.Throws<ArgumentException>(() =>
controllerFactory.CreateController(actionContext));
Assert.Equal(expected, ex.Message);
Assert.Equal("actionContext", ex.ParamName);
}
public async Task NegotiatedContentResult_SetsStatusCode()
{
// Arrange
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = CreateServices();
var stream = new MemoryStream();
httpContext.Response.Body = stream;
var context = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var result = new NegotiatedContentResult<Product>(HttpStatusCode.Ambiguous, new Product());
// Act
await result.ExecuteResultAsync(context);
// Assert
Assert.Equal(300, context.HttpContext.Response.StatusCode);
}
public async Task BadRequestErrorMessageResult_SetsStatusCode()
{
// Arrange
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = CreateServices();
var stream = new MemoryStream();
httpContext.Response.Body = stream;
var context = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var result = new BadRequestErrorMessageResult("Error");
// Act
await result.ExecuteResultAsync(context);
// Assert
Assert.Equal(StatusCodes.Status400BadRequest, context.HttpContext.Response.StatusCode);
}
public async Task ExceptionResult_SetsStatusCode()
{
// Arrange
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = CreateServices();
var stream = new MemoryStream();
httpContext.Response.Body = stream;
var context = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var result = new ExceptionResult(new Exception("hello, world!"), includeErrorDetail: false);
// Act
await result.ExecuteResultAsync(context);
// Assert
Assert.Equal(StatusCodes.Status500InternalServerError, context.HttpContext.Response.StatusCode);
}
public void AccessDependentProperties()
{
// Arrange
var controller = new ConcreteApiController();
var httpContext = new DefaultHttpContext();
httpContext.User = new ClaimsPrincipal();
var routeContext = new RouteContext(httpContext);
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
// Act
controller.ActionContext = actionContext;
// Assert
Assert.Same(httpContext, controller.Context);
Assert.Same(actionContext.ModelState, controller.ModelState);
Assert.Same(httpContext.User, controller.User);
}
public async Task ContentDispositionHeader_IsEncodedCorrectly_ForUnicodeCharacters()
{
// Arrange
var httpContext = new DefaultHttpContext();
var actionContext = CreateActionContext(httpContext);
var result = new EmptyFileResult("application/my-type")
{
FileDownloadName = "ABCXYZabcxyz012789!@#$%^&*()-=_+.:~Δ"
};
// Act
await result.ExecuteResultAsync(actionContext);
// Assert
Assert.True(result.WasWriteFileCalled);
Assert.Equal("application/my-type", httpContext.Response.Headers["Content-Type"]);
Assert.Equal(@"attachment; filename=""ABCXYZabcxyz012789!@#$%^&*()-=_+.:~_""; filename*=UTF-8''ABCXYZabcxyz012789!%40#$%25^&%2A%28%29-%3D_+.%3A~%CE%94",
httpContext.Response.Headers["Content-Disposition"]);
}
public void HttpRequestMessage_CombinesUri()
{
// Arrange
var context = new DefaultHttpContext();
var feature = new HttpRequestMessageFeature(context);
context.Request.Method = "GET";
context.Request.Scheme = "http";
context.Request.Host = new HostString("contoso.com");
context.Request.PathBase = new PathString("/app");
context.Request.Path = new PathString("/api/Products");
context.Request.QueryString = new QueryString("?orderId=3");
// Act
var request = feature.HttpRequestMessage;
// Assert
Assert.Equal("http://contoso.com/app/api/Products?orderId=3", request.RequestUri.AbsoluteUri);
}
