private void ValidateFileBasedDiContainer(DiImplementationType diImplementationType, IDiContainer diContainer)
{
Assert.IsNotNull(diContainer.Resolve <ISettings>());
Assert.IsNotNull(diContainer.Resolve <IPluginsSetup>());
Assert.IsNotNull(diContainer.Resolve <IPluginDataRepository>());
Assert.IsNotNull(diContainer.Resolve <IOnApplicationsStarted>());
ValidateDiContainer(diImplementationType, diContainer);
}
protected static void ClassInitializeCommon(DiImplementationType diImplementationType, Action <ConfigurationFileXmlDocumentLoadedEventArgs> configurationFileXmlDocumentLoadedEventHandler)
{
// JetBrains.ReSharper.TestRunner.Merged
TestsHelper.SetupLogger();
Log4Tests.LogLevel = LogLevel.Debug;
_diImplementationType = diImplementationType;
_mainLifeTimeScopeTerminatedExecuted = false;
var diContainerBuilder = new DiContainerBuilder.DiContainerBuilder();
var fileBasedConfigurationParameters = new FileBasedConfigurationParameters(new FileBasedConfigurationFileContentsProvider(
Path.Combine(Helpers.TestsEntryAssemblyFolder, "IoCConfiguration_Overview.xml")),
Helpers.TestsEntryAssemblyFolder, new LoadedAssembliesForTests())
{
AttributeValueTransformers = new[] { new FileFolderPathAttributeValueTransformer() },
ConfigurationFileXmlDocumentLoaded = (sender, e) =>
{
Helpers.EnsureConfigurationDirectoryExistsOrThrow(e.XmlDocument.SelectElement("/iocConfiguration/appDataDir").GetAttribute("path"));
Helpers.ReplaceActiveDiManagerInConfigurationFile(e.XmlDocument, _diImplementationType);
configurationFileXmlDocumentLoadedEventHandler?.Invoke(e);
}
};
_containerInfo = diContainerBuilder.StartFileBasedDi(
fileBasedConfigurationParameters, out _)
.WithoutPresetDiContainer()
.AddAdditionalDiModules(new TestModule2())
.RegisterModules()
.Start();
_diContainer = _containerInfo.DiContainer;
var injectedStartupActionsHelper = _diContainer.Resolve <ClassToTestServicesInjection <IStartupAction> >();
_startupActionsToTest = injectedStartupActionsHelper.Implementations.Where(x => x is IStartupActionState &&
new[]
{
"DynamicallyLoadedAssembly1.Implementations.StartupAction1",
"DynamicallyLoadedAssembly1.Implementations.StartupAction2"
}
.Contains(x.GetType().FullName)).ToList();
var injectedPluginsHelper = _diContainer.Resolve <ClassToTestServicesInjection <IPlugin> >();
_pluginsToTest = injectedPluginsHelper.Implementations.Where(x => x is IPluginState &&
new[]
{
"TestPluginAssembly1.Implementations.Plugin1",
"TestPluginAssembly2.Implementations.Plugin2"
}
.Contains(x.GetType().FullName)).ToList();
_diContainer.MainLifeTimeScope.LifeTimeScopeTerminated += (sender, e) => { _mainLifeTimeScopeTerminatedExecuted = true; };
}
public void Initialize()
{
_container.Register <Note>();
_container.Register <DataManager>();
_container.Register <List <Note> >();
_firstNote = _container.Resolve <Note>(parameters: new object[] { (sbyte)1, "Watch movie", "Watch Thor 3", DateTime.Now });
_secondNote =
_container.Resolve <Note>(parameters: new object[] { (sbyte)2, "Street", "Go for a walk", DateTime.Now });
_dataManager = _container.Resolve <DataManager>(parameters: new object[] { _container });
}
public void Dispatch <TCommand>(TCommand command) where TCommand : Command
{
var commandHandler = diContainer.Resolve <ICommandHandler <TCommand> >();
var transactionalCommandHandler = new TransactionalCommandHandler <TCommand>(commandHandler, diContainer);
transactionalCommandHandler.Execute(command);
}
private static async Task <bool> Test(IDiContainer container, TestInfo info)
{
Console.WriteLine($"-------------------------- {info.Title} BEGIN ------------------------------");
Console.WriteLine();
Console.WriteLine(info.Description);
var posTerminal = container.Resolve <IPosTerminal>();
foreach (var itemCode in info.ItemCodes)
{
posTerminal.ScanItemCode(itemCode);
}
foreach (var revokedCode in info.RevokedItemCodes)
{
posTerminal.RemoveItemCode(revokedCode);
}
var actualTotal = await posTerminal.CalculateTotalAsync().ConfigureAwait(false);
var passes = info.ExpectedTotal == actualTotal;
Console.WriteLine();
Console.WriteLine(posTerminal);
Console.WriteLine($"\nExpected: {info.ExpectedTotal}\nActual: {actualTotal}\nPasses: {passes}");
Console.WriteLine();
Console.WriteLine($"-------------------------- {info.Title} END ------------------------------");
return(passes);
}
public void Dispatch <TCommand>(TCommand command) where TCommand : Command
{
var commandHandler = diContainer.Resolve <ICommandHandler <TCommand> >();
var transactionDecorator = new TransactionCommandHandler <TCommand>(commandHandler, diContainer);
var logCommandDecorator = new LogCommandHandler <TCommand>(transactionDecorator);
var exceptionDecorator = new ExceptionCommandHandler <TCommand>(logCommandDecorator);
exceptionDecorator.Execute(command);
}
public void DIBuilderTests_InterfaceBind()
{
IDiContainerBuilder containerBuilder = new DiContainerBuilder();
containerBuilder.Bind <IClass1Test, Class1Test>().FromNew();
IDiContainer container = containerBuilder.Build();
IClass1Test class1Test = container.Resolve <IClass1Test>();
Assert.NotNull(class1Test);
}
public void DIBuilderTests_FromFunction()
{
IDiContainerBuilder containerBuilder = new DiContainerBuilder();
containerBuilder.Bind <Class1Test>().FromFunction((c) => new Class1Test());
IDiContainer container = containerBuilder.Build();
Class1Test class1Test = container.Resolve <Class1Test>();
Assert.IsNotNull(class1Test);
}
private void ValidateDiContainer(DiImplementationType diImplementationType, IDiContainer diContainer)
{
// Validate resolutions in module DiModule1
Assert.AreEqual(diContainer.Resolve <IService1>().GetType(), typeof(Service1));
// Validate resolutions in native modules
var interface1Test = diContainer.Resolve <ClassToTestServicesInjection <IInterface1> >();
switch (diImplementationType)
{
case DiImplementationType.Autofac:
interface1Test.ValidateHasImplementation(typeof(Interface1_Impl1));
interface1Test.ValidateDoesNotHaveImplementation(typeof(Interface1_Impl2).FullName);
break;
case DiImplementationType.Ninject:
interface1Test.ValidateHasImplementation(typeof(Interface1_Impl2));
interface1Test.ValidateDoesNotHaveImplementation(typeof(Interface1_Impl1).FullName);
break;
}
}
public void ValidateOnIoCContainerLoaded(IDiContainer diContainer, ICustomAutoGeneratedServiceInfo customAutoGeneratedServiceInfo)
{
var settings = diContainer.Resolve <ISettings>();
if (settings.GetSettingValue <bool>("failCustomServiceValidation", false, out var failCustomServiceValidation))
{
if (failCustomServiceValidation)
{
throw new Exception($"Validation {nameof(ValidateOnIoCContainerLoaded)} failed because the value of setting 'failCustomServiceValidation' is true");
}
}
}
/// <summary>
/// Метод для получения данных из бд
/// </summary>
/// <typeparam name="T">Тип входных данных</typeparam>
/// <returns>DbSet, содержащий элементы типа Note
/// или CalendarEvent</returns>
/// <exception cref="CreationException">CreationException</exception>
/// <exception cref="ArgumentException">ArgumentException</exception>
public object GetFromDatabase <T>() where T : class
{
if (typeof(T) == typeof(Note))
{
using (var db = _container.Resolve <NoteContext>())
{
var result = db.Notes;
result.Load();
return(result.Local.ToList());
}
}
if (typeof(T) != typeof(CalendarEvent))
{
throw new ArgumentException($"Invalid type {typeof(T)}");
}
using (var db = _container.Resolve <CalendarEventContext>())
{
IDictionary <Day, IList <CalendarEvent> > result = new Dictionary <Day, IList <CalendarEvent> >();
foreach (var day in db.Days.Include(e => e.Events))
{
result.Add(day, day.Events);
}
return(result);
}
}
public void DIBuilderTests_FromInstance()
{
Class1Test classTest = new Class1Test();
IDiContainerBuilder containerBuilder = new DiContainerBuilder();
containerBuilder.Bind <Class1Test>().FromInstance(classTest);
IDiContainer container = containerBuilder.Build();
Class1Test class1Test = container.Resolve <Class1Test>();
Assert.IsNotNull(class1Test);
}
public void DIBuilderTests_SimpleInit()
{
IDiContainerBuilder containerBuilder = new DiContainerBuilder();
containerBuilder.Bind <Class3Test>()
.FromNew()
.WhenInit((o) => o.Init);
IDiContainer container = containerBuilder.Build();
Class3Test class3Test = container.Resolve <Class3Test>();
Assert.IsNotNull(class3Test);
}
public void Execute(TCommand command)
{
var unitOfWork = diContainer.Resolve <IUnitOfWork>();
try
{
commandHandler.Execute(command);
unitOfWork.Commit();
}
catch (Exception e)
{
unitOfWork.RollBack();
throw;
}
}
public void Execute(Tcommand command)
{
var unitOfWork = diContainer.Resolve <IUnitOfWork>();
try
{
handler.Execute(command);
unitOfWork.Commit();
}
catch
{
unitOfWork.Rollback();
throw;
}
}
public void DIBuilderTests_AssertCircularResolve()
{
IDiContainerBuilder containerBuilder = new DiContainerBuilder();
containerBuilder.Bind <Class5Test>()
.FromFunction((x) => new Class5Test(
x.Resolve <Class6Test>()
));
containerBuilder.Bind <Class6Test>()
.FromFunction((x) => new Class6Test(
x.Resolve <Class5Test>()
));
IDiContainer container = containerBuilder.Build();
Assert.Throws <Exception>(() => container.Resolve <Class5Test>());
}
public void DIBuilderTests_MultipleContainersBind()
{
IDiContainerBuilder containerBuilder1 = new DiContainerBuilder();
containerBuilder1.Bind <Class1Test>().FromNew();
IDiContainer container1 = containerBuilder1.Build();
IDiContainerBuilder containerBuilder2 = new DiContainerBuilder();
containerBuilder2.Bind <Class2Test>()
.FromFunction((c) => new Class2Test(
c.Resolve <Class1Test>()
));
containerBuilder2.Bind(container1);
IDiContainer container2 = containerBuilder2.Build();
container2.Resolve <Class2Test>();
}
public void DIBuilderTests_SimpleDispose()
{
IDiContainerBuilder containerBuilder = new DiContainerBuilder();
containerBuilder.Bind <Class1Test>().FromNew();
containerBuilder.Bind <Class3Test>()
.FromNew()
.WhenDispose((o) => o.Dispose());
IDiContainer container = containerBuilder.Build();
Class3Test class3Test = container.Resolve <Class3Test>();
container.Dispose();
Assert.IsNotNull(class3Test);
Assert.IsTrue(class3Test.Disposed);
}
public void OnDiContainerReady(IDiContainer diContainer)
{
_diContainer = diContainer;
_parameterSerializer = _diContainer.Resolve <ITypeBasedSimpleSerializerAggregator>();
}
public override object Resolve(Type type) => container.Resolve(type);
public object Resolve(Type resolveType) => container.Resolve(resolveType);
public IDiBindingActionBuilder <T> FromContainer(IDiContainer container)
{
return(FromFunction((c) => container.Resolve <T>()));
}
public MainWindowViewModel(IDiContainer container)
{
_container = container;
_container.Register <DataManager>();
_manager = _container.Resolve <DataManager>(parameters: new object[] { _container });
}
public override void Load()
{
foreach (var serviceBindingConfiguration in _module.ServiceBindingConfigurations)
{
if (serviceBindingConfiguration.RegisterIfNotRegistered && Kernel.GetBindings(serviceBindingConfiguration.ServiceType).Any())
{
continue;
}
foreach (var implementationConfiguration in serviceBindingConfiguration.Implementations)
{
var ninjectServiceBindingConfiguration = Bind(serviceBindingConfiguration.ServiceType);
IBindingWhenInNamedWithOrOnSyntax <object> ninjectImplementationConfiguration;
switch (implementationConfiguration.TargetImplementationType)
{
case TargetImplementationType.Type:
ninjectImplementationConfiguration = ninjectServiceBindingConfiguration.To(implementationConfiguration.ImplementationType);
break;
case TargetImplementationType.Self:
ninjectImplementationConfiguration = ninjectServiceBindingConfiguration.ToSelf();
break;
case TargetImplementationType.Delegate:
ninjectImplementationConfiguration = ninjectServiceBindingConfiguration.ToMethod(context =>
implementationConfiguration.ImplementationGeneratorFunction(_diContainer));
break;
case TargetImplementationType.ProxiedType:
ninjectImplementationConfiguration = ninjectServiceBindingConfiguration.ToMethod(context =>
_diContainer.Resolve(implementationConfiguration.ImplementationType));
break;
default:
throw new Exception($"Unhandled value '{implementationConfiguration.TargetImplementationType}'.");
}
if (implementationConfiguration.WhenInjectedIntoType != null)
{
switch (implementationConfiguration.ConditionalInjectionType)
{
case ConditionalInjectionType.WhenInjectedInto:
ninjectImplementationConfiguration.WhenInjectedInto(implementationConfiguration.WhenInjectedIntoType);
break;
case ConditionalInjectionType.WhenInjectedExactlyInto:
ninjectImplementationConfiguration.WhenInjectedExactlyInto(implementationConfiguration.WhenInjectedIntoType);
break;
}
}
switch (implementationConfiguration.ResolutionScope)
{
case DiResolutionScope.Singleton:
ninjectImplementationConfiguration.InSingletonScope();
break;
case DiResolutionScope.Transient:
ninjectImplementationConfiguration.InTransientScope();
break;
case DiResolutionScope.ScopeLifetime:
ninjectImplementationConfiguration.InScope(context => _diContainer.CurrentLifeTimeScope);
break;
//case DiResolutionScope.Thread:
// ninjectImplementationConfiguration.InThreadScope();
// break;
default:
throw new Exception($"Unsupported resolution type.The value is '{implementationConfiguration.ResolutionScope}'.");
}
if (implementationConfiguration.OnImplementationObjectActivated != null)
{
ninjectImplementationConfiguration.OnActivation(activatedObject =>
implementationConfiguration.OnImplementationObjectActivated(_diContainer, activatedObject));
}
}
}
}
