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