internal static TestInternalPropertyValues<FakeWithProps> CreateSimpleValues(int tag)
{
var level3Properties = new Dictionary<string, object>
{
{ "ValueTypeProp", 3 + tag },
{ "RefTypeProp", "3" + tag },
};
var level3Values = new TestInternalPropertyValues<FakeWithProps>(level3Properties);
var level2Properties = new Dictionary<string, object>
{
{ "ValueTypeProp", 2 + tag },
{ "RefTypeProp", "2" + tag },
{ "ComplexProp", level3Values },
};
var level2Values = new TestInternalPropertyValues<FakeWithProps>(level2Properties, new[] { "ComplexProp" });
var level1Properties = new Dictionary<string, object>
{
{ "ValueTypeProp", 1 + tag },
{ "RefTypeProp", "1" + tag },
{ "ComplexProp", level2Values },
};
return new TestInternalPropertyValues<FakeWithProps>(level1Properties, new[] { "ComplexProp" });
}
public void InternalPropertyValues_ToObject_for_non_entity_type_can_be_called_from_multiple_threads()
{
ExecuteInParallel(
() =>
{
var values = new TestInternalPropertyValues <DbPropertyValuesTests.FakeTypeWithProps>(null, isEntityValues: true);
values.MockInternalContext.Setup(c => c.CreateObject(typeof(DbPropertyValuesTests.FakeTypeWithProps))).Returns(
new DbPropertyValuesTests.FakeDerivedTypeWithProps());
var clone = values.ToObject();
Assert.IsType <DbPropertyValuesTests.FakeDerivedTypeWithProps>(clone);
});
}
public void ToObject_can_set_reference_propeties_to_null()
{
var properties = new Dictionary<string, object>
{
{ "PublicNonNullStringProp", null }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
var clone = (FakeTypeWithProps)values.ToObject();
Assert.Null(clone.PublicNonNullStringProp);
}
public void Clone_for_an_entity_returns_a_new_dictionary_that_is_also_for_an_entity()
{
var values = new TestInternalPropertyValues<FakeTypeWithProps>(null, isEntityValues: true);
var clone = values.Clone();
Assert.True(clone.IsEntityValues);
}
public void SetValues_when_nested_dictionary_in_target_is_null_throws()
{
var nestedValues = new TestInternalPropertyValues<FakeTypeWithProps>();
var fromProperties = new Dictionary<string, object>
{
{ "NestedObject", nestedValues }
};
var fromValues = new TestInternalPropertyValues<FakeTypeWithProps>(fromProperties, new[] { "NestedObject" });
var toProperties = new Dictionary<string, object>
{
{ "NestedObject", null }
};
var toValues = new TestInternalPropertyValues<FakeTypeWithProps>(toProperties, new[] { "NestedObject" });
Assert.Equal(
Strings.DbPropertyValues_NestedPropertyValuesNull("NestedObject", typeof(FakeTypeWithProps).Name),
Assert.Throws<InvalidOperationException>(() => toValues.SetValues(fromValues)).Message);
}
public void Complex_values_can_be_read_from_a_property_dictionary()
{
var nestedProperties = new Dictionary<string, object>
{
{ "Id", 1 }
};
var nestedValues = new TestInternalPropertyValues<FakeTypeWithProps>(nestedProperties);
var properties = new Dictionary<string, object>
{
{ "NestedObject", nestedValues }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties, new[] { "NestedObject" });
var readValues = (InternalPropertyValues)values["NestedObject"];
Assert.Equal(1, readValues["Id"]);
}
public void Clone_ignores_null_nested_property_dictionary()
{
var properties = new Dictionary<string, object>
{
{ "Id", 1 },
{ "NestedObject", null }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties, new[] { "NestedObject" });
var clone = values.Clone();
Assert.Equal(1, clone["Id"]);
Assert.Null(clone["NestedObject"]);
}
public void Attempt_to_copy_values_from_dictionary_of_wrong_type_throws()
{
var values1 = new TestInternalPropertyValues<FakeDerivedTypeWithProps>();
var values2 = new TestInternalPropertyValues<FakeTypeWithProps>();
Assert.Equal(
Strings.DbPropertyValues_AttemptToSetValuesFromWrongType(
typeof(FakeTypeWithProps).Name, typeof(FakeDerivedTypeWithProps).Name),
Assert.Throws<ArgumentException>(() => values1.SetValues(values2)).Message);
}
public void SetValues_ignores_properties_that_are_conceptually_in_shadow_state()
{
var properties = new Dictionary<string, object>
{
{ "Id", 0 },
{ "MissingProp", "MissingPropValue" }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
values.SetValues(
new FakeTypeWithProps
{
Id = 1
});
Assert.Equal(1, values["Id"]);
Assert.Equal("MissingPropValue", values["MissingProp"]);
}
public void Clone_can_copy_null_properties()
{
var properties = new Dictionary<string, object>
{
{ "PublicNonNullStringProp", null }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
var clone = values.Clone();
Assert.Null(clone["PublicNonNullStringProp"]);
}
public void Attempt_to_copy_values_from_object_of_differnt_type_copies_no_properties_if_no_properties_match()
{
var properties = new Dictionary<string, object>
{
{ "PublicStringProp", null },
{ "PrivateStringProp", null },
{ "PublicIntProp", 0 },
{ "PrivateIntProp", 0 },
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
values.SetValues("Bang!");
Assert.Null(values["PublicStringProp"]);
Assert.Equal(0, values["PublicIntProp"]);
Assert.Null(values["PrivateStringProp"]);
Assert.Equal(0, values["PrivateIntProp"]);
}
private void Attempt_to_copy_values_from_object_of_differnt_type_copies_only_properties_that_match_implementation(object obj)
{
var properties = new Dictionary<string, object>
{
{ "Id", 0 },
{ "PublicStringProp", null },
{ "PrivateStringProp", null },
{ "PublicIntProp", 0 },
{ "PrivateIntProp", 0 },
{ "PublicIntPropWithPrivateSetter", 0 },
{ "PublicIntPropWithPrivateGetter", 0 },
{ "PublicBinaryProp", null },
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
values.SetValues(obj);
Assert.Equal(0, values["Id"]);
Assert.Equal("PublicStringPropValue", values["PublicStringProp"]);
Assert.Equal(0, values["PublicIntProp"]);
Assert.Null(values["PrivateStringProp"]);
Assert.Equal(3, values["PrivateIntProp"]);
Assert.Equal(0, values["PublicIntPropWithPrivateSetter"]);
Assert.Equal(0, values["PublicIntPropWithPrivateGetter"]);
Assert.Null(values["PublicBinaryProp"]);
}
public void SetValues_copies_values_from_object_to_property_dictionary()
{
var properties = new Dictionary<string, object>
{
{ "Id", 0 },
{ "PublicStringProp", null },
{ "PrivateStringProp", null },
{ "PublicIntProp", 0 },
{ "PrivateIntProp", 0 },
{ "PublicIntPropWithPrivateSetter", 0 },
{ "PublicIntPropWithPrivateGetter", 0 },
{ "PublicBinaryProp", null },
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
var obj = new FakeTypeWithProps(
1, "PublicStringPropValue", "PrivateStringPropValue", 2, 3, 4, 5, new byte[] { 3, 1, 4, 1, 5, 9 });
values.SetValues(obj);
Assert.Equal(1, values["Id"]);
Assert.Equal("PublicStringPropValue", values["PublicStringProp"]);
Assert.Equal(2, values["PublicIntProp"]);
Assert.Equal("PrivateStringPropValue", values["PrivateStringProp"]);
Assert.Equal(3, values["PrivateIntProp"]);
Assert.Equal(4, values["PublicIntPropWithPrivateSetter"]);
Assert.Equal(5, values["PublicIntPropWithPrivateGetter"]);
Assert.True(DbHelpers.KeyValuesEqual(new byte[] { 3, 1, 4, 1, 5, 9 }, values["PublicBinaryProp"]));
}
public void ToObject_throws_when_trying_to_set_null_values_onto_non_nullable_properties()
{
var values = new TestInternalPropertyValues<FakeTypeWithProps>(
new Dictionary<string, object>
{
{ "Id", 1 }
});
values["Id"] = null;
Assert.Equal(
Strings.DbPropertyValues_CannotSetNullValue("Id", "Int32", "FakeTypeWithProps"),
Assert.Throws<InvalidOperationException>(() => values.ToObject()).Message);
}
public void ToObject_returns_nested_property_dictionary_as_cloned_object()
{
var nestedProperties = new Dictionary<string, object>
{
{ "Id", 1 }
};
var nestedValues = new TestInternalPropertyValues<FakeTypeWithProps>(nestedProperties);
var properties = new Dictionary<string, object>
{
{ "NestedObject", nestedValues }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties, new[] { "NestedObject" });
var clone = (FakeTypeWithProps)values.ToObject();
Assert.Equal(1, clone.NestedObject.Id);
}
public void Clone_for_a_complex_object_returns_a_new_dictionary_that_is_also_for_an_complex_object()
{
var values = new TestInternalPropertyValues<FakeTypeWithProps>();
var clone = values.Clone();
Assert.False(clone.IsEntityValues);
}
public void SetValues_ignores_properties_that_are_write_only()
{
var properties = new Dictionary<string, object>
{
{ "Id", 0 },
{ "PublicWriteOnlyStringProp", "Foo" },
{ "PrivateWriteOnlyStringProp", "Bar" }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
values.SetValues(
new FakeTypeWithProps
{
Id = 1
});
Assert.Equal(1, values["Id"]);
Assert.Equal("Foo", values["PublicWriteOnlyStringProp"]);
Assert.Equal("Bar", values["PrivateWriteOnlyStringProp"]);
}
public void Clone_sets_all_properties_from_the_dictionary_into_the_new_values()
{
var properties = new Dictionary<string, object>
{
{ "Id", 1 },
{ "PublicStringProp", "PublicStringPropValue" },
{ "PrivateStringProp", "PrivateStringPropValue" },
{ "PublicIntProp", 2 },
{ "PrivateIntProp", 3 },
{ "PublicIntPropWithPrivateSetter", 4 },
{ "PublicIntPropWithPrivateGetter", 5 },
{ "PublicBinaryProp", new byte[] { 3, 1, 4, 1, 5, 9 } },
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
var clone = values.Clone();
Assert.Equal(1, clone["Id"]);
Assert.Equal("PublicStringPropValue", clone["PublicStringProp"]);
Assert.Equal(2, clone["PublicIntProp"]);
Assert.Equal("PrivateStringPropValue", clone["PrivateStringProp"]);
Assert.Equal(3, clone["PrivateIntProp"]);
Assert.Equal(4, clone["PublicIntPropWithPrivateSetter"]);
Assert.Equal(5, clone["PublicIntPropWithPrivateGetter"]);
Assert.True(DbHelpers.KeyValuesEqual(new byte[] { 3, 1, 4, 1, 5, 9 }, clone["PublicBinaryProp"]));
}
public void SetValues_can_set_reference_propeties_to_null()
{
var properties = new Dictionary<string, object>
{
{ "Id", 0 },
{ "PublicStringProp", "NonNull" }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
values.SetValues(
new FakeTypeWithProps
{
Id = 1
});
Assert.Equal(1, values["Id"]);
Assert.Null(values["PublicStringProp"]);
}
public void Clone_clones_nested_property_dictionary_into_new_cloned_nested_dictionary()
{
var nestedProperties = new Dictionary<string, object>
{
{ "Id", 2 }
};
var nestedValues = new TestInternalPropertyValues<FakeTypeWithProps>(nestedProperties);
var properties = new Dictionary<string, object>
{
{ "Id", 1 },
{ "NestedObject", nestedValues }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties, new[] { "NestedObject" });
var clone = values.Clone();
var nestedClone = (InternalPropertyValues)clone["NestedObject"];
Assert.Equal(1, clone["Id"]);
Assert.Equal(2, nestedClone["Id"]);
Assert.False(clone.GetItem("Id").IsComplex);
Assert.True(clone.GetItem("NestedObject").IsComplex);
Assert.False(nestedClone.GetItem("Id").IsComplex);
}
public void SetValues_sets_values_from_complex_object_into_nested_property_dictionary()
{
var nestedProperties = new Dictionary<string, object>
{
{ "Id", 0 }
};
var nestedValues = new TestInternalPropertyValues<FakeTypeWithProps>(nestedProperties);
var properties = new Dictionary<string, object>
{
{ "Id", 0 },
{ "NestedObject", nestedValues }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties, new[] { "NestedObject" });
values.SetValues(
new FakeTypeWithProps
{
Id = 1,
NestedObject = new FakeTypeWithProps
{
Id = 2
}
});
Assert.Equal(1, values["Id"]);
Assert.Equal(2, nestedValues["Id"]);
}
public void Modifying_properties_on_cloned_dictionary_does_not_change_properties_on_original_dictionary_and_vice_versa()
{
var nestedProperties = new Dictionary<string, object>
{
{ "Id", 2 }
};
var nestedValues = new TestInternalPropertyValues<FakeTypeWithProps>(nestedProperties);
var properties = new Dictionary<string, object>
{
{ "Id", 1 },
{ "NestedObject", nestedValues }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties, new[] { "NestedObject" });
var clone = values.Clone();
var nestedClone = (InternalPropertyValues)clone["NestedObject"];
values["Id"] = -1;
nestedValues["Id"] = -2;
clone["Id"] = -3;
nestedClone["Id"] = -4;
Assert.Equal(-1, values["Id"]);
Assert.Equal(-2, nestedValues["Id"]);
Assert.Equal(-3, clone["Id"]);
Assert.Equal(-4, nestedClone["Id"]);
}
public void SetValues_when_complex_object_is_null_throws()
{
var nestedProperties = new Dictionary<string, object>
{
{ "Id", 0 }
};
var nestedValues = new TestInternalPropertyValues<FakeTypeWithProps>(nestedProperties);
var properties = new Dictionary<string, object>
{
{ "Id", 0 },
{ "NestedObject", nestedValues }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties, new[] { "NestedObject" });
var obj = new FakeTypeWithProps
{
Id = 1,
NestedObject = null
};
Assert.Equal(
Strings.DbPropertyValues_ComplexObjectCannotBeNull("NestedObject", typeof(FakeTypeWithProps).Name),
Assert.Throws<InvalidOperationException>(() => values.SetValues(obj)).Message);
}
private TestInternalPropertyValues<FakeTypeWithProps> CreateSimpleValues()
{
var nestedProperties = new Dictionary<string, object>
{
{ "Id", 0 }
};
var nestedValues = new TestInternalPropertyValues<FakeTypeWithProps>(nestedProperties);
var properties = new Dictionary<string, object>
{
{ "Id", 0 },
{ "PublicStringProp", null },
{ "PrivateStringProp", null },
{ "PublicIntProp", 0 },
{ "PrivateIntProp", 0 },
{ "PublicIntPropWithPrivateSetter", 0 },
{ "PublicIntPropWithPrivateGetter", 0 },
{ "PublicBinaryProp", null },
{ "NestedObject", nestedValues },
};
return new TestInternalPropertyValues<FakeTypeWithProps>(properties, new[] { "NestedObject" });
}
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);
}
public void Scalar_values_can_be_read_from_a_property_dictionary()
{
var properties = new Dictionary<string, object>
{
{ "Id", 1 }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
Assert.Equal(1, values["Id"]);
}
public void ToObject_ignores_properties_that_are_conceptually_in_shadow_state()
{
var properties = new Dictionary<string, object>
{
{ "Id", 1 },
{ "MissingProp", "MissingPropValue" }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
var clone = (FakeTypeWithProps)values.ToObject();
Assert.Equal(1, clone.Id);
}
public void SetValues_when_nested_property_dictionary_in_source_is_null_throws()
{
var properties = new Dictionary<string, object>
{
{ "Id", 0 },
{ "NestedObject", null }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties, new[] { "NestedObject" });
var obj = new FakeTypeWithProps
{
Id = 1,
NestedObject = new FakeTypeWithProps
{
Id = 2
}
};
Assert.Equal(
Strings.DbPropertyValues_NestedPropertyValuesNull("NestedObject", typeof(FakeTypeWithProps).Name),
Assert.Throws<InvalidOperationException>(() => values.SetValues(obj)).Message);
}
public void ToObject_ignores_properties_that_are_readonly()
{
var properties = new Dictionary<string, object>
{
{ "Id", 1 },
{ "PublicReadonlyStringProp", "Foo" },
{ "PrivateReadonlyStringProp", "Foo" }
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
var clone = (FakeTypeWithProps)values.ToObject();
Assert.Equal(1, clone.Id);
Assert.Equal("PublicReadonlyStringProp", clone.PublicReadonlyStringProp);
Assert.Equal(
"PrivateReadonlyStringProp",
typeof(FakeTypeWithProps).GetProperty("PrivateReadonlyStringProp", PropertyBindingFlags).GetValue(clone, null));
}
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);
}
public void SetValues_does_not_attempt_to_set_values_that_are_not_different()
{
var properties = new Dictionary<string, object>
{
{ "PublicStringProp", "PublicStringPropValue" },
{ "PublicIntProp", 2 },
{ "PublicBinaryProp", new byte[] { 3, 1, 4, 1, 5, 9 } },
};
var values = new TestInternalPropertyValues<FakeTypeWithProps>(properties);
var obj = new FakeTypeWithProps
{
PublicStringProp = "PublicStringPropValue",
PublicIntProp = 2,
PublicBinaryProp = new byte[] { 3, 1, 4, 1, 5, 9 }
};
values.SetValues(obj);
values.GetMockItem("PublicStringProp").VerifySet(i => i.Value = It.IsAny<object>(), Times.Never());
values.GetMockItem("PublicIntProp").VerifySet(i => i.Value = It.IsAny<object>(), Times.Never());
values.GetMockItem("PublicBinaryProp").VerifySet(i => i.Value = It.IsAny<object>(), Times.Never());
}
