public void OfTypeOnePart_ShouldFindOnePart()
{
var ctx = new RegistrationBuilder();
ctx.ForType <FooImplementation1>().Export();
var catalog = new TypeCatalog(Helpers.GetEnumerableOfTypes(typeof(IFoo), typeof(FooImplementation1), typeof(FooImplementation2)), ctx);
Assert.IsTrue(catalog.Parts.Count() == 1);
}
// Tests follow for constructor parameters
static RegistrationBuilder ConfigureImportConstructorParameterConvention <TPart>()
{
var convention = new RegistrationBuilder();
convention.ForType <TPart>()
.SelectConstructor(cis => cis.Single(), (ci, ib) => ib.AsMany(false).AsContractName(ContractNames.ContractX).AsContractType <IContractA>());
return(convention);
}
// This set of tests is for imports at the property level
static RegistrationBuilder ConfigureImportPropertyConvention <TPart>(Expression <Func <TPart, object> > property)
{
var convention = new RegistrationBuilder();
convention.ForType <TPart>()
.ImportProperty(property, ib => ib.AsMany(false).AsContractName(ContractNames.ContractX).AsContractType <AB>());
return(convention);
}
public void AnyConvention_NotDiscoverablePart_ConventionApplied()
{
var convention = new RegistrationBuilder();
convention.ForType <NotDiscoverablePart>().Export();
AssertHasAttributesUnderConvention <NotDiscoverablePart>(convention, new object[] {
new PartNotDiscoverableAttribute(),
new ExportAttribute()
});
}
// This set of tests is for exports at the property level
static RegistrationBuilder ConfigureExportPropertyConvention <TPart>(Expression <Func <TPart, object> > property)
{
var convention = new RegistrationBuilder();
convention.ForType <TPart>()
.ExportProperty(property, eb => eb.AsContractType <IContractA>()
.AddMetadata(MetadataKeys.MetadataKeyP, MetadataValues.MetadataValueN));
return(convention);
}
// This set of tests is for exports at the class declaration level
static RegistrationBuilder ConfigureExportInterfaceConvention <TPart>()
{
var convention = new RegistrationBuilder();
convention.ForType <TPart>()
.Export(eb => eb.AsContractType <IContractA>()
.AddMetadata(MetadataKeys.MetadataKeyP, MetadataValues.MetadataValueN));
return(convention);
}
public void AmbiguousConstructorWithAttributeAppliedToOne_ShouldSucceed()
{
var ctx = new RegistrationBuilder();
ctx.ForType <AmbiguousConstructorsWithAttribute>().Export();
ctx.ForType <ConstructorArgs>().ExportProperties((m) => m.Name == "IntArg");
ctx.ForType <ConstructorArgs>().ExportProperties((m) => m.Name == "StringArg");
var catalog = new TypeCatalog(Helpers.GetEnumerableOfTypes(
typeof(AmbiguousConstructorsWithAttribute),
typeof(ConstructorArgs)),
ctx);
Assert.AreEqual(2, catalog.Parts.Count());
var container = new CompositionContainer(catalog, CompositionOptions.DisableSilentRejection);
var item = container.GetExportedValue <AmbiguousConstructorsWithAttribute>();
Assert.AreEqual(10, item.IntArg);
Assert.AreEqual("Hello, World", item.StringArg);
}
public void AmbiguousConstructor_ShouldFail()
{
var ctx = new RegistrationBuilder();
ctx.ForType <AmbiguousConstructors>().Export();
ctx.ForType <ConstructorArgs>().ExportProperties((m) => m.Name == "IntArg");
ctx.ForType <ConstructorArgs>().ExportProperties((m) => m.Name == "StringArg");
var catalog = new TypeCatalog(Helpers.GetEnumerableOfTypes(
typeof(AmbiguousConstructors),
typeof(ConstructorArgs)),
ctx);
Assert.AreEqual(catalog.Parts.Count(), 2);
var container = new CompositionContainer(catalog, CompositionOptions.DisableSilentRejection);
ExceptionAssert.Throws <CompositionException>(() =>
{
var item = container.GetExportedValue <AmbiguousConstructors>();
});
}
public void ManyConstructorsControllerFindLongestConstructorAndImportByName_ShouldSucceed()
{
var ctx = new RegistrationBuilder();
ctx.ForType <FormsAuthenticationServiceImpl>().Export <IFormsAuthenticationService>();
ctx.ForType <HttpDigestAuthentication>().Export <IAuthentication>();
ctx.ForType <MembershipServiceImpl>().Export <IMembershipService>();
ctx.ForType <SpecificMembershipServiceImpl>().Export <IMembershipService>((c) => c.AsContractName("membershipService"));
ctx.ForType <HttpRequestValidator>().Export();
ctx.ForType <ManyConstructorsController>().SelectConstructor(null, (pi, import) =>
{
if (typeof(IMembershipService).IsAssignableFrom(pi.ParameterType))
{
import.AsContractName("membershipService");
}
}).Export();
var catalog = new TypeCatalog(Helpers.GetEnumerableOfTypes(
typeof(FormsAuthenticationServiceImpl),
typeof(HttpDigestAuthentication),
typeof(MembershipServiceImpl),
typeof(SpecificMembershipServiceImpl),
typeof(HttpRequestValidator),
typeof(ManyConstructorsController)), ctx);
Assert.IsTrue(catalog.Parts.Count() == 6);
var container = new CompositionContainer(catalog, CompositionOptions.DisableSilentRejection);
var item = container.GetExportedValue <ManyConstructorsController>();
Assert.IsTrue(item.Validator != null);
Assert.IsTrue(item.FormsService != null);
Assert.IsTrue(item.MembershipService != null);
Assert.IsTrue(item.MembershipService.GetType() == typeof(SpecificMembershipServiceImpl));
}
public void ExportInterfaceWithTypeOf1()
{
var ctx = new RegistrationBuilder();
ctx.ForType <CFoo>().Export <IFoo>();
var catalog = new TypeCatalog(Helpers.GetEnumerableOfTypes(typeof(CFoo)), ctx);
Assert.IsTrue(catalog.Parts.Count() != 0);
var container = new CompositionContainer(catalog, CompositionOptions.DisableSilentRejection);
var importer = new FooImporter();
container.SatisfyImportsOnce(importer);
Assert.IsNotNull(importer.fooImporter, "fooImporter not set!");
}
public void ConventionsInInnerAndOuterRCs_InnerRCTakesPrecendence()
{
var innerConvention = new RegistrationBuilder();
innerConvention.ForType <ConventionTarget>().Export(eb => eb.AsContractName(ContractNames.ContractX));
var innerType = innerConvention.MapType(typeof(ConventionTarget).GetTypeInfo());
var outerConvention = new RegistrationBuilder();
outerConvention.ForType <ConventionTarget>().Export(eb => eb.AsContractName(ContractNames.ContractY));
var outerType = outerConvention.MapType(innerType /*.GetTypeInfo()*/);
var export = outerType.GetCustomAttributes(false).OfType <ExportAttribute>().Single();
Assert.AreEqual(ContractNames.ContractX, export.ContractName);
}
public void ConstructorConvention_OverrideOnDeclaration_ConventionIgnored()
{
var rb = new RegistrationBuilder();
rb.ForType <TwoConstructorsWithOverride>()
.SelectConstructor(pi => new TwoConstructorsWithOverride(pi.Import <IContractA>(), pi.Import <IContractB>()));
var mapped = rb.MapType(typeof(TwoConstructorsWithOverride).GetTypeInfo());
var conventional = mapped.GetConstructor(new[] { rb.MapType(typeof(IContractA).GetTypeInfo()), rb.MapType(typeof(IContractB).GetTypeInfo()) });
var conventionalAttrs = conventional.GetCustomAttributes(true);
Assert.IsFalse(conventionalAttrs.Any());
var overridden = mapped.GetConstructor(new[] { rb.MapType(typeof(IContractA).GetTypeInfo()) });
var overriddenAttr = overridden.GetCustomAttributes(true).Single();
Assert.AreEqual(new ImportingConstructorAttribute(), overriddenAttr);
}
