public void CreateParts_should_properly_extract_closed_generic_constructor_argument_when_importing_collection_and_when_contract_type_is_not_specified()
{
var exportConvention =
new ExportConvention
{
Members = t => new[] { t },
ContractType = x => typeof(ConventionPart4),
};
var importConvention =
new ImportConvention
{
Members = t => new[] { typeof(ConventionPart4).GetConstructors().Single() }
};
var convention =
new PartConvention();
convention.Imports.Add(importConvention);
convention.Exports.Add(exportConvention);
convention.Condition = t => t == typeof(ConventionPart4);
var registry =
new FakePartRegistry2(convention);
ConventionPartCreator creator = new ConventionPartCreator(registry);
var partDefinition = creator.CreateParts().First();
var importDefinitin = partDefinition.ImportDefinitions.Single();
importDefinitin.ContractName.ShouldEqual("MefContrib.Hosting.Conventions.Tests.IRepository(System.String)");
}
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 RequiredMetadata_should_not_be_null_on_new_instance()
{
var instance =
new ImportConvention();
instance.RequiredMetadata.ShouldNotBeNull();
}
public void GetImportContractName_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 ImportConvention()
{
ContractName = null,
ContractType = null,
Members = x => new[] { member }
};
var result =
service.GetImportContractName(convention, member);
result.ShouldEqual(expectedContractName);
}
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 RequiredMetadata_should_not_be_null_on_new_instance()
{
var instance =
new ImportConvention();
instance.RequiredMetadata.ShouldNotBeNull();
}
public void Equals_should_return_false_if_called_with_null()
{
var instance =
new ImportConvention();
var results =
instance.Equals((ImportConvention)null);
results.ShouldBeFalse();
}
public void Equals_should_return_false_when_contract_is_not_same_on_the_instance_that_is_being_compared_against()
{
var instance =
new ImportConvention { ContractName = x => "Foo" };
var results =
instance.Equals(new ImportConvention { ContractName = x => "Bar" });
results.ShouldBeFalse();
}
public void Equals_should_return_false_when_contract_type_is_not_same_on_the_instance_that_is_being_compared_against()
{
var instance =
new ImportConvention { ContractType = x => typeof(string) };
var results =
instance.Equals(new ImportConvention { ContractType = x => typeof(object) });
results.ShouldBeFalse();
}
public void Equals_should_return_false_when_creation_policy_is_not_same_on_the_instance_that_is_being_compared_against()
{
var instance =
new ImportConvention { CreationPolicy = CreationPolicy.Any };
var results =
instance.Equals(new ImportConvention { CreationPolicy = CreationPolicy.NonShared });
results.ShouldBeFalse();
}
public void Equals_should_return_false_when_recomposable_is_not_same_on_instance_that_is_being_compared_against()
{
var instance =
new ImportConvention { Recomposable = true };
var results =
instance.Equals(new ImportConvention { Recomposable = false });
results.ShouldBeFalse();
}
public void Equals_should_return_false_if_called_with_null()
{
var instance =
new ImportConvention();
var results =
instance.Equals((ImportConvention)null);
results.ShouldBeFalse();
}
public void Equals_should_return_true_if_called_with_itself()
{
var instance =
new ImportConvention();
var results =
instance.Equals(instance);
results.ShouldBeTrue();
}
public void Equals_should_return_true_if_identical_with_instance_that_is_being_compared_against()
{
var instance =
new ImportConvention();
var results =
instance.Equals(new ImportConvention());
results.ShouldBeTrue();
}
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 void Equals_should_return_false_when_recomposable_is_not_same_on_instance_that_is_being_compared_against()
{
var instance =
new ImportConvention {
Recomposable = true
};
var results =
instance.Equals(new ImportConvention {
Recomposable = false
});
results.ShouldBeFalse();
}
public void Equals_should_return_false_when_contract_is_not_same_on_the_instance_that_is_being_compared_against()
{
var instance =
new ImportConvention {
ContractName = x => "Foo"
};
var results =
instance.Equals(new ImportConvention {
ContractName = x => "Bar"
});
results.ShouldBeFalse();
}
public void Equals_should_return_false_when_contract_type_is_not_same_on_the_instance_that_is_being_compared_against()
{
var instance =
new ImportConvention {
ContractType = x => typeof(string)
};
var results =
instance.Equals(new ImportConvention {
ContractType = x => typeof(object)
});
results.ShouldBeFalse();
}
public void Equals_should_return_false_when_creation_policy_is_not_same_on_the_instance_that_is_being_compared_against()
{
var instance =
new ImportConvention {
CreationPolicy = CreationPolicy.Any
};
var results =
instance.Equals(new ImportConvention {
CreationPolicy = CreationPolicy.NonShared
});
results.ShouldBeFalse();
}
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_contract_name_from_convention_when_not_null()
{
const string contract = "Contract";
var convention =
new ImportConvention
{
ContractName = x => contract
};
var service =
GetServiceWithoutDefaultConventions();
var result = service.GetImportContractName(
convention, ReflectionServices.GetField <FakePart>(x => x.Count));
result.ShouldEqual(contract);
}
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 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 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 GetImportContractName_should_return_type_identity_of_convention_contract_type_when_contract_type_is_null()
{
var contractType = typeof(string);
var convention =
new ImportConvention
{
ContractName = null,
ContractType = x => contractType
};
var service =
GetServiceWithoutDefaultConventions();
var result = service.GetImportContractName(
convention, ReflectionServices.GetField <FakePart>(x => x.Count));
var expectedContractName =
AttributedModelServices.GetTypeIdentity(contractType);
result.ShouldEqual(expectedContractName);
}
public void Equals_should_return_false_when_requiredmetadata_is_not_same_on_the_instance_that_is_being_compared_againts()
{
var instance =
new ImportConvention
{
RequiredMetadata = new List<RequiredMetadataItem>
{
new RequiredMetadataItem("name", typeof(string)),
new RequiredMetadataItem("value", typeof(int))
}
};
var results =
instance.Equals(new ImportConvention
{
RequiredMetadata = new List<RequiredMetadataItem>
{
new RequiredMetadataItem("name", typeof (string)),
}
});
results.ShouldBeFalse();
}
public void Equals_should_return_false_when_requiredmetadata_is_not_same_on_the_instance_that_is_being_compared_againts()
{
var instance =
new ImportConvention
{
RequiredMetadata = new List <RequiredMetadataItem>
{
new RequiredMetadataItem("name", typeof(string)),
new RequiredMetadataItem("value", typeof(int))
}
};
var results =
instance.Equals(new ImportConvention
{
RequiredMetadata = new List <RequiredMetadataItem>
{
new RequiredMetadataItem("name", typeof(string)),
}
});
results.ShouldBeFalse();
}
public void GetImportTypeIdentity_should_return_type_identity_of_field_type_when_called_with_field_and_contract_type_is_null()
{
var member =
ReflectionServices.GetField <FakePart>(x => x.Count);
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.FieldType);
results.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 GetImportContractName_should_return_contract_name_for_property_type_when_called_with_property_and_contract_name_and_type_are_null()
{
var member =
ReflectionServices.GetProperty <FakePart>(x => x.Name);
var convention =
new ImportConvention()
{
ContractName = null,
ContractType = null,
Members = x => new[] { member }
};
var service =
GetServiceWithoutDefaultConventions();
var results =
service.GetImportContractName(convention, member);
var expectedContractName =
AttributedModelServices.GetContractName(member.PropertyType);
results.ShouldEqual(expectedContractName);
}
public void GetImportContractName_should_return_type_identity_of_convention_contract_type_when_contract_type_is_null()
{
var contractType = typeof(string);
var convention =
new ImportConvention
{
ContractName = null,
ContractType = x => contractType
};
var service =
GetServiceWithoutDefaultConventions();
var result = service.GetImportContractName(
convention, ReflectionServices.GetField<FakePart>(x => x.Count));
var expectedContractName =
AttributedModelServices.GetTypeIdentity(contractType);
result.ShouldEqual(expectedContractName);
}
public void CreateParts_should_properly_extract_closed_generic_constructor_argument_when_importing_collection_and_when_contract_type_is_not_specified()
{
var exportConvention =
new ExportConvention
{
Members = t => new[] { t },
ContractType = x => typeof(ConventionPart4),
};
var importConvention =
new ImportConvention
{
Members = t => new[] { typeof(ConventionPart4).GetConstructors().Single() }
};
var convention =
new PartConvention();
convention.Imports.Add(importConvention);
convention.Exports.Add(exportConvention);
convention.Condition = t => t == typeof(ConventionPart4);
var registry =
new FakePartRegistry2(convention);
ConventionPartCreator creator = new ConventionPartCreator(registry);
var partDefinition = creator.CreateParts().First();
var importDefinitin = partDefinition.ImportDefinitions.Single();
importDefinitin.ContractName.ShouldEqual("MefContrib.Hosting.Conventions.Tests.IRepository(System.String)");
}
public void GetImportContractName_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 ImportConvention()
{
ContractName = null,
ContractType = null,
Members = x => new[] { member }
};
var result =
service.GetImportContractName(convention, member);
result.ShouldEqual(expectedContractName);
}
public void GetImportContractName_should_return_contract_name_from_convention_when_not_null()
{
const string contract = "Contract";
var convention =
new ImportConvention
{
ContractName = x => contract
};
var service =
GetServiceWithoutDefaultConventions();
var result = service.GetImportContractName(
convention, ReflectionServices.GetField<FakePart>(x => x.Count));
result.ShouldEqual(contract);
}
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 Equals_should_return_true_if_called_with_itself()
{
var instance =
new ImportConvention();
var results =
instance.Equals(instance);
results.ShouldBeTrue();
}
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 GetImportTypeIdentity_should_return_type_identity_of_field_type_when_called_with_field_and_contract_type_is_null()
{
var member =
ReflectionServices.GetField<FakePart>(x => x.Count);
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.FieldType);
results.ShouldEqual(expectedTypeIdentity);
}
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 GetImportContractName_should_return_contract_name_for_property_type_when_called_with_property_and_contract_name_and_type_are_null()
{
var member =
ReflectionServices.GetProperty<FakePart>(x => x.Name);
var convention =
new ImportConvention()
{
ContractName = null,
ContractType = null,
Members = x => new[] { member }
};
var service =
GetServiceWithoutDefaultConventions();
var results =
service.GetImportContractName(convention, member);
var expectedContractName =
AttributedModelServices.GetContractName(member.PropertyType);
results.ShouldEqual(expectedContractName);
}
public void GetImportTypeIdentity_should_return_type_identity_of_property_type_when_called_with_property_and_contract_type_is_null()
{
var member =
ReflectionServices.GetProperty<FakePart>(x => x.Name);
var convention =
new ImportConvention()
{
ContractName = null,
ContractType = null,
Members = x => new[] { member }
};
var results =
this.Service.GetImportTypeIdentity(convention, member);
var expectedTypeIdentity =
AttributedModelServices.GetTypeIdentity(member.PropertyType);
results.ShouldEqual(expectedTypeIdentity);
}
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 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();
}
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 Equals_should_return_true_if_identical_with_instance_that_is_being_compared_against()
{
var instance =
new ImportConvention();
var results =
instance.Equals(new ImportConvention());
results.ShouldBeTrue();
}
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 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 GetImportContractName_should_return_contract_name_for_field_type_when_called_with_field_and_contract_name_and_type_are_null()
{
var member =
ReflectionServices.GetField<FakePart>(x => x.Count);
var convention =
new ImportConvention()
{
ContractName = null,
ContractType = null,
Members = x => new[] { member }
};
var results =
this.Service.GetImportContractName(convention, member);
var expectedContractName =
AttributedModelServices.GetContractName(member.FieldType);
results.ShouldEqual(expectedContractName);
}
