public void TestInrefaceFive()
{
DependenciesConfiguration configuration = new DependenciesConfiguration();
configuration.Register <IGetNum, GetFive>(TimeToLive.InstancePerDependency);
DependencyProvider provider = new DependencyProvider(configuration);
Mock <IGetNum> mockActual = new Mock <IGetNum>();
mockActual.Setup(mock => mock.GetNum()).Returns(5);
var expected = provider.Resolve <IGetNum>();
var actual = new GetFive();
try
{
Assert.AreEqual(expected.GetNum(), mockActual.Object.GetNum());
Assert.IsTrue(expected is GetFive);
Assert.AreEqual(expected.GetNum(), actual.GetNum());
logger.Info(nameof(TestInrefaceFive) + " - passed");
}
catch (Exception e)
{
logger.Error(e, nameof(TestInrefaceFive) + " - failed");
}
}
public void TestNameDependenies()
{
DependenciesConfiguration configuration = new DependenciesConfiguration();
configuration.Register <IGetNum, GetFive>(TimeToLive.InstancePerDependency, Numbers.Five);
configuration.Register <IGetNum, GetSeven>(TimeToLive.InstancePerDependency, Numbers.Seven);
configuration.Register <IGetNum, GetTen>(TimeToLive.InstancePerDependency, Numbers.Ten);
DependencyProvider provider = new DependencyProvider(configuration);
var actualSeven = provider.Resolve <IGetNum>(Numbers.Seven);
var actualFive = provider.Resolve <IGetNum>(Numbers.Five);
var actualTen = provider.Resolve <IGetNum>(Numbers.Ten);
var expectedSeven = new GetSeven();
var expectedFive = new GetFive();
var expectedTen = new GetTen();
try
{
Assert.IsTrue(actualSeven is GetSeven);
Assert.IsTrue(actualFive is GetFive);
Assert.IsTrue(actualTen is GetTen);
Assert.AreEqual(expectedSeven.GetNum(), actualSeven.GetNum());
Assert.AreEqual(expectedFive.GetNum(), actualFive.GetNum());
Assert.AreEqual(expectedTen.GetNum(), actualTen.GetNum());
logger.Info(nameof(TestNameDependenies) + " - passed");
}
catch (Exception e)
{
logger.Error(e, nameof(TestNameDependenies) + " - failed");
}
}
public void TestLifetime()
{
var dependencies = new DependenciesConfiguration();
dependencies.Register <IService, ServiceImplementation>(ImplementationLifeTime.Singleton);
dependencies.Register <IRepository, RepositoryImplementation>();
var provider = new DependencyProvider(dependencies);
var service1 = provider.Resolve <IService>();
var service2 = provider.Resolve <IService>();
Assert.IsTrue(Equals(service1, service2));
var service3 = Task.Run(() => provider.Resolve <IService>());
var service4 = Task.Run(() => provider.Resolve <IService>());
var service5 = Task.Run(() => provider.Resolve <IService>());
Assert.IsTrue(Equals(service3.Result, service4.Result) &&
Equals(service4.Result, service5.Result) &&
Equals(service3.Result, service5.Result) &&
Equals(service3.Result, service2) &&
Equals(service3.Result, service1));
dependencies = new DependenciesConfiguration();
dependencies.Register <IService, ServiceImplementation>(ImplementationLifeTime.InstancePerDependency);
dependencies.Register <IRepository, RepositoryImplementation>();
provider = new DependencyProvider(dependencies);
service1 = provider.Resolve <IService>();
service2 = provider.Resolve <IService>();
var service0 = provider.Resolve <IService>();
Assert.IsFalse(Equals(service1, service2));
Assert.IsFalse(Equals(service1, service0));
}
public static IWebHost CheckDependencies(this IWebHost host, Action <DependenciesConfiguration> configuration)
{
var c = new DependenciesConfiguration(host.Services);
configuration(c);
return(new DependenciesHost(host, c));
}
public void NumerousImplsTest()
{
logger.Info("Start NumerousImpls test");
IList <Type> implTypes = new List <Type>();
implTypes.Add(typeof(ServiceImpl));
implTypes.Add(typeof(ServiceImpl2));
var dependencies = new DependenciesConfiguration();
logger.Info("Start register <IService, ServiceImpl1>");
dependencies.Register <IService, ServiceImpl>();
logger.Info("Start register <IService, ServiceImpl2>");
dependencies.Register <IService, ServiceImpl2>();
var provider = new DependencyProvider(dependencies);
// должен быть создан ServiceImpl (реализация IService), в конструктор которому передана
// RepositoryImpl (реализация IRepository)
var services = provider.Resolve <IEnumerable <IService> >();
Assert.IsNotNull(services);
foreach (var implType in implTypes)
{
bool exists = false;
foreach (var service in services)
{
if (service.GetType() == implType)
{
exists = true;
break;
}
}
Assert.IsTrue(exists);
logger.Info("End NumerousImpls test");
}
}
public void TestEnumerableNum()
{
DependenciesConfiguration configuration = new DependenciesConfiguration();
configuration.Register <IGetNum, GetSeven>(TimeToLive.InstancePerDependency);
configuration.Register <IGetNum, GetFive>(TimeToLive.InstancePerDependency);
configuration.Register <IGetNum, GetTen>(TimeToLive.InstancePerDependency);
DependencyProvider provider = new DependencyProvider(configuration);
var test = provider.Resolve <IGetNum>();
Assert.AreEqual(test.GetNum(), 7);
var listNum = provider.Resolve <IEnumerable <IGetNum> >();
IEnumerator i = listNum.GetEnumerator();
i.MoveNext();
Assert.AreEqual(((IGetNum)i.Current).GetNum(), 7);
i.MoveNext();
Assert.AreEqual(((IGetNum)i.Current).GetNum(), 5);
i.MoveNext();
Assert.AreEqual(((IGetNum)i.Current).GetNum(), 10);
}
public void TestEnumerableNum()
{
DependenciesConfiguration configuration = new DependenciesConfiguration();
configuration.Register <IGetNum, GetSeven>(TimeToLive.InstancePerDependency);
configuration.Register <IGetNum, GetFive>(TimeToLive.InstancePerDependency);
configuration.Register <IGetNum, GetTen>(TimeToLive.InstancePerDependency);
DependencyProvider provider = new DependencyProvider(configuration);
var test = provider.Resolve <IGetNum>();
Assert.AreEqual(test.GetNum(), 7);
int actual = 0;
var listNum = provider.Resolve <IEnumerable <IGetNum> >();
IEnumerator i = listNum.GetEnumerator();
try
{
int[] expected = { 7, 5, 10 };
int j = 0;
while (i.MoveNext())
{
Assert.IsTrue(i.Current is IGetNum);
actual = ((IGetNum)i.Current).GetNum();
Assert.AreEqual(expected[j], actual);
j++;
}
logger.Info(nameof(TestEnumerableNum) + " - passed");
}
catch (Exception e)
{
logger.Error(e, nameof(TestEnumerableNum) + " - failed");
}
}
public void TestIEnumerable()
{
var configurations = new DependenciesConfiguration();
configurations.RegisterTransient <IMessage, SmsMessage>();
configurations.RegisterTransient <IMessage, MailMessage>();
var provider = new DependencyProvider(configurations);
IEnumerable <IMessage> messages = provider.Resolver <IEnumerable <IMessage> >();
int i = 0;
foreach (var message in messages)
{
if (i == 0)
{
Assert.AreEqual("Message from sms", message.Send());
}
if (i == 1)
{
Assert.AreEqual("Mail message", message.Send());
}
i++;
}
}
public void EditDependencies(IDependenciesViewModelContainer dependenciesViewModelContainer,
DependenciesConfiguration dependenciesConfiguration)
{
var viewModel = _depVmFunc();
viewModel.Init(dependenciesViewModelContainer, dependenciesConfiguration);
_applicationGlobalCommands.ShowWindowModal(() => new DependenciesView(), viewModel);
}
public void AsSelf()
{
var dependencies = new DependenciesConfiguration();
dependencies.Register <ServiceImpl1, ServiceImpl1>();
Assert.AreEqual(1, dependencies.Count());
}
public void Init(List <IDependenciesViewModelContainer> dependenciesViewModelContainers,
DependenciesConfiguration dependenciesConfiguration)
{
_dependenciesViewModelContainers = dependenciesViewModelContainers;
DependencyCreators = dependenciesConfiguration.Creators
.Select(tuple => new DependencyCreator(this, tuple.dependencyName, tuple.creator)).ToList();
}
public void DependenciesConfigurationRegister()
{
var dependencies = new DependenciesConfiguration();
dependencies.Register <IService, Service1>();
dependencies.Register <AbstractService, Service2>();
Assert.Equal(2, dependencies.Count());
}
public void RecursionTest()
{
DependenciesConfiguration configuration = new DependenciesConfiguration();
configuration.Register <SelfDependent, SelfDependent> ();
DependencyContainer container = new DependencyContainer(configuration);
Assert.Throws <DependencyException>(() => container.Resolve <SelfDependent>());
}
public void DependencyNotRegisteredTest()
{
DependenciesConfiguration configuration = new DependenciesConfiguration();
configuration.Register <IService <IRepository>, ServiceImpl3 <IRepository> > ();
DependencyContainer container = new DependencyContainer(configuration);
Assert.Throws <DependencyException>(() => container.Resolve <ServiceImpl3 <IRepository> >());
}
public void WrongIdTest()
{
DependenciesConfiguration configuration = new DependenciesConfiguration();
configuration.Register <IRepository, MyRepository> ("my");
DependencyContainer container = new DependencyContainer(configuration);
Assert.Throws <DependencyException>(() => container.Resolve <IRepository>("wrong"));
}
static void Main(string[] args)
{
var configuration = new DependenciesConfiguration();
configuration.Register <EnumInterface, ClassWithEnum>(false);
var provider = new DependencyProvider(configuration);
ClassWithEnum obj = (ClassWithEnum)provider.Resolve <EnumInterface>();
}
public void TestInterfaceDependency()
{
var dependencies = new DependenciesConfiguration();
dependencies.Register <TestInterface1, TestClass2>();
var provider = new DependencyProvider(dependencies);
Assert.AreEqual("created", provider.Resolve <TestInterface1>().ForTest());
}
public void WrongIdTest()
{
var configuration = new DependenciesConfiguration();
configuration.Register <IRepository, MyRepository>("kek");
var container = new DependencyProvider(configuration);
Assert.ThrowsException <DependencyException>(() => container.Resolve <IRepository>("wrong"));
}
public void newTestMethod()
{
var dependencies = new DependenciesConfiguration();
dependencies.Register <IService1, Service1>();
var provider = new DependencyProvider(dependencies);
logger.Info("Try incorrect data");
var service1 = provider.Resolve <int>();
}
public void Init(IDependenciesViewModelContainer dependenciesViewModelContainer,
DependenciesConfiguration dependenciesConfiguration)
{
_dependenciesViewModelContainer = dependenciesViewModelContainer;
DependencyViewModels.Clear();
DependencyViewModels.AddCollection(_dependenciesViewModelContainer.DependencyViewModels
.CloneCollection());
DependencyCreators = dependenciesConfiguration.Creators
.Select(tuple => new DependencyCreator(this, tuple.dependencyName, tuple.creator)).ToList();
}
public void NotWrongRegisterTest()
{
var config = new DependenciesConfiguration();
config.Register(typeof(WrongClass1), typeof(NotWrong));
var provider = new DependencyProvider(config);
IWrong obj = provider.Resolve <WrongClass1>();
Assert.IsNotNull(obj);
}
public void NoConstructorError()
{
var dependencies = new DependenciesConfiguration();
dependencies.Register <IService, NoConstructorImpl>();
var provider = new DependencyProvider(dependencies);
Assert.Throws(typeof(Exception), () => provider.Resolve <IService>());
}
public void CheckDependecny()
{
var dependencies = new DependenciesConfiguration();
dependencies.Register <ITest1, Test1Impl1>(DependencyLifeTime.InstancePerDependency);
var provider = new DependencyProvider(dependencies);
var result = provider.Resolve <ITest1>();
Assert.NotNull(result);
}
public void ProvideByIdTest()
{
DependenciesConfiguration configuration = new DependenciesConfiguration();
configuration.Register <IRepository, MyRepository> ("my");
DependencyContainer container = new DependencyContainer(configuration);
IRepository repository = container.Resolve <IRepository>("my");
Assert.IsInstanceOf <MyRepository>(repository);
}
public void CollectionDependencyTest()
{
DependenciesConfiguration configuration = new DependenciesConfiguration();
configuration.Register <IEnumerable <IRepository>, List <MyRepository> > ();
DependencyContainer container = new DependencyContainer(configuration);
IEnumerable <IRepository> repositories = container.Resolve <IEnumerable <IRepository> >();
Assert.IsInstanceOf <List <MyRepository> >(repositories);
}
public void ProvideByIdTest()
{
var configuration = new DependenciesConfiguration();
configuration.Register <IRepository, MyRepository>("my");
var container = new DependencyProvider(configuration);
var repository = container.Resolve <IRepository>("my");
Assert.IsInstanceOfType(repository, typeof(MyRepository));
}
public void TestEnumerableDependency()
{
var dependencies = new DependenciesConfiguration();
dependencies.Register <TestInterface1, TestClass2>();
dependencies.Register <TestInterface1, TestClass2_1>();
var provider = new DependencyProvider(dependencies);
Assert.AreEqual(2, provider.Resolve <IEnumerable <TestInterface1> >().Count());
}
public void TestGenericImplemetation()
{
var configurations = new DependenciesConfiguration();
configurations.RegisterTransient <IPhone, GenericPhone <int> >();
var provider = new DependencyProvider(configurations);
var phone = provider.Resolver <IPhone>();
Assert.AreEqual("Generic Phone", phone.Name);
}
public void TestConstructorWithUsualParameter()
{
var configurations = new DependenciesConfiguration();
configurations.RegisterTransient <Person, Person>();
var provider = new DependencyProvider(configurations);
var person = provider.Resolver <Person>();
Assert.AreEqual(0, person.Age);
}
public void TestGenClass()
{
var dependencies = new DependenciesConfiguration();
dependencies.Register(typeof(IFoo), typeof(Foo));
dependencies.Register(typeof(GenClass <IFoo>), typeof(GenClass <IFoo>));
var provider = new DependencyProvider(dependencies);
GenClass <IFoo> obj = provider.Resolve <GenClass <IFoo> >();
Assert.IsNotNull(obj);
}
