|
public ResolveType ( |
||
| serviceType | The type of the service. | |
| tag | object | The tag to register the service with. The default value is |
| return | object | |
public void ThrowsArgumentExceptionForNullTypes()
{
var serviceLocator = new ServiceLocator();
var dependencyResolver = serviceLocator.ResolveType<IDependencyResolver>();
ExceptionTester.CallMethodAndExpectException<ArgumentException>(() => dependencyResolver.CanResolveAll(null));
}
public void ReturnsTrueForEmptyArray()
{
var serviceLocator = new ServiceLocator();
var dependencyResolver = serviceLocator.ResolveType<IDependencyResolver>();
Assert.IsTrue(dependencyResolver.CanResolveAll(new Type[] { }));
}
public void ReturnsFalseForNonRegisteredType()
{
var serviceLocator = new ServiceLocator();
var dependencyResolver = serviceLocator.ResolveType<IDependencyResolver>();
Assert.IsFalse(dependencyResolver.CanResolve(typeof(IMessageService)));
}
public void ReturnsTypeFactoryUsedToCreateObject()
{
var serviceLocator = new ServiceLocator();
var typeFactory = serviceLocator.ResolveType<ITypeFactory>();
var obj = typeFactory.CreateInstance<object>();
var usedTypeFactory = obj.GetTypeFactory();
Assert.IsTrue(ReferenceEquals(typeFactory, usedTypeFactory));
}
public void ReturnsDependencyResolverUsedToCreateObject()
{
var serviceLocator = new ServiceLocator();
var dependencyResolver = serviceLocator.ResolveType<IDependencyResolver>();
var typeFactory = dependencyResolver.Resolve<ITypeFactory>();
var obj = typeFactory.CreateInstance<object>();
var usedDependencyResolver = obj.GetDependencyResolver();
Assert.IsTrue(ReferenceEquals(dependencyResolver, usedDependencyResolver));
}
public void ResolvesTypeUsingDependencyInjectionFallBackToDefaultConstructor()
{
var serviceLocator = new ServiceLocator();
var typeFactory = serviceLocator.ResolveType<ITypeFactory>();
var instance = typeFactory.CreateInstance<DependencyInjectionTestClass>();
Assert.IsTrue(instance.UsedDefaultConstructor);
}
public void CallsCustomInitializationWhenNeeded()
{
var serviceLocator = new ServiceLocator();
var typeFactory = serviceLocator.ResolveType<ITypeFactory>();
var instance = typeFactory.CreateInstance<DependencyInjectionTestClass>();
Assert.IsTrue(instance.HasCalledCustomInitialization);
}
public void TheOpenedActionIsCalledEvenWhenThereNoViewsAvailablesInTheExpectedTimeForTheCurrentViewModelButUnlockingTheInspectionThread()
{
var serviceLocator = new ServiceLocator();
var fooViewModel = new FooViewModel(serviceLocator);
var dispatcherServiceMock = new Mock<IDispatcherService>();
dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny<Action>())).Callback((Action action) => action.Invoke());
var visualizerServiceMock = new Mock<IUIVisualizerService>();
visualizerServiceMock.Setup(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(true);
var viewManagerMock = new Mock<IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] { });
serviceLocator.RegisterInstance<IDispatcherService>(dispatcherServiceMock.Object);
serviceLocator.RegisterInstance<IUIVisualizerService>(visualizerServiceMock.Object);
serviceLocator.RegisterInstance<IViewManager>(viewManagerMock.Object);
var @event = new AutoResetEvent(false);
serviceLocator.ResolveType<IUIVisualizerService>().Show(fooViewModel, () => @event.Set());
@event.WaitOne(20000);
visualizerServiceMock.Verify(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once());
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce());
}
public void RegistersTheImplementationTypesAsInterfaceTypesIfIsSetToTrue()
{
var serviceLocator = new ServiceLocator { AutoRegisterTypesViaAttributes = true };
Assert.IsTrue(serviceLocator.IsTypeRegistered<IFooService>());
Assert.IsTrue(serviceLocator.IsTypeRegisteredAsSingleton<IFooService>());
Assert.IsTrue(serviceLocator.IsTypeRegistered<IFooService2>());
Assert.IsFalse(serviceLocator.IsTypeRegisteredAsSingleton<IFooService2>());
var resolveType = serviceLocator.ResolveType<IFooService>();
Assert.IsInstanceOfType(resolveType, typeof(FooService));
var resolveType2 = serviceLocator.ResolveType<IFooService2>();
Assert.IsInstanceOfType(resolveType2, typeof(FooService2));
}
public void AutomaticSynchronization_ResolveType()
{
var serviceLocator = new ServiceLocator();
serviceLocator.AutomaticallyKeepContainersSynchronized = false;
serviceLocator.RegisterType<ITestInterface, TestClass1>();
var ninjectContainer = new StandardKernel();
serviceLocator.RegisterExternalContainer(ninjectContainer);
serviceLocator.AutomaticallyKeepContainersSynchronized = true;
serviceLocator.ResolveType<ITestInterface>();
Assert.IsTrue(ninjectContainer.GetBindings(typeof(ITestInterface)).Any());
}
public void ResolveType_RegisteredInExternalContainer()
{
var serviceLocator = new ServiceLocator();
var ninjectContainer = new StandardKernel();
serviceLocator.RegisterExternalContainer(ninjectContainer);
ninjectContainer.Bind<ITestInterface>().To<TestClass1>();
var instance = serviceLocator.ResolveType<ITestInterface>();
Assert.IsInstanceOfType(instance, typeof(TestClass1));
}
public void RegisterType_DoubleRegistration_ToChangeInstantiationStyle_And_Type()
{
var serviceLocator = new ServiceLocator();
serviceLocator.RegisterType<ITestInterface, TestClass1>();
var testInterfaceRef1 = serviceLocator.ResolveType<ITestInterface>();
var testInterfaceRef2 = serviceLocator.ResolveType<ITestInterface>();
Assert.AreSame(testInterfaceRef1, testInterfaceRef2);
Assert.AreEqual(testInterfaceRef2.GetType(), typeof(TestClass1));
serviceLocator.RegisterType<ITestInterface, TestClass2>(registrationType: RegistrationType.Transient);
testInterfaceRef1 = serviceLocator.ResolveType<ITestInterface>();
testInterfaceRef2 = serviceLocator.ResolveType<ITestInterface>();
Assert.AreNotSame(testInterfaceRef1, testInterfaceRef2);
Assert.AreEqual(testInterfaceRef2.GetType(), typeof(TestClass2));
}
public void RegisterInstance_Valid()
{
var serviceLocator = new ServiceLocator();
serviceLocator.RegisterInstance<ITestInterface>(new TestClass1 { Name = "My Instance" });
Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>());
var instance = serviceLocator.ResolveType<ITestInterface>();
Assert.AreEqual("My Instance", instance.Name);
}
public void OverridesRegistrationWithSameTag()
{
var serviceLocator = new ServiceLocator();
serviceLocator.RegisterType(typeof(ITestInterface), typeof(TestClass1), "1");
serviceLocator.RegisterType(typeof(ITestInterface), typeof(TestClass1), "2");
serviceLocator.RegisterType(typeof(ITestInterface), typeof(TestClass2), "1");
var firstService = serviceLocator.ResolveType(typeof(ITestInterface), "1");
Assert.AreEqual(typeof(TestClass2), firstService.GetType());
}
public void RemovesAllInstances()
{
var serviceLocator = new ServiceLocator { AutoRegisterTypesViaAttributes = true };
serviceLocator.RegisterType(typeof(IFoo2Service), typeof(Foo2Service), "FooService2");
var instance1 = serviceLocator.ResolveType(typeof(IFooService), "FooService1");
var instance2 = serviceLocator.ResolveType(typeof(IFooService), "FooService2");
var instance3 = serviceLocator.ResolveType(typeof(IFoo2Service), "FooService2");
serviceLocator.RemoveAllInstances();
Assert.AreNotEqual(instance1, serviceLocator.ResolveType(typeof(IFooService), "FooService1"));
Assert.AreNotEqual(instance2, serviceLocator.ResolveType(typeof(IFooService), "FooService2"));
Assert.AreNotEqual(instance3, serviceLocator.ResolveType(typeof(IFoo2Service), "FooService2"));
}
public void ResolveType_RegisteredAsInstanceInServiceLocator()
{
var serviceLocator = new ServiceLocator();
serviceLocator.RegisterInstance<ITestInterface>(new TestClass2 { Name = "instance test" });
var instance = serviceLocator.ResolveType<ITestInterface>();
Assert.AreEqual("instance test", instance.Name);
instance.Name = "changed name";
var newInstance = serviceLocator.ResolveType<ITestInterface>();
Assert.AreEqual("changed name", newInstance.Name);
Assert.AreEqual(instance, newInstance);
Assert.IsTrue(object.ReferenceEquals(instance, newInstance));
}
public void ResolveType_RegisteredAsTypeInServiceLocator()
{
var serviceLocator = new ServiceLocator();
serviceLocator.RegisterType<ITestInterface, TestClass1>();
var instance = serviceLocator.ResolveType<ITestInterface>();
Assert.IsInstanceOfType(instance, typeof(TestClass1));
}
public void ResoleType_Of_Non_Registered_Non_Abstract_Class_Without_Registration()
{
var serviceLocator = new ServiceLocator();
var dependencyInjectionTestClass = serviceLocator.ResolveType<DependencyInjectionTestClass>();
Assert.IsNotNull(dependencyInjectionTestClass);
Assert.IsFalse(serviceLocator.IsTypeRegistered(typeof(DependencyInjectionTestClass)));
}
public void ResolvesTypeUsingDependencyInjectionFallBackToDefaultConstructor()
{
var serviceLocator = new ServiceLocator();
serviceLocator.RegisterType<DependencyInjectionTestClass, DependencyInjectionTestClass>();
var instance = serviceLocator.ResolveType<DependencyInjectionTestClass>();
Assert.IsTrue(instance.UsedDefaultConstructor);
}
public void ResoleType_Of_Non_Registered_Non_Abstract_Class_Without_Registration_CanResolveNonAbstractTypesWithoutRegistration_In_False()
{
var serviceLocator = new ServiceLocator();
serviceLocator.CanResolveNonAbstractTypesWithoutRegistration = false;
ExceptionTester.CallMethodAndExpectException<NotSupportedException>(() => serviceLocator.ResolveType(typeof(DependencyInjectionTestClass)));
}
public void ResolvesSameInstanceFromBothContainers()
{
var unityContainer = new UnityContainer();
var serviceLocator = new ServiceLocator();
serviceLocator.AutomaticallyKeepContainersSynchronized = true;
serviceLocator.RegisterExternalContainer(unityContainer);
serviceLocator.RegisterTypeIfNotYetRegistered<IMessageService, MessageService>();
var ns1 = unityContainer.Resolve<IMessageService>();
var ns2 = serviceLocator.ResolveType<IMessageService>();
Assert.AreEqual(ns1, ns2);
}
public void ResoleType_Generic_TransientLifestyle()
{
var serviceLocator = new ServiceLocator();
serviceLocator.RegisterType<ITestInterface, TestClass1>(registrationType: RegistrationType.Transient);
Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>());
var firstInstance = serviceLocator.ResolveType<ITestInterface>();
Assert.IsInstanceOfType(firstInstance, typeof(TestClass1));
var secondInstance = serviceLocator.ResolveType<ITestInterface>();
Assert.IsInstanceOfType(secondInstance, typeof(TestClass1));
Assert.AreNotSame(firstInstance, secondInstance);
}
public void TheOpenedActionIsCalledWhenViewManagerHaveRegisteredAViewForTheViewModel()
{
var serviceLocator = new ServiceLocator();
var fooViewModel = new FooViewModel(serviceLocator);
var dispatcherServiceMock = new Mock<IDispatcherService>();
dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny<Action>())).Callback((Action action) => action.Invoke());
var visualizerServiceMock = new Mock<IUIVisualizerService>();
visualizerServiceMock.Setup(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(true);
var viewManagerMock = new Mock<IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] { new FooViewModelView(fooViewModel) });
serviceLocator.RegisterInstance<IDispatcherService>(dispatcherServiceMock.Object);
serviceLocator.RegisterInstance<IUIVisualizerService>(visualizerServiceMock.Object);
serviceLocator.RegisterInstance<IViewManager>(viewManagerMock.Object);
serviceLocator.ResolveType<IUIVisualizerService>().Show(fooViewModel, () =>
{
visualizerServiceMock.Verify(service => service.Show(It.Is<FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once());
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce());
this.EnqueueTestComplete();
});
}
public void ResoleType_Generic_SingletonLifestyle()
{
var serviceLocator = new ServiceLocator();
serviceLocator.RegisterType<ITestInterface, TestClass1>();
Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>());
var firstInstance = serviceLocator.ResolveType<ITestInterface>();
Assert.IsInstanceOfType(firstInstance, typeof(TestClass1));
var secondInstance = serviceLocator.ResolveType<ITestInterface>();
Assert.IsInstanceOfType(secondInstance, typeof(TestClass1));
Assert.AreSame(firstInstance, secondInstance);
}
public void ResolvesTypeUsingDependencyInjectionUsesConstructorWithMostParametersFirst()
{
var serviceLocator = new ServiceLocator();
var typeFactory = serviceLocator.ResolveType<ITypeFactory>();
var iniEntry = new IniEntry { Group = "group", Key = "key", Value = "value" };
serviceLocator.RegisterInstance(iniEntry);
serviceLocator.RegisterInstance(42);
serviceLocator.RegisterInstance("hi there");
var instance = typeFactory.CreateInstance<DependencyInjectionTestClass>();
Assert.IsFalse(instance.UsedDefaultConstructor);
Assert.AreEqual(iniEntry, instance.IniEntry);
Assert.AreEqual(42, instance.IntValue);
Assert.AreEqual("hi there", instance.StringValue);
}
public void ResolveType_Generic()
{
var serviceLocator = new ServiceLocator();
serviceLocator.RegisterType<ITestInterface, TestClass1>();
Assert.IsTrue(serviceLocator.IsTypeRegistered<ITestInterface>());
Assert.IsInstanceOfType(serviceLocator.ResolveType<ITestInterface>(), typeof(TestClass1));
}
public void ThrowsCircularDependencyExceptionForInvalidTypeRequestPath()
{
var serviceLocator = new ServiceLocator();
var typeFactory = serviceLocator.ResolveType<ITypeFactory>();
serviceLocator.RegisterType<X>();
serviceLocator.RegisterType<Y>();
serviceLocator.RegisterType<Z>();
var ex = ExceptionTester.CallMethodAndExpectException<CircularDependencyException>(() => typeFactory.CreateInstance<X>());
Assert.AreEqual(4, ex.TypePath.AllTypes.Length);
Assert.AreEqual(typeof(X), ex.TypePath.FirstType.Type);
Assert.AreEqual(typeof(X), ex.TypePath.LastType.Type);
}
public void ResolveType_InterfaceTypeNull()
{
var serviceLocator = new ServiceLocator();
ExceptionTester.CallMethodAndExpectException<ArgumentNullException>(() => serviceLocator.ResolveType(null));
}
public void ResolvesTypeUsingDependencyInjectionFallBackToFirstConstructor()
{
var serviceLocator = new ServiceLocator();
var typeFactory = serviceLocator.ResolveType<ITypeFactory>();
var iniEntry = new IniEntry { Group = "group", Key = "key", Value = "value" };
serviceLocator.RegisterInstance(iniEntry);
var instance = typeFactory.CreateInstance<DependencyInjectionTestClass>();
Assert.IsFalse(instance.UsedDefaultConstructor);
Assert.AreEqual(iniEntry, instance.IniEntry);
Assert.AreEqual(0, instance.IntValue);
Assert.AreEqual(null, instance.StringValue);
}
public void ResolveType_UnregisteredType()
{
var serviceLocator = new ServiceLocator();
Assert.IsFalse(serviceLocator.IsTypeRegistered<ITestInterface>());
ExceptionTester.CallMethodAndExpectException<NotSupportedException>(() => serviceLocator.ResolveType(typeof(ITestInterface)));
}
