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(); }
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 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 void AddWebEncoders_WithOptions_RegistersEncodersWithCustomCodeFilter() { // Arrange var serviceCollection = new ServiceCollection(); // Act serviceCollection.AddWebEncoders(options => { options.CodePointFilter = new CodePointFilter().AllowChars("ace"); // only these three chars are allowed }); // Assert var serviceProvider = serviceCollection.BuildServiceProvider(); var htmlEncoder = serviceProvider.GetRequiredService<IHtmlEncoder>(); Assert.Equal("abcde", htmlEncoder.HtmlEncode("abcde")); Assert.Same(htmlEncoder, serviceProvider.GetRequiredService<IHtmlEncoder>()); // as singleton instance var javaScriptStringEncoder = serviceProvider.GetRequiredService<IJavaScriptStringEncoder>(); Assert.Equal(@"a\u0062c\u0064e", javaScriptStringEncoder.JavaScriptStringEncode("abcde")); Assert.Same(javaScriptStringEncoder, serviceProvider.GetRequiredService<IJavaScriptStringEncoder>()); // as singleton instance var urlEncoder = serviceProvider.GetRequiredService<IUrlEncoder>(); Assert.Equal("a%62c%64e", urlEncoder.UrlEncode("abcde")); Assert.Same(urlEncoder, serviceProvider.GetRequiredService<IUrlEncoder>()); // as singleton instance }
public void Main(string[] args) { var services = new ServiceCollection(); services .AddEntityFramework() .AddSqlServer() .AddDbContext<UserDbContext>() .AddEntityFrameworkMixins(); var provider = services.BuildServiceProvider(); var context = provider.GetRequiredService<UserDbContext>(); var users = ( from u in context.Users where u.Mixin<Author>().GooglePlusProfile != null select u //u.Mixin<Author>() ).ToList(); var user = users.FirstOrDefault(); if (user != null) { var author = user.Mixin<Author>(); // You can make changes here: author.IsAwesome = true; // Save changes context.SaveChanges(); } }
public async Task CanIncludeUserClaimsTest() { // Arrange CreateContext(true); var builder = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider); var services = new ServiceCollection(); DbUtil.ConfigureDbServices<IdentityDbContext>(ConnectionString, services); services.AddIdentity<IdentityUser, IdentityRole>().AddEntityFrameworkStores<IdentityDbContext>(); builder.ApplicationServices = services.BuildServiceProvider(); var userManager = builder.ApplicationServices.GetRequiredService<UserManager<IdentityUser>>(); var dbContext = builder.ApplicationServices.GetRequiredService<IdentityDbContext>(); var username = "******" + new Random().Next(); var user = new IdentityUser() { UserName = username }; IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user)); for (var i = 0; i < 10; i++) { IdentityResultAssert.IsSuccess(await userManager.AddClaimAsync(user, new Claim(i.ToString(), "foo"))); } user = dbContext.Users.Include(x => x.Claims).FirstOrDefault(x => x.UserName == username); // Assert Assert.NotNull(user); Assert.NotNull(user.Claims); Assert.Equal(10, user.Claims.Count()); }
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 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 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 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 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 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(); }
// 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 void Main(string[] args) { var connectionString = @"Data Source=(localdb)\mssqllocaldb;Initial Catalog=Test;Integrated Security=True;Connect Timeout=30;"; IServiceCollection services = new ServiceCollection(); services.AddEntityFramework() .AddSqlServer() .AddDbContext<DataContext>(options => options.UseSqlServer(connectionString)); var serviceProvider = services.BuildServiceProvider(); //serviceProvider.Add var context = serviceProvider.GetService<DataContext>(); var categoryCount = context.Categories.Count(); Console.WriteLine($"category count is {categoryCount}"); var newCat = new Category { Name = $"Category {categoryCount + 1}", Description = $"Category {categoryCount + 1} description" }; context.Add(newCat); //context.SaveChanges(); var count = context.SaveChanges(); Console.WriteLine($"change count is {count}"); context.Dispose(); Console.WriteLine("Hello, world!"); }
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>>(); }
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 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 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(); }
/// <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 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 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 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; }
private static async Task Can_use_an_existing_closed_connection_test(bool openConnection) { var serviceCollection = new ServiceCollection(); serviceCollection .AddEntityFramework() .AddSqlServer(); var serviceProvider = serviceCollection.BuildServiceProvider(); using (var store = await SqlServerNorthwindContext.GetSharedStoreAsync()) { var openCount = 0; var closeCount = 0; var disposeCount = 0; using (var connection = new SqlConnection(store.Connection.ConnectionString)) { if (openConnection) { await connection.OpenAsync(); } connection.StateChange += (_, a) => { if (a.CurrentState == ConnectionState.Open) { openCount++; } else if (a.CurrentState == ConnectionState.Closed) { closeCount++; } }; #if !DNXCORE50 connection.Disposed += (_, __) => disposeCount++; #endif using (var context = new NorthwindContext(serviceProvider, connection)) { Assert.Equal(91, await context.Customers.CountAsync()); } if (openConnection) { Assert.Equal(ConnectionState.Open, connection.State); Assert.Equal(0, openCount); Assert.Equal(0, closeCount); } else { Assert.Equal(ConnectionState.Closed, connection.State); Assert.Equal(1, openCount); Assert.Equal(1, closeCount); } Assert.Equal(0, disposeCount); } } }
public Task Invoke(HttpContext httpContext) { var services = new ServiceCollection(); services.AddTransient<TestService>(); httpContext.RequestServices = services.BuildServiceProvider(); return _next.Invoke(httpContext); }
private IServiceProvider ConfigureServices() { var services = new ServiceCollection(); DbUtil.ConfigureDbServices<IdentityDbContext>(ConnectionString, services); services.AddLogging(); services.AddIdentity<IdentityUser, IdentityRole>().AddEntityFrameworkStores<IdentityDbContext>(); return services.BuildServiceProvider(); }
public static IServiceProvider Build() { var serviceCollection = new ServiceCollection(); serviceCollection.AddScoped<IAppDataDirectory, AppDataDirectory>(); serviceCollection.AddScoped<IRootDirectory, RootDirectory>(); return serviceCollection.BuildServiceProvider(); }
public static DbContextConfiguration CreateConfiguration() { var serviceCollection = new ServiceCollection(); serviceCollection.AddEntityFramework().AddSqlServer(); return new DbContext(serviceCollection.BuildServiceProvider(), new DbContextOptions() .UseSqlServer("Server=(localdb)\v11.0;Database=SqlServerConnectionTest;Trusted_Connection=True;")) .Configuration; }
public GenreMenuComponentTest() { var services = new ServiceCollection(); services.AddEntityFramework() .AddInMemoryStore() .AddDbContext<MusicStoreContext>(); _serviceProvider = services.BuildServiceProvider(); }
public static IServiceProvider CreateServiceProvider(Action<IServiceCollection> configure) { var collection = new ServiceCollection() .AddMessageBus() .AddSingleton<ILoggerFactory, LoggerFactory>(); configure(collection); return collection.BuildServiceProvider(); }
public CartSummaryComponentTest() { var services = new ServiceCollection(); services.AddEntityFramework() .AddInMemoryDatabase() .AddDbContext<MusicStoreContext>(options => options.UseInMemoryDatabase()); _serviceProvider = services.BuildServiceProvider(); }