public async Task Can_use_sequential_GUID_end_to_end_async() { var serviceProvider = new ServiceCollection() .AddEntityFramework() .AddSqlServer() .ServiceCollection .BuildServiceProvider(); using (var context = new BronieContext(serviceProvider, "GooieBronies")) { context.Database.EnsureDeleted(); context.Database.EnsureCreated(); for (var i = 0; i < 50; i++) { await context.AddAsync(new Pegasus { Name = "Rainbow Dash " + i }); } await context.SaveChangesAsync(); } using (var context = new BronieContext(serviceProvider, "GooieBronies")) { // TODO: Currently test passes because SQL Server happens to return values in // inserted order. When OrderBy is done on server it should be added to the query. //var pegasuses = await context.Pegasuses.OrderBy(e => e.Id).ToListAsync(); var pegasuses = await context.Pegasuses.ToListAsync(); for (var i = 0; i < 50; i++) { Assert.Equal("Rainbow Dash " + i, pegasuses[i].Name); } } }
public static ILoggerFactory AddOrchardLogging( [NotNull] this ILoggerFactory loggingFactory, IServiceProvider serviceProvider) { /* TODO (ngm): Abstract this logger stuff outta here! */ var loader = serviceProvider.GetRequiredService<IExtensionLoader>(); var manager = serviceProvider.GetRequiredService<IExtensionManager>(); var descriptor = manager.GetExtension("Orchard.Logging.Console"); var entry = loader.Load(descriptor); var loggingInitiatorTypes = entry .Assembly .ExportedTypes .Where(et => typeof(ILoggingInitiator).IsAssignableFrom(et)); IServiceCollection loggerCollection = new ServiceCollection(); foreach (var initiatorType in loggingInitiatorTypes) { loggerCollection.AddScoped(typeof(ILoggingInitiator), initiatorType); } var moduleServiceProvider = loggerCollection.BuildShellServiceProviderWithHost(serviceProvider); foreach (var service in moduleServiceProvider.GetServices<ILoggingInitiator>()) { service.Initialize(loggingFactory); } return loggingFactory; }
public void json_collection_with_default_culture_test() { // Arrange var req = new Mock<HttpRequest>(); req.Setup(x => x.Headers) .Returns(new HeaderDictionary(new Dictionary<string, StringValues> { })); req.Setup(x => x.Cookies) .Returns(new RequestCookiesCollection()); var httpContext = new Mock<HttpContext>(); httpContext.Setup(x => x.Request) .Returns(req.Object); var accessor = new Mock<IHttpContextAccessor>(); accessor.Setup(x => x.HttpContext) .Returns(httpContext.Object); var collection = new ServiceCollection(); collection.AddJsonLocalization() .AddCookieCulture() .AddInstance(accessor.Object) .AddInstance(CallContextServiceLocator.Locator.ServiceProvider.GetRequiredService<IApplicationEnvironment>()); var service = collection.BuildServiceProvider(); // Act var SR = service.GetService<ILocalizationStringCollection>(); var actual_1 = SR["Hello world."]; var actual_2 = SR["My name is {0}.", "Yuuko"]; // Assert Assert.Equal("你好,世界。", actual_1); Assert.Equal("我的名字是Yuuko", actual_2); }
public void Activate_InitializesTagHelpers(string name, int number) { // Arrange var services = new ServiceCollection(); services.InitializeTagHelper<TestTagHelper>((h, vc) => { h.Name = name; h.Number = number; h.ViewDataValue = vc.ViewData["TestData"]; }); var httpContext = MakeHttpContext(services.BuildServiceProvider()); var viewContext = MakeViewContext(httpContext); var viewDataValue = new object(); viewContext.ViewData.Add("TestData", viewDataValue); var activator = new DefaultTagHelperActivator(); var helper = new TestTagHelper(); // Act activator.Activate(helper, viewContext); // Assert Assert.Equal(name, helper.Name); Assert.Equal(number, helper.Number); Assert.Same(viewDataValue, helper.ViewDataValue); }
public static ServiceCollection GetServiceCollectionWithContextAccessor() { var services = new ServiceCollection(); IHttpContextAccessor contextAccessor = new HttpContextAccessor(); services.AddInstance<IHttpContextAccessor>(contextAccessor); return services; }
public async Task Can_use_sequential_GUID_end_to_end_async() { var serviceProvider = new ServiceCollection() .AddEntityFramework() .AddSqlServer() .ServiceCollection() .BuildServiceProvider(); using (var context = new BronieContext(serviceProvider, "GooieBronies")) { context.Database.EnsureDeleted(); context.Database.EnsureCreated(); for (var i = 0; i < 50; i++) { context.Add(new Pegasus { Name = "Rainbow Dash " + i }); } await context.SaveChangesAsync(); } using (var context = new BronieContext(serviceProvider, "GooieBronies")) { var pegasuses = await context.Pegasuses.OrderBy(e => e.Id).ToListAsync(); for (var i = 0; i < 50; i++) { Assert.Equal("Rainbow Dash " + i, pegasuses[i].Name); } } }
public void MultiRegistrationServiceTypes_AreRegistered_MultipleTimes() { // Arrange var services = new ServiceCollection(); // Register a mock implementation of each service, AddMvcServices should add another implemenetation. foreach (var serviceType in MutliRegistrationServiceTypes) { var mockType = typeof(Mock<>).MakeGenericType(serviceType.Key); services.Add(ServiceDescriptor.Transient(serviceType.Key, mockType)); } // Act MvcCoreServiceCollectionExtensions.AddMvcCoreServices(services); // Assert foreach (var serviceType in MutliRegistrationServiceTypes) { AssertServiceCountEquals(services, serviceType.Key, serviceType.Value.Length + 1); foreach (var implementationType in serviceType.Value) { AssertContainsSingle(services, serviceType.Key, implementationType); } } }
public void SaveChanges_delegates() { var commandBatchPreparerMock = new Mock<ICommandBatchPreparer>(); var batchExecutorMock = new Mock<IBatchExecutor>(); var relationalConnectionMock = new Mock<IRelationalConnection>(); var fragmentTranslatorMock = new Mock<IExpressionFragmentTranslator>(); var customServices = new ServiceCollection() .AddInstance(commandBatchPreparerMock.Object) .AddInstance(batchExecutorMock.Object) .AddInstance(relationalConnectionMock.Object) .AddInstance(fragmentTranslatorMock.Object) .AddScoped<RelationalDatabase>(); var contextServices = RelationalTestHelpers.Instance.CreateContextServices(customServices); var relationalDatabase = contextServices.GetRequiredService<RelationalDatabase>(); var entries = new List<InternalEntityEntry>(); relationalDatabase.SaveChanges(entries); commandBatchPreparerMock.Verify(c => c.BatchCommands(entries)); batchExecutorMock.Verify(be => be.Execute(It.IsAny<IEnumerable<ModificationCommandBatch>>(), relationalConnectionMock.Object)); }
public void WithControllersAsServices_ScansControllersFromSpecifiedAssemblies() { // Arrange var collection = new ServiceCollection(); var assemblies = new[] { GetType().Assembly }; var controllerTypes = new[] { typeof(ControllerTypeA), typeof(TypeBController) }; // Act MvcServiceCollectionExtensions.WithControllersAsServices(collection, assemblies); // Assert var services = collection.ToList(); Assert.Equal(4, services.Count); Assert.Equal(typeof(ControllerTypeA), services[0].ServiceType); Assert.Equal(typeof(ControllerTypeA), services[0].ImplementationType); Assert.Equal(ServiceLifetime.Transient, services[0].Lifetime); Assert.Equal(typeof(TypeBController), services[1].ServiceType); Assert.Equal(typeof(TypeBController), services[1].ImplementationType); Assert.Equal(ServiceLifetime.Transient, services[1].Lifetime); Assert.Equal(typeof(IControllerActivator), services[2].ServiceType); Assert.Equal(typeof(ServiceBasedControllerActivator), services[2].ImplementationType); Assert.Equal(ServiceLifetime.Transient, services[2].Lifetime); Assert.Equal(typeof(IControllerTypeProvider), services[3].ServiceType); var typeProvider = Assert.IsType<FixedSetControllerTypeProvider>(services[3].ImplementationInstance); Assert.Equal(controllerTypes, typeProvider.ControllerTypes.OrderBy(c => c.Name)); Assert.Equal(ServiceLifetime.Singleton, services[3].Lifetime); }
/// <summary> /// This follows the same initialization that is provided when <see cref="IDataProtectionProvider"/> /// is initialized within ASP.NET 5.0 Dependency Injection. /// </summary> /// <returns>A fully initialized <see cref="IDataProtectionProvider"/>.</returns> internal static IDataProtectionProvider GetDataProtectionProvider() { ServiceCollection serviceCollection = new ServiceCollection(); serviceCollection.AddDataProtection(); IServiceProvider services = serviceCollection.BuildServiceProvider(); return services.GetDataProtectionProvider(); }
public void TestHelloNonGenericServiceDecoratorNoInterface() { var services = new ServiceCollection(); services.AddInstance<IHelloService>(new HelloService()); services.AddSingleton<IHelloService>(sp => new HelloService()); services.AddScoped<IHelloService>(sp => new HelloService()); services.AddTransient<IHelloService>(sp => new HelloService()); services.AddSingleton<IHelloService, HelloService>(); services.AddScoped<IHelloService, HelloService>(); services.AddTransient<IHelloService, HelloService>(); services.AddDecorator(typeof(IHelloService), (sp, s) => new HelloServiceDecoratorNoInterface((IHelloService)s)); var provider = services.BuildServiceProvider(); var helloServices = provider.GetRequiredServices<IHelloService>(); Assert.NotNull(helloServices); var collection = helloServices as IHelloService[] ?? helloServices.ToArray(); Assert.Equal(7, collection.Length); Assert.NotEmpty(collection); foreach (var helloService in collection) { Assert.NotNull(helloService); Assert.Equal("Decorated without interface: Hello world.", helloService.SayHello("world")); } }
public void ClientRulesWithCompareAttribute_ErrorMessageUsesDisplayName() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForProperty(typeof(PropertyDisplayNameModel), "MyProperty"); var attribute = new CompareAttribute("OtherProperty"); var adapter = new CompareAttributeAdapter(attribute); var serviceCollection = new ServiceCollection(); var requestServices = serviceCollection.BuildServiceProvider(); var context = new ClientModelValidationContext(metadata, metadataProvider, requestServices); // Act var rules = adapter.GetClientValidationRules(context); // Assert var rule = Assert.Single(rules); // Mono issue - https://github.com/aspnet/External/issues/19 Assert.Equal( PlatformNormalizer.NormalizeContent( "'MyPropertyDisplayName' and 'OtherPropertyDisplayName' do not match."), rule.ErrorMessage); }
public void AddLocalizationWithLocalizationOptions_AddsNeededServices() { // Arrange var collection = new ServiceCollection(); // Act collection.AddLocalization(options => options.ResourcesPath = "Resources"); // Assert var services = collection.ToList(); Assert.Equal(4, services.Count); Assert.Equal(typeof(IStringLocalizerFactory), services[0].ServiceType); Assert.Equal(typeof(ResourceManagerStringLocalizerFactory), services[0].ImplementationType); Assert.Equal(ServiceLifetime.Singleton, services[0].Lifetime); Assert.Equal(typeof(IStringLocalizer<>), services[1].ServiceType); Assert.Equal(typeof(StringLocalizer<>), services[1].ImplementationType); Assert.Equal(ServiceLifetime.Transient, services[1].Lifetime); Assert.Equal(typeof(IConfigureOptions<LocalizationOptions>), services[2].ServiceType); Assert.Equal(ServiceLifetime.Singleton, services[2].Lifetime); Assert.Equal(typeof(IOptions<>), services[3].ServiceType); Assert.Equal(ServiceLifetime.Singleton, services[3].Lifetime); }
public async Task ServicesArePerRequest() { var services = new ServiceCollection() .AddScoped<ITestService, TestService>() .BuildServiceProvider(); var builder = new ApplicationBuilder(services); builder.Use(async (ctx, next) => { var serviceScopeFactory = services.GetRequiredService<IServiceScopeFactory>(); using (var serviceScope = serviceScopeFactory.CreateScope()) { var priorApplicationServices = ctx.ApplicationServices; var priorRequestServices = ctx.ApplicationServices; ctx.ApplicationServices = services; ctx.RequestServices = serviceScope.ServiceProvider; try { await next(); } finally { ctx.ApplicationServices = priorApplicationServices; ctx.RequestServices = priorRequestServices; } } }); var testServicesA = new List<ITestService>(); builder.Use(async (HttpContext ctx, Func<Task> next, ITestService testService) => { testServicesA.Add(testService); await next(); }); var testServicesB = new List<ITestService>(); builder.Use<ITestService>(async (ctx, next, testService) => { testServicesB.Add(testService); await next(); }); var app = builder.Build(); await app(new DefaultHttpContext()); await app(new DefaultHttpContext()); Assert.Equal(2, testServicesA.Count); Assert.IsType<TestService>(testServicesA[0]); Assert.IsType<TestService>(testServicesA[1]); Assert.Equal(2, testServicesB.Count); Assert.IsType<TestService>(testServicesB[0]); Assert.IsType<TestService>(testServicesB[1]); Assert.Same(testServicesA[0], testServicesB[0]); Assert.Same(testServicesA[1], testServicesB[1]); Assert.NotSame(testServicesA[0], testServicesA[1]); Assert.NotSame(testServicesB[0], testServicesB[1]); }
// Composition root private IServiceProvider BuildServiceProvider(Options options, IConfigurationSection queueConfig) { var services = new ServiceCollection().AddLogging(); services.AddSingleton<IMessageHandlerFactory, MessageHandlerFactory>(); switch (options.QueueType) { case "zeromq": services.AddZeroMq(queueConfig); break; case "msmq": services.AddMsmq(queueConfig); break; case "azure": services.AddAzure(queueConfig); break; default: throw new Exception($"Could not resolve queue type {options.QueueType}"); } if (!string.IsNullOrWhiteSpace(options.Handler)) { services.AddTransient(typeof(IMessageHandler), Type.GetType(options.Handler)); } var provider = services.BuildServiceProvider(); // configure var loggerFactory = provider.GetRequiredService<ILoggerFactory>(); loggerFactory.MinimumLevel = LogLevel.Debug; loggerFactory.AddConsole(loggerFactory.MinimumLevel); return provider; }
public Task<int> Main(string[] args) { //Add command line configuration source to read command line parameters. var config = new Configuration(); config.AddCommandLine(args); var serviceCollection = new ServiceCollection(); serviceCollection.Add(HostingServices.GetDefaultServices(config)); var services = serviceCollection.BuildServiceProvider(_hostServiceProvider); var context = new HostingContext() { Services = services, Configuration = config, ServerName = "Microsoft.AspNet.Server.WebListener", ApplicationName = "BugTracker" }; var engine = services.GetService<IHostingEngine>(); if (engine == null) { throw new Exception("TODO: IHostingEngine service not available exception"); } using (engine.Start(context)) { Console.WriteLine("Started the server.."); Console.WriteLine("Press any key to stop the server"); Console.ReadLine(); } return Task.FromResult(0); }
public void Initializes_all_entity_set_properties_with_setters() { var setFinderMock = new Mock<IDbSetFinder>(); setFinderMock.Setup(m => m.FindSets(It.IsAny<DbContext>())).Returns( new[] { new DbSetProperty(typeof(JustAContext), "One", typeof(string), hasSetter: true), new DbSetProperty(typeof(JustAContext), "Two", typeof(object), hasSetter: true), new DbSetProperty(typeof(JustAContext), "Three", typeof(string), hasSetter: true), new DbSetProperty(typeof(JustAContext), "Four", typeof(string), hasSetter: false) }); var customServices = new ServiceCollection() .AddInstance<IDbSetInitializer>(new DbSetInitializer(setFinderMock.Object, new ClrPropertySetterSource(), new DbSetSource())); var serviceProvider = TestHelpers.Instance.CreateServiceProvider(customServices); using (var context = new JustAContext(serviceProvider, new EntityOptionsBuilder().Options)) { Assert.NotNull(context.One); Assert.NotNull(context.GetTwo()); Assert.NotNull(context.Three); Assert.Null(context.Four); } }
public void Non_generic_GetRequiredService_throws_useful_exception_if_service_not_registered() { var serviceProvider = new ServiceCollection().BuildServiceProvider(); Assert.Throws<InvalidOperationException>( () => serviceProvider.GetRequiredService(typeof(IPilkington))); }
public async Task Can_use_explicit_values() { var serviceProvider = new ServiceCollection() .AddEntityFramework() .AddSqlServer() .ServiceCollection() .BuildServiceProvider(); var guids = new List<Guid>(); using (var context = new BronieContext(serviceProvider, "GooieExplicitBronies")) { context.Database.EnsureDeleted(); context.Database.EnsureCreated(); for (var i = 0; i < 50; i++) { guids.Add(context.Add(new Pegasus { Name = "Rainbow Dash " + i, Index = i, Id = Guid.NewGuid() }).Entity.Id); } await context.SaveChangesAsync(); } using (var context = new BronieContext(serviceProvider, "GooieExplicitBronies")) { var pegasuses = await context.Pegasuses.OrderBy(e => e.Index).ToListAsync(); for (var i = 0; i < 50; i++) { Assert.Equal("Rainbow Dash " + i, pegasuses[i].Name); Assert.Equal(guids[i], pegasuses[i].Id); } } }
public async Task BindModel_CallsBindAsync_OnProvidedModelBinder() { // Arrange var bindingContext = GetBindingContext(typeof(Person), binderType: typeof(TrueModelBinder)); var model = new Person(); var serviceProvider = new ServiceCollection() .AddSingleton(typeof(IModelBinder)) .BuildServiceProvider(); bindingContext.OperationBindingContext.HttpContext.RequestServices = serviceProvider; var binder = new BinderTypeBasedModelBinder(); // Act var binderResult = await binder.BindModelAsync(bindingContext); // Assert var p = (Person)binderResult.Model; Assert.Equal(model.Age, p.Age); Assert.Equal(model.Name, p.Name); Assert.NotNull(binderResult.ValidationNode); Assert.Equal(bindingContext.ModelName, binderResult.ValidationNode.Key); Assert.Same(binderResult.Model, binderResult.ValidationNode.Model); }
public void AddMvcServicesTwice_DoesNotAddDuplicates() { // Arrange var services = new ServiceCollection(); // Act MvcCoreServiceCollectionExtensions.AddMvcCoreServices(services); MvcCoreServiceCollectionExtensions.AddMvcCoreServices(services); // Assert var singleRegistrationServiceTypes = SingleRegistrationServiceTypes; foreach (var service in services) { if (singleRegistrationServiceTypes.Contains(service.ServiceType)) { // 'single-registration' services should only have one implementation registered. AssertServiceCountEquals(services, service.ServiceType, 1); } else { // 'multi-registration' services should only have one *instance* of each implementation registered. AssertContainsSingle(services, service.ServiceType, service.ImplementationType); } } }
public void Duplicate_entries_are_not_created_for_navigations_to_dependant() { var serviceProvider = new ServiceCollection() .AddEntityFramework() .AddInMemoryStore() .AddDbContext<GoTContext>() .ServiceCollection() .BuildServiceProvider(); using (var context = serviceProvider.GetRequiredService<GoTContext>()) { context.ConfigAction = (modelBuilder) => { modelBuilder.Entity<Person>().Reference(p => p.SiblingReverse).InverseCollection(p => p.Siblings).Required(false); modelBuilder.Entity<Person>().Reference(p => p.Lover).InverseReference(p => p.LoverReverse).Required(false); return 0; }; var model = context.Model; var entityType = model.EntityTypes.First(); Assert.Equal("'Person' {'LoverId'} -> 'Person' {'Id'}", entityType.GetForeignKeys().First().ToString()); Assert.Equal("'Person' {'SiblingReverseId'} -> 'Person' {'Id'}", entityType.GetForeignKeys().Skip(1).First().ToString()); } }
public void Activate_InitializesTagHelpersWithMultipleInitializers() { // Arrange var services = new ServiceCollection(); services.InitializeTagHelper<TestTagHelper>((h, vc) => { h.Name = "Test 1"; h.Number = 100; }); services.InitializeTagHelper<TestTagHelper>((h, vc) => { h.Name += ", Test 2"; h.Number += 100; }); var httpContext = MakeHttpContext(services.BuildServiceProvider()); var viewContext = MakeViewContext(httpContext); var activator = new DefaultTagHelperActivator(); var helper = new TestTagHelper(); // Act activator.Activate(helper, viewContext); // Assert Assert.Equal("Test 1, Test 2", helper.Name); Assert.Equal(200, helper.Number); }
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 ClientRulesWithMaxLengthAttribute_StringLocalizer_ReturnsLocalizedErrorString() { // Arrange var provider = TestModelMetadataProvider.CreateDefaultProvider(); var metadata = provider.GetMetadataForProperty(typeof(string), "Length"); var errorKey = metadata.GetDisplayName(); var attribute = new MaxLengthAttribute(10); attribute.ErrorMessage = errorKey; var localizedString = new LocalizedString(errorKey, "Longueur est invalide"); var stringLocalizer = new Mock<IStringLocalizer>(); stringLocalizer.Setup(s => s[errorKey]).Returns(localizedString); var adapter = new MaxLengthAttributeAdapter(attribute, stringLocalizer.Object); var serviceCollection = new ServiceCollection(); var requestServices = serviceCollection.BuildServiceProvider(); var context = new ClientModelValidationContext(metadata, provider, requestServices); // Act var rules = adapter.GetClientValidationRules(context); // Assert var rule = Assert.Single(rules); Assert.Equal("maxlength", rule.ValidationType); Assert.Equal(1, rule.ValidationParameters.Count); Assert.Equal(10, rule.ValidationParameters["max"]); Assert.Equal("Longueur est invalide", rule.ErrorMessage); }
public async Task Can_use_GUIDs_end_to_end_async() { var serviceProvider = new ServiceCollection() .AddEntityFramework() .AddInMemoryStore() .ServiceCollection .BuildServiceProvider(); var guids = new List<Guid>(); var guidsHash = new HashSet<Guid>(); using (var context = new BronieContext(serviceProvider)) { for (var i = 0; i < 10; i++) { guids.Add((await context.AddAsync(new Pegasus { Name = "Rainbow Dash " + i })).Id); guidsHash.Add(guids.Last()); } await context.SaveChangesAsync(); } Assert.Equal(10, guidsHash.Count); using (var context = new BronieContext(serviceProvider)) { var pegasuses = await context.Pegasuses.OrderBy(e => e.Name).ToListAsync(); for (var i = 0; i < 10; i++) { Assert.Equal(guids[i], pegasuses[i].Id); } } }
public void ConfigureServices() { IServiceProvider mainProv = CallContextServiceLocator.Locator.ServiceProvider; IApplicationEnvironment appEnv = mainProv.GetService<IApplicationEnvironment>(); IRuntimeEnvironment runtimeEnv = mainProv.GetService<IRuntimeEnvironment>(); ILoggerFactory logFactory = new LoggerFactory(); logFactory.AddConsole(LogLevel.Information); ServiceCollection sc = new ServiceCollection(); sc.AddInstance(logFactory); sc.AddSingleton(typeof(ILogger<>), typeof(Logger<>)); sc.AddEntityFramework() .AddSqlite() .AddDbContext<StarDbContext>(); sc.AddSingleton<ILibraryManager, LibraryManager>(factory => mainProv.GetService<ILibraryManager>() as LibraryManager); sc.AddSingleton<ICache, Cache>(factory => new Cache(new CacheContextAccessor())); sc.AddSingleton<IExtensionAssemblyLoader, ExtensionAssemblyLoader>(); sc.AddSingleton<IStarLibraryManager, StarLibraryManager>(); sc.AddSingleton<PluginLoader>(); sc.AddSingleton(factory => mainProv.GetService<IAssemblyLoadContextAccessor>()); sc.AddInstance(appEnv); sc.AddInstance(runtimeEnv); Services = sc; ServiceProvider = sc.BuildServiceProvider(); }
public async Task OnValidatePrincipalTestSuccess(bool isPersistent) { var user = new TestUser("test"); var userManager = MockHelpers.MockUserManager<TestUser>(); var claimsManager = new Mock<IUserClaimsPrincipalFactory<TestUser>>(); var identityOptions = new IdentityOptions { SecurityStampValidationInterval = TimeSpan.Zero }; var options = new Mock<IOptions<IdentityOptions>>(); options.Setup(a => a.Options).Returns(identityOptions); var httpContext = new Mock<HttpContext>(); var contextAccessor = new Mock<IHttpContextAccessor>(); contextAccessor.Setup(a => a.HttpContext).Returns(httpContext.Object); var signInManager = new Mock<SignInManager<TestUser>>(userManager.Object, contextAccessor.Object, claimsManager.Object, options.Object, null); signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny<ClaimsPrincipal>(), user.Id)).ReturnsAsync(user).Verifiable(); signInManager.Setup(s => s.SignInAsync(user, isPersistent, null)).Returns(Task.FromResult(0)).Verifiable(); var services = new ServiceCollection(); services.AddInstance(options.Object); services.AddInstance(signInManager.Object); services.AddInstance<ISecurityStampValidator>(new SecurityStampValidator<TestUser>()); httpContext.Setup(c => c.RequestServices).Returns(services.BuildServiceProvider()); var id = new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationScheme); id.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id)); var ticket = new AuthenticationTicket(new ClaimsPrincipal(id), new AuthenticationProperties { IssuedUtc = DateTimeOffset.UtcNow, IsPersistent = isPersistent }, IdentityOptions.ApplicationCookieAuthenticationScheme); var context = new CookieValidatePrincipalContext(httpContext.Object, ticket, new CookieAuthenticationOptions()); Assert.NotNull(context.Properties); Assert.NotNull(context.Options); Assert.NotNull(context.Principal); await SecurityStampValidator.ValidatePrincipalAsync(context); Assert.NotNull(context.Principal); signInManager.VerifyAll(); }
private async Task Create_checks_for_existence_and_retries_until_it_passes(int errorNumber, bool async) { var customServices = new ServiceCollection() .AddScoped<ISqlServerConnection, FakeSqlServerConnection>() .AddScoped<ISqlStatementExecutor, FakeSqlStatementExecutor>(); var contextServices = SqlServerTestHelpers.Instance.CreateContextServices(customServices); var connection = (FakeSqlServerConnection)contextServices.GetRequiredService<ISqlServerConnection>(); connection.ErrorNumber = errorNumber; connection.FailAfter = 5; var creator = contextServices.GetRequiredService<IRelationalDatabaseCreator>(); if (async) { await creator.CreateAsync(); } else { creator.Create(); } Assert.Equal(5, connection.OpenCount); }
public ActivityApiControllerTest() { if (_serviceProvider == null) { var services = new ServiceCollection(); // Add Configuration to the Container var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddEnvironmentVariables(); IConfiguration configuration = builder.Build(); services.AddSingleton(x => configuration); // Add EF (Full DB, not In-Memory) services.AddEntityFramework() .AddInMemoryDatabase() .AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase()); // Setup hosting environment IHostingEnvironment hostingEnvironment = new HostingEnvironment(); hostingEnvironment.EnvironmentName = "Development"; services.AddSingleton(x => hostingEnvironment); _serviceProvider = services.BuildServiceProvider(); } }