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 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(); }
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 void GetKeyEscrowSink_MultipleKeyEscrowRegistration_ReturnsAggregate() { // Arrange List<string> output = new List<string>(); var mockKeyEscrowSink1 = new Mock<IKeyEscrowSink>(); mockKeyEscrowSink1.Setup(o => o.Store(It.IsAny<Guid>(), It.IsAny<XElement>())) .Callback<Guid, XElement>((keyId, element) => { output.Add(String.Format(CultureInfo.InvariantCulture, "[sink1] {0:D}: {1}", keyId, element.Name.LocalName)); }); var mockKeyEscrowSink2 = new Mock<IKeyEscrowSink>(); mockKeyEscrowSink2.Setup(o => o.Store(It.IsAny<Guid>(), It.IsAny<XElement>())) .Callback<Guid, XElement>((keyId, element) => { output.Add(String.Format(CultureInfo.InvariantCulture, "[sink2] {0:D}: {1}", keyId, element.Name.LocalName)); }); var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance<IKeyEscrowSink>(mockKeyEscrowSink1.Object); serviceCollection.AddInstance<IKeyEscrowSink>(mockKeyEscrowSink2.Object); var services = serviceCollection.BuildServiceProvider(); // Act var sink = services.GetKeyEscrowSink(); sink.Store(new Guid("39974d8e-3e53-4d78-b7e9-4ff64a2a5d7b"), XElement.Parse("<theElement />")); // Assert Assert.Equal(new[] { "[sink1] 39974d8e-3e53-4d78-b7e9-4ff64a2a5d7b: theElement", "[sink2] 39974d8e-3e53-4d78-b7e9-4ff64a2a5d7b: theElement" }, output); }
public static ServiceCollection GetServiceCollectionWithContextAccessor() { var services = new ServiceCollection(); IHttpContextAccessor contextAccessor = new HttpContextAccessor(); services.AddInstance<IHttpContextAccessor>(contextAccessor); services.AddInstance<INotifier>(new Notifier(new ProxyNotifierMethodAdapter())); return services; }
public IServiceProvider CreateContainer(ShellSettings settings, ShellBlueprint blueprint) { ServiceCollection serviceCollection = new ServiceCollection(); serviceCollection.AddScoped<IOrchardShell, DefaultOrchardShell>(); serviceCollection.AddScoped<IRouteBuilder, DefaultShellRouteBuilder>(); serviceCollection.AddInstance(settings); serviceCollection.AddInstance(blueprint.Descriptor); serviceCollection.AddInstance(blueprint); foreach (var dependency in blueprint.Dependencies .Where(t => typeof (IModule).IsAssignableFrom(t.Type))) { Logger.Debug("IModule Type: {0}", dependency.Type); // TODO: Rewrite to get rid of reflection. var instance = (IModule) Activator.CreateInstance(dependency.Type); instance.Configure(serviceCollection); } var p = _serviceProvider.GetService<IOrchardLibraryManager>(); serviceCollection.AddInstance<IAssemblyProvider>(new DefaultAssemblyProviderTest(p, _serviceProvider, _serviceProvider.GetService<IAssemblyLoaderContainer>())); foreach (var dependency in blueprint.Dependencies .Where(t => !typeof(IModule).IsAssignableFrom(t.Type))) { foreach (var interfaceType in dependency.Type.GetInterfaces() .Where(itf => typeof(IDependency).IsAssignableFrom(itf))) { Logger.Debug("Type: {0}, Interface Type: {1}", dependency.Type, interfaceType); if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddSingleton(interfaceType, dependency.Type); } else if (typeof(IUnitOfWorkDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddScoped(interfaceType, dependency.Type); } else if (typeof(ITransientDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddTransient(interfaceType, dependency.Type); } else { serviceCollection.AddScoped(interfaceType, dependency.Type); } } } serviceCollection.AddLogging(); return new WrappingServiceProvider(_serviceProvider, serviceCollection); }
public static IServiceProvider RegisterServices(IEnumerable<IViewLocator> viewLocators, IEnumerable<IStaticFileLocator> staticFileLocators) { // register types for IServiceProvider here var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance(typeof(IEnumerable<IViewLocator>), viewLocators); serviceCollection.AddInstance(typeof(IEnumerable<IStaticFileLocator>), staticFileLocators); serviceCollection.AddTransient<IViewLocatorService, ViewLocatorService>(); serviceCollection.AddTransient<IStaticFileGeneratorService, StaticFileGeneratorService>(); serviceCollection.AddTransient<IControllerRewriterService, ControllerRewriterService>(); serviceCollection.AddTransient<IControllerGeneratorService, ControllerGeneratorService>(); serviceCollection.AddTransient<R4MvcGenerator, R4MvcGenerator>(); return serviceCollection.BuildServiceProvider(); }
public IServiceCollection ConfigureServices() { var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance<IAmazonS3>(new AmazonS3Client()); serviceCollection.AddInstance<IAmazonCodeDeploy>(new AmazonCodeDeployClient()); serviceCollection.AddInstance<IAmazonECS>(new AmazonECSClient()); serviceCollection.AddInstance<IApplicationEnvironment>(this._appEnv); serviceCollection.AddInstance<IConfiguration>(this.Configuration); serviceCollection.AddSingleton<UtilityService>(); return serviceCollection; }
public IServiceProvider CreateContainer(ShellSettings settings, ShellBlueprint blueprint) { ServiceCollection serviceCollection = new ServiceCollection(); serviceCollection.AddScoped<IOrchardShell, DefaultOrchardShell>(); serviceCollection.AddScoped<IRouteBuilder, DefaultShellRouteBuilder>(); serviceCollection.AddInstance(settings); serviceCollection.AddInstance(blueprint.Descriptor); serviceCollection.AddInstance(blueprint); serviceCollection.AddMvc(); serviceCollection.Configure<RazorViewEngineOptions>(options => { var expander = new ModuleViewLocationExpander(); options.ViewLocationExpanders.Add(expander); }); var p = _serviceProvider.GetService<IOrchardLibraryManager>(); serviceCollection.AddInstance<IAssemblyProvider>(new DefaultAssemblyProviderTest(p, _serviceProvider, _serviceProvider.GetService<IAssemblyLoaderContainer>())); foreach (var dependency in blueprint.Dependencies) { foreach (var interfaceType in dependency.Type.GetInterfaces() .Where(itf => typeof(IDependency).IsAssignableFrom(itf))) { Logger.Debug("Type: {0}, Interface Type: {1}", dependency.Type, interfaceType); if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddSingleton(interfaceType, dependency.Type); } else if (typeof(IUnitOfWorkDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddScoped(interfaceType, dependency.Type); } else if (typeof (ITransientDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddTransient(interfaceType, dependency.Type); } else { serviceCollection.AddScoped(interfaceType, dependency.Type); } } } //foreach (var item in blueprint.Controllers) { // var serviceKeyName = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant(); // var serviceKeyType = item.Type; // serviceCollection.AddScoped(serviceKeyType); //} return BuildFallbackServiceProvider( serviceCollection, _serviceProvider); }
public static ServiceCollection GetServiceCollectionWithContextAccessor() { var services = new ServiceCollection(); IHttpContextAccessor contextAccessor = new HttpContextAccessor(); services.AddInstance<IHttpContextAccessor>(contextAccessor); return services; }
private async Task Can_use_connection_string_name_in_OnConfiguring_test(string connectionName) { var configuration = new Configuration { new MemoryConfigurationSource( new Dictionary<string, string> { { "Data:Northwind:ConnectionString", SqlServerTestDatabase.NorthwindConnectionString } }) }; var serviceCollection = new ServiceCollection(); serviceCollection .AddInstance<IConfiguration>(configuration) .AddEntityFramework() .AddSqlServer(); var serviceProvider = serviceCollection.BuildServiceProvider(); using (await SqlServerTestDatabase.Northwind()) { using (var context = new NorthwindContext(serviceProvider, connectionName)) { Assert.Equal(91, await context.Customers.CountAsync()); } } }
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 async Task OnValidateIdentityRejectsWhenValidateSecurityStampFails() { var user = new IdentityUser("test"); var httpContext = new Mock<HttpContext>(); var userManager = MockHelpers.MockUserManager<IdentityUser>(); var authManager = new Mock<IAuthenticationManager>(); var claimsManager = new Mock<IClaimsIdentityFactory<IdentityUser>>(); var signInManager = new Mock<SignInManager<IdentityUser>>(userManager.Object, authManager.Object, claimsManager.Object); signInManager.Setup(s => s.ValidateSecurityStamp(It.IsAny<ClaimsIdentity>(), user.Id)).ReturnsAsync(null).Verifiable(); var services = new ServiceCollection(); services.AddInstance(signInManager.Object); httpContext.Setup(c => c.ApplicationServices).Returns(services.BuildServiceProvider()); var id = new ClaimsIdentity(ClaimsIdentityOptions.DefaultAuthenticationType); id.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id)); var ticket = new AuthenticationTicket(id, new AuthenticationProperties { IssuedUtc = DateTimeOffset.UtcNow }); var context = new CookieValidateIdentityContext(httpContext.Object, ticket, new CookieAuthenticationOptions()); Assert.NotNull(context.Properties); Assert.NotNull(context.Options); Assert.NotNull(context.Identity); await SecurityStampValidator.OnValidateIdentity<IdentityUser>(TimeSpan.Zero).Invoke(context); Assert.Null(context.Identity); signInManager.VerifyAll(); }
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)); serviceCollection.AddInstance<IHostingEnvironment>(new HostingEnvironment() { WebRoot = "wwwroot" }); 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 static RoleManager<IdentityRole> CreateRoleManager(InMemoryContext context) { var services = new ServiceCollection(); services.AddIdentity<IdentityUser, IdentityRole>(); services.AddInstance<IRoleStore<IdentityRole>>(new RoleStore<IdentityRole>(context)); return services.BuildServiceProvider().GetRequiredService<RoleManager<IdentityRole>>(); }
private static ModelBindingContext GetBindingContext(Type modelType) { var metadataProvider = new TestModelMetadataProvider(); metadataProvider.ForType(modelType).BindingDetails(d => d.BindingSource = BindingSource.Services); var modelMetadata = metadataProvider.GetMetadataForType(modelType); var services = new ServiceCollection(); services.AddInstance<IService>(new Service()); var bindingContext = new ModelBindingContext { ModelMetadata = modelMetadata, ModelName = "modelName", FieldName = "modelName", ModelState = new ModelStateDictionary(), OperationBindingContext = new OperationBindingContext { ModelBinder = new HeaderModelBinder(), MetadataProvider = metadataProvider, HttpContext = new DefaultHttpContext() { RequestServices = services.BuildServiceProvider(), }, }, BinderModelName = modelMetadata.BinderModelName, BindingSource = modelMetadata.BindingSource, ValidationState = new ValidationStateDictionary(), }; return bindingContext; }
private static IServiceCollection CreateServices() { var services = new ServiceCollection(); services.AddInstance<ILoggerFactory>(NullLoggerFactory.Instance); return services; }
public void Ctor_WithEncryptorButNoRepository_IgnoresFallback_FailsWithServiceNotFound() { // Arrange var mockFallback = new Mock<IDefaultKeyServices>(); mockFallback.Setup(o => o.GetKeyEncryptor()).Returns(new Mock<IXmlEncryptor>().Object); mockFallback.Setup(o => o.GetKeyRepository()).Returns(new Mock<IXmlRepository>().Object); var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance<IDefaultKeyServices>(mockFallback.Object); serviceCollection.AddInstance<IXmlEncryptor>(new Mock<IXmlEncryptor>().Object); serviceCollection.AddInstance<IAuthenticatedEncryptorConfiguration>(new Mock<IAuthenticatedEncryptorConfiguration>().Object); var services = serviceCollection.BuildServiceProvider(); // Act & assert - we don't care about exception type, only exception message Exception ex = Assert.ThrowsAny<Exception>(() => new XmlKeyManager(services)); Assert.Contains("IXmlRepository", ex.Message); }
public IServiceProvider CreateContainer(ShellSettings settings, ShellBlueprint blueprint) { IServiceCollection serviceCollection = new ServiceCollection(); serviceCollection.AddInstance(settings); serviceCollection.AddInstance(blueprint.Descriptor); serviceCollection.AddInstance(blueprint); // Sure this is right? serviceCollection.AddInstance(_loggerFactory); IServiceCollection moduleServiceCollection = new ServiceCollection(); foreach (var dependency in blueprint.Dependencies .Where(t => typeof(IModule).IsAssignableFrom(t.Type))) { moduleServiceCollection.AddScoped(typeof(IModule), dependency.Type); } foreach (var service in moduleServiceCollection.BuildServiceProvider().GetServices<IModule>()) { service.Configure(serviceCollection); } foreach (var dependency in blueprint.Dependencies .Where(t => !typeof(IModule).IsAssignableFrom(t.Type))) { foreach (var interfaceType in dependency.Type.GetInterfaces() .Where(itf => typeof(IDependency).IsAssignableFrom(itf))) { _logger.LogDebug("Type: {0}, Interface Type: {1}", dependency.Type, interfaceType); if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddSingleton(interfaceType, dependency.Type); } else if (typeof(IUnitOfWorkDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddScoped(interfaceType, dependency.Type); } else if (typeof(ITransientDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddTransient(interfaceType, dependency.Type); } else { serviceCollection.AddScoped(interfaceType, dependency.Type); } } } return serviceCollection.BuildShellServiceProviderWithHost(_serviceProvider); }
public void ThrowsWhenNoServicesAreAvailable() { // Arrange var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance<IEnumerable<IFoo>>(new List<IFoo>()); var serviceProvider = serviceCollection.BuildServiceProvider(); // Act + Assert Assert.Throws<InvalidOperationException>(() => serviceProvider.GetRequiredServices<IFoo>()); }
public void Encrypt_Decrypt_RoundTrips() { // Arrange var aes = new AesCryptoServiceProvider(); aes.GenerateKey(); var serviceCollection = new ServiceCollection(); var mockInternalEncryptor = new Mock<IInternalCertificateXmlEncryptor>(); mockInternalEncryptor.Setup(o => o.PerformEncryption(It.IsAny<EncryptedXml>(), It.IsAny<XmlElement>())) .Returns<EncryptedXml, XmlElement>((encryptedXml, element) => { encryptedXml.AddKeyNameMapping("theKey", aes); // use symmetric encryption return encryptedXml.Encrypt(element, "theKey"); }); serviceCollection.AddInstance<IInternalCertificateXmlEncryptor>(mockInternalEncryptor.Object); var mockInternalDecryptor = new Mock<IInternalEncryptedXmlDecryptor>(); mockInternalDecryptor.Setup(o => o.PerformPreDecryptionSetup(It.IsAny<EncryptedXml>())) .Callback<EncryptedXml>(encryptedXml => { encryptedXml.AddKeyNameMapping("theKey", aes); // use symmetric encryption }); serviceCollection.AddInstance<IInternalEncryptedXmlDecryptor>(mockInternalDecryptor.Object); var services = serviceCollection.BuildServiceProvider(); var encryptor = new CertificateXmlEncryptor(services); var decryptor = new EncryptedXmlDecryptor(services); var originalXml = XElement.Parse(@"<mySecret value='265ee4ea-ade2-43b1-b706-09b259e58b6b' />"); // Act & assert - run through encryptor and make sure we get back <EncryptedData> element var encryptedXmlInfo = encryptor.Encrypt(originalXml); Assert.Equal(typeof(EncryptedXmlDecryptor), encryptedXmlInfo.DecryptorType); Assert.Equal(XName.Get("EncryptedData", "http://www.w3.org/2001/04/xmlenc#"), encryptedXmlInfo.EncryptedElement.Name); Assert.Equal("http://www.w3.org/2001/04/xmlenc#Element", (string)encryptedXmlInfo.EncryptedElement.Attribute("Type")); Assert.DoesNotContain("265ee4ea-ade2-43b1-b706-09b259e58b6b", encryptedXmlInfo.EncryptedElement.ToString(), StringComparison.OrdinalIgnoreCase); // Act & assert - run through decryptor and make sure we get back the original value var roundTrippedElement = decryptor.Decrypt(encryptedXmlInfo.EncryptedElement); XmlAssert.Equal(originalXml, roundTrippedElement); }
public IServiceProvider CreateContainer(ShellSettings settings, ShellBlueprint blueprint) { IServiceCollection serviceCollection = new ServiceCollection(); serviceCollection.AddInstance(settings); serviceCollection.AddInstance(blueprint.Descriptor); serviceCollection.AddInstance(blueprint); foreach (var dependency in blueprint.Dependencies .Where(t => typeof(IModule).IsAssignableFrom(t.Type))) { _logger.LogDebug("IModule Type: {0}", dependency.Type); ((IModule)ActivatorUtilities .CreateInstance(_serviceProvider, dependency.Type)) .Configure(serviceCollection); } foreach (var dependency in blueprint.Dependencies .Where(t => !typeof(IModule).IsAssignableFrom(t.Type))) { foreach (var interfaceType in dependency.Type.GetInterfaces() .Where(itf => typeof(IDependency).IsAssignableFrom(itf))) { _logger.LogDebug("Type: {0}, Interface Type: {1}", dependency.Type, interfaceType); if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddSingleton(interfaceType, dependency.Type); } else if (typeof(IUnitOfWorkDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddScoped(interfaceType, dependency.Type); } else if (typeof(ITransientDependency).IsAssignableFrom(interfaceType)) { serviceCollection.AddTransient(interfaceType, dependency.Type); } else { serviceCollection.AddScoped(interfaceType, dependency.Type); } } } return new WrappingServiceProvider(_serviceProvider, serviceCollection); }
public void Ctor_WithoutEncryptorOrRepository_UsesFallback() { // Arrange var expectedEncryptor = new Mock<IXmlEncryptor>().Object; var expectedRepository = new Mock<IXmlRepository>().Object; var mockFallback = new Mock<IDefaultKeyServices>(); mockFallback.Setup(o => o.GetKeyEncryptor()).Returns(expectedEncryptor); mockFallback.Setup(o => o.GetKeyRepository()).Returns(expectedRepository); var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance<IDefaultKeyServices>(mockFallback.Object); serviceCollection.AddInstance<IAuthenticatedEncryptorConfiguration>(new Mock<IAuthenticatedEncryptorConfiguration>().Object); var services = serviceCollection.BuildServiceProvider(); // Act var keyManager = new XmlKeyManager(services); // Assert Assert.Same(expectedEncryptor, keyManager.KeyEncryptor); Assert.Same(expectedRepository, keyManager.KeyRepository); }
public void ThrowsWhenNoServicesAreAvailable() { // Arrange var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance <IEnumerable <IFoo> >(new List <IFoo>()); var serviceProvider = serviceCollection.BuildServiceProvider(); // Act + Assert Assert.Throws <InvalidOperationException>(() => serviceProvider.GetRequiredServices <IFoo>()); }
public async Task CanCreateUsingAddRoleManager() { var services = new ServiceCollection(); services.AddEntityFramework().AddInMemoryStore(); var store = new RoleStore<IdentityRole>(new InMemoryContext()); services.AddInstance<IRoleStore<IdentityRole>>(store); services.AddIdentity<IdentityUser,IdentityRole>(); var provider = services.BuildServiceProvider(); var manager = provider.GetRequiredService<RoleManager<IdentityRole>>(); Assert.NotNull(manager); IdentityResultAssert.IsSuccess(await manager.CreateAsync(new IdentityRole("arole"))); }
public void GetActivator_ServiceProviderHasActivator_ReturnsSameInstance() { // Arrange var expectedActivator = new Mock<IActivator>().Object; var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance<IActivator>(expectedActivator); // Act var actualActivator = serviceCollection.BuildServiceProvider().GetActivator(); // Assert Assert.Same(expectedActivator, actualActivator); }
public void Throws_WhenNo_Services_AreAvailable_NonGeneric() { // Arrange var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance <IEnumerable <IFoo> >(new List <IFoo>()); var serviceProvider = serviceCollection.BuildServiceProvider(); // Act + Assert ExceptionAssert.Throws <InvalidOperationException>(() => serviceProvider.GetRequiredServices(typeof(IFoo)), $"No service for type '{typeof(IFoo)}' has been registered."); }
public static IServiceProvider CreateServices(string applicationWebSiteName) { var originalProvider = CallContextServiceLocator.Locator.ServiceProvider; var appEnvironment = originalProvider.GetService<IApplicationEnvironment>(); // When an application executes in a regular context, the application base path points to the root // directory where the application is located, for example MvcSample.Web. However, when executing // an aplication as part of a test, the ApplicationBasePath of the IApplicationEnvironment points // to the root folder of the test project. // To compensate for this, we need to calculate the original path and override the application // environment value so that components like the view engine work properly in the context of the // test. var appBasePath = CalculateApplicationBasePath(appEnvironment, applicationWebSiteName); var services = new ServiceCollection(); services.AddInstance( typeof(IApplicationEnvironment), new TestApplicationEnvironment(appEnvironment, appBasePath)); // Injecting a custom assembly provider via configuration setting. It's not good enough to just // add the service directly since it's registered by MVC. var providerType = CreateAssemblyProviderType(applicationWebSiteName); var configuration = new TestConfigurationProvider(); configuration.Configuration.Set( typeof(IControllerAssemblyProvider).FullName, providerType.AssemblyQualifiedName); services.AddInstance( typeof(ITestConfigurationProvider), configuration); services.AddInstance( typeof(ILoggerFactory), NullLoggerFactory.Instance); return services.BuildServiceProvider(originalProvider); }
public void NonGeneric_GetServices_WithBuildServiceProvider_Returns_EmptyList_WhenNoServicesAvailable() { // Arrange var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance <IEnumerable <IFoo> >(new List <IFoo>()); var serviceProvider = serviceCollection.BuildServiceProvider(); // Act var services = serviceProvider.GetServices(typeof(IFoo)); // Assert Assert.Empty(services); Assert.IsType <List <IFoo> >(services); }
public void ValidationAttribute_ForwardsCallToValidateAntiForgeryTokenAuthorizationFilter() { // Arrange var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance<AntiForgery>(GetAntiForgeryInstance()); var serviceProvider = serviceCollection.BuildServiceProvider(); var attribute = new ValidateAntiForgeryTokenAttribute(); // Act var filter = attribute.CreateInstance(serviceProvider); // Assert var validationFilter = filter as ValidateAntiForgeryTokenAuthorizationFilter; Assert.NotNull(validationFilter); }
public void StartupClassMayHaveHostingServicesInjected() { var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance<IFakeStartupCallback>(this); var services = serviceCollection.BuildServiceProvider(); var diagnosticMessages = new List<string>(); var startup = ApplicationStartup.LoadStartupMethods(services, "Microsoft.AspNet.Hosting.Tests", "WithServices", diagnosticMessages); var app = new ApplicationBuilder(services); app.ApplicationServices = startup.ConfigureServicesDelegate(serviceCollection); startup.ConfigureDelegate(app); Assert.Equal(2, _configurationMethodCalledList.Count); }
private static IServiceProvider CreateServices() { var options = new OptionsManager<MvcOptions>(new IConfigureOptions<MvcOptions>[] { }); options.Value.OutputFormatters.Add(new StringOutputFormatter()); options.Value.OutputFormatters.Add(new JsonOutputFormatter()); var services = new ServiceCollection(); services.AddInstance(new ObjectResultExecutor( options, new ActionBindingContextAccessor(), new TestHttpResponseStreamWriterFactory(), NullLoggerFactory.Instance)); return services.BuildServiceProvider(); }
/// <summary> /// Provides a default implementation of required services, calls the developer's /// configuration overrides, then creates an <see cref="IDataProtectionProvider"/>. /// </summary> internal IDataProtectionProvider InternalConfigureServicesAndCreateProtectionProvider() { // Configure the default implementation, passing in our custom discriminator var services = new ServiceCollection(); services.AddDataProtection(); services.AddInstance<IApplicationDiscriminator>(new SystemWebApplicationDiscriminator()); // Run user-specified configuration and get an instance of the provider ConfigureServices(services); var provider = CreateDataProtectionProvider(services.BuildServiceProvider()); if (provider == null) { throw new InvalidOperationException(Resources.Startup_CreateProviderReturnedNull); } // And we're done! return provider; }