public void Get_generation_property_returns_generation_property_from_foreign_key_tree()
{
var model = new Model();
var leftType = new EntityType("Left", model);
var leftId = leftType.AddProperty("Id", typeof(int), true);
var leftKey = leftType.AddKey(leftId);
var rightType = new EntityType("Right", model);
var rightId1 = rightType.AddProperty("Id1", typeof(int), true);
var rightId2 = rightType.AddProperty("Id2", typeof(int), true);
var rightKey = rightType.AddKey(new[] { rightId1, rightId2 });
var middleType = new EntityType("Middle", model);
var middleProperty1 = middleType.AddProperty("FK1", typeof(int), true);
var middleProperty2 = middleType.AddProperty("FK2", typeof(int), true);
var middleKey1 = middleType.AddKey(middleProperty1);
var middleFK1 = middleType.AddForeignKey(middleProperty1, leftKey, leftType);
var middleFK2 = middleType.AddForeignKey(new[] { middleProperty2, middleProperty1 }, rightKey, rightType);
var endType = new EntityType("End", model);
var endProperty = endType.AddProperty("FK", typeof(int), true);
var endFK = endType.AddForeignKey(endProperty, middleKey1, middleType);
rightId2.RequiresValueGenerator = true;
Assert.Equal(rightId2, endProperty.GetGenerationProperty());
}
public static EntityType EntityType()
{
var entityType = new EntityType(typeof(IntKeysPoco));
entityType.AddProperty("PartitionID", typeof(int)).SetColumnName("PartitionKey");
entityType.AddProperty("RowID", typeof(int)).SetColumnName("RowKey");
return entityType;
}
public static EntityType EntityType()
{
var entityType = new EntityType(typeof(NullablePoco));
entityType.AddProperty("NullInt", typeof(int?));
entityType.AddProperty("NullDouble", typeof(double?));
return entityType;
}
public TableEntityAdapterFactoryTests()
{
_factory = new TableEntityAdapterFactory();
_entityType = new EntityType(typeof(PocoTestType));
_entityType.AddProperty("PartitionKey", typeof(string));
_entityType.AddProperty("RowKey", typeof(string));
_entityType.AddProperty("Timestamp", typeof(DateTime));
}
public void Can_create_key_from_properties()
{
var entityType = new EntityType("E");
var property1 = entityType.AddProperty(Customer.IdProperty);
var property2 = entityType.AddProperty(Customer.NameProperty);
var key = new Key(new[] { property1, property2 });
Assert.True(new[] { property1, property2 }.SequenceEqual(key.Properties));
}
public TestStateEntry WithType(string name)
{
var e = new EntityType(name);
e.AddProperty("PartitionKey", typeof(string), true, false);
e.AddProperty("RowKey", typeof(string), true, false);
e.AddProperty("ETag", typeof(string), true, false);
e.AddProperty("Timestamp", typeof(DateTime), true, false);
_entityType = e;
return this;
}
public TestStateEntry WithType(Type type)
{
var e = new EntityType(type);
e.AddProperty("PartitionKey", typeof(string));
e.AddProperty("RowKey", typeof(string));
e.AddProperty("ETag", typeof(string));
e.AddProperty("Timestamp", typeof(DateTimeOffset));
_entityType = e;
return this;
}
public void IsRequired_when_dependent_property_nullable()
{
var entityType = new EntityType("E");
entityType.SetKey(entityType.AddProperty("Id", typeof(int)));
var dependentProp = entityType.AddProperty("P", typeof(int?));
var foreignKey = new ForeignKey(entityType.GetKey(), new[] { dependentProp });
Assert.False(foreignKey.IsRequired);
}
public void Select_throws_when_composite_key()
{
var selector = CreateSelector();
var entityType = new EntityType("Entity");
var property = entityType.AddProperty("Id1", typeof(long));
property.ValueGenerationOnAdd = ValueGenerationOnAdd.Client;
entityType.SetKey(property, entityType.AddProperty("Id2", typeof(long)));
Assert.Throws<NotSupportedException>(() => selector.Select(property));
}
public void Can_create_unique_index_from_properties()
{
var entityType = new EntityType("E");
var property1 = entityType.AddProperty(Customer.IdProperty);
var property2 = entityType.AddProperty(Customer.NameProperty);
var index = new Index(new[] { property1, property2 }) { IsUnique = true, };
Assert.True(new[] { property1, property2 }.SequenceEqual(index.Properties));
Assert.True(index.IsUnique);
}
public void Validates_properties_from_same_entity()
{
var entityType = new EntityType("E");
var property1 = entityType.AddProperty(Customer.IdProperty);
var property2 = entityType.AddProperty(Customer.NameProperty);
property1.EntityType = new EntityType("E1");
property2.EntityType = new EntityType("E2");
Assert.Equal(Strings.FormatInconsistentEntityType("properties"),
Assert.Throws<ArgumentException>(
() => new Key(new[] { property1, property2 })).Message);
}
public void Reader_contains_nulls_for_unmatched_properties()
{
var entityType = new EntityType("TestType");
entityType.AddProperty("Prop1", typeof(string));
entityType.AddProperty("Prop2", typeof(int));
var buffer = new AtsNamedValueBuffer(new Dictionary<string, EntityProperty>());
var reader = _factory.Create(entityType, buffer);
Assert.Equal(2, reader.Count);
Assert.True(reader.IsNull(0));
Assert.True(reader.IsNull(1));
Assert.DoesNotThrow(() => reader.ReadValue<string>(0));
}
public void It_adds_composite_key()
{
var entityType = new EntityType("John Maynard");
entityType.AddProperty("PartitionKey", typeof(string));
entityType.AddProperty("RowKey", typeof(string));
_convention.Apply(entityType);
var key = entityType.GetKey();
Assert.Equal(2, key.Properties.Count);
Assert.Contains("PartitionKey", key.Properties.Select(p => p.ColumnName()));
Assert.Contains("RowKey", key.Properties.Select(p => p.ColumnName()));
}
public void Can_add_and_remove_properties()
{
var entityType = new EntityType(typeof(Customer));
var property1 = entityType.AddProperty(Customer.IdProperty);
var property2 = entityType.AddProperty(Customer.NameProperty);
Assert.True(new[] { property1, property2 }.SequenceEqual(entityType.Properties));
entityType.RemoveProperty(property1);
Assert.True(new[] { property2 }.SequenceEqual(entityType.Properties));
}
public void Can_create_materializer_for_entity_with_fields()
{
var entityType = new EntityType(typeof(SomeEntityWithFields));
entityType.AddProperty("Id", typeof(int));
entityType.AddProperty("Foo", typeof(string));
entityType.AddProperty("Goo", typeof(Guid));
var factory = new EntityMaterializerSource(new MemberMapper(new FieldMatcher())).GetMaterializer(entityType);
var gu = Guid.NewGuid();
var entity = (SomeEntityWithFields)factory(new ObjectArrayValueReader(new object[] { "Fu", gu, 77 }));
Assert.Equal(77, entity.Id);
Assert.Equal("Fu", entity.Foo);
Assert.Equal(gu, entity.Goo);
}
public void Members_check_arguments()
{
Assert.Equal(
"type",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => new EntityType((Type)null)).ParamName);
Assert.Equal(
"name",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => new EntityType((string)null)).ParamName);
var entityType = new EntityType(typeof(Random));
Assert.Equal(
"propertyInfo",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => entityType.AddProperty((PropertyInfo)null)).ParamName);
Assert.Equal(
"property",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => entityType.RemoveProperty(null)).ParamName);
Assert.Equal(
Strings.FormatArgumentIsEmpty("name"),
Assert.Throws<ArgumentException>(() => entityType.TryGetProperty("")).Message);
Assert.Equal(
Strings.FormatArgumentIsEmpty("name"),
Assert.Throws<ArgumentException>(() => entityType.GetProperty("")).Message);
}
public void Delegate_getter_is_returned_for_IProperty_property()
{
var entityType = new EntityType(typeof(Customer));
var idProperty = entityType.AddProperty("Id", typeof(int));
Assert.Equal(7, new ClrPropertyGetterSource().GetAccessor(idProperty).GetClrValue(new Customer { Id = 7 }));
}
public void Can_lookup_by_storage_name()
{
var entityType = new EntityType("Customer");
var property = entityType.AddProperty("Name", typeof(string));
property.SetColumnName("FirstName");
Assert.Equal(property, entityType.GetPropertyByColumnName("FirstName"));
Assert.Equal(property, entityType.TryGetPropertyByColumnName("FirstName"));
}
public virtual void Apply(EntityType entityType)
{
var etag = entityType.TryGetProperty("ETag");
if (etag == null)
{
entityType.AddProperty("ETag", typeof(string), true, true);
}
}
public void M_underscore_matching_field_is_not_used_if_type_is_not_compatible()
{
var entityType = new EntityType(typeof(TheDarkSideOfTheMoon));
var property = entityType.AddProperty("SpeakToMe", typeof(int));
var propertyInfo = entityType.Type.GetAnyProperty("SpeakToMe");
var fields = propertyInfo.DeclaringType.GetRuntimeFields().ToDictionary(f => f.Name);
Assert.Null(new FieldMatcher().TryMatchFieldName(property, propertyInfo, fields));
}
public void Can_create_foreign_key()
{
var entityType = new EntityType("E");
var dependentProp = entityType.AddProperty("P", typeof(int));
var principalProp = entityType.AddProperty("Id", typeof(int));
entityType.SetKey(principalProp);
var foreignKey
= new ForeignKey(entityType.GetKey(), new[] { dependentProp })
{
IsUnique = true,
};
Assert.Same(entityType, foreignKey.ReferencedEntityType);
Assert.Same(principalProp, foreignKey.ReferencedProperties.Single());
Assert.Same(dependentProp, foreignKey.Properties.Single());
Assert.True(foreignKey.IsUnique);
}
public void Get_generation_property_returns_null_for_property_without_generator()
{
var model = new Model();
var entityType = new EntityType("Entity", model);
var property = entityType.AddProperty("Property", typeof(int), true);
Assert.Null(property.GetGenerationProperty());
}
public void It_requires_both_properties(string onlyProp)
{
var entityType = new EntityType("John Maynard");
entityType.AddProperty(onlyProp, typeof(string));
_convention.Apply(entityType);
Assert.Equal(1, entityType.Properties.Count);
Assert.Null(entityType.TryGetKey());
}
private static Property CreateProperty(Type propertyType, ValueGenerationOnAdd valueGeneration)
{
var entityType = new EntityType("MyType");
var property = entityType.AddProperty("MyProperty", propertyType);
property.ValueGenerationOnAdd = valueGeneration;
new Model().AddEntityType(entityType);
return property;
}
protected override Model BuildModel()
{
var model = new Model();
var entityType1 = new EntityType("SomeEntity");
model.AddEntityType(entityType1);
var key1 = entityType1.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false);
key1.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
key1.ValueGenerationOnAdd = ValueGenerationOnAdd.Client;
entityType1.SetKey(key1);
entityType1.AddProperty("Name", typeof(string), shadowProperty: true, concurrencyToken: true);
var entityType2 = new EntityType("SomeDependentEntity");
model.AddEntityType(entityType2);
var key2a = entityType2.AddProperty("Id1", typeof(int), shadowProperty: true, concurrencyToken: false);
var key2b = entityType2.AddProperty("Id2", typeof(string), shadowProperty: true, concurrencyToken: false);
entityType2.SetKey(key2a, key2b);
var fk = entityType2.AddProperty("SomeEntityId", typeof(int), shadowProperty: true, concurrencyToken: false);
entityType2.AddForeignKey(entityType1.GetKey(), new[] { fk });
var justAProperty = entityType2.AddProperty("JustAProperty", typeof(int), shadowProperty: true, concurrencyToken: false);
justAProperty.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
justAProperty.ValueGenerationOnAdd = ValueGenerationOnAdd.Client;
var entityType3 = new EntityType(typeof(FullNotificationEntity));
model.AddEntityType(entityType3);
entityType3.SetKey(entityType3.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
entityType3.AddProperty("Name", typeof(string), shadowProperty: true, concurrencyToken: true);
var entityType4 = new EntityType(typeof(ChangedOnlyEntity));
model.AddEntityType(entityType4);
entityType4.SetKey(entityType4.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
entityType4.AddProperty("Name", typeof(string), shadowProperty: true, concurrencyToken: true);
var entityType5 = new EntityType("SomeMoreDependentEntity");
model.AddEntityType(entityType5);
var key5 = entityType5.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false);
entityType5.SetKey(key5);
var fk5a = entityType5.AddProperty("Fk1", typeof(int), shadowProperty: true, concurrencyToken: false);
var fk5b = entityType5.AddProperty("Fk2", typeof(string), shadowProperty: true, concurrencyToken: false);
entityType5.AddForeignKey(entityType2.GetKey(), new[] { fk5a, fk5b });
return model;
}
public void Select_throws_when_non_integer_column_key()
{
var selector = CreateSelector();
var entityType = new EntityType("Entity");
var property = entityType.AddProperty("Id", typeof(int));
property.ValueGenerationOnAdd = ValueGenerationOnAdd.Client;
entityType.SetKey(property);
Assert.Throws<NotSupportedException>(() => selector.Select(property));
}
public void Select_returns_null_when_ValueGenerationOnAdd_is_not_Client()
{
var entityType = new EntityType("Entity");
var property = entityType.AddProperty("Id", typeof(long));
entityType.SetKey(property);
var result = CreateSelector().Select(property);
Assert.Null(result);
}
public void Lookup_by_storage_name_returns_null()
{
var entityType = new EntityType("Customer");
entityType.AddProperty("Name", typeof(string));
Assert.Equal(
Strings.FormatPropertyWithStorageNameNotFound("FirstName", "Customer"),
Assert.Throws<ModelItemNotFoundException>(() => entityType.GetPropertyByColumnName("FirstName")).Message);
Assert.Null(entityType.TryGetPropertyByColumnName("FirstName"));
}
public static EntityType EntityType()
{
var entityType =
new EntityType(typeof(PocoTestType));
foreach (var property in typeof(PocoTestType).GetProperties())
{
entityType.AddProperty(property);
}
return entityType;
}
public void Throws_if_no_match_found_and_no_property_setter()
{
var entityType = new EntityType(typeof(TheDarkSide));
entityType.AddProperty("Time", typeof(string));
Assert.Equal(
Strings.FormatNoFieldOrSetter("TheDarkSide", "Time"),
Assert.Throws<InvalidOperationException>(
() => new MemberMapper(new FieldMatcher()).MapPropertiesToMembers(entityType)).Message);
}
public IEntityType GetEntityType(Type type)
{
var entityType = new EntityType(type);
var efEntityType = _model.GetEntityType(type);
foreach (var prop in efEntityType.Properties)
{
var property = new Property(entityType, prop.Name, prop.PropertyType)
{
IsNullable = prop.IsNullable,
IsReadOnly = prop.IsReadOnly
};
entityType.AddProperty(property);
}
return(entityType);
}
public void It_gets_value_by_storage_name()
{
var entityType = new EntityType("TestType");
var property = entityType.AddProperty("ClrName", typeof(object));
property.SetColumnName("StorageName");
var data = new Dictionary <string, EntityProperty>
{
{ "StorageName", new EntityProperty(3987) },
{ "ClrName", new EntityProperty(0) },
};
var buffer = new AtsNamedValueBuffer(data);
var reader = _factory.Create(entityType, buffer);
Assert.Equal(1, reader.Count);
Assert.Equal(3987, reader.ReadValue <int>(0));
}
public void Entry_subscribes_to_INotifyPropertyChanging_and_INotifyPropertyChanged()
{
var entityType = new EntityType(typeof(FullNotificationEntity));
var property = entityType.AddProperty("Name", typeof(string));
var entity = new FullNotificationEntity();
var entryMock = new Mock <StateEntry>();
entryMock.Setup(m => m.EntityType).Returns(entityType);
entryMock.Setup(m => m.Entity).Returns(entity);
new StateEntrySubscriber().SnapshotAndSubscribe(entryMock.Object);
entity.Name = "George";
entryMock.Verify(m => m.PropertyChanging(property));
entryMock.Verify(m => m.PropertyChanged(property));
}
public void Every_eventId_has_a_logger_method_and_logs_when_level_enabled()
{
var propertyInfo = typeof(DateTime).GetTypeInfo().GetDeclaredProperty(nameof(DateTime.Now));
var entityType = new EntityType(typeof(object), new Model(new ConventionSet()), ConfigurationSource.Convention);
var property = new Property("A", typeof(int), propertyInfo, null, entityType, ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherEntityType = new EntityType(typeof(object), entityType.Model, ConfigurationSource.Convention);
var otherProperty = otherEntityType.AddProperty("A", typeof(int), ConfigurationSource.Convention);
var otherKey = otherEntityType.AddKey(otherProperty, ConfigurationSource.Convention);
var foreignKey = new ForeignKey(new[] { property }, otherKey, entityType, otherEntityType, ConfigurationSource.Convention);
var navigation = new Navigation("N", propertyInfo, null, foreignKey);
var queryModel = new QueryModel(new MainFromClause("A", typeof(object), Expression.Constant("A")), new SelectClause(Expression.Constant("A")));
var includeResultOperator = new IncludeResultOperator(new[] { "Foo" }, Expression.Constant("A"));
var options = new DbContextOptionsBuilder().UseInMemoryDatabase("D").Options;
var fakeFactories = new Dictionary <Type, Func <object> >
{
{ typeof(Type), () => typeof(object) },
{ typeof(DbContext), () => new DbContext(options) },
{ typeof(DbContextOptions), () => options },
{ typeof(QueryModel), () => queryModel },
{ typeof(string), () => "Fake" },
{ typeof(IExpressionPrinter), () => new ExpressionPrinter() },
{ typeof(Expression), () => Expression.Constant("A") },
{ typeof(IEntityType), () => entityType },
{ typeof(IKey), () => new Key(new[] { property }, ConfigurationSource.Convention) },
{ typeof(IPropertyBase), () => property },
{ typeof(IServiceProvider), () => new FakeServiceProvider() },
{ typeof(ICollection <IServiceProvider>), () => new List <IServiceProvider>() },
{ typeof(IReadOnlyList <IPropertyBase>), () => new[] { property } },
{ typeof(IEnumerable <Tuple <MemberInfo, Type> >), () => new[] { new Tuple <MemberInfo, Type>(propertyInfo, typeof(object)) } },
{ typeof(MemberInfo), () => propertyInfo },
{ typeof(IncludeResultOperator), () => includeResultOperator },
{ typeof(IReadOnlyList <Exception>), () => new[] { new Exception() } },
{ typeof(IProperty), () => property },
{ typeof(INavigation), () => navigation },
{ typeof(IForeignKey), () => foreignKey },
{ typeof(InternalEntityEntry), () => new FakeInternalEntityEntry(entityType) },
{ typeof(ISet <object>), () => new HashSet <object>() }
};
TestEventLogging(typeof(CoreEventId), typeof(CoreLoggerExtensions), fakeFactories);
}
public void Subscriptions_to_INotifyPropertyChanging_and_INotifyPropertyChanged_ignore_unmapped_properties()
{
var entityType = new EntityType(typeof(FullNotificationEntity));
entityType.AddProperty("Name", typeof(string));
var entity = new FullNotificationEntity();
var entryMock = new Mock <StateEntry>();
entryMock.Setup(m => m.EntityType).Returns(entityType);
entryMock.Setup(m => m.Entity).Returns(entity);
new StateEntrySubscriber().SnapshotAndSubscribe(entryMock.Object);
entity.NotMapped = "Formby";
entryMock.Verify(m => m.PropertyChanging(It.IsAny <IProperty>()), Times.Never);
entryMock.Verify(m => m.PropertyChanged(It.IsAny <IProperty>()), Times.Never);
}
public void FK_back_pointer_is_fixed_up_as_FK_is_added()
{
var entityType = new EntityType(typeof(Customer));
var property = entityType.AddProperty(Customer.IdProperty);
entityType.SetKey(property);
var foreignKey
= entityType.AddForeignKey(entityType.GetKey(), property);
Assert.Same(entityType, foreignKey.EntityType);
Assert.Same(entityType, property.EntityType);
entityType.RemoveForeignKey(foreignKey);
// Currently property is not removed when FK is removed
Assert.Empty(entityType.ForeignKeys);
Assert.Same(property, entityType.Properties.Single());
Assert.Same(entityType, foreignKey.EntityType); // TODO: Throw here?
Assert.Same(entityType, property.EntityType);
}
private static IModel CreateModel()
{
var model = new Metadata.Model {
StorageName = "MyDatabase"
};
var dependentEntityType = new EntityType("Dependent")
{
StorageName = "dbo.MyTable0"
};
var principalEntityType = new EntityType("Principal")
{
StorageName = "dbo.MyTable1"
};
var dependentProperty = dependentEntityType.AddProperty("Id", typeof(int));
var principalProperty = principalEntityType.AddProperty("Id", typeof(int));
principalProperty.ValueGenerationStrategy = ValueGenerationStrategy.StoreIdentity;
model.AddEntityType(principalEntityType);
model.AddEntityType(dependentEntityType);
principalProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentEntityType.SetKey(dependentProperty);
principalEntityType.SetKey(principalProperty);
dependentEntityType.GetKey().StorageName = "MyPK0";
principalEntityType.GetKey().StorageName = "MyPK1";
var foreignKey = dependentEntityType.AddForeignKey(principalEntityType.GetKey(), dependentProperty);
foreignKey.StorageName = "MyFK";
foreignKey.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.CascadeDelete, "True"));
return(model);
}
public void Get_generation_property_returns_generation_property_from_foreign_key_chain()
{
var model = new Model();
var firstType = new EntityType("First", model);
var firstProperty = firstType.AddProperty("ID", typeof(int), true);
var firstKey = firstType.AddKey(firstProperty);
var secondType = new EntityType("Second", model);
var secondProperty = secondType.AddProperty("ID", typeof(int), true);
var secondKey = secondType.AddKey(secondProperty);
var secondForeignKey = secondType.AddForeignKey(secondProperty, firstKey);
var thirdType = new EntityType("Third", model);
var thirdProperty = thirdType.AddProperty("ID", typeof(int), true);
var thirdForeignKey = thirdType.AddForeignKey(thirdProperty, secondKey);
firstProperty.GenerateValueOnAdd = true;
Assert.Equal(firstProperty, thirdProperty.GetGenerationProperty());
}
public void Generate_model_snapshot_class()
{
var model = new Model();
var entityType = new EntityType("Entity");
entityType.SetKey(entityType.AddProperty("Id", typeof(int)));
model.AddEntityType(entityType);
var stringBuilder = new IndentedStringBuilder();
new CSharpModelCodeGenerator().GenerateModelSnapshotClass("MyNamespace", "MyClass", model, stringBuilder);
Assert.Equal(
@"using Microsoft.Data.Entity.Metadata;
using Microsoft.Data.Entity.Migrations.Infrastructure;
using System;
namespace MyNamespace
{
public class MyClass : ModelSnapshot
{
public override IModel Model
{
get
{
var builder = new ModelBuilder();
builder.Entity(""Entity"", b =>
{
b.Property<int>(""Id"");
b.Key(""Id"");
});
return builder.Model;
}
}
}
}",
stringBuilder.ToString());
}
private static IModel CreateModelWithForeignKeys()
{
var model = new Model();
var houseType = new EntityType("Ho!use[]");
var houseId = houseType.AddProperty("Id", typeof(int));
houseType.SetKey(houseId);
model.AddEntityType(houseType);
var customerType = new EntityType(@"Customer");
var customerId = customerType.AddProperty("Id", typeof(int));
var customerFkProperty = customerType.AddProperty("HouseId", typeof(int));
customerFkProperty.SetColumnName(@"House[""Id]Column");
customerType.SetSchema("dbo");
customerType.SetTableName(@"Cus[""om.er]s");
customerType.SetKey(customerId);
customerType.GetKey().SetKeyName(@"My[""PK]");
customerType.GetKey().Annotations.Add(new Annotation(@"My""PK""Annotat!on", @"""Foo"""));
var customerFk = customerType.AddForeignKey(houseType.GetKey(), customerFkProperty);
customerFk.SetKeyName(@"My_[""FK]");
customerFk.Annotations.Add(new Annotation(@"My""FK""Annotation", @"""Bar"""));
model.AddEntityType(customerType);
var orderType = new EntityType(@"Order");
var orderId = orderType.AddProperty(@"OrderId", typeof(int));
var orderFK = orderType.AddProperty(@"CustomerId", typeof(int));
orderType.SetSchema("dbo");
orderType.SetKey(orderId);
orderType.SetTableName(@"Ord[""e.r]s");
orderType.AddForeignKey(customerType.GetKey(), orderFK);
orderType.Annotations.Add(new Annotation("Random annotation", "42"));
model.AddEntityType(orderType);
return(model);
}
public void Every_eventId_has_a_logger_method_and_logs_when_level_enabled()
{
var propertyInfo = typeof(DateTime).GetTypeInfo().GetDeclaredProperty(nameof(DateTime.Now));
var entityType = new Model().AddEntityType(typeof(object), ConfigurationSource.Convention);
var property = entityType.AddProperty("A", typeof(int), ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherEntityType = new EntityType(typeof(object), entityType.Model, ConfigurationSource.Convention);
var otherProperty = otherEntityType.AddProperty(
"A", typeof(int), ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherKey = otherEntityType.AddKey(otherProperty, ConfigurationSource.Convention);
var foreignKey = new ForeignKey(new[] { property }, otherKey, entityType, otherEntityType, ConfigurationSource.Convention);
var navigation = new Navigation("N", propertyInfo, null, foreignKey);
var skipNavigation = new SkipNavigation(
"SN", propertyInfo, null, entityType, otherEntityType, true, false, ConfigurationSource.Convention);
var navigationBase = new FakeNavigationBase("FNB", ConfigurationSource.Convention, entityType);
entityType.Model.FinalizeModel();
var options = new DbContextOptionsBuilder()
.UseInternalServiceProvider(InMemoryFixture.DefaultServiceProvider)
.UseInMemoryDatabase("D").Options;
var fakeFactories = new Dictionary <Type, Func <object> >
{
{ typeof(Type), () => typeof(object) },
private static Model BuildModel()
{
var model = new Model();
var entityType = new EntityType(typeof(Banana));
var property1 = entityType.AddProperty("P1", typeof(int));
var property2 = entityType.AddProperty("P2", typeof(string));
var property3 = entityType.AddProperty("P3", typeof(Random));
var property4 = entityType.AddProperty("P4", typeof(int));
var property5 = entityType.AddProperty("P5", typeof(string));
var property6 = entityType.AddProperty("P6", typeof(Random));
entityType.SetKey(property1, property2, property3);
entityType.AddForeignKey(entityType.GetKey(), property6, property4, property5);
model.AddEntityType(entityType);
return(model);
}
public void Can_create_materializer_for_entity_ignoring_shadow_fields()
{
var entityType = new EntityType(typeof(SomeEntity));
entityType.AddProperty("Id", typeof(int));
entityType.AddProperty("IdShadow", typeof(int), shadowProperty: true, concurrencyToken: false);
entityType.AddProperty("Foo", typeof(string));
entityType.AddProperty("FooShadow", typeof(string), shadowProperty: true, concurrencyToken: false);
entityType.AddProperty("Goo", typeof(Guid));
entityType.AddProperty("GooShadow", typeof(Guid), shadowProperty: true, concurrencyToken: false);
var factory = new EntityMaterializerSource(new MemberMapper(new FieldMatcher())).GetMaterializer(entityType);
var gu = Guid.NewGuid();
var entity = (SomeEntity)factory(new ObjectArrayValueReader(new object[] { "Fu", "FuS", gu, Guid.NewGuid(), 77, 777 }));
Assert.Equal(77, entity.Id);
Assert.Equal("Fu", entity.Foo);
Assert.Equal(gu, entity.Goo);
}
public virtual ForeignKey CreateForeignKey(
[NotNull] EntityType principalType,
[NotNull] EntityType dependentType,
[CanBeNull] string navigationToPrincipal,
[CanBeNull] IReadOnlyList <Property> foreignKeyProperties,
[CanBeNull] IReadOnlyList <Property> referencedProperties,
bool?isUnique)
{
foreignKeyProperties = foreignKeyProperties ?? ImmutableList <Property> .Empty;
if (foreignKeyProperties.Any() &&
dependentType.TryGetForeignKey(foreignKeyProperties) != null)
{
return(null);
}
Key principalKey;
if (referencedProperties != null &&
referencedProperties.Any())
{
// TODO: Use ConfigurationSource
principalKey = principalType.GetOrAddKey(referencedProperties);
}
else
{
// Use the primary key if it is compatible with the FK properties, otherwise return null
principalKey = principalType.TryGetPrimaryKey();
if (principalKey == null ||
(foreignKeyProperties.Any() &&
!principalKey.Properties.Select(p => p.UnderlyingType).SequenceEqual(foreignKeyProperties.Select(p => p.UnderlyingType))))
{
return(null);
}
}
// Create foreign key properties in shadow state if no properties are specified
if (!foreignKeyProperties.Any())
{
var baseName = (string.IsNullOrEmpty(navigationToPrincipal) ? principalType.SimpleName : navigationToPrincipal) + "Id";
var isComposite = principalKey.Properties.Count > 1;
var fkProperties = new List <Property>();
var index = 0;
foreach (var keyProperty in principalKey.Properties)
{
string name;
do
{
name = baseName + (isComposite || index > 0 ? index.ToString() : "");
index++;
}while (dependentType.TryGetProperty(name) != null);
fkProperties.Add(dependentType.AddProperty(name, keyProperty.PropertyType.MakeNullable(), shadowProperty: true));
}
foreignKeyProperties = fkProperties;
}
var newForeignKey = dependentType.AddForeignKey(foreignKeyProperties, principalKey);
newForeignKey.IsUnique = isUnique;
return(newForeignKey);
}
public void SetPrimaryKey(EntityType entityType)
{
var property = entityType.AddProperty("Id", typeof(int));
entityType.SetPrimaryKey(property);
}
protected override void InvokeInternal(CommandProcessorContext cpc)
{
// safety check, this should never be hit
Debug.Assert(EntityType != null, "InvokeInternal is called when EntityType is null.");
if (EntityType == null)
{
throw new InvalidOperationException("InvokeInternal is called when EntityType is null");
}
// check for uniqueness
string msg;
if (!ModelHelper.ValidateEntityPropertyName(EntityType, Name, true, out msg))
{
throw new CommandValidationFailedException(msg);
}
// create the property
_createdProperty = new ComplexConceptualProperty(EntityType, null, _insertPosition);
// set the name and add to the parent entity
_createdProperty.LocalName.Value = Name;
if (ComplexType != null)
{
_createdProperty.ComplexType.SetRefName(ComplexType);
}
else if (!String.IsNullOrEmpty(_typeName))
{
// separate this name into the namespace and name parts
string typeNamespace;
string typeLocalName;
EFNormalizableItemDefaults.SeparateRefNameIntoParts(_typeName, out typeNamespace, out typeLocalName);
// look to see if the referenced complex type exists (it may not if they are pasting across models)
// just search on local name since two models will have different namespaces probably
ComplexType type = null;
var cem = EntityType.EntityModel as ConceptualEntityModel;
foreach (var c in cem.ComplexTypes())
{
if (string.Compare(typeLocalName, c.LocalName.Value, StringComparison.CurrentCultureIgnoreCase) == 0)
{
type = c;
break;
}
}
// set the complex type reference
if (type == null)
{
// if we didn't find the complex type locally, write out the type name - but for the local namespace
// this will let the user subsequently copy the complex type and this property will start working again
var typeSymbol = new Symbol(cem.Namespace.Value, typeLocalName);
_createdProperty.ComplexType.SetXAttributeValue(typeSymbol.ToDisplayString());
}
else
{
_createdProperty.ComplexType.SetRefName(type);
}
}
else
{
_createdProperty.ComplexType.SetXAttributeValue(Resources.ComplexPropertyUndefinedType);
}
// runtime does not support nullable complex properties, need to set it to false since the default is true
_createdProperty.Nullable.Value = BoolOrNone.FalseValue;
EntityType.AddProperty(_createdProperty);
XmlModelHelper.NormalizeAndResolve(_createdProperty);
}
public void Compare_returns_0_only_for_commands_that_are_equal()
{
var mCC = new ModificationCommandComparer();
var configuration = new DbContext(new DbContextOptions().UseInMemoryStore(persist: false)).Configuration;
var entityType1 = new EntityType(typeof(object));
var key1 = entityType1.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false);
entityType1.SetKey(key1);
var stateEntry1 = new MixedStateEntry(configuration, entityType1, new object());
stateEntry1[key1] = 0;
stateEntry1.EntityState = EntityState.Added;
var modificationCommandAdded = new ModificationCommand(new SchemaQualifiedName("A"), new ParameterNameGenerator());
modificationCommandAdded.AddStateEntry(stateEntry1);
var entityType2 = new EntityType(typeof(object));
var key2 = entityType2.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false);
entityType2.SetKey(key2);
var stateEntry2 = new MixedStateEntry(configuration, entityType2, new object());
stateEntry2[key2] = 0;
stateEntry2.EntityState = EntityState.Modified;
var modificationCommandModified = new ModificationCommand(new SchemaQualifiedName("A"), new ParameterNameGenerator());
modificationCommandModified.AddStateEntry(stateEntry2);
var entityType3 = new EntityType(typeof(object));
var key3 = entityType3.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false);
entityType3.SetKey(key3);
var stateEntry3 = new MixedStateEntry(configuration, entityType3, new object());
stateEntry3[key3] = 0;
stateEntry3.EntityState = EntityState.Deleted;
var modificationCommandDeleted = new ModificationCommand(new SchemaQualifiedName("A"), new ParameterNameGenerator());
modificationCommandDeleted.AddStateEntry(stateEntry3);
Assert.True(0 == mCC.Compare(modificationCommandAdded, modificationCommandAdded));
Assert.True(0 == mCC.Compare(null, null));
Assert.True(0 == mCC.Compare(
new ModificationCommand(new SchemaQualifiedName("A", "dbo"), new ParameterNameGenerator()),
new ModificationCommand(new SchemaQualifiedName("A", "dbo"), new ParameterNameGenerator())));
Assert.True(0 > mCC.Compare(null, new ModificationCommand(new SchemaQualifiedName("A"), new ParameterNameGenerator())));
Assert.True(0 < mCC.Compare(new ModificationCommand(new SchemaQualifiedName("A"), new ParameterNameGenerator()), null));
Assert.True(0 > mCC.Compare(
new ModificationCommand(new SchemaQualifiedName("A"), new ParameterNameGenerator()),
new ModificationCommand(new SchemaQualifiedName("A", "dbo"), new ParameterNameGenerator())));
Assert.True(0 < mCC.Compare(
new ModificationCommand(new SchemaQualifiedName("A", "dbo"), new ParameterNameGenerator()),
new ModificationCommand(new SchemaQualifiedName("A"), new ParameterNameGenerator())));
Assert.True(0 > mCC.Compare(
new ModificationCommand(new SchemaQualifiedName("A", "dbo"), new ParameterNameGenerator()),
new ModificationCommand(new SchemaQualifiedName("A", "foo"), new ParameterNameGenerator())));
Assert.True(0 < mCC.Compare(
new ModificationCommand(new SchemaQualifiedName("A", "foo"), new ParameterNameGenerator()),
new ModificationCommand(new SchemaQualifiedName("A", "dbo"), new ParameterNameGenerator())));
Assert.True(0 > mCC.Compare(
new ModificationCommand(new SchemaQualifiedName("A"), new ParameterNameGenerator()),
new ModificationCommand(new SchemaQualifiedName("B"), new ParameterNameGenerator())));
Assert.True(0 < mCC.Compare(
new ModificationCommand(new SchemaQualifiedName("B"), new ParameterNameGenerator()),
new ModificationCommand(new SchemaQualifiedName("A"), new ParameterNameGenerator())));
Assert.True(0 > mCC.Compare(modificationCommandModified, modificationCommandAdded));
Assert.True(0 < mCC.Compare(modificationCommandAdded, modificationCommandModified));
Assert.True(0 > mCC.Compare(modificationCommandDeleted, modificationCommandAdded));
Assert.True(0 < mCC.Compare(modificationCommandAdded, modificationCommandDeleted));
Assert.True(0 > mCC.Compare(modificationCommandDeleted, modificationCommandModified));
Assert.True(0 < mCC.Compare(modificationCommandModified, modificationCommandDeleted));
}
private static Property CreateProperty(Type propertyType)
{
var entityType = new EntityType("MyType");
return(entityType.AddProperty("MyProperty", propertyType));
}
private static Property CreateProperty()
{
var entityType = new EntityType("Led");
return(entityType.AddProperty("Zeppelin", typeof(int)));
}
public async Task Can_add_update_delete_end_to_end_using_only_shadow_state()
{
var model = new Model();
var customerType = new EntityType("Customer");
customerType.SetKey(customerType.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
customerType.AddProperty("Name", typeof(string), shadowProperty: true, concurrencyToken: false);
model.AddEntityType(customerType);
var configuration = new DbContextOptions()
.UseModel(model)
.UseInMemoryStore()
.BuildConfiguration();
using (var context = new DbContext(configuration))
{
// TODO: Better API for shadow state access
var customerEntry = context.ChangeTracker.StateManager.CreateNewEntry(customerType);
customerEntry[customerType.GetProperty("Id")] = 42;
customerEntry[customerType.GetProperty("Name")] = "Daenerys";
await customerEntry.SetEntityStateAsync(EntityState.Added);
await context.SaveChangesAsync();
customerEntry[customerType.GetProperty("Name")] = "Changed!";
}
// TODO: Fix this when we can query shadow entities
// var customerFromStore = await inMemoryDataStore.Read(customerType).SingleAsync();
//
// Assert.Equal(new object[] { 42, "Daenerys" }, customerFromStore);
using (var context = new DbContext(configuration))
{
var customerEntry = context.ChangeTracker.StateManager.CreateNewEntry(customerType);
customerEntry[customerType.GetProperty("Id")] = 42;
customerEntry[customerType.GetProperty("Name")] = "Daenerys Targaryen";
await customerEntry.SetEntityStateAsync(EntityState.Modified);
await context.SaveChangesAsync();
}
// TODO: Fix this when we can query shadow entities
// customerFromStore = await inMemoryDataStore.Read(customerType).SingleAsync();
//
// Assert.Equal(new object[] { 42, "Daenerys Targaryen" }, customerFromStore);
using (var context = new DbContext(configuration))
{
var customerEntry = context.ChangeTracker.StateManager.CreateNewEntry(customerType);
customerEntry[customerType.GetProperty("Id")] = 42;
await customerEntry.SetEntityStateAsync(EntityState.Deleted);
await context.SaveChangesAsync();
}
// TODO: Fix this when we can query shadow entities
// Assert.Equal(0, await inMemoryDataStore.Read(customerType).CountAsync());
}
public void Every_eventId_has_a_logger_method_and_logs_when_level_enabled()
{
var propertyInfo = typeof(DateTime).GetTypeInfo().GetDeclaredProperty(nameof(DateTime.Now));
var entityType = new Model().AddEntityType(typeof(object), ConfigurationSource.Convention);
var property = entityType.AddProperty("A", typeof(int), ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherEntityType = new EntityType(typeof(object), entityType.Model, ConfigurationSource.Convention);
var otherProperty = otherEntityType.AddProperty(
"A", typeof(int), ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherKey = otherEntityType.AddKey(otherProperty, ConfigurationSource.Convention);
var foreignKey = new ForeignKey(new[] { property }, otherKey, entityType, otherEntityType, ConfigurationSource.Convention);
var navigation = new Navigation("N", propertyInfo, null, foreignKey);
var skipNavigation = new SkipNavigation(
"SN", propertyInfo, null, entityType, otherEntityType, true, false, ConfigurationSource.Convention);
var navigationBase = new FakeNavigationBase("FNB", ConfigurationSource.Convention, entityType);
entityType.Model.FinalizeModel();
var options = new DbContextOptionsBuilder()
.UseInternalServiceProvider(InMemoryFixture.DefaultServiceProvider)
.UseInMemoryDatabase("D").Options;
var fakeFactories = new Dictionary <Type, Func <object> >
{
{ typeof(Type), () => typeof(object) },
{ typeof(DbContext), () => new DbContext(options) },
{ typeof(DbContextOptions), () => options },
{ typeof(string), () => "Fake" },
{ typeof(ExpressionPrinter), () => new ExpressionPrinter() },
{ typeof(Expression), () => Expression.Constant("A") },
{ typeof(IEntityType), () => entityType },
{ typeof(IReadOnlyEntityType), () => entityType },
{ typeof(IConventionEntityType), () => entityType },
{ typeof(IKey), () => new Key(new[] { property }, ConfigurationSource.Convention) },
{ typeof(IPropertyBase), () => property },
{ typeof(IReadOnlyProperty), () => property },
{ typeof(IServiceProvider), () => new FakeServiceProvider() },
{ typeof(ICollection <IServiceProvider>), () => new List <IServiceProvider>() },
{ typeof(IReadOnlyList <IPropertyBase>), () => new[] { property } },
{ typeof(IReadOnlyList <IReadOnlyPropertyBase>), () => new[] { property } },
{
typeof(IEnumerable <Tuple <MemberInfo, Type> >),
() => new[] { new Tuple <MemberInfo, Type>(propertyInfo, typeof(object)) }
},
{ typeof(MemberInfo), () => propertyInfo },
{ typeof(IReadOnlyList <Exception>), () => new[] { new Exception() } },
{ typeof(IProperty), () => property },
{ typeof(INavigation), () => navigation },
{ typeof(IReadOnlyNavigation), () => navigation },
{ typeof(ISkipNavigation), () => skipNavigation },
{ typeof(IReadOnlySkipNavigation), () => skipNavigation },
{ typeof(INavigationBase), () => navigationBase },
{ typeof(IForeignKey), () => foreignKey },
{ typeof(IReadOnlyForeignKey), () => foreignKey },
{ typeof(InternalEntityEntry), () => new FakeInternalEntityEntry(entityType) },
{ typeof(ISet <object>), () => new HashSet <object>() },
{
typeof(IList <IDictionary <string, string> >),
() => new List <IDictionary <string, string> > {
new Dictionary <string, string> {
{ "A", "B" }
}
}
},
{ typeof(IDictionary <string, string>), () => new Dictionary <string, string>() }
};
TestEventLogging(
typeof(CoreEventId),
typeof(CoreLoggerExtensions),
typeof(TestLoggingDefinitions),
fakeFactories);
}
private static IModel BuildModel()
{
var model = new Model();
var builder = new ModelBuilder(model);
builder.Annotation("ModelAnnotation1", "ModelValue1");
builder.Annotation("ModelAnnotation2", "ModelValue2");
var entityType1 = new EntityType(typeof(KoolEntity1));
var property = entityType1.AddProperty("Id1", typeof(int));
property.StorageName = "MyKey1";
entityType1.SetKey(property);
entityType1.AddProperty("Id2", typeof(Guid)).StorageName = "MyKey2";
entityType1.AddProperty("KoolEntity2Id", typeof(int));
model.AddEntityType(entityType1);
var entityType2 = new EntityType(typeof(KoolEntity2));
entityType2.AddProperty("KoolEntity1Id1", typeof(int));
entityType2.AddProperty("KoolEntity1Id2", typeof(Guid));
entityType2.AddProperty("KoolEntity3Id", typeof(int));
model.AddEntityType(entityType2);
var entityType3 = new EntityType(typeof(KoolEntity3));
entityType3.AddProperty("KoolEntity4Id", typeof(int));
model.AddEntityType(entityType3);
var entityType4 = new EntityType(typeof(KoolEntity4));
model.AddEntityType(entityType4);
var entityType5 = new EntityType(typeof(KoolEntity5));
model.AddEntityType(entityType5);
var entityType6 = new EntityType(typeof(KoolEntity6));
entityType6.AddProperty("Kool5Id", typeof(int));
model.AddEntityType(entityType6);
for (var i = 7; i <= 20; i++)
{
var type = Type.GetType("Microsoft.Data.Entity.FunctionalTests.Metadata.KoolEntity" + i);
Assert.NotNull(type);
model.AddEntityType(new EntityType(type));
}
for (var i = 2; i <= 20; i++)
{
var type = Type.GetType("Microsoft.Data.Entity.FunctionalTests.Metadata.KoolEntity" + i);
var entityType = model.GetEntityType(type);
var id = entityType.AddProperty(entityType.Type.GetProperty("Id"));
id.StorageName = "MyKey";
entityType.SetKey(id);
}
for (var i = 1; i <= 20; i++)
{
var type = Type.GetType("Microsoft.Data.Entity.FunctionalTests.Metadata.KoolEntity" + i);
var entityType = model.GetEntityType(type);
entityType.StorageName = entityType.Name + "Table";
entityType.Annotations.Add(new Annotation("Annotation1", "Value1"));
entityType.Annotations.Add(new Annotation("Annotation2", "Value2"));
var foo = entityType.AddProperty(entityType.Type.GetProperty("Foo" + i));
foo.Annotations.Add(new Annotation("Foo" + i + "Annotation1", "Foo" + i + "Value1"));
foo.Annotations.Add(new Annotation("Foo" + i + "Annotation2", "Foo" + i + "Value2"));
var goo = entityType.AddProperty(entityType.Type.GetProperty("Goo" + i));
}
var fk11 = entityType1.AddForeignKey(entityType2.GetKey(), new[] { entityType1.GetProperty("KoolEntity2Id") });
var fk21 = entityType2.AddForeignKey(entityType1.GetKey(), new[] { entityType2.GetProperty("KoolEntity1Id1") });
var fk22 = entityType2.AddForeignKey(entityType3.GetKey(), new[] { entityType2.GetProperty("KoolEntity3Id") });
var fk31 = entityType3.AddForeignKey(entityType4.GetKey(), new[] { entityType3.GetProperty("KoolEntity4Id") });
var fk61 = entityType6.AddForeignKey(entityType5.GetKey(), new[] { entityType6.GetProperty("Kool5Id") });
entityType1.AddNavigation(new Navigation(fk11, "NavTo2"));
entityType1.AddNavigation(new Navigation(fk21, "NavTo2s"));
entityType2.AddNavigation(new Navigation(fk21, "NavTo1"));
entityType2.AddNavigation(new Navigation(fk11, "NavTo1s"));
entityType2.AddNavigation(new Navigation(fk22, "NavTo3"));
entityType3.AddNavigation(new Navigation(fk22, "NavTo2s"));
entityType3.AddNavigation(new Navigation(fk31, "NavTo4"));
entityType4.AddNavigation(new Navigation(fk31, "NavTo3s"));
entityType5.AddNavigation(new Navigation(fk61, "Kool6s"));
entityType6.AddNavigation(new Navigation(fk61, "Kool5"));
return(model);
}
public void Every_eventId_has_a_logger_method_and_logs_when_level_enabled()
{
var constantExpression = Expression.Constant("A");
var model = new Model();
var entityType = new EntityType(typeof(object), model, ConfigurationSource.Convention);
var property = entityType.AddProperty("A", typeof(int), ConfigurationSource.Convention, ConfigurationSource.Convention);
var key = entityType.AddKey(property, ConfigurationSource.Convention);
var foreignKey = new ForeignKey(new List <Property> {
property
}, key, entityType, entityType, ConfigurationSource.Convention);
var index = new Index(new List <Property> {
property
}, "IndexName", entityType, ConfigurationSource.Convention);
var contextServices = RelationalTestHelpers.Instance.CreateContextServices(model.FinalizeModel());
var fakeFactories = new Dictionary <Type, Func <object> >
{
{ typeof(string), () => "Fake" },
{ typeof(IList <string>), () => new List <string> {
"Fake1", "Fake2"
} },
{
typeof(IEnumerable <IUpdateEntry>), () => new List <IUpdateEntry>
{
new InternalClrEntityEntry(
contextServices.GetRequiredService <IStateManager>(),
entityType,
new object())
}
},
{ typeof(IRelationalConnection), () => new FakeRelationalConnection() },
{ typeof(LoggingDefinitions), () => new TestRelationalLoggingDefinitions() },
{ typeof(DbCommand), () => new FakeDbCommand() },
{ typeof(DbTransaction), () => new FakeDbTransaction() },
{ typeof(DbDataReader), () => new FakeDbDataReader() },
{ typeof(Transaction), () => new CommittableTransaction() },
{ typeof(IMigrator), () => new FakeMigrator() },
{ typeof(Migration), () => new FakeMigration() },
{ typeof(IMigrationsAssembly), () => new FakeMigrationsAssembly() },
{ typeof(MethodCallExpression), () => Expression.Call(constantExpression, typeof(object).GetMethod("ToString")) },
{ typeof(Expression), () => constantExpression },
{ typeof(IEntityType), () => entityType },
{ typeof(IProperty), () => property },
{ typeof(IKey), () => key },
{ typeof(IForeignKey), () => foreignKey },
{ typeof(IIndex), () => index },
{ typeof(TypeInfo), () => typeof(object).GetTypeInfo() },
{ typeof(Type), () => typeof(object) },
{ typeof(ValueConverter), () => new BoolToZeroOneConverter <int>() },
{ typeof(DbContext), () => new FakeDbContext() },
{ typeof(SqlExpression), () => new FakeSqlExpression() }
};
TestEventLogging(
typeof(RelationalEventId),
typeof(RelationalLoggerExtensions),
new[]
{
typeof(IRelationalConnectionDiagnosticsLogger),
typeof(IRelationalCommandDiagnosticsLogger)
},
new TestRelationalLoggingDefinitions(),
fakeFactories,
services => FakeRelationalOptionsExtension.AddEntityFrameworkRelationalDatabase(services),
new Dictionary <string, IList <string> >
{
{
nameof(RelationalEventId.CommandExecuting),
new List <string>
{
nameof(IRelationalCommandDiagnosticsLogger.CommandReaderExecuting),
nameof(IRelationalCommandDiagnosticsLogger.CommandScalarExecuting),
nameof(IRelationalCommandDiagnosticsLogger.CommandNonQueryExecuting),
nameof(IRelationalCommandDiagnosticsLogger.CommandReaderExecutingAsync),
nameof(IRelationalCommandDiagnosticsLogger.CommandScalarExecutingAsync),
nameof(IRelationalCommandDiagnosticsLogger.CommandNonQueryExecutingAsync)
}
},
{
nameof(RelationalEventId.CommandExecuted),
new List <string>
{
nameof(IRelationalCommandDiagnosticsLogger.CommandReaderExecutedAsync),
nameof(IRelationalCommandDiagnosticsLogger.CommandScalarExecutedAsync),
nameof(IRelationalCommandDiagnosticsLogger.CommandNonQueryExecutedAsync),
nameof(IRelationalCommandDiagnosticsLogger.CommandReaderExecuted),
nameof(IRelationalCommandDiagnosticsLogger.CommandScalarExecuted),
nameof(IRelationalCommandDiagnosticsLogger.CommandNonQueryExecuted)
}
}
});
}
public async Task Can_add_update_delete_end_to_end_using_partial_shadow_state()
{
var model = new Model();
var customerType = new EntityType(typeof(Customer));
customerType.SetKey(customerType.AddProperty("Id", typeof(int), shadowProperty: false, concurrencyToken: false));
customerType.AddProperty("Name", typeof(string), shadowProperty: true, concurrencyToken: false);
model.AddEntityType(customerType);
var configuration = new DbContextOptions()
.UseModel(model)
.UseInMemoryStore()
.BuildConfiguration();
var customer = new Customer {
Id = 42
};
using (var context = new DbContext(configuration))
{
context.Add(customer);
// TODO: Better API for shadow state access
var customerEntry = context.ChangeTracker.Entry(customer).StateEntry;
customerEntry[customerType.GetProperty("Name")] = "Daenerys";
await context.SaveChangesAsync();
customerEntry[customerType.GetProperty("Name")] = "Changed!";
}
using (var context = new DbContext(configuration))
{
var customerFromStore = context.Set <Customer>().Single();
Assert.Equal(42, customerFromStore.Id);
Assert.Equal(
"Daenerys",
(string)context.ChangeTracker.Entry(customerFromStore).Property("Name").CurrentValue);
}
using (var context = new DbContext(configuration))
{
var customerEntry = context.ChangeTracker.Entry(customer).StateEntry;
customerEntry[customerType.GetProperty("Name")] = "Daenerys Targaryen";
context.Update(customer);
await context.SaveChangesAsync();
}
using (var context = new DbContext(configuration))
{
var customerFromStore = context.Set <Customer>().Single();
Assert.Equal(42, customerFromStore.Id);
Assert.Equal(
"Daenerys Targaryen",
(string)context.ChangeTracker.Entry(customerFromStore).Property("Name").CurrentValue);
}
using (var context = new DbContext(configuration))
{
context.Delete(customer);
await context.SaveChangesAsync();
}
using (var context = new DbContext(configuration))
{
Assert.Equal(0, context.Set <Customer>().Count());
}
}