public void Create_CreatesInstancesOfTypes(Type type)
{
// Arrange
var activator = new DefaultControllerActivator(new TypeActivatorCache());
var serviceProvider = new Mock<IServiceProvider>(MockBehavior.Strict);
var httpContext = new DefaultHttpContext
{
RequestServices = serviceProvider.Object
};
var context = new ControllerContext(
new ActionContext(
httpContext,
new RouteData(),
new ControllerActionDescriptor
{
ControllerTypeInfo = type.GetTypeInfo()
}));
// Act
var instance = activator.Create(context);
// Assert
Assert.IsType(type, instance);
}
public void Create_TypeActivatesTypesWithServices()
{
// Arrange
var activator = new DefaultControllerActivator(new TypeActivatorCache());
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 context = new ControllerContext(
new ActionContext(
httpContext,
new RouteData(),
new ControllerActionDescriptor
{
ControllerTypeInfo = typeof(TypeDerivingFromControllerWithServices).GetTypeInfo()
}));
// Act
var instance = activator.Create(context);
// Assert
var controller = Assert.IsType<TypeDerivingFromControllerWithServices>(instance);
Assert.Same(testService, controller.TestService);
serviceProvider.Verify();
}
public void Create_ThrowsIfControllerIsNotRegisteredInServiceProvider()
{
// Arrange
var expected = "No service for type '" + typeof(DIController) + "' has been registered.";
var controller = new DIController();
var httpContext = new DefaultHttpContext
{
RequestServices = Mock.Of<IServiceProvider>()
};
var activator = new ServiceBasedControllerActivator();
var context = new ControllerContext(
new ActionContext(
httpContext,
new RouteData(),
new ControllerActionDescriptor
{
ControllerTypeInfo = typeof(DIController).GetTypeInfo()
}));
// Act and Assert
var ex = Assert.Throws<InvalidOperationException>(
() => activator.Create(context));
Assert.Equal(expected, ex.Message);
}
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 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.Value).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 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 = new StringSegment(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 StringWriter();
// 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 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.AddSingleton<IHttpContextAccessor>(contextAccessor);
if (actionContext != null)
{
var si = new ActionContextAccessor();
si.ActionContext = actionContext;
services.AddSingleton<IActionContextAccessor>(si);
}
if (requestTelemetry != null)
{
services.AddSingleton<RequestTelemetry>(requestTelemetry);
}
IServiceProvider serviceProvider = services.BuildServiceProvider();
contextAccessor.HttpContext.RequestServices = serviceProvider;
return contextAccessor;
}
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.RequestServices = new ServiceProvider();
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 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 GenerateRequestToken_AuthenticatedWithoutUsernameAndNoAdditionalData_NoAdditionalData()
{
// Arrange
var cookieToken = new AntiforgeryToken()
{
IsCookieToken = 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.GenerateRequestToken(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);
}
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.RequestServices = new ServiceProvider();
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 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<IFilterMetadata>(),
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 void Create_GetsServicesFromServiceProvider()
{
// Arrange
var controller = new DIController();
var serviceProvider = new Mock<IServiceProvider>(MockBehavior.Strict);
serviceProvider.Setup(s => s.GetService(typeof(DIController)))
.Returns(controller)
.Verifiable();
var httpContext = new DefaultHttpContext
{
RequestServices = serviceProvider.Object
};
var activator = new ServiceBasedControllerActivator();
var context = new ControllerContext(new ActionContext(
httpContext,
new RouteData(),
new ControllerActionDescriptor
{
ControllerTypeInfo = typeof(DIController).GetTypeInfo()
}));
// Act
var instance = activator.Create(context);
// Assert
Assert.Same(controller, instance);
serviceProvider.Verify();
}
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()
{
TypeInfo = typeof(object).GetTypeInfo(),
};
var viewComponentContext = new ViewComponentContext(
viewComponentDescriptor,
new Dictionary<string, object>(),
new HtmlTestEncoder(),
viewContext,
writer);
return viewComponentContext;
}
public TestBase()
{
if (ServiceProvider == null)
{
var services = new ServiceCollection();
// set up empty in-memory test db
services
.AddEntityFrameworkInMemoryDatabase()
.AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase().UseInternalServiceProvider(services.BuildServiceProvider()));
// 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();
}
}
private static HttpContext GetHttpContext()
{
var httpContext = new DefaultHttpContext();
httpContext.Request.PathBase = new PathString("");
httpContext.Response.Body = new MemoryStream();
httpContext.RequestServices = CreateServices();
return httpContext;
}
public async void EmptyContext()
{
var context = new DefaultHttpContext();
var secret = await _parser.ParseAsync(context);
secret.Should().BeNull();
}
public void WithHttpContextShouldPopulateCustomHttpContextForPocoController()
{
MyApplication
.StartsFrom<TestStartup>()
.WithServices(services =>
{
services.AddMemoryCache();
services.AddDistributedMemoryCache();
services.AddSession();
services.AddHttpContextAccessor();
});
var httpContext = new DefaultHttpContext();
httpContext.Request.Scheme = "Custom";
httpContext.Response.StatusCode = 404;
httpContext.Response.ContentType = ContentType.ApplicationJson;
httpContext.Response.ContentLength = 100;
MyController<MvcController>
.Instance()
.WithHttpContext(httpContext)
.ShouldPassForThe<HttpContext>(setHttpContext =>
{
Assert.Equal("Custom", setHttpContext.Request.Scheme);
Assert.IsAssignableFrom<HttpResponseMock>(setHttpContext.Response);
Assert.Same(httpContext.Response.Body, setHttpContext.Response.Body);
Assert.Equal(httpContext.Response.ContentLength, setHttpContext.Response.ContentLength);
Assert.Equal(httpContext.Response.ContentType, setHttpContext.Response.ContentType);
Assert.Equal(httpContext.Response.StatusCode, setHttpContext.Response.StatusCode);
Assert.Same(httpContext.Items, setHttpContext.Items);
Assert.Same(httpContext.Features, setHttpContext.Features);
Assert.Same(httpContext.RequestServices, setHttpContext.RequestServices);
Assert.Same(httpContext.Session, setHttpContext.Session);
Assert.Same(httpContext.TraceIdentifier, setHttpContext.TraceIdentifier);
Assert.Same(httpContext.User, setHttpContext.User);
});
MyController<PocoController>
.Instance()
.WithHttpContext(httpContext)
.ShouldPassForThe<PocoController>(controller =>
{
Assert.Equal("Custom", controller.CustomHttpContext.Request.Scheme);
Assert.IsAssignableFrom<HttpResponseMock>(controller.CustomHttpContext.Response);
Assert.Same(httpContext.Response.Body, controller.CustomHttpContext.Response.Body);
Assert.Equal(httpContext.Response.ContentLength, controller.CustomHttpContext.Response.ContentLength);
Assert.Equal(httpContext.Response.ContentType, controller.CustomHttpContext.Response.ContentType);
Assert.Equal(httpContext.Response.StatusCode, controller.CustomHttpContext.Response.StatusCode);
Assert.Same(httpContext.Items, controller.CustomHttpContext.Items);
Assert.Same(httpContext.Features, controller.CustomHttpContext.Features);
Assert.Same(httpContext.RequestServices, controller.CustomHttpContext.RequestServices);
Assert.Same(httpContext.Session, controller.CustomHttpContext.Session);
Assert.Same(httpContext.TraceIdentifier, controller.CustomHttpContext.TraceIdentifier);
Assert.Same(httpContext.User, controller.CustomHttpContext.User);
});
MyApplication.StartsFrom<DefaultStartup>();
}
public async void EmptyOwinEnvironment()
{
var context = new DefaultHttpContext();
context.Request.Body = new MemoryStream();
var secret = await _parser.ParseAsync(context);
secret.Should().BeNull();
}
private static HttpContext GetHttpContext()
{
var services = CreateServices();
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = services.BuildServiceProvider();
return httpContext;
}
public void Can_get_tenant_instance()
{
HttpContext httpContext = new DefaultHttpContext();
var tenant = new TestTenant { Id = "1" };
httpContext.SetTenantContext(new TenantContext<TestTenant>(tenant));
Assert.Same(tenant, httpContext.GetTenant<TestTenant>());
}
public void Can_get_and_set_tenant_context()
{
HttpContext httpContext = new DefaultHttpContext();
var tenantContext = new TenantContext<TestTenant>(new TestTenant());
httpContext.SetTenantContext(tenantContext);
Assert.Same(tenantContext, httpContext.GetTenantContext<TestTenant>());
}
public async Task No_Header_no_Body_Post()
{
var ctx = new DefaultHttpContext();
ctx.Request.Method = "POST";
var validator = new BearerTokenUsageValidator();
var result = await validator.ValidateAsync(ctx);
result.TokenFound.Should().BeFalse();
}
public void AppendLargeCookie_Appended()
{
HttpContext context = new DefaultHttpContext();
string testString = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
new ChunkingCookieManager() { ChunkSize = null }.AppendResponseCookie(context, "TestCookie", testString, new CookieOptions());
var values = context.Response.Headers["Set-Cookie"];
Assert.Equal(1, values.Count);
Assert.Equal("TestCookie=" + testString + "; path=/", values[0]);
}
public async void BasicAuthentication_Request_With_Empty_Basic_Header()
{
var context = new DefaultHttpContext();
context.Request.Headers.Add("Authorization", new StringValues(""));
var secret = await _parser.ParseAsync(context);
secret.Should().BeNull();
}
public async Task TestSdkVersionIsPopulatedByMiddleware()
{
var context = new DefaultHttpContext();
context.Request.Scheme = HttpRequestScheme;
context.Request.Host = this.httpRequestHost;
await middleware.Invoke(context, new RequestTelemetry());
Assert.NotEmpty(this.sentTelemetry.Context.GetInternalContext().SdkVersion);
Assert.Contains(SdkVersionTestUtils.VersionPrefix, this.sentTelemetry.Context.GetInternalContext().SdkVersion);
}
public async Task Whitespaces_Bearer_Scheme_Header()
{
var ctx = new DefaultHttpContext();
ctx.Request.Method = "GET";
ctx.Request.Headers.Add("Authorization", new string[] { "Bearer " });
var validator = new BearerTokenUsageValidator();
var result = await validator.ValidateAsync(ctx);
result.TokenFound.Should().BeFalse();
}
public void WithHttpContextSessionShouldThrowExceptionIfSessionIsNotRegistered()
{
var httpContext = new DefaultHttpContext();
MyViewComponent<NormalComponent>
.Instance()
.WithHttpContext(httpContext)
.ShouldPassForThe<HttpContext>(context =>
{
Assert.Throws<InvalidOperationException>(() => context.Session);
});
}
public void ApiKeyHandler_AuthenticatedEvent()
{
var context = new Microsoft.AspNetCore.Http.DefaultHttpContext();
var handler = CreateHandler(context);
handler.Options.Events.OnAuthenticatedAsync = (ctx) =>
{
ctx.Identity.AddClaim(new System.Security.Claims.Claim("Foo", "Bar"));
return(System.Threading.Tasks.Task.CompletedTask);
};
context.Request.Headers.Add("Authorization", "ApiKey TestName:TestKey");
var authResult = handler.AuthenticateAsync().ConfigureAwait(false).GetAwaiter().GetResult();
Assert.IsTrue(authResult.Principal.HasClaim(x => x.Type == "Foo"));
}
public void ApiKeyHandler_OnRequestEvent()
{
var context = new Microsoft.AspNetCore.Http.DefaultHttpContext();
var handler = CreateHandler(context);
handler.Options.Events.OnRequestAsync = (ctx) =>
{
ctx.AuthenticationType = "ApiKey";
ctx.ClientID = "TestName";
ctx.Token = "TestKey";
return(System.Threading.Tasks.Task.CompletedTask);
};
var authResult = handler.AuthenticateAsync().ConfigureAwait(false).GetAwaiter().GetResult();
Assert.AreEqual(true, authResult.Succeeded);
Assert.AreEqual(true, authResult.Principal.Identity.IsAuthenticated);
Assert.AreEqual("TestName", authResult.Principal.Identity.Name);
}
public void ApiKeyHandler_HandleRequestWithCustomTokenProvider()
{
var context = new Microsoft.AspNetCore.Http.DefaultHttpContext();
var handler = CreateHandler(context);
handler.Options.Events.OnRequestAsync = async(ctx) =>
{
ctx.Key = new ApiKey()
{
ClientID = "TestName",
Secret = "TestKey"
};
};
var authResult = handler.AuthenticateAsync().ConfigureAwait(false).GetAwaiter().GetResult();
Assert.AreEqual(true, authResult.Succeeded);
Assert.AreEqual(true, authResult.Principal.Identity.IsAuthenticated);
Assert.AreEqual("TestName", authResult.Principal.Identity.Name);
}
public void UpdateFeatures_ClearsCachedFeatures()
{
var features = new FeatureCollection();
features.Set <IHttpRequestFeature>(new HttpRequestFeature());
features.Set <IHttpResponseFeature>(new HttpResponseFeature());
features.Set <IHttpWebSocketFeature>(new TestHttpWebSocketFeature());
// featurecollection is set. all cached interfaces are null.
var context = new DefaultHttpContext(features);
TestAllCachedFeaturesAreNull(context, features);
Assert.Equal(3, features.Count());
// getting feature properties populates feature collection with defaults
TestAllCachedFeaturesAreSet(context, features);
Assert.NotEqual(3, features.Count());
// featurecollection is null. and all cached interfaces are null.
// only top level is tested because child objects are inaccessible.
context.Uninitialize();
TestCachedFeaturesAreNull(context, null);
var newFeatures = new FeatureCollection();
newFeatures.Set <IHttpRequestFeature>(new HttpRequestFeature());
newFeatures.Set <IHttpResponseFeature>(new HttpResponseFeature());
newFeatures.Set <IHttpWebSocketFeature>(new TestHttpWebSocketFeature());
// featurecollection is set to newFeatures. all cached interfaces are null.
context.Initialize(newFeatures);
TestAllCachedFeaturesAreNull(context, newFeatures);
Assert.Equal(3, newFeatures.Count());
// getting feature properties populates new feature collection with defaults
TestAllCachedFeaturesAreSet(context, newFeatures);
Assert.NotEqual(3, newFeatures.Count());
}
public async Task UseMiddlewareWithIMiddlewareWorks()
{
var mockServiceProvider = new DummyServiceProvider();
var builder = new ApplicationBuilder(mockServiceProvider);
builder.UseMiddleware(typeof(Middleware));
var app = builder.Build();
var context = new DefaultHttpContext();
var sp = new DummyServiceProvider();
var middlewareFactory = new BasicMiddlewareFactory();
sp.AddService(typeof(IMiddlewareFactory), middlewareFactory);
context.RequestServices = sp;
await app(context);
Assert.True(Assert.IsType <bool>(context.Items["before"]));
Assert.True(Assert.IsType <bool>(context.Items["after"]));
Assert.NotNull(middlewareFactory.Created);
Assert.NotNull(middlewareFactory.Released);
Assert.IsType <Middleware>(middlewareFactory.Created);
Assert.IsType <Middleware>(middlewareFactory.Released);
Assert.Same(middlewareFactory.Created, middlewareFactory.Released);
}
public void ReplacingResponseBody_DoesNotCreateOnCompletedRegistration()
{
var features = new FeatureCollection();
var originalStream = new FlushAsyncCheckStream();
var replacementStream = new FlushAsyncCheckStream();
var responseBodyMock = new Mock <IHttpResponseBodyFeature>();
responseBodyMock.Setup(o => o.Stream).Returns(originalStream);
features.Set(responseBodyMock.Object);
var responseMock = new Mock <IHttpResponseFeature>();
features.Set(responseMock.Object);
var context = new DefaultHttpContext(features);
Assert.Same(originalStream, context.Response.Body);
Assert.Same(responseBodyMock.Object, context.Features.Get <IHttpResponseBodyFeature>());
context.Response.Body = replacementStream;
Assert.Same(replacementStream, context.Response.Body);
Assert.NotSame(responseBodyMock.Object, context.Features.Get <IHttpResponseBodyFeature>());
context.Response.Body = originalStream;
Assert.Same(originalStream, context.Response.Body);
Assert.Same(responseBodyMock.Object, context.Features.Get <IHttpResponseBodyFeature>());
// The real issue was not that an OnCompleted registration existed, but that it would previously flush
// the original response body in the OnCompleted callback after the response body was disposed.
// However, since now there's no longer an OnCompleted registration at all, it's easier to verify that.
// https://github.com/dotnet/aspnetcore/issues/25342
responseMock.Verify(m => m.OnCompleted(It.IsAny <Func <object, Task> >(), It.IsAny <object>()), Times.Never);
}
public void Cookies_GetAndSet()
{
var request = new DefaultHttpContext().Request;
var cookieHeaders = request.Headers["Cookie"];
Assert.Empty(cookieHeaders);
var cookies0 = request.Cookies;
Assert.Empty(cookies0);
Assert.Null(cookies0["key0"]);
Assert.False(cookies0.ContainsKey("key0"));
var newCookies = new[] { "name0=value0%2C", "%5Ename1=value1" };
request.Headers["Cookie"] = newCookies;
cookies0 = RequestCookieCollection.Parse(newCookies);
var cookies1 = request.Cookies;
Assert.Equal(cookies0, cookies1);
Assert.Equal(2, cookies1.Count);
Assert.Equal("value0,", cookies1["name0"]);
Assert.Equal("value1", cookies1["^name1"]);
Assert.Equal(newCookies, request.Headers["Cookie"]);
var cookies2 = new RequestCookieCollection(new Dictionary <string, string>()
{
{ "name2", "value2" }
});
request.Cookies = cookies2;
Assert.Equal(cookies2, request.Cookies);
Assert.Equal("value2", request.Cookies["name2"]);
cookieHeaders = request.Headers["Cookie"];
Assert.Equal(new[] { "name2=value2" }, cookieHeaders);
}
public DefaultHttpRequest(DefaultHttpContext context)
{
_context = context;
_features.Initalize(context.Features);
}
private HttpContext CreateContext()
{
var context = new DefaultHttpContext();
return(context);
}
public InversionRecuperadasController_Details_test()
{
_contextOptions = CreateNewContextOptions();
context = new ApplicationDbContext(_contextOptions);
//Insertar datos semilla en la base de datos usando una instancia de contexto
var rating = new Rating {
Nombre = "A"
};
context.Rating.Add(rating);
var area = new Areas {
Nombre = "Sanidad"
};
context.Areas.Add(area);
var tipo = new TiposInversiones {
Nombre = "Crownfunding"
};
context.TiposInversiones.Add(tipo);
Proyecto proyecto1 = new Proyecto
{
ProyectoId = 1,
FechaExpiracion = new DateTime(2020, 1, 1),
Importe = 12,
Interes = 50,
MinInversion = 5,
Nombre = "Pruebas en sanidad",
NumInversores = 0,
Plazo = 12,
Progreso = 34,
Rating = rating
};
context.Proyecto.Add(proyecto1);
context.ProyectoAreas.Add(new ProyectoAreas {
Proyecto = proyecto1, Areas = area
});
Monedero monedero1 = new Monedero
{
MonederoId = 1,
Dinero = 500
};
context.Monedero.Add(monedero1);
Inversor inversor1 = new Inversor
{
Id = "1",
Nombre = "*****@*****.**",
Email = "*****@*****.**",
Apellido1 = "Girón",
Apellido2 = "López",
Domicilio = "C/Cuenca",
Municipio = "Albacete",
NIF = "48259596",
Nacionalidad = "Española",
PaisDeResidencia = "España",
Provincia = "Albacete",
PasswordHash = "hola",
UserName = "******",
Monedero = monedero1
};
context.Users.Add(inversor1);
Inversion inversion1 = new Inversion
{
InversionId = 1,
Cuota = 150,
EstadosInversiones = "En_Curso",
Intereses = 50,
Inversor = inversor1,
Proyecto = proyecto1,
TipoInversionesId = 1,
Total = 200
};
context.Inversion.Add(inversion1);
Inversion inversion2 = new Inversion
{
InversionId = 2,
Cuota = 150,
EstadosInversiones = "Finalizado",
Intereses = 50,
Inversor = inversor1,
Proyecto = proyecto1,
TipoInversionesId = 1,
Total = 200
};
context.Inversion.Add(inversion2);
InversionRecuperada invRec1 = new InversionRecuperada
{
InversionRecuperadaId = 1,
CantidadRecuperada = 5,
Inversion = inversion1,
Comentario = "OK 1",
FechaRecuperacion = DateTime.Now,
};
InversionRecuperada invRec2 = new InversionRecuperada
{
InversionRecuperadaId = 2,
CantidadRecuperada = 10,
Inversion = inversion1,
Comentario = "OK 2",
FechaRecuperacion = DateTime.Now,
};
context.InversionRecuperada.Add(invRec1);
context.InversionRecuperada.Add(invRec2);
context.SaveChanges();
//Para simular la conexión:
System.Security.Principal.GenericIdentity user = new System.Security.Principal.GenericIdentity("*****@*****.**");
System.Security.Claims.ClaimsPrincipal identity = new System.Security.Claims.ClaimsPrincipal(user);
inversionRecuperadaContext = new Microsoft.AspNetCore.Http.DefaultHttpContext();
inversionRecuperadaContext.User = identity;
}
public ManageControllerTest()
{
var efServiceProvider = new ServiceCollection().AddEntityFrameworkInMemoryDatabase().BuildServiceProvider();
var services = new ServiceCollection();
services.AddOptions();
services
.AddDbContext<MusicStoreContext>(b => b.UseInMemoryDatabase().UseInternalServiceProvider(efServiceProvider));
services.AddIdentity<ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores<MusicStoreContext>();
services.AddLogging();
services.AddOptions();
// IHttpContextAccessor is required for SignInManager, and UserManager
var context = new DefaultHttpContext();
context.Features.Set<IHttpAuthenticationFeature>(new HttpAuthenticationFeature() { Handler = new TestAuthHandler() });
services.AddSingleton<IHttpContextAccessor>(
new HttpContextAccessor()
{
HttpContext = context,
});
_serviceProvider = services.BuildServiceProvider();
}