public void GetImportTypeIdentity_should_return_tyoe_identity_of_default_contract_type_of_last_default_convention_when_match_is_available() { var service = GetServiceWithDefaultConventions(); service.DefaultConventions.Add( new TypeDefaultConvention { ContractName = string.Empty, ContractType = typeof(decimal), TargetType = typeof(string) }); var member = ReflectionServices.GetProperty <FakePart>(x => x.Name); var convention = new ImportConvention() { ContractName = null, ContractType = null, Members = x => new[] { member } }; var result = service.GetImportTypeIdentity(convention, member); var expectedTypeIdentity = AttributedModelServices.GetTypeIdentity(typeof(decimal)); result.ShouldEqual(expectedTypeIdentity); }
public void CreateParts_should_properly_extract_closed_generic_type_parameter() { var exportConvention = new ExportConvention { Members = t => new[] { t }, ContractType = x => typeof(ConventionPart2), }; var importConvention = new ImportConvention { Members = t => new[] { ReflectionServices.GetProperty <ConventionPart2>(p => p.Repository) }, ContractType = x => typeof(IRepository <string>) }; var convention = new PartConvention(); convention.Imports.Add(importConvention); convention.Exports.Add(exportConvention); convention.Condition = t => t == typeof(ConventionPart2); var registry = new FakePartRegistry2(convention); ConventionPartCreator creator = new ConventionPartCreator(registry); var partDefinition = creator.CreateParts().First(); partDefinition.ImportDefinitions.Single().ContractName.ShouldEqual("MefContrib.Hosting.Conventions.Tests.IRepository(System.String)"); }
public void GetExportContractName_should_return_default_contract_name_of_last_default_convention_when_match_is_available() { const string expectedContractName = "Bar"; var service = GetServiceWithDefaultConventions(); service.DefaultConventions.Add( new TypeDefaultConvention { ContractName = expectedContractName, ContractType = typeof(decimal), TargetType = typeof(string) }); var member = ReflectionServices.GetProperty <FakePart>(x => x.Name); var convention = new ExportConvention { ContractName = null, ContractType = null, Members = x => new[] { member } }; var result = service.GetExportContractName(convention, member); result.ShouldEqual(expectedContractName); }
public FakeConventionRegistry() { this.TypeScanner = new TypeScanner(); PartWithConvention <PartConvention>() .ForTypesMatching(x => true) .MakeNonShared() .AddMetadata("Foo", "Bar") .Imports(i => i.ImportWithConvention <ImportConvention>() .ContractName("Contract") .ContractType <IImportConvention>() .Members(x => new[] { ReflectionServices.GetProperty <IImportConvention>(z => z.ContractName), ReflectionServices.GetProperty <IImportConvention>(z => z.ContractType) })) .Exports(e => e.ExportWithConvention <ExportConvention>() .ContractName(x => AttributedModelServices.GetContractName(typeof(FakeExportConvention))) .ContractType <IExportConvention>() .Members(x => new[] { ReflectionServices.GetProperty <IExportConvention>(z => z.ContractName), ReflectionServices.GetProperty <IExportConvention>(z => z.ContractType) })); PartWithConvention <PartConvention>() .ForTypesMatching(x => x.Equals(typeof(FakePart))); PartWithConvention <PartConvention>() .ForTypesMatching(x => false); }
public void ConventionCatalog_should_import_closed_generic() { var exportConvention = new ExportConvention { Members = t => new[] { t }, ContractType = x => typeof(ConventionPart2), }; var importConvention = new ImportConvention { Members = t => new[] { ReflectionServices.GetProperty <ConventionPart2>(p => p.Repository) }, ContractType = x => typeof(IRepository <string>) }; var convention = new PartConvention(); convention.Imports.Add(importConvention); convention.Exports.Add(exportConvention); convention.Condition = t => t == typeof(ConventionPart2); var model = new FakePartRegistry2(convention); // Setup container ConventionCatalog conventionCatalog = new ConventionCatalog(model); var typeCatalog = new TypeCatalog(typeof(AttributedClosedRepository), typeof(AttributedPart2)); var aggregated = new AggregateCatalog(typeCatalog, conventionCatalog); var container = new CompositionContainer(aggregated); var part = new AttributedPart2(); var batch = new CompositionBatch(); batch.AddPart(part); container.Compose(batch); // Assert part.Part.ShouldNotBeNull(); part.Part.Repository.ShouldNotBeNull(); }
public NonEmptyRegistry() { Part() .ForTypesMatching(x => x.Equals(typeof(FakePart))) .AddMetadata(new { Foo = "Bar" }) .MakeShared() .ImportConstructor() .Exports(x => { x.Export() .Members(m => new[] { ReflectionServices.GetProperty <FakePart>(z => z.Delegate) }) .AddMetadata(new { Name = "Delegate" }); x.Export() .Members(m => new[] { ReflectionServices.GetProperty <FakePart>(z => z.Name) }) .AddMetadata(new { Name = "Name" }); }) .Imports(x => { x.Import() .Members(m => new[] { ReflectionServices.GetProperty <FakePart>(z => z.Delegate) }) .RequireMetadata <string>("Name") .AllowDefaultValue() .Recomposable(); x.Import() .Members(m => new[] { ReflectionServices.GetProperty <FakePart>(z => z.Name) }) .RequireMetadata <string>("Description"); x.Import() .Members(m => new[] { ReflectionServices.GetProperty <FakePart>(z => z.Values) }); }); Part() .ForTypesMatching(x => false); ContractService.Configure(x => { x.ForType <Func <string, string, object> >().ContractType <FakePart>().ContractName("Test"); x.ForType <string>().ContractType <FakePart>().ContractName("Test"); }); //Scan(x => { // x.ExecutingAssembly(); // x.Assembly //}) var scanner = new TypeScanner(); scanner.AddTypes(() => Assembly.GetExecutingAssembly().GetExportedTypes()); this.TypeScanner = scanner; }
public void ContractName_should_set_contract_name_on_convention_when_called_with_function() { this.conventionBuilder .ContractName(x => x.Name); var convention = this.conventionBuilder .GetConvention(); var member = ReflectionServices.GetProperty <ExportConvention>(x => x.ContractName); convention.ContractName.Invoke(member).ShouldEqual(member.Name); }
public void ContractType_should_set_contract_type_on_convention_when_called_with_function() { this.conventionBuilder .ContractType(x => x.DeclaringType); var convention = this.conventionBuilder .GetConvention(); var property = ReflectionServices.GetProperty <ExportConvention>(x => x.ContractType); convention.ContractType.Invoke(property).ShouldBeOfType <ExportConvention>(); }
public void GetImportTypeIdentity_should_return_null_when_convention_contract_type_is_of_type_object() { var convention = new ImportConvention() { ContractName = null, ContractType = x => typeof(object) }; var service = GetServiceWithoutDefaultConventions(); var results = service.GetImportTypeIdentity( convention, ReflectionServices.GetProperty <FakePart>(x => x.Name)); results.ShouldBeNull(); }
public void GetImportContractName_should_return_default_contract_name_when_match_is_available() { var member = ReflectionServices.GetProperty <FakePart>(x => x.Name); var convention = new ImportConvention() { ContractName = null, ContractType = null, Members = x => new[] { member } }; var result = GetServiceWithDefaultConventions().GetImportContractName(convention, member); result.ShouldEqual("Foo"); }
public void GetExportContractName_should_return_contract_name_of_property_type_when_called_with_property_and_contract_name_and_type_are_null() { var member = ReflectionServices.GetProperty <FakePart>(x => x.Name); var convention = new ExportConvention { ContractName = null, ContractType = null, Members = x => new[] { member } }; var results = this.Service.GetExportContractName(convention, member); var expectedContractName = AttributedModelServices.GetContractName(member.PropertyType); results.ShouldEqual(expectedContractName); }
public void GetImportTypeIdentity_should_return_type_identity_of_default_contract_type_when_match_is_available() { var member = ReflectionServices.GetProperty <FakePart>(x => x.Name); var convention = new ImportConvention { ContractName = null, ContractType = null, Members = x => new[] { member } }; var result = GetServiceWithDefaultConventions().GetImportTypeIdentity(convention, member); var expectedTypeIdentity = AttributedModelServices.GetTypeIdentity(typeof(int)); result.ShouldEqual(expectedTypeIdentity); }
public void CreateParts_should_set_type_identity_on_import_deinition_to_contract_type_from_import_convention() { var registry = new NonEmptyRegistry(); var conventions = registry.GetConventions(); var partDefinitions = GetPartDefinitionsFromNonEmptyRegistry(); var member = ReflectionServices.GetProperty <FakePart>(x => x.Delegate); var inspectedImportDefinition = partDefinitions.First().ImportDefinitions.Cast <ContractBasedImportDefinition>().Skip(2).First(); var expectedTypeIdentity = registry.ContractService.GetImportTypeIdentity(conventions.First().Imports.First(), member); inspectedImportDefinition.RequiredTypeIdentity.ShouldEqual(expectedTypeIdentity); }
public void CreateParts_should_set_contract_name_on_import_definition_to_contract_name_from_import_convention_using_contract_service_that_is_defined_on_registry() { var registry = new NonEmptyRegistry(); var conventions = registry.GetConventions(); var partDefinitions = GetPartDefinitionsFromNonEmptyRegistry(); var member = ReflectionServices.GetProperty <FakePart>(x => x.Delegate); var inspectedImportDefinition = partDefinitions.First().ImportDefinitions.Skip(2).First(); var expectedContractName = registry.ContractService.GetImportContractName(conventions.First().Imports.First(), member); inspectedImportDefinition.ContractName.ShouldEqual(expectedContractName); }
public void GetImportTypeIdentity_should_return_type_identity_of_convention_contract_type_when_contract_type_is_not_object_or_delegate() { var contractType = typeof(string); var convention = new ImportConvention() { ContractName = null, ContractType = x => contractType }; var service = GetServiceWithoutDefaultConventions(); var results = service.GetImportTypeIdentity( convention, ReflectionServices.GetProperty <FakePart>(x => x.Name)); var expectedTypeIdentity = AttributedModelServices.GetTypeIdentity(contractType); results.ShouldEqual(expectedTypeIdentity); }
public void CreateParts_should_set_type_identity_metadata_on_export_definition_to_contract_type_from_export_convention_using_contract_service_that_is_defined_on_registry() { var registry = new NonEmptyRegistry(); var conventions = registry.GetConventions(); var partDefinitions = GetPartDefinitionsFromNonEmptyRegistry(); var member = ReflectionServices.GetProperty <FakePart>(x => x.Delegate); var inspectedExportDefinition = partDefinitions.First().ExportDefinitions.First(); var expectedMetadata = new KeyValuePair <string, object>(CompositionConstants.ExportTypeIdentityMetadataName, registry.ContractService.GetExportTypeIdentity(conventions.First().Exports.First(), member)); inspectedExportDefinition.Metadata.Contains(expectedMetadata).ShouldBeTrue(); }
public void GetExportTypeIdentity_should_return_type_identify_of_property_type_when_called_with_property_member_and_convention_contract_type_is_null() { var convention = new ExportConvention { ContractName = null, ContractType = null }; var member = ReflectionServices.GetProperty <FakePart>(x => x.Name); var service = GetServiceWithoutDefaultConventions(); var result = service.GetExportTypeIdentity(convention, member); var expectedTypeIdentity = AttributedModelServices.GetTypeIdentity(member.PropertyType); result.ShouldEqual(expectedTypeIdentity); }
public void GetImportTypeIdentity_should_return_type_identity_of_invoke_method_when_convention_contract_type_is_delegate() { var member = ReflectionServices.GetProperty <FakePart>(x => x.Delegate); var convention = new ImportConvention() { ContractName = null, ContractType = null, Members = x => new[] { member } }; var service = GetServiceWithoutDefaultConventions(); var results = service.GetImportTypeIdentity(convention, member); var expectedTypeIdentity = AttributedModelServices.GetTypeIdentity(member.PropertyType.GetMethod("Invoke")); results.ShouldEqual(expectedTypeIdentity); }
public void ConventionCatalog_should_export_conventionpart() { // Setup conventions using the semantic model // This is NOT the API that the user will be exposed to, // there will be a DSL at the front var exportConvention = new ExportConvention { Members = t => new[] { t }, ContractType = x => typeof(IConventionPart), }; var importConvention = new ImportConvention { Members = t => new[] { ReflectionServices.GetProperty <IConventionPart>(p => p.Logger) }, ContractType = x => typeof(ILogger) }; var convention = new PartConvention(); convention.Imports.Add(importConvention); convention.Exports.Add(exportConvention); convention.Condition = t => t.GetInterfaces().Contains(typeof(IConventionPart)); var exportConvention2 = new ExportConvention { Members = t => new[] { typeof(NullLogger) }, ContractType = x => typeof(ILogger), }; var convention2 = new PartConvention(); convention2.Exports.Add(exportConvention2); convention2.Condition = t => t.GetInterfaces().Contains(typeof(ILogger)); var model = new FakePartRegistry2(convention, convention2); // Setup container ConventionCatalog conventionCatalog = new ConventionCatalog(model); var typeCatalog = new TypeCatalog(typeof(AttributedPart)); var aggregated = new AggregateCatalog(typeCatalog, conventionCatalog); var container = new CompositionContainer(aggregated); var part = new AttributedPart(); var batch = new CompositionBatch(); batch.AddPart(part); container.Compose(batch); // Assert part.Part.Count().ShouldEqual(2); part.Part[0].Logger.ShouldNotBeNull(); part.Part[1].Logger.ShouldNotBeNull(); }