public TestBase() { if (ServiceProvider == null) { var services = new ServiceCollection(); // set up empty in-memory test db services.AddEntityFramework() .AddInMemoryDatabase() .AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase()); // add identity service services.AddIdentity<ApplicationUser, IdentityRole>() .AddEntityFrameworkStores<AllReadyContext>(); var context = new DefaultHttpContext(); context.Features.Set<IHttpAuthenticationFeature>(new HttpAuthenticationFeature()); services.AddSingleton<IHttpContextAccessor>(h => new HttpContextAccessor { HttpContext = context }); // Setup hosting environment IHostingEnvironment hostingEnvironment = new HostingEnvironment(); hostingEnvironment.EnvironmentName = "Development"; services.AddSingleton(x => hostingEnvironment); // set up service provider for tests ServiceProvider = services.BuildServiceProvider(); } }
public void SettingViewData_AlsoUpdatesViewBag() { // Arrange var httpContext = new DefaultHttpContext(); var originalViewData = new ViewDataDictionary(metadataProvider: new EmptyModelMetadataProvider()); var context = new ViewContext( new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor()), view: Mock.Of<IView>(), viewData: originalViewData, tempData: new TempDataDictionary(httpContext, Mock.Of<ITempDataProvider>()), writer: TextWriter.Null, htmlHelperOptions: new HtmlHelperOptions()); var replacementViewData = new ViewDataDictionary(metadataProvider: new EmptyModelMetadataProvider()); // Act context.ViewBag.Hello = "goodbye"; context.ViewData = replacementViewData; context.ViewBag.Another = "property"; // Assert Assert.NotSame(originalViewData, context.ViewData); Assert.Same(replacementViewData, context.ViewData); Assert.Null(context.ViewBag.Hello); Assert.Equal("property", context.ViewBag.Another); Assert.Equal("property", context.ViewData["Another"]); }
public void Clear_AlreadyStarted_Throws() { var context = new DefaultHttpContext(); context.Features.Set<IHttpResponseFeature>(new StartedResponseFeature()); Assert.Throws<InvalidOperationException>(() => context.Response.Clear()); }
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.Features.Get<IFormFeature>(); Assert.Null(formFeature); // Act var formCollection = await context.Request.ReadFormAsync(); // Assert Assert.Equal("bar", formCollection["foo"]); Assert.Equal("2", formCollection["baz"]); Assert.Equal(0, context.Request.Body.Position); Assert.True(context.Request.Body.CanSeek); // Cached formFeature = context.Features.Get<IFormFeature>(); Assert.NotNull(formFeature); Assert.NotNull(formFeature.Form); Assert.Same(formFeature.Form, formCollection); }
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 async void Invoke_DoesNotLog_WhenHandled() { // Arrange var isHandled = true; var sink = new TestSink( TestSink.EnableWithTypeName<RouterMiddleware>, TestSink.EnableWithTypeName<RouterMiddleware>); var loggerFactory = new TestLoggerFactory(sink, enabled: true); 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.Empty(sink.Scopes); Assert.Empty(sink.Writes); }
public async void Invoke_LogsCorrectValues_WhenNotHandled() { // Arrange var expectedMessage = "Request did not match any routes."; var isHandled = false; var sink = new TestSink( TestSink.EnableWithTypeName<RouterMiddleware>, TestSink.EnableWithTypeName<RouterMiddleware>); var loggerFactory = new TestLoggerFactory(sink, enabled: true); 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.Empty(sink.Scopes); Assert.Single(sink.Writes); Assert.Equal(expectedMessage, sink.Writes[0].State?.ToString()); }
public void SelectResponseCharacterEncoding_SelectsEncoding( string acceptCharsetHeaders, string[] supportedEncodings, string expectedEncoding) { // Arrange var httpContext = new Mock<HttpContext>(); var httpRequest = new DefaultHttpContext().Request; httpRequest.Headers[HeaderNames.AcceptCharset] = acceptCharsetHeaders; httpRequest.Headers[HeaderNames.Accept] = "application/acceptCharset"; httpContext.SetupGet(o => o.Request).Returns(httpRequest); var formatter = new TestOutputFormatter(); foreach (string supportedEncoding in supportedEncodings) { formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding)); } var context = new OutputFormatterWriteContext( httpContext.Object, new TestHttpResponseStreamWriterFactory().CreateWriter, typeof(string), "someValue") { ContentType = MediaTypeHeaderValue.Parse(httpRequest.Headers[HeaderNames.Accept]), }; // Act var actualEncoding = formatter.SelectCharacterEncoding(context); // Assert Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding); }
public void CopyConstructor_CopiesExpectedProperties() { // Arrange var httpContext = new DefaultHttpContext(); var originalContext = new ViewContext( new ActionContext(httpContext, new RouteData(), new ActionDescriptor()), view: Mock.Of<IView>(), viewData: new ViewDataDictionary(metadataProvider: new EmptyModelMetadataProvider()), tempData: new TempDataDictionary(httpContext, Mock.Of<ITempDataProvider>()), writer: TextWriter.Null, htmlHelperOptions: new HtmlHelperOptions()); var view = Mock.Of<IView>(); var viewData = new ViewDataDictionary(originalContext.ViewData); var writer = new HtmlContentWrapperTextWriter(new HtmlContentBuilder(), Encoding.UTF8); // Act var context = new ViewContext(originalContext, view, viewData, writer); // Assert Assert.Same(originalContext.ActionDescriptor, context.ActionDescriptor); Assert.Equal(originalContext.ClientValidationEnabled, context.ClientValidationEnabled); Assert.Same(originalContext.ExecutingFilePath, context.ExecutingFilePath); Assert.Same(originalContext.FormContext, context.FormContext); Assert.Equal(originalContext.Html5DateRenderingMode, context.Html5DateRenderingMode); Assert.Same(originalContext.HttpContext, context.HttpContext); Assert.Same(originalContext.ModelState, context.ModelState); Assert.Same(originalContext.RouteData, context.RouteData); Assert.Same(originalContext.TempData, context.TempData); Assert.Same(originalContext.ValidationMessageElement, context.ValidationMessageElement); Assert.Same(originalContext.ValidationSummaryMessageElement, context.ValidationSummaryMessageElement); Assert.Same(view, context.View); Assert.Same(viewData, context.ViewData); Assert.Same(writer, context.Writer); }
public async Task Index_ReturnsNoCartItems_WhenNoItemsInCart() { // Arrange var httpContext = new DefaultHttpContext(); httpContext.Session = new TestSession(); 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 void EmptyUserIsNeverNull() { var context = new DefaultHttpContext(new FeatureCollection()); Assert.NotNull(context.User); Assert.Equal(1, context.User.Identities.Count()); Assert.True(object.ReferenceEquals(context.User, context.User)); Assert.False(context.User.Identity.IsAuthenticated); Assert.True(string.IsNullOrEmpty(context.User.Identity.AuthenticationType)); context.User = null; Assert.NotNull(context.User); Assert.Equal(1, context.User.Identities.Count()); Assert.True(object.ReferenceEquals(context.User, context.User)); Assert.False(context.User.Identity.IsAuthenticated); Assert.True(string.IsNullOrEmpty(context.User.Identity.AuthenticationType)); context.User = new ClaimsPrincipal(); Assert.NotNull(context.User); Assert.Equal(0, context.User.Identities.Count()); Assert.True(object.ReferenceEquals(context.User, context.User)); Assert.Null(context.User.Identity); context.User = new ClaimsPrincipal(new ClaimsIdentity("SomeAuthType")); Assert.Equal("SomeAuthType", context.User.Identity.AuthenticationType); Assert.True(context.User.Identity.IsAuthenticated); }
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 void GetT_UnknownTypeWithTryParseAndMissingValue_Null() { var context = new DefaultHttpContext(); var result = context.Request.GetTypedHeaders().Get<TestHeaderValue>("custom"); Assert.Null(result); }
public void GetT_UnknownTypeWithoutTryParse_Throws() { var context = new DefaultHttpContext(); context.Request.Headers["custom"] = "valid"; Assert.Throws<NotSupportedException>(() => context.Request.GetTypedHeaders().Get<object>("custom")); }
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 void Initialize_SessionHeaderCreated() { var ctxt = new DefaultHttpContext(); var session = Subject.Initialize(ctxt); Assert.Equal(session, ctxt.Response.Headers[Options.SessionHeader]); }
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.Features.Get<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 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 formatter = new TestOutputFormatter(); foreach (string supportedEncoding in supportedEncodings) { formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding)); } var formatterContext = new OutputFormatterContext() { Object = "someValue", HttpContext = mockHttpContext.Object, DeclaredType = typeof(string) }; // Act var actualEncoding = formatter.SelectCharacterEncoding(formatterContext); // Assert Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding); }
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 void CanUseRegisterExtensionMethod() { var curie = new CuriesLink("aap", "http://www.helpt.com/{?rel}"); var builder = Hypermedia.CreateBuilder(); var selfLink = new Link<ProductRepresentation>("product", "http://www.product.com?id=1"); var link2 = new Link("related", "http://www.related.com"); var link3 = curie.CreateLink<CategoryRepresentation>("category", "http://www.category.com"); builder.Register(selfLink, link2, link3); var config = builder.Build(); // arrange var mediaFormatter = new JsonHalOutputFormatter(config) { }; var type = representation.GetType(); var httpContext = new Mock<HttpContext>(); var httpRequest = new DefaultHttpContext().Request; httpContext.SetupGet(o => o.Request).Returns(httpRequest); // act using (var stream = new MemoryStream()) { mediaFormatter.WriteResponseBodyAsync(new OutputFormatterWriteContext(httpContext.Object, (s,e)=> new HttpResponseStreamWriter(s, e), type, representation)); //WriteToStreamAsync(type, representation, stream, content, null); stream.Seek(0, SeekOrigin.Begin); var serialisedResult = new StreamReader(stream).ReadToEnd(); // assert Approvals.Verify(serialisedResult); } }
private static ViewComponentContext GetViewComponentContext(IView view, Stream stream) { var httpContext = new DefaultHttpContext(); var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor()); var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider()); var viewContext = new ViewContext( actionContext, view, viewData, new TempDataDictionary(httpContext, new SessionStateTempDataProvider()), 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 Create_InstanceNotNull() { var ctxt = new DefaultHttpContext(); var session = await CreateNew(ctxt, "Test"); Assert.NotNull(session.Instance); }
public void GetIdentifier_ExistingSession_NotNull() { var ctxt = new DefaultHttpContext(); var session = Subject.Initialize(ctxt); Assert.Equal(session, Subject.GetIdentifier(ctxt)); }
public void OnActionExecuted_HandlesExceptionAndReturnsObjectResult() { // Arrange var filter = new HttpResponseExceptionActionFilter(); var httpContext = new DefaultHttpContext(); httpContext.Request.Method = "GET"; var actionContext = new ActionContext( httpContext, new RouteData(), Mock.Of<ActionDescriptor>()); var context = new ActionExecutedContext( actionContext, filters: new List<IFilter>(), controller: new object()); context.Exception = new HttpResponseException(HttpStatusCode.BadRequest); // Act filter.OnActionExecuted(context); // Assert Assert.True(context.ExceptionHandled); var result = Assert.IsType<ObjectResult>(context.Result); Assert.Equal(typeof(HttpResponseMessage), result.DeclaredType); var response = Assert.IsType<HttpResponseMessage>(result.Value); Assert.NotNull(response.RequestMessage); Assert.Equal(context.HttpContext.GetHttpRequestMessage(), response.RequestMessage); Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); }
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; }
public void GenerateFormToken_AuthenticatedWithoutUsernameAndNoAdditionalData_NoAdditionalData() { // Arrange var cookieToken = new AntiforgeryToken() { IsSessionToken = true }; var httpContext = new DefaultHttpContext(); httpContext.User = new ClaimsPrincipal(new MyAuthenticatedIdentityWithoutUsername()); var options = new AntiforgeryOptions(); var claimUidExtractor = new Mock<IClaimUidExtractor>().Object; var tokenProvider = new DefaultAntiforgeryTokenGenerator( claimUidExtractor: claimUidExtractor, additionalDataProvider: null); // Act & assert var exception = Assert.Throws<InvalidOperationException>( () => tokenProvider.GenerateFormToken(httpContext, cookieToken)); Assert.Equal( "The provided identity of type " + $"'{typeof(MyAuthenticatedIdentityWithoutUsername).FullName}' " + "is marked IsAuthenticated = true but does not have a value for Name. " + "By default, the antiforgery system requires that all authenticated identities have a unique Name. " + "If it is not possible to provide a unique Name for this identity, " + "consider extending IAntiforgeryAdditionalDataProvider by overriding the " + "DefaultAntiforgeryAdditionalDataProvider " + "or a custom type that can provide some form of unique identifier for the current user.", exception.Message); }
private static HttpContext GetHttpContext() { var httpContext = new Mock<HttpContext>(); var realContext = new DefaultHttpContext(); var request = realContext.Request; request.PathBase = new PathString(""); var response = realContext.Response; response.Body = new MemoryStream(); httpContext.Setup(o => o.Request) .Returns(request); httpContext.Setup(o => o.Response) .Returns(response); var optionsAccessor = new MockMvcOptionsAccessor(); optionsAccessor.Options.OutputFormatters.Add(new StringOutputFormatter()); optionsAccessor.Options.OutputFormatters.Add(new JsonOutputFormatter()); httpContext .Setup(p => p.RequestServices.GetService(typeof(IOptions<MvcOptions>))) .Returns(optionsAccessor); httpContext .Setup(p => p.RequestServices.GetService(typeof(ILogger<ObjectResult>))) .Returns(new Mock<ILogger<ObjectResult>>().Object); var mockActionBindingContext = new Mock<IScopedInstance<ActionBindingContext>>(); mockActionBindingContext .SetupGet(o=> o.Value) .Returns(new ActionBindingContext() { OutputFormatters = optionsAccessor.Options.OutputFormatters }); httpContext .Setup(o => o.RequestServices.GetService(typeof(IScopedInstance<ActionBindingContext>))) .Returns(mockActionBindingContext.Object); return httpContext.Object; }
public void GetT_UnknownTypeWithTryParseAndValidValue_Success() { var context = new DefaultHttpContext(); context.Request.Headers["custom"] = "valid"; var result = context.Request.GetTypedHeaders().Get<TestHeaderValue>("custom"); Assert.NotNull(result); }
private HttpContext CreateContext() { var context = new DefaultHttpContext(); return(context); }
public DefaultHttpRequest(DefaultHttpContext context, IFeatureCollection features) { _context = context; _features = features; }