public void When_removing_a_part_from_the_intercepted_catalog_intercepting_catalog_is_recomposed_and_removes_that_part()
{
var innerCatalog1 = new TypeCatalog(typeof(RecomposablePart1), typeof(RecomposablePartImporter));
var innerCatalog2 = new TypeCatalog(typeof(RecomposablePart2));
var cfg = new InterceptionConfiguration().AddInterceptor(new RecomposablePartInterceptor());
var aggregateCatalog = new AggregateCatalog(innerCatalog1, innerCatalog2);
var catalog = new InterceptingCatalog(aggregateCatalog, cfg);
container = new CompositionContainer(catalog);
var importer = container.GetExportedValue<RecomposablePartImporter>();
Assert.That(importer, Is.Not.Null);
Assert.That(importer.Parts, Is.Not.Null);
Assert.That(importer.Parts.Length, Is.EqualTo(2));
Assert.That(importer.Parts[0].Count, Is.EqualTo(1));
Assert.That(importer.Parts[1].Count, Is.EqualTo(1));
Assert.That(catalog.Parts.Count(), Is.EqualTo(3));
// Recompose
aggregateCatalog.Catalogs.Remove(innerCatalog2);
Assert.That(importer, Is.Not.Null);
Assert.That(importer.Parts, Is.Not.Null);
Assert.That(importer.Parts.Length, Is.EqualTo(1));
Assert.That(importer.Parts[0].Count, Is.EqualTo(1));
Assert.That(catalog.Parts.Count(), Is.EqualTo(2));
}
public void Adding_s_is_reflecteed_in_the_Interceptors_collection()
{
var cfg = new InterceptionConfiguration()
.AddInterceptionCriteria(new PredicateInterceptionCriteria(new EmptyInterceptor(), part => true));
Assert.That(cfg.InterceptionCriteria.Count(), Is.EqualTo(1));
Assert.That(cfg.InterceptionCriteria.OfType<PredicateInterceptionCriteria>().Any());
}
public void When_querying_for_a_part_not_being_intercepted_it_should_return_original_part_definition()
{
var innerCatalog = new TypeCatalog(typeof(Logger));
var cfg = new InterceptionConfiguration();
var catalog = new InterceptingCatalog(innerCatalog, cfg);
var partDefinition = catalog.Parts.First();
partDefinition.ShouldNotBeOfType<InterceptingComposablePartDefinition>();
}
public void When_querying_for_a_part_it_should_return_an_intercepting_part_definition()
{
var innerCatalog = new TypeCatalog(typeof(Logger));
var mockInterceptor = new Mock<IExportedValueInterceptor>();
var cfg = new InterceptionConfiguration().AddInterceptor(mockInterceptor.Object);
var catalog = new InterceptingCatalog(innerCatalog, cfg);
var partDefinition = catalog.Parts.First();
partDefinition.ShouldBeOfType<InterceptingComposablePartDefinition>();
}
public void Adding_part_handlers_is_reflected_in_the_PartHandlers_collection()
{
var cfg = new InterceptionConfiguration()
.AddHandler(new FakePartHandler1())
.AddHandler(new FakePartHandler1());
Assert.That(cfg.PartHandlers.Count(), Is.EqualTo(2));
Assert.That(cfg.PartHandlers.OfType<FakePartHandler1>().Any());
Assert.That(cfg.PartHandlers.OfType<FakePartHandler1>().Any());
}
public void Adding_export_handlers_is_reflecteed_in_the_Handlers_collection()
{
var cfg = new InterceptionConfiguration()
.AddHandler(new GenericExportHandler())
.AddHandler(new ConcreteTypeExportHandler());
Assert.That(cfg.Handlers.Count(), Is.EqualTo(2));
Assert.That(cfg.Handlers.OfType<GenericExportHandler>().Any());
Assert.That(cfg.Handlers.OfType<ConcreteTypeExportHandler>().Any());
}
public void Adding_interceptors_is_reflecteed_in_the_Interceptors_collection()
{
var cfg = new InterceptionConfiguration()
.AddInterceptor(new CompositeValueInterceptor())
.AddInterceptor(new EmptyInterceptor());
Assert.That(cfg.Interceptors.Count(), Is.EqualTo(2));
Assert.That(cfg.Interceptors.OfType<CompositeValueInterceptor>().Any());
Assert.That(cfg.Interceptors.OfType<EmptyInterceptor>().Any());
}
/// <summary>
/// Initializes a new instance of the <see cref="ConventionCatalog"/> class, using the provided array part registries.
/// </summary>
/// <param name="registries">An array of <see cref="IPartRegistry{T}"/> instance.</param>
public ConventionCatalog(params IPartRegistry<IContractService>[] registries)
{
if (registries == null)
{
throw new ArgumentNullException("registries", "The registries parameter cannot be null.");
}
var cfg = new InterceptionConfiguration()
.AddHandler(new ConventionPartHandler(registries));
this.interceptingCatalog = new InterceptingCatalog(new EmptyCatalog(), cfg);
}
public void TestSetUp()
{
var innerCatalog = new TypeCatalog(typeof(Customer));
var interceptor = new FreezableInterceptor();
interceptor.Freeze();
var valueInterceptor = new DynamicProxyInterceptor(interceptor);
var cfg = new InterceptionConfiguration()
.AddInterceptor(valueInterceptor);
var catalog = new InterceptingCatalog(innerCatalog, cfg);
container = new CompositionContainer(catalog);
}
public void TestSetUp()
{
var innerCatalog = new TypeCatalog(typeof(Part1), typeof(Part2), typeof(Part3));
var cfg = new InterceptionConfiguration()
.AddInterceptor(new GeneralInterceptor())
.AddInterceptionCriteria(
new PredicateInterceptionCriteria(
new PartInterceptor(), d => d.Metadata.ContainsKey("metadata1")));
var catalog = new InterceptingCatalog(innerCatalog, cfg);
container = new CompositionContainer(catalog);
}
public void TestSetUp()
{
var typeCatalog = new TypeCatalog(typeof(CtorOrderProcessor), typeof(OrderProcessor), typeof(TestGenericContractRegistry));
var cfg = new InterceptionConfiguration().AddHandler(new GenericExportHandler());
var catalog = new InterceptingCatalog(typeCatalog, cfg);
var provider = new CatalogExportProvider(catalog);
provider.SourceProvider = provider;
ExportProvider = provider;
}
/// <summary>
/// Initializes a new instance of the <see cref="FilteringCatalog"/> class.
/// </summary>
/// <param name="inner">A <see cref="ComposablePartCatalog"/> whose parts
/// are to be filtered based on a given criteria.</param>
/// <param name="filter">A filter query.</param>
public FilteringCatalog(ComposablePartCatalog inner, Func<ComposablePartDefinition, bool> filter)
{
if (inner == null)
throw new ArgumentNullException("inner");
if (filter == null)
throw new ArgumentNullException("filter");
var cfg = new InterceptionConfiguration()
.AddHandler(new FilteringPartHandler(filter));
this.interceptingCatalog = new InterceptingCatalog(inner, cfg);
}
public void Catalog_should_filter_out_parts()
{
var innerCatalog = new TypeCatalog(typeof(Part0), typeof(Part1), typeof(Part2), typeof(Part3));
var cfg = new InterceptionConfiguration()
.AddHandler(new PartFilter());
var catalog = new InterceptingCatalog(innerCatalog, cfg);
container = new CompositionContainer(catalog);
var parts = container.GetExportedValues<IPart>();
Assert.That(parts.Count(), Is.EqualTo(1));
Assert.That(parts.First().GetType(), Is.EqualTo(typeof(Part0)));
}
private ComposablePartCatalog GetInterceptionCatalog()
{
_applicationCatalog = new ApplicationCatalog();
_adapterdirectoryCatalog = new DirectoryCatalog(AdaptersDirectory);
_pluginsdirectoryCatalog = new DirectoryCatalog(PluginsDirectory);
var catalog = new AggregateCatalog(_applicationCatalog, _adapterdirectoryCatalog, _pluginsdirectoryCatalog);
var cfg = new InterceptionConfiguration().AddInterceptionCriteria(
new PredicateInterceptionCriteria(
new CopyConfigInterceptor(_robot.Settings),
def => def.ExportDefinitions.First().ContractName.Contains("IAdapter") ||
def.ExportDefinitions.First().ContractName.Contains("IRobotPlugin")));
return new InterceptingCatalog(catalog, cfg);
}
private static CompositionContainer CreateContainer1()
{
// Create source catalog, note we are passing the registry part.
// During the runtime, GenericExportHandler will query this catalog for
// all types implementing IGenericContractRegistry
var typeCatalog = new TypeCatalog(typeof(Trampoline), typeof(MyGenericContractRegistry));
// Create the interception configuration and add support for open generics
var cfg = new InterceptionConfiguration()
.AddHandler(new GenericExportHandler());
// Create the InterceptingCatalog and pass the configuration
var interceptingCatalog = new InterceptingCatalog(typeCatalog, cfg);
// Create the container
return new CompositionContainer(interceptingCatalog);
}
public void Run()
{
Console.WriteLine("\n*** Interception Demo ***");
// Create source catalog
var catalog = new TypeCatalog(typeof(Bar), typeof(Foo));
// Create interception configuration
var cfg = new InterceptionConfiguration()
// Add catalog wide startable interceptor
.AddInterceptor(new StartableStrategy())
/*
.AddInterceptionCriteria(
new LogInterceptionCriteria(
new DynamicProxyInterceptor(
new LoggingInterceptor())))
*/
// Add Castle DynamicProxy based logging interceptor for parts
// which want to be logged, does exactly the same as the above code
.AddInterceptionCriteria(
new PredicateInterceptionCriteria(
// Apply the interceptor only to parts which contain
// Log export metadata which equals to true
new DynamicProxyInterceptor(new LoggingInterceptor()), def =>
def.ExportDefinitions.First().Metadata.ContainsKey("Log") &&
def.ExportDefinitions.First().Metadata["Log"].Equals(true)));
// Create the InterceptingCatalog with above configuration
var interceptingCatalog = new InterceptingCatalog(catalog, cfg);
// Create the container
var container = new CompositionContainer(interceptingCatalog);
// Bar part will be intercepted only by the startable strategy
var barPart = container.GetExportedValue<IBar>();
barPart.Foo();
// Foo part will be intercepted by both startable and logging strategies
var fooPart = container.GetExportedValue<IFoo>();
fooPart.Bar();
}
public void When_adding_new_part_to_the_intercepted_catalog_intercepting_catalog_raises_recomposition_events()
{
var innerCatalog = new TypeCatalog(typeof(RecomposablePart1));
var cfg = new InterceptionConfiguration().AddInterceptor(new RecomposablePartInterceptor());
var aggregateCatalog = new AggregateCatalog(innerCatalog);
var catalog = new InterceptingCatalog(aggregateCatalog, cfg);
container = new CompositionContainer(catalog);
uint changingEventInvokeCount = 0;
uint changedEventInvokeCount = 0;
catalog.Changing += (s, e) => changingEventInvokeCount++;
catalog.Changed += (s, e) => changedEventInvokeCount++;
// Recompose
aggregateCatalog.Catalogs.Add(new TypeCatalog(typeof(RecomposablePart2)));
Assert.That(changingEventInvokeCount, Is.EqualTo(1));
Assert.That(changedEventInvokeCount, Is.EqualTo(1));
}
public void Disposing_catalog_should_dispose_parts_implementing_dispose_pattern()
{
var innerCatalog = new TypeCatalog(typeof(DisposablePart));
var cfg = new InterceptionConfiguration();
var catalog = new InterceptingCatalog(innerCatalog, cfg);
container = new CompositionContainer(catalog);
var part = container.GetExportedValueOrDefault<DisposablePart>();
Assert.That(part.IsDisposed, Is.False);
container.Dispose();
Assert.That(part.IsDisposed, Is.True);
}
public Request(ComposablePartCatalog parentCatalog, CompositionContainer parentContainer)
{
Console.WriteLine("/* Request */");
// Create interception configuration with non-shared parts filter
var cfg = new InterceptionConfiguration()
.AddHandler(new PartCreationPolicyFilter(CreationPolicy.NonShared));
// Create the InterceptingCatalog with above configuration
var interceptingCatalog = new InterceptingCatalog(parentCatalog, cfg);
// Create the child container
this.requestContainer = new CompositionContainer(interceptingCatalog, parentContainer);
}
/// <summary>
/// Initializes a new instance of the <see cref="GenericCatalog"/> class.
/// </summary>
/// <param name="catalog"><see cref="ComposablePartCatalog"/> from which <see cref="IGenericContractRegistry"/> instances will be retrieved.</param>
/// <param name="registries">Additional registries.</param>
public GenericCatalog(ComposablePartCatalog catalog, params IGenericContractRegistry[] registries)
{
var cfg = new InterceptionConfiguration()
.AddHandler(new GenericExportHandler(registries));
this.interceptingCatalog = new InterceptingCatalog(catalog, cfg);
}
public void When_removing_existing_part_from_the_part_handler_intercepting_catalog_is_recomposed_and_removes_that_part()
{
var partHandler = new RecomposablePartHandler();
var part2Catalog = new TypeCatalog(typeof (RecomposablePart2));
var innerCatalog = new TypeCatalog(typeof(RecomposablePartImporter), typeof(RecomposablePart1));
var aggregateCatalog = new AggregateCatalog(innerCatalog, part2Catalog);
var cfg = new InterceptionConfiguration()
.AddInterceptor(new RecomposablePartInterceptor())
.AddHandler(partHandler);
var catalog = new InterceptingCatalog(aggregateCatalog, cfg);
container = new CompositionContainer(catalog);
var importer = container.GetExportedValue<RecomposablePartImporter>();
Assert.That(importer, Is.Not.Null);
Assert.That(importer.Parts, Is.Not.Null);
Assert.That(importer.Parts.Length, Is.EqualTo(2));
Assert.That(importer.Parts[0].Count, Is.EqualTo(1));
Assert.That(importer.Parts[1].Count, Is.EqualTo(1));
Assert.That(catalog.Parts.Count(), Is.EqualTo(3));
Assert.That(catalog.Parts.OfType<InterceptingComposablePartDefinition>().Count(), Is.EqualTo(3));
// Recompose
partHandler.RemoveParts(part2Catalog);
Assert.That(importer, Is.Not.Null);
Assert.That(importer.Parts, Is.Not.Null);
Assert.That(importer.Parts.Length, Is.EqualTo(1));
Assert.That(importer.Parts[0].Count, Is.EqualTo(1));
Assert.That(importer.Parts[0].GetType(), Is.EqualTo(typeof(RecomposablePart1)));
Assert.That(catalog.Parts.Count(), Is.EqualTo(2));
Assert.That(catalog.Parts.OfType<InterceptingComposablePartDefinition>().Count(), Is.EqualTo(2));
}
public void Catalog_should_call_Initialize_on_a_given_part_handlers()
{
var innerCatalog = new TypeCatalog();
var partHandlerMock = new Mock<IPartHandler>(MockBehavior.Strict);
partHandlerMock.Setup(p => p.Initialize(innerCatalog)).Verifiable();
var cfg = new InterceptionConfiguration()
.AddHandler(partHandlerMock.Object);
var catalog = new InterceptingCatalog(innerCatalog, cfg);
Assert.That(catalog, Is.Not.Null);
partHandlerMock.Verify();
}
