public void AddWebEncoders_DoesNotOverrideExistingRegisteredEncoders() { // Arrange var serviceCollection = new ServiceCollection(); // Act serviceCollection.AddSingleton<IHtmlEncoder, CommonTestEncoder>(); serviceCollection.AddSingleton<IJavaScriptStringEncoder, CommonTestEncoder>(); // we don't register an existing URL encoder serviceCollection.AddWebEncoders(options => { options.CodePointFilter = new CodePointFilter().AllowChars("ace"); // only these three chars are allowed }); // Assert var serviceProvider = serviceCollection.BuildServiceProvider(); var htmlEncoder = serviceProvider.GetHtmlEncoder(); Assert.Equal("HtmlEncode[[abcde]]", htmlEncoder.HtmlEncode("abcde")); var javaScriptStringEncoder = serviceProvider.GetJavaScriptStringEncoder(); Assert.Equal("JavaScriptStringEncode[[abcde]]", javaScriptStringEncoder.JavaScriptStringEncode("abcde")); var urlEncoder = serviceProvider.GetUrlEncoder(); Assert.Equal("a%62c%64e", urlEncoder.UrlEncode("abcde")); }
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(); } }
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 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")); } }
private void RegisterServices() { ServiceCollection services = new ServiceCollection(); services.AddSingleton<IBooksService, BooksService>(); services.AddSingleton<IMessagingService, WPFMessagingService>(); services.AddTransient<BooksViewModel>(); services.AddTransient<BookViewModel>(); services.AddTransient<RandomViewModel>(); Container = services.BuildServiceProvider(); }
public static IEnumerable<ServiceDescriptor> GetDefaultServices() { var services = new ServiceCollection(); // // Discovery & Reflection. // services.AddTransient<ITypeActivator, DefaultTypeActivator>(); services.AddTransient<ITypeSelector, DefaultTypeSelector>(); services.AddTransient<IAssemblyProvider, DefaultAssemblyProvider>(); services.AddTransient<ITypeService, DefaultTypeService>(); // TODO: consider making above singleton // // Context. // services.AddTransient(typeof(IContextData<>), typeof(ContextData<>)); // // Messages. // services.AddSingleton<IMessageConverter, DefaultMessageConverter>(); // // JSON.Net. // services.AddTransient<JsonSerializer, JsonSerializer>(); return services; }
public static IServiceCollection GetDefaultServices() { var services = new ServiceCollection(); // // Options // services.AddTransient<IConfigureOptions<GlimpseAgentWebOptions>, GlimpseAgentWebOptionsSetup>(); services.AddSingleton<IRequestIgnorerUriProvider, DefaultRequestIgnorerUriProvider>(); services.AddSingleton<IRequestIgnorerStatusCodeProvider, DefaultRequestIgnorerStatusCodeProvider>(); services.AddSingleton<IRequestIgnorerContentTypeProvider, DefaultRequestIgnorerContentTypeProvider>(); services.AddSingleton<IRequestIgnorerProvider, DefaultRequestIgnorerProvider>(); services.AddSingleton<IRequestProfilerProvider, DefaultRequestProfilerProvider>(); return services; }
// 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 static IServiceCollection CreateTestServices() { var services = new ServiceCollection(); services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>(); services.AddLogging(); services.AddIdentity<IdentityUser, IdentityRole>(); return services; }
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 IServiceCollection DefineServices() { var services = new ServiceCollection(); services.AddSingleton<ICall, CallOne>(); services.AddScoped<ICall, CallTwo>(); services.AddTransient<ICall, CallThree>(); return services; }
public static IServiceCollection GetDefaultServices() { var services = new ServiceCollection(); // // Broker // //yield return describe.Singleton<IChannelSender, RemoteStreamMessagePublisher>(); services.AddSingleton<IChannelSender, WebSocketChannelSender>(); // // Connection // //yield return describe.Singleton<IStreamProxy, DefaultStreamProxy>(); services.AddSingleton<IStreamHubProxyFactory, SignalrStreamHubProxyFactory>(); return services; }
public async Task VerifyAccountControllerSignIn(bool isPersistent) { var app = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider); app.UseCookieAuthentication(); var context = new Mock<HttpContext>(); var auth = new Mock<AuthenticationManager>(); context.Setup(c => c.Authentication).Returns(auth.Object).Verifiable(); auth.Setup(a => a.SignInAsync(new IdentityCookieOptions().ApplicationCookieAuthenticationScheme, It.IsAny<ClaimsPrincipal>(), It.IsAny<AuthenticationProperties>())).Returns(Task.FromResult(0)).Verifiable(); // REVIEW: is persistant mocking broken //It.Is<AuthenticationProperties>(v => v.IsPersistent == isPersistent))).Returns(Task.FromResult(0)).Verifiable(); var contextAccessor = new Mock<IHttpContextAccessor>(); contextAccessor.Setup(a => a.HttpContext).Returns(context.Object); var services = new ServiceCollection(); services.AddLogging(); services.AddInstance(contextAccessor.Object); services.AddIdentity<TestUser, TestRole>(); services.AddSingleton<IUserStore<TestUser>, InMemoryUserStore<TestUser>>(); services.AddSingleton<IRoleStore<TestRole>, InMemoryRoleStore<TestRole>>(); app.ApplicationServices = services.BuildServiceProvider(); // Act var user = new TestUser { UserName = "******" }; const string password = "******"; var userManager = app.ApplicationServices.GetRequiredService<UserManager<TestUser>>(); var signInManager = app.ApplicationServices.GetRequiredService<SignInManager<TestUser>>(); IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password)); var result = await signInManager.PasswordSignInAsync(user, password, isPersistent, false); // Assert Assert.True(result.Succeeded); context.VerifyAll(); auth.VerifyAll(); contextAccessor.VerifyAll(); }
public static IServiceCollection GetLocalAgentServices() { var services = new ServiceCollection(); // // Broker // services.AddSingleton<IChannelSender, InProcessChannel>(); return services; }
public static IServiceCollection GetDefaultServices() { var services = new ServiceCollection(); // // Broker // services.AddSingleton<IAgentBroker, DefaultAgentBroker>(); return services; }
public ActivityApiControllerTest() { if (_serviceProvider == null) { var services = new ServiceCollection(); services.AddEntityFramework() .AddInMemoryDatabase() .AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase()); var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("testConfig.json"); IConfiguration configuration = builder.Build(); services.AddSingleton(x => configuration); IHostingEnvironment hostingEnvironment = new HostingEnvironment(); hostingEnvironment.EnvironmentName = "Development"; services.AddSingleton(x => hostingEnvironment); _serviceProvider = services.BuildServiceProvider(); } }
public static IServiceCollection GetDefaultServices() { var services = new ServiceCollection(); // // Broker // services.AddSingleton<IChannelSender, HttpChannelSender>(); return services; }
public async Task CanCreateRoleWithSingletonManager() { var services = new ServiceCollection(); services.AddEntityFramework().AddInMemoryStore(); services.AddTransient<InMemoryContext>(); services.AddTransient<IRoleStore<IdentityRole>, RoleStore<IdentityRole, InMemoryContext>>(); services.AddIdentity<IdentityUser, IdentityRole>(); services.AddSingleton<RoleManager<IdentityRole>>(); var provider = services.BuildServiceProvider(); var manager = provider.GetRequiredService<RoleManager<IdentityRole>>(); Assert.NotNull(manager); IdentityResultAssert.IsSuccess(await manager.CreateAsync(new IdentityRole("someRole"))); }
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 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 static IServiceCollection GetDefaultServices() { var services = new ServiceCollection(); // // Broker // services.AddSingleton<IServerBroker, DefaultServerBroker>(); services.AddSingleton<IClientBroker, DefaultClientBroker>(); // // Store // services.AddSingleton<IStorage, InMemoryStorage>(); // // Options // services.AddTransient<IConfigureOptions<GlimpseServerWebOptions>, GlimpseServerWebOptionsSetup>(); services.AddSingleton<IAllowRemoteProvider, DefaultAllowRemoteProvider>(); 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); } 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); } } } return new WrappingServiceProvider(_serviceProvider, serviceCollection); }
public SqliteMetadataModelProviderTest() { _testStore = SqliteTestStore.CreateScratch(); var serviceCollection = new ServiceCollection(); serviceCollection.AddLogging(); new SqliteDesignTimeMetadataProviderFactory().AddMetadataProviderServices(serviceCollection); serviceCollection.AddSingleton<IFileService, FileSystemFileService>(); var serviceProvider = serviceCollection .BuildServiceProvider(); _logger = new TestLogger(); serviceProvider.GetService<ILoggerFactory>().AddProvider(new TestLoggerProvider(_logger)); _metadataModelProvider = serviceProvider .GetService<IDatabaseMetadataModelProvider>() as SqliteMetadataModelProvider; }
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 ActivityApiControllerTest() { if (_serviceProvider == null) { var services = new ServiceCollection(); // 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(); } }
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 static IServiceCollection DefaultServices() { var services = new ServiceCollection(); services.AddTransient<IFakeService, FakeService>(); services.AddTransient<IFakeMultipleService, FakeOneMultipleService>(); services.AddTransient<IFakeMultipleService, FakeTwoMultipleService>(); services.AddTransient<IFakeOuterService, FakeOuterService>(); services.AddInstance<IFakeServiceInstance>(new FakeService() { Message = "Instance" }); services.AddScoped<IFakeScopedService, FakeService>(); services.AddSingleton<IFakeSingletonService, FakeService>(); services.AddTransient<IDependOnNonexistentService, DependOnNonexistentService>(); services.AddTransient<IFakeOpenGenericService<string>, FakeService>(); services.AddTransient(typeof(IFakeOpenGenericService<>), typeof(FakeOpenGenericService<>)); services.AddTransient<IFactoryService>(provider => { var fakeService = provider.GetService<IFakeService>(); return new TransientFactoryService { FakeService = fakeService, Value = 42 }; }); services.AddScoped(provider => { var fakeService = provider.GetService<IFakeService>(); return new ScopedFactoryService { FakeService = fakeService, }; }); services.AddScoped<ClassWithNestedReferencesToProvider>(); services.AddTransient<ServiceAcceptingFactoryService, ServiceAcceptingFactoryService>(); return services; }
public void Context_with_options_and_options_action_can_be_used_as_service() { var services = new ServiceCollection(); var contextOptionsExtension = new FakeDbContextOptionsExtension(); services .AddSingleton<FakeService>() .AddEntityFramework() .AddDbContext<ContextWithOptions>(optionsBuilder => ((IOptionsBuilderExtender)optionsBuilder).AddOrUpdateExtension(contextOptionsExtension)); var serviceProvider = services.BuildServiceProvider(); using (var context = serviceProvider.GetRequiredService<ContextWithOptions>()) { var contextServices = ((IAccessor<IServiceProvider>)context).Service; var options = contextServices.GetRequiredService<IDbContextOptions>(); Assert.NotNull(contextServices.GetRequiredService<FakeService>()); Assert.Equal(1, options.Extensions.Count()); Assert.Same(contextOptionsExtension, options.Extensions.Single()); } }
// Need full wrap for generics like IOptions public WrappingServiceProvider(IServiceProvider fallback, IServiceCollection replacedServices) { var services = new ServiceCollection(); var manifest = fallback.GetRequiredService<IRuntimeServices>(); foreach (var service in manifest.Services) { services.AddTransient(service, sp => fallback.GetService(service)); } services.AddSingleton<IRuntimeServices>(sp => new HostingManifest(services)); services.Add(replacedServices); _services = services.BuildServiceProvider(); }
public void Context_with_defaults_can_be_used_as_service() { var services = new ServiceCollection(); services .AddSingleton<FakeService>() .AddEntityFramework() .AddDbContext<ContextWithDefaults>(); var serviceProvider = services.BuildServiceProvider(); using (var context = serviceProvider.GetRequiredService<ContextWithDefaults>()) { var contextServices = ((IAccessor<IServiceProvider>)context).Service; Assert.NotNull(serviceProvider.GetRequiredService<FakeService>()); Assert.NotSame(serviceProvider, contextServices); Assert.Equal(0, contextServices.GetRequiredService<IDbContextOptions>().Extensions.Count()); } }