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());
}
