public async Task ObjectResult_ExecuteResultAsync_SetsStatusCode() { // Arrange var result = new ObjectResult("Hello") { StatusCode = 404, Formatters = new List<IOutputFormatter>() { new NoOpOutputFormatter(), }, }; var actionContext = new ActionContext() { HttpContext = new DefaultHttpContext() { RequestServices = CreateServices(), } }; // Act await result.ExecuteResultAsync(actionContext); // Assert Assert.Equal(404, actionContext.HttpContext.Response.StatusCode); }
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 RedirectToRoute_Execute_ThrowsOnNullUrl() { // Arrange var httpContext = new Mock<HttpContext>(); httpContext .Setup(o => o.Response) .Returns(new Mock<HttpResponse>().Object); httpContext .SetupGet(o => o.RequestServices) .Returns(CreateServices().BuildServiceProvider()); var actionContext = new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor()); var urlHelper = GetMockUrlHelper(returnValue: null); var result = new RedirectToRouteResult(null, new Dictionary<string, object>()) { UrlHelper = urlHelper, }; // Act & Assert await ExceptionAssert.ThrowsAsync<InvalidOperationException>( async () => { await result.ExecuteResultAsync(actionContext); }, "No route matches the supplied values."); }
public async void RedirectToRoute_Execute_PassesCorrectValuesToRedirect(object values) { // Arrange var expectedUrl = "SampleAction"; var expectedPermanentFlag = false; var httpContext = new Mock<HttpContext>(); httpContext.SetupGet(o => o.RequestServices).Returns(CreateServices().BuildServiceProvider()); var httpResponse = new Mock<HttpResponse>(); httpContext.Setup(o => o.Response).Returns(httpResponse.Object); var actionContext = new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor()); var urlHelper = GetMockUrlHelper(expectedUrl); var result = new RedirectToRouteResult(null, PropertyHelper.ObjectToDictionary(values)) { UrlHelper = urlHelper, }; // Act await result.ExecuteResultAsync(actionContext); // Assert // Verifying if Redirect was called with the specific Url and parameter flag. // Thus we verify that the Url returned by UrlHelper is passed properly to // Redirect method and that the method is called exactly once. httpResponse.Verify(r => r.Redirect(expectedUrl, expectedPermanentFlag), Times.Exactly(1)); }
public async Task PartialViewResult_UsesFindPartialViewOnSpecifiedViewEngineToLocateViews() { // Arrange var viewName = "myview"; var context = new ActionContext(GetHttpContext(), new RouteData(), new ActionDescriptor()); var viewEngine = new Mock<IViewEngine>(); var view = Mock.Of<IView>(); viewEngine .Setup(e => e.FindPartialView(context, "myview")) .Returns(ViewEngineResult.Found("myview", view)) .Verifiable(); var viewResult = new PartialViewResult { ViewName = viewName, ViewEngine = viewEngine.Object, ViewData = new ViewDataDictionary(new EmptyModelMetadataProvider()), TempData = Mock.Of<ITempDataDictionary>(), }; // Act await viewResult.ExecuteResultAsync(context); // Assert viewEngine.Verify(); }
public async Task<IDictionary<string, object>> BindActionArgumentsAsync( ActionContext actionContext, ActionBindingContext actionBindingContext, object controller) { var actionDescriptor = actionContext.ActionDescriptor as ControllerActionDescriptor; if (actionDescriptor == null) { throw new ArgumentException( Resources.FormatActionDescriptorMustBeBasedOnControllerAction( typeof(ControllerActionDescriptor)), nameof(actionContext)); } var operationBindingContext = GetOperationBindingContext(actionContext, actionBindingContext); var controllerProperties = new Dictionary<string, object>(StringComparer.Ordinal); await PopulateArgumentsAsync( operationBindingContext, actionContext.ModelState, controllerProperties, actionDescriptor.BoundProperties); var controllerType = actionDescriptor.ControllerTypeInfo.AsType(); ActivateProperties(controller, controllerType, controllerProperties); var actionArguments = new Dictionary<string, object>(StringComparer.Ordinal); await PopulateArgumentsAsync( operationBindingContext, actionContext.ModelState, actionArguments, actionDescriptor.Parameters); return actionArguments; }
public async Task ExecuteResultAsync_InvokesForbiddenAsyncOnAllConfiguredSchemes() { // Arrange var authProperties = new AuthenticationProperties(); var authenticationManager = new Mock<AuthenticationManager>(); authenticationManager .Setup(c => c.ForbidAsync("Scheme1", authProperties)) .Returns(TaskCache.CompletedTask) .Verifiable(); authenticationManager .Setup(c => c.ForbidAsync("Scheme2", authProperties)) .Returns(TaskCache.CompletedTask) .Verifiable(); var httpContext = new Mock<HttpContext>(); httpContext.Setup(c => c.RequestServices).Returns(CreateServices()); httpContext.Setup(c => c.Authentication).Returns(authenticationManager.Object); var result = new ForbidResult(new[] { "Scheme1", "Scheme2" }, authProperties); var routeData = new RouteData(); var actionContext = new ActionContext( httpContext.Object, routeData, new ActionDescriptor()); // Act await result.ExecuteResultAsync(actionContext); // Assert authenticationManager.Verify(); }
public async Task ExecuteResult_UsesEncoderIfSpecified() { // Arrange var expected = Enumerable.Concat(Encoding.UTF8.GetPreamble(), _abcdUTF8Bytes); var memoryStream = new MemoryStream(); var response = new Mock<HttpResponse>(); response.SetupGet(r => r.Body) .Returns(memoryStream); var context = new Mock<HttpContext>(); context.SetupGet(c => c.Response) .Returns(response.Object); var actionContext = new ActionContext(context.Object, new RouteData(), new ActionDescriptor()); var result = new JsonResult(new { foo = "abcd" }) { Encoding = Encoding.UTF8 }; // Act await result.ExecuteResultAsync(actionContext); // Assert Assert.Equal(expected, memoryStream.ToArray()); }
/// <inheritdoc /> public override Task ExecuteResultAsync(ActionContext context) { var response = context.HttpContext.Response; response.ContentType = ContentType.Bson; if (StatusCode != null) { response.StatusCode = StatusCode.Value; } var serializerSettings = _serializerSettings; if (serializerSettings == null) { serializerSettings = context .HttpContext .RequestServices .GetRequiredService<IOptions<MvcJsonOptions>>() .Value .SerializerSettings; } using (var bsonWriter = new BsonWriter(response.Body)) { bsonWriter.CloseOutput = false; var jsonSerializer = JsonSerializer.Create(serializerSettings); jsonSerializer.Serialize(bsonWriter, Value); } return Task.FromResult(true); }
public override Task ExecuteResultAsync(ActionContext context) { var executor = context.HttpContext.RequestServices.GetRequiredService<ObjectResultExecutor>(); var result = executor.ExecuteAsync(context, this); return result; }
public async Task ExecuteResultAsync(ActionContext context) { var routeDef = context.RouteData.DataTokens.ContainsKey("umbraco-route-def") ? context.RouteData.DataTokens["umbraco-route-def"] as RouteDefinition : null; if (routeDef == null) throw new InvalidOperationException($"The route data DataTokens must contain an instance of {typeof(RouteDefinition)} with a key of umbraco-route-def"); var actionFactory = context.HttpContext.RequestServices .GetService<IActionInvokerFactory>(); var providers = context.HttpContext.RequestServices .GetService<IActionDescriptorsCollectionProvider>(); var actionDesc = providers.ActionDescriptors .Items .OfType<ControllerActionDescriptor>() .First(x => x.ControllerName.InvariantEquals(routeDef.ControllerName) && x.Name.InvariantEquals(routeDef.ActionName)); var copied = new ActionContext(context.HttpContext, context.RouteData, actionDesc); copied.ModelState.Merge(context.ModelState); copied.RouteData.DataTokens["umbraco-vdd"] = _vdd; await actionFactory.CreateInvoker(copied).InvokeAsync(); }
private ViewDataDictionary GetViewDataDictionary(ActionContext context) { var serviceProvider = context.HttpContext.RequestServices; return new ViewDataDictionary( _modelMetadataProvider, context.ModelState); }
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 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)); }
/// <inheritdoc /> public override void OnFormatting(ActionContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } base.OnFormatting(context); var request = context.HttpContext.Request; var urlHelper = UrlHelper ?? context.HttpContext.RequestServices.GetRequiredService<IUrlHelper>(); var url = urlHelper.Action( ActionName, ControllerName, RouteValues, request.Scheme, request.Host.ToUriComponent()); if (string.IsNullOrEmpty(url)) { throw new InvalidOperationException(Resources.NoRoutesMatched); } context.HttpContext.Response.Headers[HeaderNames.Location] = url; }
public Task ExecuteResultAsync(ActionContext context) { context.HttpContext.Response.StatusCode = StatusCodes.Status200OK; context.HttpContext.Response.ContentType = "text/plain"; context.HttpContext.Response.ContentLength = _helloWorldPayload.Length; return context.HttpContext.Response.Body.WriteAsync(_helloWorldPayload, 0, _helloWorldPayload.Length); }
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 void Create_TypeActivatesTypesWithServices() { // Arrange var activator = new DefaultControllerActivator(new DefaultTypeActivatorCache()); var serviceProvider = new Mock<IServiceProvider>(MockBehavior.Strict); var testService = new TestService(); serviceProvider.Setup(s => s.GetService(typeof(TestService))) .Returns(testService) .Verifiable(); var httpContext = new DefaultHttpContext { RequestServices = serviceProvider.Object }; var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor()); // Act var instance = activator.Create(actionContext, typeof(TypeDerivingFromControllerWithServices)); // Assert var controller = Assert.IsType<TypeDerivingFromControllerWithServices>(instance); Assert.Same(testService, controller.TestService); serviceProvider.Verify(); }
public static HttpContextAccessor CreateHttpContextAccessor(RequestTelemetry requestTelemetry = null, ActionContext actionContext = null) { var services = new ServiceCollection(); var request = new DefaultHttpContext().Request; request.Method = "GET"; request.Path = new PathString("/Test"); var contextAccessor = new HttpContextAccessor() { HttpContext = request.HttpContext }; services.AddInstance<IHttpContextAccessor>(contextAccessor); if (actionContext != null) { var si = new ActionContextAccessor(); si.ActionContext = actionContext; services.AddInstance<IActionContextAccessor>(si); } if (requestTelemetry != null) { services.AddInstance<RequestTelemetry>(requestTelemetry); } IServiceProvider serviceProvider = services.BuildServiceProvider(); contextAccessor.HttpContext.RequestServices = serviceProvider; return contextAccessor; }
/// <inheritdoc /> public override Task ExecuteResultAsync(ActionContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var loggerFactory = context.HttpContext.RequestServices.GetRequiredService<ILoggerFactory>(); var logger = loggerFactory.CreateLogger<FileResult>(); var response = context.HttpContext.Response; response.ContentType = ContentType.ToString(); if (!string.IsNullOrEmpty(FileDownloadName)) { // From RFC 2183, Sec. 2.3: // The sender may want to suggest a filename to be used if the entity is // detached and stored in a separate file. If the receiving MUA writes // the entity to a file, the suggested filename should be used as a // basis for the actual filename, where possible. var contentDisposition = new ContentDispositionHeaderValue("attachment"); contentDisposition.SetHttpFileName(FileDownloadName); context.HttpContext.Response.Headers[HeaderNames.ContentDisposition] = contentDisposition.ToString(); } logger.FileResultExecuting(FileDownloadName); return WriteFileAsync(response); }
public override async Task ExecuteResultAsync(ActionContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var loggerFactory = context.HttpContext.RequestServices.GetRequiredService<ILoggerFactory>(); var logger = loggerFactory.CreateLogger<ChallengeResult>(); var authentication = context.HttpContext.Authentication; if (AuthenticationSchemes.Count > 0) { foreach (var scheme in AuthenticationSchemes) { await authentication.ChallengeAsync(scheme, Properties); } } else { await authentication.ChallengeAsync(Properties); } logger.ChallengeResultExecuting(AuthenticationSchemes); }
public override Task ExecuteResultAsync(ActionContext context) { var webSocket = context.HttpContext.WebSockets.AcceptWebSocketAsync().Result; BlockingStream stream = new BlockingStream(16); //Read from stream as it comes in. Task.Factory.StartNew(() => _streamHandlerAction(stream)); var receive = Task.Factory.StartNew(() => { byte[] buffer = new byte[1024 * 63]; while (true) { // MUST read if we want the state to get updated... var result = webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None).Result; stream.Write(buffer, 0, result.Count); if (result.MessageType == WebSocketMessageType.Close) { webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, CancellationToken.None); stream.CompleteWriting(); break; } } }); return receive; }
public async Task ExecuteResultAsync_FallsBackToWebRootFileProvider_IfNoFileProviderIsPresent() { // Arrange var path = Path.Combine("TestFiles", "FilePathResultTestFile.txt"); var result = new TestVirtualFileResult(path, "text/plain"); var appEnvironment = new Mock<IHostingEnvironment>(); appEnvironment.Setup(app => app.WebRootFileProvider) .Returns(GetFileProvider(path)); var httpContext = GetHttpContext(); httpContext.Response.Body = new MemoryStream(); httpContext.RequestServices = new ServiceCollection() .AddSingleton<IHostingEnvironment>(appEnvironment.Object) .AddTransient<ILoggerFactory, LoggerFactory>() .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 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); }
private static ViewComponentContext GetViewComponentContext(IView view, Stream stream) { var actionContext = new ActionContext(GetHttpContext(), new RouteData(), new ActionDescriptor()); var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider()); var viewContext = new ViewContext( actionContext, view, viewData, Mock.Of<ITempDataDictionary>(), TextWriter.Null, new HtmlHelperOptions()); var writer = new StreamWriter(stream) { AutoFlush = true }; var viewComponentDescriptor = new ViewComponentDescriptor() { Type = typeof(object), }; var viewComponentContext = new ViewComponentContext( viewComponentDescriptor, new Dictionary<string, object>(), new HtmlTestEncoder(), viewContext, writer); return viewComponentContext; }
public async Task ExecuteResultAsync_ReturnsError_IfViewCouldNotBeFound() { // Arrange var expected = string.Join(Environment.NewLine, "The view 'MyView' was not found. The following locations were searched:", "Location1", "Location2."); var actionContext = new ActionContext(GetHttpContext(), new RouteData(), new ActionDescriptor()); var viewEngine = new Mock<IViewEngine>(); viewEngine.Setup(v => v.FindPartialView(It.IsAny<ActionContext>(), It.IsAny<string>())) .Returns(ViewEngineResult.NotFound("MyView", new[] { "Location1", "Location2" })) .Verifiable(); var viewResult = new PartialViewResult { ViewEngine = viewEngine.Object, ViewName = "MyView" }; // Act and Assert var ex = await Assert.ThrowsAsync<InvalidOperationException>( () => viewResult.ExecuteResultAsync(actionContext)); Assert.Equal(expected, ex.Message); viewEngine.Verify(); }
/// <inheritdoc /> public override void OnFormatting(ActionContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } base.OnFormatting(context); var urlHelper = UrlHelper; if (urlHelper == null) { var services = context.HttpContext.RequestServices; urlHelper = services.GetRequiredService<IUrlHelperFactory>().GetUrlHelper(context); } var url = urlHelper.Link(RouteName, RouteValues); if (string.IsNullOrEmpty(url)) { throw new InvalidOperationException(Resources.NoRoutesMatched); } context.HttpContext.Response.Headers[HeaderNames.Location] = url; }
public override async Task ExecuteResultAsync(ActionContext context) { // See if the list of content types added to this object result is valid. ThrowIfUnsupportedContentType(); var formatters = GetDefaultFormatters(context); var formatterContext = new OutputFormatterContext() { DeclaredType = DeclaredType, ActionContext = context, Object = Value, StatusCode = StatusCode }; var selectedFormatter = SelectFormatter(formatterContext, formatters); if (selectedFormatter == null) { // No formatter supports this. context.HttpContext.Response.StatusCode = StatusCodes.Status406NotAcceptable; return; } if (StatusCode.HasValue) { context.HttpContext.Response.StatusCode = StatusCode.Value; } OnFormatting(context); await selectedFormatter.WriteAsync(formatterContext); }
public override Task ExecuteResultAsync(ActionContext context) { if(context == null) { throw new ArgumentNullException(nameof(context)); } return iCalendarOutputFormatter.WriteResponseBodyAsync(context.HttpContext.Response, _uid, _datetime, _duration, _summary, _description, _location); }
public Task<ActionBindingContext> GetActionBindingContextAsync(ActionContext actionContext) { if (_bindingContext != null) { if (actionContext == _bindingContext.Item1) { return Task.FromResult(_bindingContext.Item2); } } var factoryContext = new ValueProviderFactoryContext( actionContext.HttpContext, actionContext.RouteData.Values); var valueProvider = _compositeValueProviderFactory.GetValueProvider(factoryContext); var context = new ActionBindingContext( actionContext, _modelMetadataProvider, _compositeModelBinder, valueProvider, _inputFormatterProvider, _validatorProviders); _bindingContext = new Tuple<ActionContext, ActionBindingContext>(actionContext, context); return Task.FromResult(context); }
protected virtual async Task <ActionDescriptor> SelectBestCandidate( RouteContext context, List <ActionDescriptor> candidates) { var applicableCandiates = new List <ActionDescriptorCandidate>(); foreach (var action in candidates) { var isApplicable = true; var candidate = new ActionDescriptorCandidate() { Action = action, }; var actionContext = new ActionContext(context, action); var actionBindingContext = await _bindingProvider.GetActionBindingContextAsync(actionContext); foreach (var parameter in action.Parameters.Where(p => p.ParameterBindingInfo != null)) { if (!ValueProviderResult.CanConvertFromString(parameter.ParameterBindingInfo.ParameterType)) { continue; } if (await actionBindingContext.ValueProvider.ContainsPrefixAsync( parameter.ParameterBindingInfo.Prefix)) { candidate.FoundParameters++; if (parameter.IsOptional) { candidate.FoundOptionalParameters++; } } else if (!parameter.IsOptional) { isApplicable = false; break; } } if (isApplicable) { applicableCandiates.Add(candidate); } } if (applicableCandiates.Count == 0) { return(null); } var mostParametersSatisfied = applicableCandiates .GroupBy(c => c.FoundParameters) .OrderByDescending(g => g.Key) .First(); var fewestOptionalParameters = mostParametersSatisfied .GroupBy(c => c.FoundOptionalParameters) .OrderBy(g => g.Key).First() .ToArray(); if (fewestOptionalParameters.Length > 1) { throw new InvalidOperationException("The actions are ambiguious."); } return(fewestOptionalParameters[0].Action); }
/// <inheritdoc /> public virtual object Create([NotNull] ActionContext actionContext, [NotNull] Type controllerType) { var serviceProvider = actionContext.HttpContext.RequestServices; return(_typeActivatorCache.CreateInstance <object>(serviceProvider, controllerType)); }