public void CanBuildRelationsBetweenMutuallyDependentTypes()
{
//-- Arrange
var cache = new TypeMetadataCache(new DataObjectConventions(), new PascalCaseRelationalMappingConvention(usePluralTableNames: true));
//-- Act
var orderMetadata = cache.GetTypeMetadata(typeof(TestDataObjects.Repository1.IOrder));
var orderLineMetadata = cache.GetTypeMetadata(typeof(TestDataObjects.Repository1.IOrderLine));
//-- Assert
var orderToOrderLine = orderMetadata.Properties.Single(p => p.Name == "OrderLines").Relation;
var orderLineToOrder = orderLineMetadata.Properties.Single(p => p.Name == "Order").Relation;
var orderLineToProdyct = orderLineMetadata.Properties.Single(p => p.Name == "Product").Relation;
Assert.That(Jsonlike.Stringify(orderToOrderLine), Is.EqualTo(
"{relationKind:OneToMany,thisPartyKind:Principal,thisPartyKey:PK_Order,relatedPartyType:OrderLine,relatedPartyKind:Dependent,relatedPartyKey:FK_Order}"
));
Assert.That(Jsonlike.Stringify(orderLineToOrder), Is.EqualTo(
"{relationKind:ManyToOne,thisPartyKind:Dependent,thisPartyKey:FK_Order,relatedPartyType:Order,relatedPartyKind:Principal,relatedPartyKey:PK_Order}"
));
Assert.That(Jsonlike.Stringify(orderLineToProdyct), Is.EqualTo(
"{relationKind:ManyToOne,thisPartyKind:Dependent,thisPartyKey:FK_Product,relatedPartyType:Product,relatedPartyKind:Principal,relatedPartyKey:PK_Product}"
));
//Console.WriteLine(JsonlikeMetadataStringifier.Stringify(orderMetadata));
//Console.WriteLine(JsonlikeMetadataStringifier.Stringify(productMetadata));
//Console.WriteLine(JsonlikeMetadataStringifier.Stringify(orderLineMetadata));
}
public void CanCreateBlogEntitiesMetadata()
{
//-- Act
var metadataCache = new TypeMetadataCache(
new DataObjectConventions(),
new PascalCaseRelationalMappingConvention(usePluralTableNames: true),
GetRepositoryMixinsRegistrations());
//-- Assert
//TODO
}
public void CanBuildScalarPrimaryKey()
{
//-- Arrange
var cache = new TypeMetadataCache(new DataObjectConventions(), new PascalCaseRelationalMappingConvention(usePluralTableNames: true));
//-- Act
var product = cache.GetTypeMetadata(typeof(TestDataObjects.Repository1.IProduct));
//-- Assert
Assert.That(product.PrimaryKey.Properties.Single().Name, Is.EqualTo("Id"));
}
public void CanCreateMetadata()
{
//-- Arrange
var metadataCache = new TypeMetadataCache(
new DataObjectConventions(),
new PascalCaseRelationalMappingConvention(usePluralTableNames: true),
GetRepositoryMixinsRegistrations());
//-- Act
var userAccountMetadata = metadataCache.GetTypeMetadata(typeof(IR3.IUserAccountEntity));
//-- Assert
Console.WriteLine(Jsonlike.Stringify(userAccountMetadata));
}
public void CanBuildScalarProperties()
{
//-- Arrange
var cache = new TypeMetadataCache(new DataObjectConventions(), new PascalCaseRelationalMappingConvention(usePluralTableNames: true));
//-- Act
var product = cache.GetTypeMetadata(typeof(TestDataObjects.Repository1.IProduct));
//-- Assert
Assert.That(
product.Properties.Select(p => p.Name).ToArray(),
Is.EqualTo(new[] { "Id", "Name", "Price" }));
Assert.That(
product.Properties.Select(p => p.ClrType.Name).ToArray(),
Is.EqualTo(new[] { "Int32", "String", "Decimal" }));
}
public void CanCreateBlogEntities()
{
//-- Arrange
var metadataCache = new TypeMetadataCache(
new DataObjectConventions(),
new PascalCaseRelationalMappingConvention(usePluralTableNames: true),
GetRepositoryMixinsRegistrations());
var entityFactory = new EfEntityObjectFactory(_dynamicModule, metadataCache);
//-- Act
var author = entityFactory.NewEntity<IR2.IAuthorEntity>();
var article = entityFactory.NewEntity<IR2.IArticleEntity>();
var post = entityFactory.NewEntity<IR2.IPostEntity>();
var tag = entityFactory.NewEntity<IR2.ITagEntity>();
//-- Assert
//TODO
}
public void CanCreateEntityObjects()
{
//-- Arrange
var metadataCache = new TypeMetadataCache(
new DataObjectConventions(),
new PascalCaseRelationalMappingConvention(usePluralTableNames: true),
GetRepositoryMixinsRegistrations());
var entityObjectFactory = new EfEntityObjectFactory(_dynamicModule, metadataCache);
//-- Act
var password = entityObjectFactory.NewEntity<IR3.IPasswordEntity>();
var role = entityObjectFactory.NewEntity<IR3.IUserRoleEntity>();
var userAccount = entityObjectFactory.NewEntity<IR3.IUserAccountEntity>();
//-- Assert
Assert.That(password, Is.Not.Null);
Assert.That(role, Is.Not.Null);
Assert.That(userAccount, Is.Not.Null);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private EfDataRepositoryFactory CreateDataRepositoryFactory()
{
var metadataCache = new TypeMetadataCache(new DataObjectConventions(), new PascalCaseRelationalMappingConvention(usePluralTableNames: true));
var entityFactory = new EfEntityObjectFactory(_dyamicModule, metadataCache);
var repoFactory = new EfDataRepositoryFactory(_dyamicModule, entityFactory, metadataCache, new MySqlClientFactory(), ResolveAuto<IDatabaseConfig>());
return repoFactory;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private EfEntityObjectFactory CreateEntityObjectFactory()
{
var metadataCache = new TypeMetadataCache(new DataObjectConventions(), new PascalCaseRelationalMappingConvention(usePluralTableNames: true));
return new EfEntityObjectFactory(base.Module, metadataCache);
}
public void CanIncludeMixinContracts()
{
//-- Arrange
var cache = new TypeMetadataCache(
new DataObjectConventions(),
new PascalCaseRelationalMappingConvention(usePluralTableNames: true),
new[] {
new MixinRegistration(typeof(TestDataObjects.Repository2.IPrimaryContract), typeof(TestDataObjects.Repository2.IFirstMixinContract)),
new MixinRegistration(typeof(TestDataObjects.Repository2.IPrimaryContract), typeof(TestDataObjects.Repository2.ISecondMixinContract))
});
//-- Act
var primaryContractMetadata = cache.GetTypeMetadata(typeof(TestDataObjects.Repository2.IPrimaryContract));
//-- Assert
Assert.That(primaryContractMetadata.ContractType, Is.EqualTo(typeof(TestDataObjects.Repository2.IPrimaryContract)));
Assert.That(primaryContractMetadata.MixinContractTypes, Is.EquivalentTo(new[] {
typeof(TestDataObjects.Repository2.IFirstMixinContract),
typeof(TestDataObjects.Repository2.ISecondMixinContract)
}));
var propertyNames = primaryContractMetadata.Properties.Select(p => p.Name).ToArray();
Assert.That(propertyNames, Is.EquivalentTo(new[] {
"PrimaryProperty", "FirstMixinProperty", "SecondMixinPropertyA", "SecondMixinPropertyB"
}));
}
public void CanIncludePropertyDefaultValue()
{
//-- Arrange
var cache = new TypeMetadataCache(new DataObjectConventions(), new PascalCaseRelationalMappingConvention(usePluralTableNames: true));
//-- Act
var orderType = cache.GetTypeMetadata(typeof(TestDataObjects.Repository1.IOrder));
var statusProperty = orderType.GetPropertyByName("Status");
//-- Assert
Assert.That(statusProperty.DefaultValue, Is.EqualTo(TestDataObjects.Repository1.OrderStatus.New));
}
