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();
}
}
