public void GetAllInstanceJustReturnsCollectionOfWithOnylOneResolvedInstanceOfNonRegisteredNonAbstractClasses() { var serviceLocator = new ServiceLocator(); var serviceLocatorAdapter = new ServiceLocatorAdapter(serviceLocator); FooNonAbstractClass[] list = serviceLocatorAdapter.GetAllInstances<FooNonAbstractClass>().ToArray(); Assert.AreEqual(1, list.Length); }
public void ThrowsArgumentExceptionForNullTypes() { var serviceLocator = new ServiceLocator(); var dependencyResolver = serviceLocator.ResolveType<IDependencyResolver>(); ExceptionTester.CallMethodAndExpectException<ArgumentException>(() => dependencyResolver.CanResolveAll(null)); }
public void GetAllInstanceJustReturnsEmptyCollectionIfTheTypeIsNonRegistered() { var serviceLocator = new ServiceLocator(); var serviceLocatorAdapter = new ServiceLocatorAdapter(serviceLocator); IFooInterface[] list = serviceLocatorAdapter.GetAllInstances<IFooInterface>().ToArray(); Assert.AreEqual(0, list.Length); }
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 ResolvesInstancesOfTypeRegisteredWithSingletonParameterToFalseFromNinjectContainer() { var serviceLocator = new ServiceLocator(); var standardKernel = new StandardKernel(); serviceLocator.RegisterExternalContainer(standardKernel); serviceLocator.RegisterType<ITestInterface, TestClass1>(registrationType: RegistrationType.Transient); Assert.AreNotSame(standardKernel.Get<ITestInterface>(), standardKernel.Get<ITestInterface>()); }
public void ResolvesInstancesOfTypeRegisteredWithSingletonParameterToFalseFromUnityContainer() { var serviceLocator = new ServiceLocator(); var unityContainer = new UnityContainer(); serviceLocator.RegisterExternalContainer(unityContainer); serviceLocator.RegisterType<ITestInterface, TestClass1>(registrationType: RegistrationType.Transient); Assert.AreNotSame(unityContainer.Resolve<ITestInterface>(), unityContainer.Resolve<ITestInterface>()); }
public void ResolvesInstancesOfTypeRegisteredWithSingletonParameterToTrueFromWindsorContainer() { var serviceLocator = new ServiceLocator(); var windsorContainer = new WindsorContainer(); serviceLocator.RegisterExternalContainer(windsorContainer); serviceLocator.RegisterType<ITestInterface, TestClass1>(); Assert.AreSame(windsorContainer.Resolve<ITestInterface>(), windsorContainer.Resolve<ITestInterface>()); }
public void GetAllInstanceJustReturnsCollectionOfWithOnylOneResolvedInstanceIfTheTypeIsRegistered() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<IFooInterface, FooNonAbstractClass>(); var serviceLocatorAdapter = new ServiceLocatorAdapter(serviceLocator); IFooInterface[] list = serviceLocatorAdapter.GetAllInstances<IFooInterface>().ToArray(); Assert.AreEqual(1, list.Length); }
public void ResolvesTypeUsingDependencyInjectionFallBackToDefaultConstructor() { var serviceLocator = new ServiceLocator(); var typeFactory = serviceLocator.ResolveType<ITypeFactory>(); var instance = typeFactory.CreateInstance<DependencyInjectionTestClass>(); Assert.IsTrue(instance.UsedDefaultConstructor); }
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 override void Prepare() { var serviceLocator = new ServiceLocator(); serviceLocator.RegisterType<ISingleton, Singleton>(RegistrationType.Singleton); serviceLocator.RegisterType<ITransient, Transient>(RegistrationType.Transient); serviceLocator.RegisterType<ICombined, Combined>(RegistrationType.Transient); container = serviceLocator; }
public void DisposesAllDisposableInstances() { var isDisposed = false; var disposable = new Disposable(); disposable.Disposed += (sender, e) => isDisposed = true; var serviceLocator = new ServiceLocator(); serviceLocator.RegisterInstance(typeof(Disposable), disposable); serviceLocator.Dispose(); Assert.IsTrue(isDisposed); }
public void Constructor_InjectedServiceLocator() { var serviceLocator = new ServiceLocator(); var messageService = new MessageService(); serviceLocator.RegisterInstance<IMessageService>(messageService); var navigationService = new NavigationService(); serviceLocator.RegisterInstance<INavigationService>(navigationService); var viewModel = new TestViewModel(serviceLocator); Assert.AreEqual(messageService, viewModel.GetService<IMessageService>()); Assert.IsTrue(ReferenceEquals(messageService, viewModel.GetService<IMessageService>())); Assert.AreEqual(navigationService, viewModel.GetService<INavigationService>()); Assert.IsTrue(ReferenceEquals(navigationService, viewModel.GetService<INavigationService>())); }
public void InitializeServiceLocatorFromNonDefaultConfiguration() { Configuration openExeConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); var configurationSection = openExeConfiguration.GetSection<IoCConfigurationSection>("ioc", "catel"); var serviceLocatorConfiguration = configurationSection.GetServiceLocatorConfiguration("test"); Assert.IsNotNull(serviceLocatorConfiguration); var serviceLocator = new ServiceLocator(); serviceLocatorConfiguration.Configure(serviceLocator); Assert.AreEqual(serviceLocatorConfiguration.SupportDependencyInjection, serviceLocator.SupportDependencyInjection); foreach (Registration registration in serviceLocatorConfiguration) { serviceLocator.IsTypeRegistered(registration.InterfaceType); if (registration.RegistrationType == RegistrationType.Singleton) { serviceLocator.IsTypeRegisteredAsSingleton(registration.InterfaceType); } } }
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 RegistersTheBootTasksAndCallsCommitAsync() { var splashScreenServiceMock = new Mock<ISplashScreenService>(); var serviceLocator = new ServiceLocator(); serviceLocator.RegisterInstance<ISplashScreenService>(splashScreenServiceMock.Object); new FooBootstrapper(serviceLocator).RunWithSplashScreen<ProgressNotifyableViewModel>(); splashScreenServiceMock.Verify(service => service.Enqueue(It.IsAny<ITask>()), Times.AtLeast(12)); splashScreenServiceMock.Verify(service => service.CommitAsync<ProgressNotifyableViewModel>(null), Times.Once()); }
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(); }); }
/// <summary> /// Initializes a new instance of the <see cref="UnknowModuleBootstrapper"/> class. /// </summary> /// <param name="serviceLocator"> /// The service locator. /// </param> public UnknowModuleBootstrapper(ServiceLocator serviceLocator) : base(serviceLocator) { }
/// <summary> /// Initializes a new instance of the <see cref="NullModuleCatalogBootstrapper"/> class. /// </summary> /// <param name="serviceLocator"> /// The service locator. /// </param> public NullModuleCatalogBootstrapper(ServiceLocator serviceLocator) : base(serviceLocator) { }
public void DoesNotRegisterAModuleIfModuleManagerDoesNotNotifyThe100PercentOfLoadProgress() { var serviceLocator = new ServiceLocator(); var moduleManagerMock = new Mock<IModuleManager>(); moduleManagerMock.Setup(manager => manager.Run()).Raises(manager => manager.ModuleDownloadProgressChanged += null, new ModuleDownloadProgressChangedEventArgs(new ModuleInfo("FooModule", typeof(FooModule).FullName), 100, 50)); serviceLocator.RegisterInstance<IModuleManager>(moduleManagerMock.Object); new FooBootstrapper(serviceLocator).Run(); Assert.IsFalse(serviceLocator.IsTypeRegistered<FooModule>()); }
public void DoesNotRegisterTheImplementationTypesAsTheInterfaceTypesByDefault() { var serviceLocator = new ServiceLocator(); Assert.IsFalse(serviceLocator.IsTypeRegistered<IFooService>()); Assert.IsFalse(serviceLocator.IsTypeRegistered<IFooService2>()); }
public void CallsCustomInitializationWhenNeeded() { var serviceLocator = new ServiceLocator(); var typeFactory = serviceLocator.ResolveType<ITypeFactory>(); var instance = typeFactory.CreateInstance<DependencyInjectionTestClass>(); Assert.IsTrue(instance.HasCalledCustomInitialization); }
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 DoesNotRegisterTheImplementationTypesAsTheInterfaceTypesIfIsSetToFalse() { var serviceLocator = new ServiceLocator { AutoRegisterTypesViaAttributes = false }; Assert.IsFalse(serviceLocator.IsTypeRegistered<IFooService>()); Assert.IsFalse(serviceLocator.IsTypeRegistered<IFooService2>()); }
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 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 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 ThrowsInvalidOperationExceptionIfIgnoreRuntimeIncorrectUsageOfRegisterAttributePropertyIsSetToFalseAndSetBackToFalse() { var serviceLocator = new ServiceLocator { IgnoreRuntimeIncorrectUsageOfRegisterAttribute = false }; ExceptionTester.CallMethodAndExpectException<InvalidOperationException>(() => serviceLocator.AutoRegisterTypesViaAttributes = true); Assert.IsFalse(serviceLocator.AutoRegisterTypesViaAttributes); }