public void TestInitialize() { _contextBuilder = ContextBuilderFactory.CreateContextBuilder() .WithData <MyData>() .RegisterAttributes(TestContext); _target = _contextBuilder.GetInstance <MyApplicationService>(); }
public TestUsersService(ITestOutputHelper output) { var testContext = new TestContext(output); _contextBuilder = ContextBuilderFactory.CreateContextBuilder() .RegisterAttributes(testContext) .Build(); _target = _contextBuilder.GetHttpClient(); }
public void TestInitialize() { _contextBuilder = ContextBuilderFactory.CreateContextBuilder(); _dataWithOneMockReader = _contextBuilder.GetInstance <DataWithOneMockReader>(); _dataWithTwoMocksReader = _contextBuilder.GetInstance <DataWithTwoMocksReader>(); _dataWithOneStateHandlerReader = _contextBuilder.GetInstance <DataWithOneStateHandlerReader>(); _dataWithTwoStateHandlersReader = _contextBuilder.GetInstance <DataWithTwoStateHandlersReader>(); _dataWithOneMockAndStateHandlersReader = _contextBuilder.GetInstance <DataWithOneMockAndOneStateHandlerReader>(); }
/// <summary>ASP.NET Core version of setting up IoC and builders.</summary> /// <param name="mode">Always use ReCreate to recreate the IoC container before each test.</param> /// <param name="webHostBuilder">The ASP.NET Core web host builder from production code, overridden with mocks using .ConfigureTestServices().</param> /// <param name="iocContainerFactory">Creates the IoC container, such as e.g. 'provider => new IocContainer(provider)'.</param> /// <remarks>The passed in web host builder is used to create a <c>TestHost</c>. /// A client is created and can be accessed through <c>GetHttpClient()</c>. /// The test host instance is disposed as the first step of initialisation.</remarks> public static void Initialize(CleanContextMode mode, Func <IWebHostBuilder> webHostBuilder, Func <IServiceProvider, IIocContainer> iocContainerFactory) => ContextBuilderFactory.Initialize(mode, () => { _wrapped?.DisposeAndRemove(); var testServer = new TestServer(webHostBuilder()); _wrapped = new Wrapper(testServer, testServer.CreateClient()); IServiceProvider serviceProvider = testServer.Host.Services; return(iocContainerFactory(serviceProvider)); });
/// <summary>ASP.NET Core version of setting up IoC and builders.</summary> /// <param name="mode">Always use ReCreate to recreate the IoC container before each test.</param> /// <param name="factoryFactory">The factory used to create a WebApplicationFactory<T> instance.</param> /// <param name="iocContainerFactory">Creates the IoC container, such as e.g. 'provider => new IocContainer(provider)'.</param> /// <typeparam name="T">The Startup class of the unit under test.</typeparam> public static void Initialize <T>(CleanContextMode mode, Func <WebApplicationFactory <T> > factoryFactory, Func <IServiceProvider, IIocContainer> iocContainerFactory) where T : class => ContextBuilderFactory.Initialize(mode, () => { _wrapped?.DisposeAndRemove(); var factory = new FactoryWrapper <T>(factoryFactory); _wrapped = factory; IServiceProvider serviceProvider = factory.GetFactory()?.Services; return(iocContainerFactory(serviceProvider)); });
/// <summary>ASP.NET Core version of setting up IoC and builders.</summary> /// <param name="mode">Always use ReCreate to recreate the IoC container before each test.</param> /// <param name="webHostBuilder">The ASP.NET Core web host builder from production code, overridden with mocks using .ConfigureTestServices().</param> /// <param name="iocContainerFactory">Creates the IoC container, such as e.g. 'provider => new IocContainer(provider)'.</param> /// <remarks>The passed in web host builder is used to create a <c>TestHost</c>. /// A client is created and can be accessed through <c>GetClient()</c>. /// The test host instance is disposed as the first step of initialisation.</remarks> public static void Initialize(CleanContextMode mode, Func <IWebHostBuilder> webHostBuilder, Func <IServiceProvider, IIocContainer> iocContainerFactory) => ContextBuilderFactory.Initialize(mode, () => { _testServer?.Dispose(); _testServer = null; _client = null; _testServer = new TestServer(webHostBuilder()); IServiceProvider serviceProvider = _testServer.Host.Services; _client = _testServer.CreateClient(); return(iocContainerFactory(serviceProvider)); });
/// <summary>ASP.NET Core version of setting up IoC and builders.</summary> /// <param name="mode">Always use ReCreate to recreate the IoC container before each test.</param> /// <param name="hostBuilder">The ASP.NET Core host builder from production code, overridden with mocks using .ConfigureTestServices().</param> /// <param name="iocContainerFactory">Creates the IoC container, such as e.g. 'provider => new IocContainer(provider)'.</param> /// <remarks>The passed in web host builder is used to create a <c>TestHost</c>. /// A client is created and can be accessed through <c>GetHttpClient()</c>. /// The test host instance is disposed as the first step of initialisation.</remarks> public static void Initialize(CleanContextMode mode, Func <IHostBuilder> hostBuilder, Func <IServiceProvider, IIocContainer> iocContainerFactory) => ContextBuilderFactory.Initialize(mode, () => { _wrapped?.DisposeAndRemove(); var host = hostBuilder().Build(); host.Start(); var testServer = host.GetTestServer(); var client = testServer.CreateClient(); _wrapped = new Wrapper(testServer, client); IServiceProvider serviceProvider = testServer.Services; return(iocContainerFactory(serviceProvider)); });
public static void AssemblyCleanup() => ContextBuilderFactory.Cleanup();
public static void AssemblyInitialize(TestContext _) { IIocContainer IocFactory() => new IocContainer(L0CompositionRootForTest.Initialize(CompositionRoot.Initialize(new ServiceCollection()))); ContextBuilderFactory.Initialize(CleanContextMode.ReCreate, IocFactory); }
public FactoryWrapper(Func <WebApplicationFactory <T> > factoryFactory) { _factory = factoryFactory(); ContextBuilderFactory.AddForCleanup(this); }
public Wrapper(TestServer testServer, HttpClient client) { _testServer = testServer; _client = client; ContextBuilderFactory.AddForCleanup(this); }