private static IUnityContainer ConfigureContainer(IServiceProvider package, ServiceLocatorOptions options) { if (package == null) throw new ArgumentNullException(nameof(package), $"{nameof(package)} is null."); IUnityContainer container = new UnityContainer(); container.AddExtension(new ServiceProviderUnityExtension(package, options)); container.RegisterType<IToolkit, TookitImpl>(new ContainerControlledLifetimeManager()); container.RegisterTypes(new SolutionExplorerNodeFactoryRegistrationConvention()); container.RegisterType<IEnumerable<ISolutionExplorerNodeFactory>, ISolutionExplorerNodeFactory[]>(); container.RegisterType<ISolutionExplorerNodeFactory, GlobalSolutionExplorerNodeFactory>(); container.RegisterType<ISolutionExplorer, SolutionExplorer>(); container.RegisterType<IOutputWindow, OutputWindow>(new ContainerControlledLifetimeManager()); container.RegisterType<IDialogService, DialogService>(new ContainerControlledLifetimeManager()); container.RegisterType<IEnumerable<ICommandImplementation>, ICommandImplementation[]>(); container.RegisterInstance<IServiceProvider>(package); container.RegisterType<ICommandManager, CommandManager>(new ContainerControlledLifetimeManager()); UnityServiceLocator serviceLocator = new UnityServiceLocator(container); container.RegisterInstance<IServiceLocator>(serviceLocator); if (!ServiceLocator.IsLocationProviderSet) ServiceLocator.SetLocatorProvider(() => serviceLocator); return container; }
public void ResolveLooseInterfaceTest() { var container = new UnityContainer(); container.AddExtension(MockUnit.Extension); var list = container.Resolve<IList>(); Assert.IsFalse(list.Contains(string.Empty)); }
public void Test() { var container = new UnityContainer(); var settings = new Settings(); container.AddExtension(new Bootstrapper(settings)); container.Resolve<ProjectController>(); }
public void Ext_ContainerCallsExtensionsInitializeMethod() { MockContainerExtension extension = new MockContainerExtension(); IUnityContainer container = new UnityContainer(); container.AddExtension(extension); Assert.IsTrue(extension.InitializeWasCalled); }
public void CheckExtensionAdded() { MyCustomExtension extension = new MyCustomExtension(); IUnityContainer uc = new UnityContainer(); uc.AddExtension(extension); Assert.IsTrue(extension.CheckExtensionValue); }
public void CheckExtensionAddedToContainer() { MyCustomExtension extension = new MyCustomExtension(); IUnityContainer uc = new UnityContainer(); uc.AddExtension(extension); Assert.AreSame(uc, extension.Container); }
public void ResolveOnRegisteredTypeShouldNotBeMocked() { var container = new UnityContainer(); container.AddExtension(MockUnit.Extension); container.RegisterType<IMyInterface, MyClass>(new ContainerControlledLifetimeManager()); var resolved = container.Resolve<IMyInterface>(); Assert.IsNotNull(resolved); Assert.AreEqual(typeof (MyClass), resolved.GetType()); }
public void ResolveLooseInterfaceWithSetupTest() { var container = new UnityContainer(); container.AddExtension(MockUnit.Extension); var mock = MockUnit.Get<IList>(); mock.Setup(x => x.Contains(It.IsAny<string>())).Returns(true); var list = container.Resolve<IList>(); Assert.IsTrue(list.Contains(string.Empty)); }
public static IUnityContainer Register() { var container = new UnityContainer(); // Register types in TextUtilModule container.AddExtension(new TextUtilModule()); return container; }
public void AddExistingMyCustonExtensionToContainer() { MyCustomExtension extension = new MyCustomExtension(); IUnityContainer uc = new UnityContainer(); uc.AddExtension(extension); Assert.IsNotNull(uc); Assert.IsTrue(extension.CheckPolicyValue); }
public void Ext_ReceivesExtensionContextInInitialize() { MockContainerExtension extension = new MockContainerExtension(); IUnityContainer container = new UnityContainer(); container.AddExtension(extension); Assert.IsNotNull(extension.Context); Assert.AreSame(container, extension.Context.Container); }
public UnityContainerAdapter CreateNewContainer() { IUnityContainer container = new UnityContainer(); foreach ( UnityContainerExtension extension in Extensions ) { container.AddExtension( extension ); } return new UnityContainerAdapter( container, InjectionMembers ); }
public void InstallsHandlerInstance() { // Arrange var container = new UnityContainer(); container.RegisterInstance(new EmbeddableDocumentStore { RunInMemory = true }.Initialize()); // Act var aggregateHandlers = new IEventHandler[] { new AggregateHandler() }; var extension = EventStoreContainerExtension.FromHandlerInstances(aggregateHandlers); container.AddExtension(extension); // Assert VerifyContainer(new UnityServiceLocator(container), 1); }
public void InstallsHandlerTypes() { // Arrange var container = new UnityContainer(); container.RegisterInstance(new EmbeddableDocumentStore { RunInMemory = true }.Initialize()); // Act var handlerTypes = new[] { typeof(AggregateHandler), typeof(AnotherAggregateHandler) }; var extension = EventStoreContainerExtension.FromHandlerTypes(handlerTypes); container.AddExtension(extension); // Assert VerifyContainer(new UnityServiceLocator(container), 2); }
public static UnityContainer Install() { var container = new UnityContainer(); container.AddExtension( new UnityInterfaceInterceptionRegister( new[] { typeof(IValuesProvider), typeof(IDisposableValuesProvider) }, new IInterceptionBehavior[] { new LoggingInterceptionBehaviour() })); container.RegisterType(typeof(IValuesProvider), typeof(ValuesProvider), new PerRequestLifetimeManager()); container.RegisterType( typeof(IDisposableValuesProvider), typeof(DisposableValuesProvider), new PerRequestLifetimeManager()); container.RegisterType(typeof(System.Web.Http.Tracing.ITraceWriter), typeof(NLogger), new HierarchicalLifetimeManager()); return container; }
public void UnityCanResolveLazyTypeRegisteredInMefTest() { MefComponent1.InstanceCount = 0; // Setup var unityContainer = new UnityContainer(); var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); // Add composition support for unity unityContainer.AddExtension(new CompositionIntegration(false)); unityContainer.Configure<CompositionIntegration>().Catalogs.Add(assemblyCatalog); Assert.That(MefComponent1.InstanceCount, Is.EqualTo(0)); var lazyMefComponent = unityContainer.Resolve<Lazy<IMefComponent>>(); Assert.That(MefComponent1.InstanceCount, Is.EqualTo(0)); Assert.That(lazyMefComponent, Is.Not.Null); Assert.That(lazyMefComponent.Value, Is.Not.Null); Assert.That(MefComponent1.InstanceCount, Is.EqualTo(1)); Assert.That(lazyMefComponent.Value.GetType(), Is.EqualTo(typeof(MefComponent1))); }
public void UnityCanResolveLazyTypeRegisteredInMefWithTextMetadataTest() { // Setup var unityContainer = new UnityContainer(); var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); // Add composition support for unity unityContainer.AddExtension(new CompositionIntegration(false)); unityContainer.Configure<CompositionIntegration>().Catalogs.Add(assemblyCatalog); // Lazy<IPartWithTextMetadata, IDictionary<string, object>> v = new Lazy<IPartWithTextMetadata, IDictionary<string, object>>(); //unityContainer.Configure<InjectedMembers>().ConfigureInjectionFor<Lazy<IPartWithTextMetadata, IDictionary<string, object>>>( // new InjectionConstructor() // ); Lazy<IPartWithTextMetadata, IDictionary<string, object>> lazyMefComponent = unityContainer.Resolve<Lazy<IPartWithTextMetadata, IDictionary<string, object>>>(); Assert.That(lazyMefComponent, Is.Not.Null); Assert.That(lazyMefComponent.Value, Is.Not.Null); Assert.That(lazyMefComponent.Metadata, Is.Not.Null); Assert.That(lazyMefComponent.Value.GetType(), Is.EqualTo(typeof(HelloWorldDispatcher))); }
public void Test_TaskID_16777() { UnityContainer uc = new UnityContainer(); uc.RemoveAllExtensions(); uc.AddExtension(new MyExtension()); uc.RegisterType<UnityTestClass>(new ContainerControlledLifetimeManager()); UnityTestClass mytestparent = uc.Resolve<UnityTestClass>(); }
public void UnityCanResolveEnumerableOfTypesRegisteredInUnityTest() { // Setup var unityContainer = new UnityContainer(); var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); // Add composition support for unity unityContainer.AddExtension(new CompositionIntegration(true)); unityContainer.Configure<CompositionIntegration>().Catalogs.Add(assemblyCatalog); UnityComponent1.InstanceCount = 0; unityContainer.RegisterType<IUnityComponent, UnityComponent1>(); unityContainer.RegisterType<IUnityComponent, UnityComponent2>("component2"); var collectionOfLazyUnityComponents = unityContainer.Resolve<IEnumerable<IUnityComponent>>(); Assert.That(collectionOfLazyUnityComponents, Is.Not.Null); Assert.That(UnityComponent1.InstanceCount, Is.EqualTo(1)); var list = new List<IUnityComponent>(collectionOfLazyUnityComponents); Assert.That(list.Count, Is.EqualTo(2)); }
public void UnityCanResolveEnumerableOfLazyTypesRegisteredInUnityAndMefTest() { // Setup var unityContainer = new UnityContainer(); var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); MixedComponent1.InstanceCount = 0; MixedComponent2.InstanceCount = 0; MixedComponent5.InstanceCount = 0; // Add composition support for unity unityContainer.AddExtension(new CompositionIntegration(true)); unityContainer.Configure<CompositionIntegration>().Catalogs.Add(assemblyCatalog); unityContainer.RegisterType<IMixedComponent, MixedComponent1>("component1"); unityContainer.RegisterType<IMixedComponent, MixedComponent2>("component2"); unityContainer.RegisterType<IMixedComponent, MixedComponent3>(); var collectionOfLazyUnityComponents = unityContainer.Resolve<IEnumerable<Lazy<IMixedComponent>>>(); Assert.That(collectionOfLazyUnityComponents, Is.Not.Null); Assert.That(MixedComponent1.InstanceCount, Is.EqualTo(0)); Assert.That(MixedComponent2.InstanceCount, Is.EqualTo(0)); Assert.That(MixedComponent5.InstanceCount, Is.EqualTo(0)); var list = new List<Lazy<IMixedComponent>>(collectionOfLazyUnityComponents); Assert.That(MixedComponent1.InstanceCount, Is.EqualTo(0)); Assert.That(MixedComponent2.InstanceCount, Is.EqualTo(0)); Assert.That(MixedComponent5.InstanceCount, Is.EqualTo(0)); Assert.That(list[0].Value, Is.Not.Null); Assert.That(list[1].Value, Is.Not.Null); Assert.That(list[2].Value, Is.Not.Null); Assert.That(list[3].Value, Is.Not.Null); Assert.That(list[4].Value, Is.Not.Null); Assert.That(MixedComponent1.InstanceCount, Is.EqualTo(1)); Assert.That(MixedComponent2.InstanceCount, Is.EqualTo(1)); Assert.That(MixedComponent5.InstanceCount, Is.EqualTo(1)); Assert.That(list.Count, Is.EqualTo(5)); Assert.That(list.Select(t => t.Value).OfType<MixedComponent1>().Count(), Is.EqualTo(1)); Assert.That(list.Select(t => t.Value).OfType<MixedComponent2>().Count(), Is.EqualTo(1)); Assert.That(list.Select(t => t.Value).OfType<MixedComponent3>().Count(), Is.EqualTo(1)); Assert.That(list.Select(t => t.Value).OfType<MixedComponent4>().Count(), Is.EqualTo(1)); Assert.That(list.Select(t => t.Value).OfType<MixedComponent5>().Count(), Is.EqualTo(1)); }
public void UnityCannotResolveCompositionContainerWhenExplicitlyDisallowedTest() { // Setup var unityContainer = new UnityContainer(); var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); // Add composition support for unity unityContainer.AddExtension(new CompositionIntegration(false)); unityContainer.Configure<CompositionIntegration>().Catalogs.Add(assemblyCatalog); var internalCompositionContainer = unityContainer.Configure<CompositionIntegration>().CompositionContainer; Assert.That(internalCompositionContainer, Is.Not.Null); Assert.That(unityContainer.Configure<CompositionIntegration>().Register, Is.False); Assert.That(delegate { unityContainer.Resolve<CompositionContainer>(); }, Throws.TypeOf<ResolutionFailedException>()); }
public void CreatedPoliciesIncludeContainerLifetime() { TraceListenerData listenerData = new MockTraceListenerData("listener"); loggingSettings.TraceListeners.Add(listenerData); MockTraceListener listener = null; using (IUnityContainer newContainer = new UnityContainer()) { newContainer.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource)); listener = (MockTraceListener)((ReconfigurableTraceListenerWrapper)newContainer.Resolve<TraceListener>("listener")).InnerTraceListener; Assert.IsNotNull(listener); Assert.AreSame( listener, ((ReconfigurableTraceListenerWrapper)newContainer.Resolve<TraceListener>("listener")).InnerTraceListener); // lifetime managed? Assert.IsFalse(listener.wasDisposed); } Assert.IsTrue(listener.wasDisposed); // lifetime managed by the container? }
public void ResolveStrictInterfaceTest() { var container = new UnityContainer(); MockUnit.Extension.Behavior = MockBehavior.Strict; container.AddExtension(MockUnit.Extension); var list = container.Resolve<IList>(); var res = list.Contains(string.Empty); }
public void UnityCanResolveLazyTypeRegisteredInMefWithStronglyTypedMetadataTest() { //throw new NotImplementedException(); // Setup var unityContainer = new UnityContainer(); var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); // Add composition support for unity unityContainer.AddExtension(new CompositionIntegration(false)); unityContainer.Configure<CompositionIntegration>().Catalogs.Add(assemblyCatalog); Lazy<IPartWithStronglyTypedMetadata, IMyStronglyTypedMetadataAttribute> lazyMefComponent = unityContainer.Resolve<Lazy<IPartWithStronglyTypedMetadata, IMyStronglyTypedMetadataAttribute>>(); Assert.That(lazyMefComponent, Is.Not.Null); Assert.That(lazyMefComponent.Value, Is.Not.Null); Assert.That(lazyMefComponent.Metadata, Is.Not.Null); Assert.That(lazyMefComponent.Metadata.ListOfNames[0], Is.EqualTo("Element One")); Assert.That(lazyMefComponent.Metadata.ListOfNames[1], Is.EqualTo("Element Two")); Assert.That(lazyMefComponent.Metadata.MetadataIdentifier, Is.EqualTo(5)); Assert.That(lazyMefComponent.Value.GetType(), Is.EqualTo(typeof(StronglyTypedHelloWorldDispatcher))); }
public void UnityCanResolveLazyTypeRegisteredInMefWithoutItsMetadataTest() { // Setup var unityContainer = new UnityContainer(); var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); // Add composition support for unity unityContainer.AddExtension(new CompositionIntegration(false)); unityContainer.Configure<CompositionIntegration>().Catalogs.Add(assemblyCatalog); var lazyMefComponent = unityContainer.Resolve<Lazy<IPartWithTextMetadata>>(); Assert.That(lazyMefComponent, Is.Not.Null); Assert.That(lazyMefComponent.Value, Is.Not.Null); Assert.That(lazyMefComponent, Is.Not.Null); }
public void ExtensionCanBeAddByInstance() { var container = new UnityContainer(); container.AddExtension(new IngredientExtension()); var ingredients = container.ResolveAll<IIngredient>(); Assert.True(ingredients.OfType<Steak>().Any()); Assert.True(ingredients.OfType<SauceBéarnaise>().Any()); }