public void Can_get_model()
{
var model = new Model();
var sequence = new Sequence(model, RelationalAnnotationNames.Prefix, "Foo");
Assert.Same(model, sequence.Model);
}
private ForeignKey CreateForeignKey()
{
var model = new Model();
var entityType = model.AddEntityType("E");
var idProperty = entityType.AddProperty("id", typeof(int));
var key = entityType.SetPrimaryKey(idProperty);
var fkProperty = entityType.AddProperty("p", typeof(int));
return entityType.AddForeignKey(fkProperty, key, entityType);
}
public void Constructor_validates_properties_from_same_entity()
{
var property1 = new Model().AddEntityType(typeof(Customer)).GetOrAddProperty(Customer.IdProperty);
var property2 = new Model().AddEntityType(typeof(Order)).GetOrAddProperty(Order.IdProperty);
Assert.Equal(CoreStrings.InconsistentEntityType("properties"),
Assert.Throws<ArgumentException>(
() => new Index(new[] { property1, property2 })).Message);
}
public void Can_create_key_from_properties()
{
var entityType = new Model().AddEntityType(typeof(Customer));
var property1 = entityType.GetOrAddProperty(Customer.IdProperty);
var property2 = entityType.GetOrAddProperty(Customer.NameProperty);
var key = new Key(new[] { property1, property2 });
Assert.True(new[] { property1, property2 }.SequenceEqual(key.Properties));
}
public void Throws_if_no_match_found_and_no_property_setter()
{
var entityType = new Model().AddEntityType(typeof(TheDarkSide));
var property = entityType.AddProperty(TheDarkSide.TimeProperty);
Assert.Equal(
CoreStrings.NoFieldOrSetter(typeof(TheDarkSide).FullName, "Time"),
Assert.Throws<InvalidOperationException>(
() => new MemberMapper(new FieldMatcher()).MapPropertiesToMembers(entityType)).Message);
}
public void M_underscore_matching_field_is_not_used_if_type_is_not_compatible()
{
var entityType = new Model().AddEntityType(typeof(TheDarkSideOfTheMoon));
var property = entityType.AddProperty("SpeakToMe", typeof(int));
property.IsShadowProperty = false;
var propertyInfo = entityType.ClrType.GetAnyProperty("SpeakToMe");
var fields = propertyInfo.DeclaringType.GetRuntimeFields().ToDictionary(f => f.Name);
Assert.Null(new FieldMatcher().TryMatchFieldName(property, propertyInfo, fields));
}
public void Delegate_setter_is_returned_for_IProperty_property()
{
var entityType = new Model().AddEntityType(typeof(Customer));
var idProperty = entityType.AddProperty(Customer.IdProperty);
var customer = new Customer { Id = 7 };
new ClrPropertySetterFactory().Create(idProperty).SetClrValue(customer, 77);
Assert.Equal(77, customer.Id);
}
public void Property_setter_is_used_if_no_matching_field_is_found()
{
var entityType = new Model().AddEntityType(typeof(TheDarkSide));
var property = entityType.AddProperty(TheDarkSide.OnTheRunProperty);
var mapping = new MemberMapper(new FieldMatcher()).MapPropertiesToMembers(entityType).Single();
Assert.Same(property, mapping.Item1);
Assert.IsAssignableFrom<PropertyInfo>(mapping.Item2);
Assert.Equal("OnTheRun", mapping.Item2.Name);
}
public void Field_name_match_is_used_in_preference_to_property_setter()
{
var entityType = new Model().AddEntityType(typeof(TheDarkSide));
var property = entityType.AddProperty(TheDarkSide.BreatheProperty);
var mapping = new MemberMapper(new FieldMatcher()).MapPropertiesToMembers(entityType).Single();
Assert.Same(property, mapping.Item1);
Assert.IsAssignableFrom<FieldInfo>(mapping.Item2);
Assert.Equal("_breathe", mapping.Item2.Name);
}
public void Throws_if_annotated_field_if_types_not_compatible()
{
var entityType = new Model().AddEntityType(typeof(TheDarkSide));
var property = entityType.AddProperty(TheDarkSide.SpeakToMeProperty);
property["BackingField"] = "_badFieldForSpeak";
Assert.Equal(
CoreStrings.BadBackingFieldType("_badFieldForSpeak", typeof(string).Name, typeof(TheDarkSide).FullName, "SpeakToMe", typeof(int).Name),
Assert.Throws<InvalidOperationException>(
() => new MemberMapper(new FieldMatcher()).MapPropertiesToMembers(entityType)).Message);
}
public void Throws_if_annotated_field_name_is_not_found()
{
var entityType = new Model().AddEntityType(typeof(TheDarkSide));
var property = entityType.AddProperty(TheDarkSide.SpeakToMeProperty);
property["BackingField"] = "_speakToMe";
Assert.Equal(
CoreStrings.MissingBackingField(typeof(TheDarkSide).FullName, "SpeakToMe", "_speakToMe"),
Assert.Throws<InvalidOperationException>(
() => new MemberMapper(new FieldMatcher()).MapPropertiesToMembers(entityType)).Message);
}
public void Annotated_field_name_is_used_if_present()
{
var entityType = new Model().AddEntityType(typeof(TheDarkSide));
var property = entityType.AddProperty(TheDarkSide.SpeakToMeProperty);
property["BackingField"] = "fieldForSpeak";
var mapping = new MemberMapper(new FieldMatcher()).MapPropertiesToMembers(entityType).Single();
Assert.Same(property, mapping.Item1);
Assert.Equal("fieldForSpeak", mapping.Item2.Name);
}
public void Can_set_ClrType()
{
var entityType = new Model().AddEntityType(typeof(object));
var property = entityType.AddProperty("Kake");
Assert.Null(property.ClrType);
Assert.Equal(typeof(string), ((IProperty)property).ClrType);
property.ClrType = typeof(int);
Assert.Equal(typeof(int), property.ClrType);
}
public void Delegate_setter_can_set_value_type_property()
{
var entityType = new Model().AddEntityType(typeof(Customer));
var idProperty = entityType.AddProperty(Customer.IdProperty);
var customer = new Customer { Id = 7 };
new ClrPropertySetterFactory().Create(idProperty).SetClrValue(customer, 1);
Assert.Equal(1, customer.Id);
}
public void Can_create_unique_index_from_properties()
{
var entityType = new Model().AddEntityType(typeof(Customer));
var property1 = entityType.GetOrAddProperty(Customer.IdProperty);
var property2 = entityType.GetOrAddProperty(Customer.NameProperty);
var index = new Index(new[] { property1, property2 }) { IsUnique = true };
Assert.True(new[] { property1, property2 }.SequenceEqual(index.Properties));
Assert.True(index.IsUnique.Value);
}
public void Delegate_setter_can_set_reference_type_property()
{
var entityType = new Model().AddEntityType(typeof(Customer));
var idProperty = entityType.AddProperty(Customer.ContentProperty);
var customer = new Customer { Id = 7 };
new ClrPropertySetterFactory().Create(idProperty).SetClrValue(customer, "MyString");
Assert.Equal("MyString", customer.Content);
}
public void Entity_returns_same_instance_for_entity_type_name()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
var entityBuilder = modelBuilder.Entity(typeof(Customer).FullName, ConfigurationSource.DataAnnotation);
Assert.NotNull(entityBuilder);
Assert.NotNull(model.FindEntityType(typeof(Customer).FullName));
Assert.Same(entityBuilder, modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit));
}
public void Delegate_setter_can_set_nullable_property()
{
var entityType = new Model().AddEntityType(typeof(Customer));
var idProperty = entityType.AddProperty(Customer.OptionalIntProperty);
var customer = new Customer { Id = 7 };
new ClrPropertySetterFactory().Create(idProperty).SetClrValue(customer, 3);
Assert.Equal(3, customer.OptionalInt);
}
public void Cannot_remove_entity_type_when_it_has_derived_types()
{
var model = new Model();
var customerType = model.GetOrAddEntityType(typeof(Customer));
var specialCustomerType = model.GetOrAddEntityType(typeof(SpecialCustomer));
specialCustomerType.BaseType = customerType;
Assert.Equal(
CoreStrings.EntityTypeInUseByDerived(typeof(Customer).Name, typeof(SpecialCustomer).Name),
Assert.Throws<InvalidOperationException>(() => model.RemoveEntityType(customerType.Name)).Message);
}
private static void FieldMatchTest(string propertyName, string fieldName)
{
var entityType = new Model().AddEntityType(typeof(TheDarkSideOfTheMoon));
var property = entityType.AddProperty(propertyName, typeof(int));
property.IsShadowProperty = false;
var propertyInfo = entityType.ClrType.GetAnyProperty(propertyName);
var fields = propertyInfo.DeclaringType.GetRuntimeFields().ToDictionary(f => f.Name);
var matchedField = new FieldMatcher().TryMatchFieldName(property, propertyInfo, fields);
Assert.Equal(fieldName, matchedField.Name);
}
public void Can_get_model_default_schema_if_sequence_schema_not_specified()
{
var model = new Model();
var sequence = new Sequence(model, RelationalAnnotationNames.Prefix, "Foo");
Assert.Null(sequence.Schema);
model.Relational().DefaultSchema = "db0";
Assert.Equal("db0", sequence.Schema);
}
public void Cannot_ignore_same_or_higher_source_entity_type_using_entity_clr_type()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
Assert.True(modelBuilder.Ignore(typeof(Customer), ConfigurationSource.DataAnnotation));
Assert.NotNull(modelBuilder.Entity(typeof(Customer), ConfigurationSource.DataAnnotation));
Assert.NotNull(modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit));
Assert.False(modelBuilder.Ignore(typeof(Customer), ConfigurationSource.DataAnnotation));
Assert.NotNull(model.FindEntityType(typeof(Customer)));
}
public void Can_ignore_lower_source_entity_type_using_entity_clr_type()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity(typeof(Customer), ConfigurationSource.Convention);
Assert.True(modelBuilder.Ignore(typeof(Customer), ConfigurationSource.DataAnnotation));
Assert.Null(model.FindEntityType(typeof(Customer)));
Assert.True(modelBuilder.Ignore(typeof(Customer), ConfigurationSource.DataAnnotation));
Assert.Null(modelBuilder.Entity(typeof(Customer), ConfigurationSource.Convention));
Assert.NotNull(modelBuilder.Entity(typeof(Customer), ConfigurationSource.DataAnnotation));
}
public void Setting_ClrType_throws_when_referenced()
{
var entityType = new Model().AddEntityType(typeof(object));
var principalProperty = entityType.AddProperty("Kake");
var key = entityType.AddKey(principalProperty);
var dependentProperty = entityType.AddProperty("Alaska");
entityType.AddForeignKey(dependentProperty, key, entityType);
Assert.Equal(CoreStrings.PropertyClrTypeCannotBeChangedWhenReferenced("Kake", "{'Alaska'}", "object"),
Assert.Throws<InvalidOperationException>(() =>
principalProperty.ClrType = typeof(int)).Message);
Assert.Equal(typeof(string), ((IProperty)principalProperty).ClrType);
}
public void Property_nullability_is_changed_if_property_made_part_of_primary_key()
{
var entityType = new Model().AddEntityType(typeof(object));
var stringProperty = entityType.AddProperty("Name", typeof(string));
stringProperty.IsNullable = true;
Assert.True(stringProperty.IsNullable.Value);
stringProperty.DeclaringEntityType.SetPrimaryKey(stringProperty);
Assert.Null(stringProperty.IsNullable);
Assert.False(((IProperty)stringProperty).IsNullable);
}
public void Constructor_throws_when_referenced_key_not_on_referenced_entity()
{
var model = new Model();
var principalEntityType = model.AddEntityType("R");
var dependentEntityType = model.AddEntityType("D");
var fk = dependentEntityType.AddProperty("Fk", typeof(int));
var principalKey = dependentEntityType.SetPrimaryKey(fk);
Assert.Equal(
CoreStrings.ForeignKeyReferencedEntityKeyMismatch("{'Fk'}", "R"),
Assert.Throws<ArgumentException>(() => new ForeignKey(new[] { fk }, principalKey, dependentEntityType, principalEntityType)).Message);
}
public void Can_read_nulls()
{
var entityType = new Model().AddEntityType(typeof(SomeEntity));
entityType.AddProperty(SomeEntity.FooProperty);
entityType.AddProperty(SomeEntity.GooProperty);
entityType.AddProperty(SomeEntity.IdProperty);
var factory = GetMaterializer(new EntityMaterializerSource(new MemberMapper(new FieldMatcher())), entityType);
var entity = (SomeEntity)factory(new ValueBuffer(new object[] { null, null, 77 }));
Assert.Equal(77, entity.Id);
Assert.Null(entity.Foo);
Assert.Null(entity.Goo);
}
public void Constructor_throws_when_principal_and_depedent_property_count_do_not_match()
{
var dependentType = new Model().AddEntityType("D");
var principalType = new Model().AddEntityType("P");
var dependentProperty1 = dependentType.AddProperty("P1", typeof(int));
var dependentProperty2 = dependentType.AddProperty("P2", typeof(int));
var idProperty = principalType.AddProperty("Id", typeof(int));
principalType.GetOrSetPrimaryKey(idProperty);
Assert.Equal(
CoreStrings.ForeignKeyCountMismatch("{'P1', 'P2'}", "D", "{'Id'}", "P"),
Assert.Throws<InvalidOperationException>(
() => new ForeignKey(new[] { dependentProperty1, dependentProperty2 }, principalType.FindPrimaryKey(), dependentType, principalType)).Message);
}
public void Can_ignore_lower_source_entity_type_using_entity_type_name()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity(typeof(Customer).FullName, ConfigurationSource.DataAnnotation);
Assert.True(modelBuilder.Ignore(typeof(Customer).FullName, ConfigurationSource.Explicit));
Assert.Null(model.FindEntityType(typeof(Customer).FullName));
Assert.True(modelBuilder.Ignore(typeof(Customer).FullName, ConfigurationSource.Explicit));
Assert.Null(modelBuilder.Entity(typeof(Customer).FullName, ConfigurationSource.DataAnnotation));
Assert.Equal(Strings.EntityIgnoredExplicitly(typeof(Customer).FullName),
Assert.Throws<InvalidOperationException>(() =>
Assert.Null(modelBuilder.Entity(typeof(Customer).FullName, ConfigurationSource.Explicit))).Message);
}
public void Can_only_override_existing_ClrType_value_explicitly()
{
var model = new Model();
model.AddEntityType(typeof(Customer)).AddProperty(Customer.NameProperty);
var modelBuilder = new InternalModelBuilder(model, new ConventionSet());
var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit);
var builder = entityBuilder.Property(Customer.NameProperty.Name, ConfigurationSource.Convention);
Assert.True(builder.ClrType(typeof(string), ConfigurationSource.DataAnnotation));
Assert.False(builder.ClrType(typeof(int), ConfigurationSource.DataAnnotation));
Assert.Equal(typeof(string), builder.Metadata.ClrType);
Assert.True(builder.ClrType(typeof(int), ConfigurationSource.Explicit));
Assert.Equal(typeof(int), builder.Metadata.ClrType);
}
