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