public void Test_that_null_is_returned_if_all_providers_return_no_value_type_merging_strategy()
{
var nestedProvider1Mock = new Mock <IMetamodelProvider>();
var nestedProvider2Mock = new Mock <IMetamodelProvider>();
nestedProvider1Mock
.Setup(x => x.TryGetValueTypeMergingStrategy(It.IsAny <Type>()))
.Returns <Type>(t => ValueTypeMergingStrategy.None);
nestedProvider2Mock
.Setup(x => x.TryGetValueTypeMergingStrategy(It.IsAny <Type>()))
.Returns <Type>(t => ValueTypeMergingStrategy.None);
var provider = new CompositeMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
provider
.AddProvider(nestedProvider1Mock.Object)
.AddProvider(nestedProvider2Mock.Object);
// Act
var serializer = metamodelProvider.TryGetValueTypeMergingStrategy(typeof(TestType));
// Assert
Assert.AreEqual(ValueTypeMergingStrategy.None, serializer);
}
public void Test_that_null_is_returned_if_all_providers_return_no_serializer_when_getting_type_serializer()
{
var nestedProvider1Mock = new Mock <IMetamodelProvider>();
var nestedProvider2Mock = new Mock <IMetamodelProvider>();
nestedProvider1Mock
.Setup(x => x.TryGetTypeSerializer(It.IsAny <Type>()))
.Returns <Type>(t => null);
nestedProvider2Mock
.Setup(x => x.TryGetTypeSerializer(It.IsAny <Type>()))
.Returns <Type>(t => null);
var provider = new CompositeMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
provider
.AddProvider(nestedProvider1Mock.Object)
.AddProvider(nestedProvider2Mock.Object);
// Act
var serializer = metamodelProvider.TryGetTypeSerializer(typeof(TestType));
// Assert
Assert.IsNull(serializer);
}
/// <summary>
/// Adds provider. Composite metamodel will be built in that order, in which providers were added
/// </summary>
public CompositeMetamodelProvider AddProvider(IMetamodelProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
_builders = _builders.Add(provider);
return(this);
}
public void Test_that_for_no_matched_type_null_value_type_merging_strategy_is_returned()
{
// Arrange
var provider = new ConventionBasedMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
provider.AddTypeValueTypesMergingStrategyRule(t => t.Name == "FictionalTipe", ValueTypeMergingStrategy.UpdateIfDirty);
// Act
var strategy = metamodelProvider.TryGetValueTypeMergingStrategy(typeof(TestType));
// Assert
Assert.AreEqual(ValueTypeMergingStrategy.None, strategy);
}
public void Test_that_property_expression_works1()
{
// Arrange
var provider = new ImperativeMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
// Act
provider.UseSerializer((TestEntity e) => e.StringProperty, new JsonStorageValueSerializer());
// Assert
var serialier = metamodelProvider.TryGetPropertySerializer(TestEntityType.GetProperty(nameof(TestEntity.StringProperty)));
Assert.IsNotNull(serialier);
Assert.IsInstanceOfType(serialier, typeof(JsonStorageValueSerializer));
}
public void Test_that_for_no_matched_type_null_serializer_is_returned()
{
// Arrange
var provider = new ConventionBasedMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
provider
.AddTypeSerializerRule(
t => t.Name == "FictionalTipe",
t => new ValueSerializerMock());
// Act
var serializer = metamodelProvider.TryGetTypeSerializer(typeof(TestType));
// Assert
Assert.IsNull(serializer);
}
public void Test_that_for_no_matched_property_null_serializer_is_returned()
{
// Arrange
var provider = new ConventionBasedMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
provider
.AddPropertySerializerRule(
p => p.Name == "FictionalProperty",
p => new ValueSerializerMock());
// Act
var serializer = metamodelProvider.TryGetPropertySerializer(typeof(TestType).GetProperty(nameof(TestType.Property)));
// Assert
Assert.IsNull(serializer);
}
/// <summary>
/// Configures metamodel with the given <paramref name="provider"/>
/// </summary>
/// <param name="provider">Metamodel provider</param>
public static void Configure(IMetamodelProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (_isConfigured)
{
throw new InvalidOperationException("Metamodel has already been configured");
}
Instance = new EntityMetamodelImpl(provider);
_isConfigured = true;
}
public void Test_that_provider_used_in_the_order_which_they_was_registered_when_getting_type_serializer()
{
// Arrange
var counter = 0;
var mock1Order = 0;
var mock2Order = 0;
var nestedProvider1Mock = new Mock <IMetamodelProvider>();
var nestedProvider2Mock = new Mock <IMetamodelProvider>();
nestedProvider1Mock
.Setup(x => x.TryGetTypeSerializer(It.IsAny <Type>()))
.Returns <Type>(t =>
{
++counter;
mock1Order = counter;
return(null);
});
nestedProvider2Mock
.Setup(x => x.TryGetTypeSerializer(It.IsAny <Type>()))
.Returns <Type>(t =>
{
++counter;
mock2Order = counter;
return(null);
});
var provider = new CompositeMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
provider
.AddProvider(nestedProvider1Mock.Object)
.AddProvider(nestedProvider2Mock.Object);
// Act
metamodelProvider.TryGetTypeSerializer(typeof(TestType));
// Assert
nestedProvider1Mock.Verify(x => x.TryGetTypeSerializer(It.IsAny <Type>()), Times.Once);
nestedProvider2Mock.Verify(x => x.TryGetTypeSerializer(It.IsAny <Type>()), Times.Once);
Assert.AreEqual(1, mock1Order);
Assert.AreEqual(2, mock2Order);
}
public void Test_that_type_value_type_merging_strategy_rules_applied_in_the_same_order_as_they_was_registered2()
{
// Arrange
var provider = new ConventionBasedMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
provider
.AddTypeValueTypesMergingStrategyRule(t => t.Name == "AnotherTestType", ValueTypeMergingStrategy.UpdateAlways)
.AddTypeValueTypesMergingStrategyRule(t => t.Name.EndsWith("TestType"), ValueTypeMergingStrategy.UpdateIfDirty);
// Act
var testTypeStrategy = metamodelProvider.TryGetValueTypeMergingStrategy(typeof(TestType));
var anotherTestTypeStrategy = metamodelProvider.TryGetValueTypeMergingStrategy(typeof(AnotherTestType));
// Assert
Assert.AreEqual(ValueTypeMergingStrategy.UpdateIfDirty, testTypeStrategy);
Assert.AreEqual(ValueTypeMergingStrategy.UpdateAlways, anotherTestTypeStrategy);
}
public void Test_that_serializer_returned_by_provider_which_registered_before_is_used_and_no_registered_later_providers_are_used_when_getting_property_erializer()
{
// Arrange
var nestedProvider1Mock = new Mock <IMetamodelProvider>();
var nestedProvider2Mock = new Mock <IMetamodelProvider>();
var nestedProvider3Mock = new Mock <IMetamodelProvider>();
nestedProvider1Mock
.Setup(x => x.TryGetPropertySerializer(It.IsAny <PropertyInfo>()))
.Returns <PropertyInfo>(t => null);
nestedProvider2Mock
.Setup(x => x.TryGetPropertySerializer(It.IsAny <PropertyInfo>()))
.Returns <PropertyInfo>(t => new ValueSerializerMock());
nestedProvider3Mock
.Setup(x => x.TryGetPropertySerializer(It.IsAny <PropertyInfo>()))
.Returns <PropertyInfo>(t => new AnotherValueSerializerMock());
var provider = new CompositeMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
provider
.AddProvider(nestedProvider1Mock.Object)
.AddProvider(nestedProvider2Mock.Object)
.AddProvider(nestedProvider3Mock.Object);
// Act
var serializer = metamodelProvider.TryGetPropertySerializer(typeof(TestType).GetProperty(nameof(TestType.Property)));
// Assert
nestedProvider1Mock.Verify(x => x.TryGetPropertySerializer(It.IsAny <PropertyInfo>()), Times.Once);
nestedProvider2Mock.Verify(x => x.TryGetPropertySerializer(It.IsAny <PropertyInfo>()), Times.Once);
nestedProvider3Mock.Verify(x => x.TryGetPropertySerializer(It.IsAny <PropertyInfo>()), Times.Never);
Assert.IsNotNull(serializer);
Assert.IsInstanceOfType(serializer, typeof(ValueSerializerMock));
}
public void Test_that_type_serializer_rules_applied_in_the_same_order_as_they_was_registered1()
{
// Arrange
var provider = new ConventionBasedMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
provider
.AddTypeSerializerRule(
t => t.Name.EndsWith("TestType"),
t => new ValueSerializerMock())
.AddTypeSerializerRule(
t => t.Name == "AnotherTestType",
t => new AnotherValueSerializerMock());
// Act
var testTypeSerializer = metamodelProvider.TryGetTypeSerializer(typeof(TestType));
var anotherTestTypeSerializer = metamodelProvider.TryGetTypeSerializer(typeof(AnotherTestType));
// Assert
Assert.IsNotNull(testTypeSerializer);
Assert.IsNotNull(anotherTestTypeSerializer);
Assert.IsInstanceOfType(testTypeSerializer, typeof(ValueSerializerMock));
Assert.IsInstanceOfType(anotherTestTypeSerializer, typeof(ValueSerializerMock));
}
public void Test_that_property_rules_applied_in_the_same_order_as_they_was_registered2()
{
// Arrange
var provider = new ConventionBasedMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
provider
.AddPropertySerializerRule(
p => p.PropertyType == typeof(string),
p => new AnotherValueSerializerMock())
.AddPropertySerializerRule(
p => p.Name == "Property",
p => new ValueSerializerMock());
// Act
var testTypeSerializer = metamodelProvider.TryGetPropertySerializer(typeof(TestType).GetProperty(nameof(TestType.Property)));
var anotherTestTypeSerializer = metamodelProvider.TryGetPropertySerializer(typeof(AnotherTestType).GetProperty(nameof(AnotherTestType.Property)));
// Assert
Assert.IsNotNull(testTypeSerializer);
Assert.IsNotNull(anotherTestTypeSerializer);
Assert.IsInstanceOfType(testTypeSerializer, typeof(ValueSerializerMock));
Assert.IsInstanceOfType(anotherTestTypeSerializer, typeof(AnotherValueSerializerMock));
}
public void Test_that_value_type_merging_strategy_returned_by_provider_which_registered_before_is_used_and_no_registered_later_providers_are_used()
{
// Arrange
var nestedProvider1Mock = new Mock <IMetamodelProvider>();
var nestedProvider2Mock = new Mock <IMetamodelProvider>();
var nestedProvider3Mock = new Mock <IMetamodelProvider>();
nestedProvider1Mock
.Setup(x => x.TryGetValueTypeMergingStrategy(It.IsAny <Type>()))
.Returns <Type>(t => ValueTypeMergingStrategy.None);
nestedProvider2Mock
.Setup(x => x.TryGetValueTypeMergingStrategy(It.IsAny <Type>()))
.Returns <Type>(t => ValueTypeMergingStrategy.UpdateIfDirty);
nestedProvider3Mock
.Setup(x => x.TryGetValueTypeMergingStrategy(It.IsAny <Type>()))
.Returns <Type>(t => ValueTypeMergingStrategy.UpdateAlways);
var provider = new CompositeMetamodelProvider();
IMetamodelProvider metamodelProvider = provider;
provider
.AddProvider(nestedProvider1Mock.Object)
.AddProvider(nestedProvider2Mock.Object)
.AddProvider(nestedProvider3Mock.Object);
// Act
var strategy = metamodelProvider.TryGetValueTypeMergingStrategy(typeof(TestType));
// Assert
nestedProvider1Mock.Verify(x => x.TryGetValueTypeMergingStrategy(It.IsAny <Type>()), Times.Once);
nestedProvider2Mock.Verify(x => x.TryGetValueTypeMergingStrategy(It.IsAny <Type>()), Times.Once);
nestedProvider3Mock.Verify(x => x.TryGetValueTypeMergingStrategy(It.IsAny <Type>()), Times.Never);
Assert.AreEqual(ValueTypeMergingStrategy.UpdateIfDirty, strategy);
}
public void InitializeTest()
{
_metamodelProvider = new AnnotationsBasedMetamodelProvider();
}
public EntityMetamodelImpl(IMetamodelProvider provider)
{
_provider = provider;
}
