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