public void Non_generic_DbCollectionEntry_for_collection_cannot_be_converted_to_generic_version_of_derived_entity_type()
{
var memberEntry =
new DbEntityEntry <FakeWithProps>(FakeWithProps.CreateMockInternalEntityEntry().Object).Collection("Collection");
Assert.Equal(
Strings.DbMember_BadTypeForCast(
typeof(DbCollectionEntry).Name, typeof(DerivedFakeWithProps).Name, typeof(FakeEntity).Name,
typeof(FakeWithProps).Name, typeof(FakeEntity).Name),
Assert.Throws <InvalidCastException>(() => memberEntry.Cast <DerivedFakeWithProps, FakeEntity>()).Message);
}
public void Parent_PropertyEntity_can_be_obtained_from_nested_non_generic_DbComplexPropertyEntry_back_reference()
{
var mockInternalEntry = FakeWithProps.CreateMockInternalEntityEntry();
var propEntry =
new DbComplexPropertyEntry <FakeWithProps, FakeWithProps>(
new InternalEntityPropertyEntry(mockInternalEntry.Object, FakeWithProps.ComplexPropertyMetadata));
var backEntry = propEntry.Property("ValueTypeProp").ParentProperty;
Assert.Same(propEntry.Name, backEntry.Name);
}
public void Generic_DbMemberEntry_for_collection_can_be_converted_to_non_generic_version()
{
var memberEntry =
new DbEntityEntry <FakeWithProps>(FakeWithProps.CreateMockInternalEntityEntry().Object).Member <ICollection <FakeEntity> >(
"Collection");
var nonGeneric = ImplicitConvert(memberEntry);
Assert.IsType <DbCollectionEntry>(nonGeneric);
Assert.Same(memberEntry.InternalMemberEntry, nonGeneric.InternalMemberEntry);
}
public void Non_generic_DbMemberEntry_for_collection_cannot_be_converted_to_generic_version_of_base_property_type()
{
var memberEntry = new DbEntityEntry <FakeWithProps>(FakeWithProps.CreateMockInternalEntityEntry().Object).Member(
"Collection");
// This cast fails because an ICollection<FakeEntity> is not an IColletion<object>.
Assert.Equal(
Strings.DbMember_BadTypeForCast(
typeof(DbMemberEntry).Name, typeof(FakeWithProps).Name, typeof(ICollection <object>).Name, typeof(FakeWithProps).Name,
typeof(ICollection <FakeEntity>).Name),
Assert.Throws <InvalidCastException>(() => memberEntry.Cast <FakeWithProps, ICollection <object> >()).Message);
}
public void Current_value_returned_for_complex_property_is_actual_complex_object_instance()
{
var entityEntry = FakeWithProps.CreateMockInternalEntityEntry().Object;
var propEntry = new InternalEntityPropertyEntry(entityEntry, FakeWithProps.ComplexPropertyMetadata);
var entity = (FakeWithProps)entityEntry.Entity;
var value = (FakeWithProps)propEntry.CurrentValue;
Assert.Same(entity.ComplexProp, value);
Assert.Equal(12, value.ValueTypeProp);
Assert.Equal(13, value.ComplexProp.ValueTypeProp);
}
public void IsModified_can_be_set_to_true_when_it_is_currently_false()
{
var entityEntry = FakeWithProps.CreateMockInternalEntityEntry().Object;
var propEntry = new InternalEntityPropertyEntry(entityEntry, FakeWithProps.RefTypePropertyMetadata);
var mockStateEntry = Mock.Get(entityEntry.ObjectStateEntry);
Assert.False(propEntry.IsModified);
propEntry.IsModified = true;
Assert.True(propEntry.IsModified);
mockStateEntry.Verify(e => e.SetModifiedProperty("RefTypeProp"));
}
public void Current_value_returned_for_complex_property_can_be_null()
{
var properties = new Dictionary <string, object>
{
{ "ComplexProp", null }
};
var currentValues = new TestInternalPropertyValues <FakeWithProps>(properties, new[] { "ComplexProp" });
var entityEntry = FakeWithProps.CreateMockInternalEntityEntry(currentValues).Object;
var propEntry = new InternalEntityPropertyEntry(entityEntry, FakeWithProps.ComplexPropertyMetadata);
var value = propEntry.CurrentValue;
Assert.Null(value);
}
private void InternalReferenceEntry_sets_current_value_onto_entity_if_property_exists_implementation(bool isDetached)
{
var entity = new FakeWithProps
{
Reference = new FakeEntity()
};
var internalEntry = new InternalReferenceEntry(
MockHelper.CreateMockInternalEntityEntry(entity, isDetached).Object, FakeWithProps.ReferenceMetadata);
var relatedEntity = new FakeEntity();
internalEntry.CurrentValue = relatedEntity;
Assert.Same(relatedEntity, entity.Reference);
}
public void Current_value_for_complex_property_cannot_be_set_to_null_even_if_it_is_already_null()
{
var properties = new Dictionary <string, object>
{
{ "ComplexProp", null }
};
var currentValues = new TestInternalPropertyValues <FakeWithProps>(properties, new[] { "ComplexProp" });
var entityEntry = FakeWithProps.CreateMockInternalEntityEntry(currentValues).Object;
var propEntry = new InternalEntityPropertyEntry(entityEntry, FakeWithProps.ComplexPropertyMetadata);
Assert.Equal(
Strings.DbPropertyValues_ComplexObjectCannotBeNull("ComplexProp", "FakeWithProps"),
Assert.Throws <InvalidOperationException>(() => propEntry.CurrentValue = null).Message);
}
private void InternalCollectionEntry_sets_current_value_onto_entity_if_property_exists_implementation(bool isDetached)
{
var entity = new FakeWithProps
{
Collection = new List<FakeEntity>()
};
var internalEntry = new InternalCollectionEntry(
MockHelper.CreateMockInternalEntityEntry(
entity, isDetached).Object, FakeWithProps.CollectionMetadata);
var relatedCollection = new List<FakeEntity>();
internalEntry.CurrentValue = relatedCollection;
Assert.Same(relatedCollection, entity.Collection);
}
private void InternalReferenceEntry_sets_current_value_onto_entity_if_property_exists_implementation(bool isDetached)
{
var entity = new FakeWithProps
{
Reference = new FakeEntity()
};
var internalEntry = new InternalReferenceEntry(
MockHelper.CreateMockInternalEntityEntry(entity, isDetached).Object, FakeWithProps.ReferenceMetadata);
var relatedEntity = new FakeEntity();
internalEntry.CurrentValue = relatedEntity;
Assert.Same(relatedEntity, entity.Reference);
}
public void Current_value_for_complex_property_cannot_be_set_to_instance_with_nested_null_complex_property()
{
var entityEntry = FakeWithProps.CreateMockInternalEntityEntry().Object;
var propEntry = new InternalEntityPropertyEntry(entityEntry, FakeWithProps.ComplexPropertyMetadata);
var complexObject = new FakeWithProps
{
ValueTypeProp = -2,
ComplexProp = null
};
Assert.Equal(
Strings.DbPropertyValues_ComplexObjectCannotBeNull("ComplexProp", typeof(FakeWithProps).Name),
Assert.Throws <InvalidOperationException>(() => propEntry.CurrentValue = complexObject).Message);
}
private void InternalCollectionEntry_gets_current_value_from_entity_if_property_exists_implementation(bool isDetached)
{
var relatedCollection = new List <FakeEntity>();
var entity = new FakeWithProps
{
Collection = relatedCollection
};
var internalEntry = new InternalCollectionEntry(
MockHelper.CreateMockInternalEntityEntry(
entity, isDetached).Object, FakeWithProps.CollectionMetadata);
var propValue = internalEntry.CurrentValue;
Assert.Same(relatedCollection, propValue);
}
public void Generic_DbCollectionEntry_throws_OperationCanceledException_if_task_is_cancelled()
{
var entityEntry = new DbEntityEntry <FakeWithProps>(FakeWithProps.CreateMockInternalEntityEntry().Object);
var mockWrapper = new Mock <IEntityWrapper>();
mockWrapper.Setup(w => w.Entity).Returns(new object());
((RelatedEnd)entityEntry
.Reference(e => e.Reference).InternalMemberEntry.InternalEntityEntry.GetRelatedEnd("Reference"))
.SetWrappedOwner(mockWrapper.Object);
Assert.Throws <OperationCanceledException>(
() => entityEntry.Reference(e => e.Reference).LoadAsync(new CancellationToken(canceled: true))
.GetAwaiter().GetResult());
}
public void Complex_original_value_can_be_set()
{
var entityEntry = FakeWithProps.CreateMockInternalEntityEntry().Object;
var propEntry = new InternalEntityPropertyEntry(entityEntry, FakeWithProps.ComplexPropertyMetadata);
propEntry.OriginalValue = new FakeWithProps
{
ValueTypeProp = -2,
ComplexProp = new FakeWithProps
{
ValueTypeProp = -3
}
};
Assert.Equal(21, entityEntry.OriginalValues["ValueTypeProp"]);
Assert.Equal(-2, ((InternalPropertyValues)entityEntry.OriginalValues["ComplexProp"])["ValueTypeProp"]);
Assert.Equal(
-3,
((InternalPropertyValues)((InternalPropertyValues)entityEntry.OriginalValues["ComplexProp"])["ComplexProp"])[
"ValueTypeProp"]);
}
public void Current_value_for_complex_property_cannot_be_set_to_instance_with_nested_null_complex_property()
{
var entityEntry = FakeWithProps.CreateMockInternalEntityEntry().Object;
var propEntry = new InternalEntityPropertyEntry(entityEntry, FakeWithProps.ComplexPropertyMetadata);
var complexObject = new FakeWithProps
{
ValueTypeProp = -2,
ComplexProp = null
};
Assert.Equal(
Strings.DbPropertyValues_ComplexObjectCannotBeNull("ComplexProp", typeof(FakeWithProps).Name),
Assert.Throws<InvalidOperationException>(() => propEntry.CurrentValue = complexObject).Message);
}
public void Complex_current_value_can_be_set_and_the_actual_complex_object_is_set()
{
var entityEntry = FakeWithProps.CreateMockInternalEntityEntry().Object;
var propEntry = new InternalEntityPropertyEntry(entityEntry, FakeWithProps.ComplexPropertyMetadata);
var entity = (FakeWithProps)entityEntry.Entity;
var complexObject = new FakeWithProps
{
ValueTypeProp = -2,
ComplexProp = new FakeWithProps
{
ValueTypeProp = -3
}
};
propEntry.CurrentValue = complexObject;
Assert.Same(entity.ComplexProp, complexObject);
Assert.Equal(-2, entity.ComplexProp.ValueTypeProp);
Assert.Equal(-3, entity.ComplexProp.ComplexProp.ValueTypeProp);
Assert.Equal(11, entityEntry.CurrentValues["ValueTypeProp"]);
Assert.Equal(-2, ((InternalPropertyValues)entityEntry.CurrentValues["ComplexProp"])["ValueTypeProp"]);
Assert.Equal(
-3,
((InternalPropertyValues)((InternalPropertyValues)entityEntry.CurrentValues["ComplexProp"])["ComplexProp"])[
"ValueTypeProp"]);
}
