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