public void MetadataModelBuilderFromModelTest() { var builder = new MetadataModelBuilder(); var entityBuilder = builder.Entity <Receipt>(); entityBuilder.Property(p => p.Id).ValueGeneration = AutoGenerateValue.OnInsert; var nr = entityBuilder.Property(p => p.ReceiptNumber); nr.MaxLength = 20; nr.Nullable = false; entityBuilder.PrimaryKey.Add("Id"); var invoice = builder.Entity <Invoice>(); invoice.BaseEntity = entityBuilder; var delivery = invoice.Property(p => p.ExpectedDeliveryDate); delivery.DateTimeType = DateTimePropertyType.DateTime; var oldModel = builder.ToModel(); var newBuilder = new MetadataModelBuilder().FromModel(oldModel); var newModel = newBuilder.ToModel(); Assert.All(oldModel.Entities, p => Assert.NotNull(newModel.GetEntityMetadata(p.ClrType))); Assert.All(oldModel.Entities, p => { var newEntity = newModel.GetEntityMetadata(p.ClrType); Assert.All(p.GetProperties(), x => Assert.NotNull(newEntity.GetProperties().FirstOrDefault(y => y.Name == x.Name))); }); }
public void FromDbOneToManyMultimplicityTest() { var builder = new MetadataModelBuilder(); using (var ctx = CreateContext()) { builder.UseDbContext(ctx); } var model = builder.ToModel(); var receipt = model.GetEntityMetadata <Receipt>(); var receiptDetail = model.GetEntityMetadata <ReceiptDetail>(); var receiptDetailsProperty = (NavigationPropertyMetadata)receipt["Details"]; var receiptDetailReceiptProperty = (NavigationPropertyMetadata)receiptDetail["Receipt"]; Assert.Equal(NavigationPropertyMultiplicity.Many, receiptDetailsProperty.Multiplicity); Assert.Equal(NavigationPropertyMultiplicity.One, receiptDetailsProperty.TargetMultiplicity); Assert.Equal(NavigationPropertyMultiplicity.One, receiptDetailReceiptProperty.Multiplicity); Assert.Equal(NavigationPropertyMultiplicity.Many, receiptDetailReceiptProperty.TargetMultiplicity); Assert.Equal(receiptDetailsProperty.TargetNavigationProperty, receiptDetailReceiptProperty); Assert.Equal(receiptDetailReceiptProperty.TargetNavigationProperty, receiptDetailsProperty); Assert.Single(receiptDetailReceiptProperty.ForeignKeyProperties); Assert.Equal(receiptDetail["ReceiptId"], receiptDetailReceiptProperty.ForeignKeyProperties[0].Dependant); Assert.Equal(receipt["Id"], receiptDetailReceiptProperty.ForeignKeyProperties[0].Principal); }
public void InequalityTest() { var builder = new MetadataModelBuilder(); builder.Entity <Invoice>().Property(p => p.ReceiptType); builder.Entity <Invoice>().Property(p => p.ReceiptNumber); builder.Entity <Invoice>().Property(p => p.Id); builder.Entity <Invoice>().Property(p => p.ReceiptDate); builder.Entity <Invoice>().PrimaryKey.Add("ReceiptNumber"); builder.Entity <Invoice>().PrimaryKey.Add("ReceiptType"); var model = builder.ToModel(); var entity = model.GetEntityMetadata <Invoice>(); var invoice = new Invoice { ReceiptNumber = "TestNumber", ReceiptType = ReceiptType.Invoice }; var key = entity.GetPrimaryKeyObject(invoice); var typed = key as EntityKey <string, ReceiptType>; var keycompare = new EntityKey <string, ReceiptType>(entity) { Value0 = "Bla", Value1 = ReceiptType.Invoice }; Assert.NotEqual(key.GetHashCode(), keycompare.GetHashCode()); Assert.NotEqual(key, keycompare); }
public void MetadataModelBuilderGenericEntityTest() { var builder = new MetadataModelBuilder(); var entityBuilder = builder.Entity <Receipt>(); Assert.Equal("Receipt", entityBuilder.Name); Assert.Equal(typeof(Receipt), entityBuilder.TypeInfo.ClrType); }
public void DefaultStructureConventionTest() { var builder = new MetadataModelBuilder(); builder.Entity <Invoice>(); builder.Entity <Article>().HasOne(p => p.ArticleSettings).WithPrincipal(); builder.ApplyConventions(); TestModelValidations.ValidateInvoiceArticleDefaultModel(builder); }
public ModelCreationScope(MetadataModelBuilder builder, IValueAccessorFactory valueAccessorFactory) { _valueAccessorFactory = valueAccessorFactory; _modelBuilder = builder; _entities = new Dictionary <Type, EntityMetadata>(); _navigationProperties = new Dictionary <EntityMetadata, Dictionary <string, NavigationPropertyMetadata> >(); Entities = new ReadOnlyDictionary <Type, EntityMetadata>(_entities); NavigationProperties = new ReadOnlyDictionary <EntityMetadata, Dictionary <string, NavigationPropertyMetadata> >(_navigationProperties); }
public void MetadataModelBuilderMaxLengthTest() { var builder = new MetadataModelBuilder(); var entityBuilder = builder.Entity <Receipt>(); builder.ApplyConventions(); Assert.Equal(100, entityBuilder.Property(c => c.ReceiptNumber).MaxLength); }
public void EntityMetadataBuilderGenericBlobProperty() { var builder = new MetadataModelBuilder(); var prop = builder.Entity <AllTypesEntity>() .Property(p => p.BlobProperty); Assert.IsType <BlobPropertyBuilder>(prop); Assert.Equal("BlobProperty", prop.Name); Assert.True(prop.Nullable); }
public static void UseWorkspace(this MetadataModelBuilder builder, MetadataWorkspace metadata) { var entityTypes = metadata .GetItems <EntityType>(DataSpace.CSpace); foreach (var entity in entityTypes) { var entityBuilder = builder.FromEntityType(metadata, entity); } }
public void EntityMetadataBuilderTextProperty() { var builder = new MetadataModelBuilder(); var prop = builder.Entity <Receipt>() .Property("ReceiptNumber", typeof(string)); Assert.IsType <TextPropertyBuilder>(prop); Assert.Equal("ReceiptNumber", prop.Name); Assert.True(prop.Nullable); }
public static void UseDbModel(this MetadataModelBuilder builder, IModel model) { var entities = model.GetEntityTypes().ToList(); entities = entities.Where(p => p.FindPrimaryKey() != null).ToList(); foreach (var entity in entities) { var entityBuilder = builder.FromEntityType(entity); } }
public void TestCustomAccessor_ExpectsNoError() { var builder = new MetadataModelBuilder(); builder.Entity <Article>(); builder.Entity <ArticleName>(); builder.Entity <Contact>(); var model = builder.ApplyConventions().ToModel(new CustomAccessorFactory()); Assert.NotNull(model); }
public void FromDbAbstractBaseClassRelationTest() { var builder = new MetadataModelBuilder(); using (var ctx = new TestContext()) { builder.UseDbContext(ctx); } var model = builder.ToModel(); model.GetEntityMetadata <ChangeVersion>(); }
public void ProtoBufSerializationPreviousVersionDeserializationTest() { MetadataModelBuilder builder = null; using (var ms = typeof(MetadataModelBuilderSerializationTest).Assembly.GetManifestResourceStream("Lucile.Core.Test.Serialization.previous-model.proto")) { builder = ProtoBuf.Serializer.Deserialize <MetadataModelBuilder>(ms); } var model = builder.ToModel(); TestModelValidations.ValidateInvoiceArticleDefaultModel(model); }
public void MaxLengthAnnotation_ExpectsValue() { var builder = new MetadataModelBuilder(); using (var ctx = new TestContext()) { builder.UseDbContext(ctx); } var model = builder.ToModel(); var entity = model.GetEntityMetadata <ArticleName>(); Assert.Equal(255, ((TextProperty)entity.GetProperties().First(p => p.Name == nameof(ArticleName.TranlatedText))).MaxLength); }
public void DataContractSerializationPreviousVersionDeserializationTest() { MetadataModelBuilder builder = null; using (var ms = typeof(MetadataModelBuilderSerializationTest).Assembly.GetManifestResourceStream("Lucile.Core.Test.Serialization.previous-model.xml")) { var ser = new DataContractSerializer(typeof(MetadataModelBuilder)); builder = ser.ReadObject(ms) as MetadataModelBuilder; } var model = builder.ToModel(); TestModelValidations.ValidateInvoiceArticleDefaultModel(model); }
public void TestNoneClrPropertiyInModel_UsePropertyMethod_ExpectsOK() { var modelBuilder = new MetadataModelBuilder(); modelBuilder.Entity <Contact>() .Property <string>("NoneClrProperty"); var model = modelBuilder.ToModel(); var entity = model.GetEntityMetadata <Contact>(); var property = entity["NoneClrProperty"]; Assert.NotNull(property); }
public void OneToOneWithConfigDefaultStructureConventionTest() { var builder = new MetadataModelBuilder(); builder.Entity <Test1>().HasOne(p => p.Test2).WithPrincipal(p => p.Test1); builder.ApplyConventions(); EntityMetadataBuilder entity = builder.Entity <Test1>(); Assert.Equal(1, entity.PrimaryKey.Count); Assert.Equal("Id", entity.PrimaryKey.First()); entity = builder.Entity <Test2>(); Assert.Equal(1, entity.PrimaryKey.Count); Assert.Equal("Test2ID", entity.PrimaryKey.First()); }
private static void ResolveNavigations(MetadataModelBuilder builder, IEnumerable <IStructureConvention> conventions, IEnumerable <Type> types) { var targetTypes = types.SelectMany(p => conventions.SelectMany(x => x.GetNavigations(p)?.Values ?? Enumerable.Empty <Type>())).Distinct(); var missingTypes = targetTypes.Except(builder.Entities.Select(p => p.TypeInfo.ClrType)).ToList(); if (missingTypes.Any()) { foreach (var item in missingTypes) { builder.Entity(item); } ResolveNavigations(builder, conventions, missingTypes); } }
public void CheckUniqueNameForGenericEntitiesTest() { var builder = new MetadataModelBuilder(); using (var ctx = new TestContext()) { builder.UseDbContext(ctx); } var model = builder.ToModel(); foreach (var entity in model.Entities) { Assert.All(model.Entities.Except(new[] { entity }), p => Assert.NotEqual(entity.Name, p.Name)); } }
public void TestNoneClrPropertiyInModel_UsePropertyNameProperty_ExpectsOK() { var modelBuilder = new MetadataModelBuilder(); var entityBuilder = modelBuilder.Entity <Contact>(); entityBuilder.Properties.Add(new TextPropertyBuilder { Name = "NoneClrProperty", PropertyType = new ClrTypeInfo(typeof(string)) }); var model = modelBuilder.ToModel(); var entity = model.GetEntityMetadata <Contact>(); var property = entity["NoneClrProperty"]; Assert.NotNull(property); }
public void OneToOneDefaultStructureConventionTest() { var builder = new MetadataModelBuilder(); var entity = builder.Entity <Test1>(); builder.ApplyConventions(); var entity2 = builder.Entity <Test2>(); var nav1 = entity.Navigation("Test2"); var nav2 = entity2.Navigation("Test1"); Assert.Equal(NavigationPropertyMultiplicity.ZeroOrOne, nav1.Multiplicity); Assert.Equal(NavigationPropertyMultiplicity.Many, nav1.TargetMultiplicity); Assert.Equal(NavigationPropertyMultiplicity.ZeroOrOne, nav2.Multiplicity); Assert.Equal(NavigationPropertyMultiplicity.Many, nav2.TargetMultiplicity); }
public void DefaultValueAnnotationTest() { var builder = new MetadataModelBuilder(); using (var ctx = CreateContext()) { builder.UseDbContext(ctx); } var model = builder.ToModel(); var prop = model.GetEntityMetadata <ArticleName>().GetProperties().First(p => p.Name == "TranlatedText"); var prop2 = model.GetEntityMetadata <ArticleName>().GetProperties().First(p => p.Name == "LanguageId"); Assert.True(prop.HasDefaultValue); Assert.False(prop2.HasDefaultValue); }
public void EntityMetadataBuilderReplacetItemWithNullTest() { var builder = new MetadataModelBuilder(); var receiptBuilder = builder.Entity <Receipt>(); receiptBuilder.HasMany(p => p.Details) .WithOne(p => p.Receipt) .HasForeignKey("ReceiptId"); receiptBuilder.Property(p => p.Id).Nullable = false; receiptBuilder.PrimaryKey.Add("Id"); builder.Entity <Invoice>().BaseEntity = receiptBuilder; var receiptDetailBuilder = builder.Entity <ReceiptDetail>(); receiptDetailBuilder.PrimaryKey.Add("Id"); receiptDetailBuilder.Property(p => p.Id).Nullable = false; receiptDetailBuilder.Property(p => p.ReceiptId).Nullable = false; var model = builder.ToModel(); var receipt = new Invoice { Id = Guid.NewGuid() }; var rd1 = new ReceiptDetail { Id = Guid.NewGuid(), ReceiptId = receipt.Id }; var rd2 = new ReceiptDetail { Id = Guid.NewGuid(), ReceiptId = receipt.Id }; receipt.Details.AddRange(new[] { rd1, rd2 }); var entity = model.GetEntityMetadata(receipt); var details = entity.GetNavigations().First(p => p.Name == "Details"); Assert.Equal(2, receipt.Details.Count); Assert.All(receipt.Details, p => Assert.NotNull(p)); details.ReplaceItem(receipt, rd1, null); Assert.Single(receipt.Details); Assert.All(receipt.Details, p => Assert.NotNull(p)); }
public void ExcludeQueryTypes_ExpectsOk() { var builder = new MetadataModelBuilder(); using (var ctx = new TestContext()) { builder.UseDbContext(ctx); var queryType = ctx.Model.FindEntityType(typeof(ArticleStatistics)); Assert.NotNull(queryType); Assert.Null(queryType.FindPrimaryKey()); } var model = builder.ToModel(); var metadataEntry = model.GetEntityMetadata <ArticleStatistics>(); Assert.Null(metadataEntry); }
public void DefaultKeyConventionTest() { var builder = new MetadataModelBuilder(); builder.Entity <Test1>().HasOne(p => p.Test2).WithPrincipal(p => p.Test1); builder.ApplyConventions(); var entity = builder.Entity <Test1>(); var entity2 = builder.Entity <Test2>(); var nav1 = entity.Navigation("Test2"); var nav2 = entity2.Navigation("Test1"); Assert.Equal(NavigationPropertyMultiplicity.ZeroOrOne, nav1.Multiplicity); Assert.Equal(NavigationPropertyMultiplicity.One, nav1.TargetMultiplicity); Assert.Equal(NavigationPropertyMultiplicity.One, nav2.Multiplicity); Assert.Equal(NavigationPropertyMultiplicity.ZeroOrOne, nav2.TargetMultiplicity); }
public void FromDbSerializationTest() { var builder = new MetadataModelBuilder(); MetadataModelBuilder newBuilder = null; using (var ctx = new TestContext()) { builder.UseDbContext(ctx); } using (var ms = new MemoryStream()) { ProtoBuf.Serializer.Serialize(ms, builder); ms.Seek(0, SeekOrigin.Begin); newBuilder = ProtoBuf.Serializer.Deserialize <MetadataModelBuilder>(ms); } foreach (var item in builder.Entities) { var newItem = newBuilder.Entities.FirstOrDefault(p => p.Name == item.Name); Assert.NotNull(newItem); foreach (var prop in item.Properties) { var newProp = newItem.Properties.FirstOrDefault(p => p.Name == prop.Name); Assert.NotNull(newProp); Assert.Equal(prop.IsExcluded, newProp.IsExcluded); Assert.Equal(prop.ValueGeneration, newProp.ValueGeneration); Assert.Equal(prop.Nullable, newProp.Nullable); } foreach (var nav in item.Navigations) { var newNav = newItem.Navigations.FirstOrDefault(p => p.Name == nav.Name); Assert.NotNull(newNav); Assert.Equal(nav.IsExcluded, newNav.IsExcluded); Assert.Equal(nav.Multiplicity, newNav.Multiplicity); Assert.Equal(nav.ForeignKey, newNav.ForeignKey); Assert.Equal(nav.Nullable, newNav.Nullable); Assert.Equal(nav.Target, newNav.Target); Assert.Equal(nav.TargetMultiplicity, newNav.TargetMultiplicity); Assert.Equal(nav.TargetProperty, newNav.TargetProperty); } } }
public void EntityMetadataBuilderEnumProperty() { var builder = new MetadataModelBuilder(); var prop = builder.Entity <Receipt>() .Property(p => p.ReceiptType); Assert.Equal("ReceiptType", prop.Name); Assert.Equal(NumericPropertyType.Byte, prop.UnderlyingNumericType); Assert.Equal(typeof(ReceiptType), prop.EnumTypeInfo.ClrType); Assert.False(prop.Nullable); prop = builder.Entity <Contact>() .Property(p => p.ContactType); Assert.Equal("ContactType", prop.Name); Assert.Equal(NumericPropertyType.Int32, prop.UnderlyingNumericType); Assert.Equal(typeof(ContactType), prop.EnumTypeInfo.ClrType); Assert.True(prop.Nullable); }
public void FromDbOneToOneMultimplicityTest() { var builder = new MetadataModelBuilder(); using (var ctx = new TestContext()) { builder.UseDbContext(ctx); } var model = builder.ToModel(); var contact = model.GetEntityMetadata <Contact>(); var contactSettings = model.GetEntityMetadata <ContactSettings>(); var contactSettingsContactProperty = (NavigationPropertyMetadata)contactSettings["Contact"]; Assert.Equal(NavigationPropertyMultiplicity.One, contactSettingsContactProperty.Multiplicity); Assert.Equal(NavigationPropertyMultiplicity.ZeroOrOne, contactSettingsContactProperty.TargetMultiplicity); Assert.Null(contactSettingsContactProperty.TargetNavigationProperty); Assert.Equal(contact, contactSettingsContactProperty.TargetEntity); }
internal MetadataModel(MetadataModelBuilder modelBuilder, IValueAccessorFactory valueAccessorFactory) { var scope = new ModelCreationScope(modelBuilder, valueAccessorFactory); var unordered = GetSorted(modelBuilder.Entities).Where(p => !p.IsExcluded).Select(p => scope.GetEntity(p.TypeInfo.ClrType)).ToList(); var targetList = unordered.Where(p => p.BaseEntity == null).OrderBy(p => p.Name).ToList(); targetList.ForEach(p => unordered.Remove(p)); while (unordered.Any()) { var nextLayer = unordered.Where(p => targetList.Contains(p.BaseEntity)).ToList(); foreach (var item in nextLayer.OrderByDescending(p => p.Name)) { unordered.Remove(item); targetList.Insert(0, item); } } Entities = ImmutableList.CreateRange(targetList); }