public void CollectionNameAndSchemaFromAttribute()
{
EntityMapping.AddMappingProcessor(new CollectionNameProcessor());
var definition = EntityMapping.RegisterType(typeof(CustomCollectionAndSchemaModel));
Assert.AreEqual("CustomSchema.CustomCollection", definition.CollectionName);
}
public async Task SumAsync_NullableDecimal_HasValue()
{
EntityMapping.RegisterType(typeof(QueryableAsyncSumModel));
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var provider = new MongoFrameworkQueryProvider <QueryableAsyncSumModel>(connection);
var queryable = new MongoFrameworkQueryable <QueryableAsyncSumModel>(provider);
context.ChangeTracker.SetEntityState(new QueryableAsyncSumModel {
Title = "SumAsync_NullableDecimal_HasValue.1", NullableDecimalNumber = 5
}, EntityEntryState.Added);
context.ChangeTracker.SetEntityState(new QueryableAsyncSumModel {
Title = "SumAsync_NullableDecimal_HasValue.2", NullableDecimalNumber = 9
}, EntityEntryState.Added);
context.ChangeTracker.SetEntityState(new QueryableAsyncSumModel {
Title = "SumAsync_NullableDecimal_HasValue.3"
}, EntityEntryState.Added);
context.SaveChanges();
var a = queryable.Select(e => e.NullableDecimalNumber).Sum();
var result = await queryable.Select(e => e.NullableDecimalNumber).SumAsync();
Assert.AreEqual(14, result);
}
public void CollectionNameFromClassName()
{
EntityMapping.AddMappingProcessor(new CollectionNameProcessor());
var definition = EntityMapping.RegisterType(typeof(DefaultCollectionNameModel));
Assert.AreEqual("DefaultCollectionNameModel", definition.CollectionName);
}
public void ApplyMapping(IEntityDefinition definition, BsonClassMap classMap)
{
var entityType = definition.EntityType;
var properties = entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
foreach (var property in properties)
{
var propertyType = property.PropertyType;
//Maps the property type for handling property nesting
if (propertyType.IsClass && propertyType != entityType)
{
if (!EntityMapping.IsRegistered(propertyType))
{
EntityMapping.RegisterType(propertyType);
}
}
else if (
propertyType.IsGenericType && propertyType.GetGenericArguments().Count() == 1 &&
(
propertyType.GetGenericTypeDefinition() == typeof(IEnumerable <>) ||
propertyType.GetInterfaces().Where(i => i.IsGenericType).Any(i => i.GetGenericTypeDefinition() == typeof(IEnumerable <>))
)
)
{
var genericType = propertyType.GetGenericArguments()[0];
if (!EntityMapping.IsRegistered(genericType))
{
EntityMapping.RegisterType(genericType);
}
}
}
}
public void Setup()
{
EntityMapping.RemoveAllDefinitions();
MongoDbDriverHelper.ResetDriver();
EntityMapping.RegisterType(typeof(FlatIndexModel));
EntityMapping.RegisterType(typeof(NestedIndexParentModel));
}
private IBsonSerializer GetRealSerializer(Type type)
{
if (type == typeof(object))
{
return(new DictionaryInterfaceImplementerSerializer <Dictionary <string, object> >());
}
else if (type.IsGenericType && DictionaryTypes.Contains(type.GetGenericTypeDefinition()))
{
var serializerType = typeof(DictionaryInterfaceImplementerSerializer <>).MakeGenericType(type);
var serializer = (IBsonSerializer)Activator.CreateInstance(serializerType);
return(serializer);
}
else
{
if (type.IsClass && type != typeof(string))
{
//Force the type to be processed by the Entity Mapper
if (!EntityMapping.IsRegistered(type))
{
EntityMapping.RegisterType(type);
}
var classMap = BsonClassMap.LookupClassMap(type);
var serializerType = typeof(BsonClassMapSerializer <>).MakeGenericType(type);
var serializer = (IBsonSerializer)Activator.CreateInstance(serializerType, classMap);
return(serializer);
}
else
{
return(BsonSerializer.LookupSerializer(type));
}
}
}
public void EntityProcessorsNotFiredWhenNotTEntity()
{
EntityMapping.RegisterType(typeof(MongoFrameworkQueryableModel));
var connection = TestConfiguration.GetConnection();
var collection = connection.GetDatabase().GetCollection <MongoFrameworkQueryableModel>(nameof(MongoFrameworkQueryableModel));
var underlyingQueryable = collection.AsQueryable();
var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel, MongoFrameworkQueryableModel>(connection, underlyingQueryable);
var processor = new TestProcessor <MongoFrameworkQueryableModel>();
queryable.EntityProcessors.Add(processor);
var entityCollection = new EntityCollection <MongoFrameworkQueryableModel>();
var writerPipeline = new EntityWriterPipeline <MongoFrameworkQueryableModel>(connection);
writerPipeline.AddCollection(entityCollection);
entityCollection.Update(new MongoFrameworkQueryableModel {
Title = "EntityProcessorNoFireTest"
}, EntityEntryState.Added);
writerPipeline.Write();
foreach (var titles in queryable.Select(e => e.Title))
{
//Do nothing
}
Assert.IsFalse(processor.EntityProcessed);
}
public void EntityProcessorsFiresOnEnumerationOfTEntity()
{
EntityMapping.RegisterType(typeof(MongoFrameworkQueryableModel));
var connection = TestConfiguration.GetConnection();
var provider = new MongoFrameworkQueryProvider <MongoFrameworkQueryableModel>(connection);
var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel>(provider);
var processor = new TestProcessor <MongoFrameworkQueryableModel>();
provider.EntityProcessors.Add(processor);
var entityCollection = new EntityCollection <MongoFrameworkQueryableModel>();
var writerPipeline = new EntityWriterPipeline <MongoFrameworkQueryableModel>(connection);
writerPipeline.AddCollection(entityCollection);
entityCollection.Update(new MongoFrameworkQueryableModel {
Title = "EntityProcessorFireTest"
}, EntityEntryState.Added);
writerPipeline.Write();
foreach (var entity in queryable)
{
//Do nothing
}
Assert.IsTrue(processor.EntityProcessed);
}
public void EntityProcessorsRunWhenToDictionaryIsUsed()
{
EntityMapping.RegisterType(typeof(MongoFrameworkQueryableModel));
var connection = TestConfiguration.GetConnection();
var provider = new MongoFrameworkQueryProvider <MongoFrameworkQueryableModel>(connection);
var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel>(provider);
var processor = new TestProcessor <MongoFrameworkQueryableModel>();
provider.EntityProcessors.Add(processor);
var entityCollection = new EntityCollection <MongoFrameworkQueryableModel>();
var writerPipeline = new EntityWriterPipeline <MongoFrameworkQueryableModel>(connection);
writerPipeline.AddCollection(entityCollection);
entityCollection.Update(new MongoFrameworkQueryableModel {
Title = "EntityProcessorsRunWithToDictionaryTest"
}, EntityEntryState.Added);
writerPipeline.Write();
var result = queryable.ToDictionary(m => m.Id);
Assert.AreEqual("EntityProcessorsRunWithToDictionaryTest", result.FirstOrDefault().Value.Title);
Assert.IsTrue(processor.EntityProcessed);
}
public void MapsNestedCollectionPropertyModel()
{
EntityMapping.AddMappingProcessor(new NestedTypeProcessor());
Assert.IsFalse(BsonClassMap.IsClassMapRegistered(typeof(CollectionNestedModel)));
EntityMapping.RegisterType(typeof(CollectionBaseModel));
Assert.IsTrue(BsonClassMap.IsClassMapRegistered(typeof(CollectionNestedModel)));
}
public void ExtraElementsSerializationIntegrationTest()
{
EntityMapping.AddMappingProcessor(new CollectionNameProcessor());
EntityMapping.AddMappingProcessor(new PropertyMappingProcessor());
EntityMapping.AddMappingProcessor(new ExtraElementsProcessor());
EntityMapping.RegisterType(typeof(ExtraElementsAttrModel));
EntityMapping.RegisterType(typeof(ModelWithExtraElements));
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var entity = new ModelWithExtraElements
{
PropertyOne = "ModelWithExtraElements",
PropertyTwo = 123
};
context.ChangeTracker.SetEntityState(entity, EntityEntryState.Added);
context.SaveChanges();
var dbEntity = context.Query <ExtraElementsAttrModel>().Where(e => e.Id == entity.Id).FirstOrDefault();
Assert.AreEqual("ModelWithExtraElements", dbEntity.AdditionalElements[nameof(ModelWithExtraElements.PropertyOne)]);
Assert.AreEqual(123, dbEntity.AdditionalElements[nameof(ModelWithExtraElements.PropertyTwo)]);
}
public void UnsupportedIdTypeOnRelationship()
{
EntityMapping.AddMappingProcessor(new PropertyMappingProcessor());
EntityMapping.AddMappingProcessor(new EntityRelationshipProcessor());
EntityMapping.RegisterType(typeof(UnsupportedIdModel));
}
public void NullDeserialization()
{
EntityMapping.AddMappingProcessor(new TypeDiscoveryProcessor());
EntityMapping.RegisterType(typeof(KnownBaseModel));
var serializer = TypeDiscoverySerializationProvider.Instance.GetSerializer(typeof(KnownBaseModel));
var document = new BsonDocument
{
{ "Item", BsonNull.Value }
};
KnownBaseModel deserializedResult;
using (var reader = new BsonDocumentReader(document))
{
reader.ReadBsonType();
reader.ReadStartDocument();
reader.ReadBsonType();
reader.SkipName();
var context = BsonDeserializationContext.CreateRoot(reader);
deserializedResult = (KnownBaseModel)serializer.Deserialize(context);
}
Assert.IsNull(deserializedResult);
}
public void InversePropertyMappingInvalidPropertyType()
{
EntityMapping.AddMappingProcessor(new PropertyMappingProcessor());
EntityMapping.AddMappingProcessor(new EntityRelationshipProcessor());
EntityMapping.RegisterType(typeof(InversePropertyMappingInvalidPropertyTypeModel));
}
public void InversePropertyMappingNonExistantProperty()
{
EntityMapping.AddMappingProcessor(new PropertyMappingProcessor());
EntityMapping.AddMappingProcessor(new EntityRelationshipProcessor());
EntityMapping.RegisterType(typeof(InversePropertyNonExistantPropertyModel));
}
public void InvalidForeignKeyOnRelationship()
{
EntityMapping.AddMappingProcessor(new PropertyMappingProcessor());
EntityMapping.AddMappingProcessor(new EntityRelationshipProcessor());
EntityMapping.RegisterType(typeof(InvalidForeignKeyModel));
}
public void EntityProcessorsNotFiredWhenNotTEntity_Select()
{
EntityMapping.RegisterType(typeof(MongoFrameworkQueryableModel));
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var provider = new MongoFrameworkQueryProvider <MongoFrameworkQueryableModel>(connection);
var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel>(provider);
var processor = new TestProcessor <MongoFrameworkQueryableModel>();
provider.EntityProcessors.Add(processor);
context.ChangeTracker.SetEntityState(new MongoFrameworkQueryableModel {
Title = "EntityProcessorsNotFiredWhenNotTEntity_Select"
}, EntityEntryState.Added);
context.SaveChanges();
foreach (var titles in queryable.Select(e => e.Title))
{
//Do nothing
}
Assert.IsFalse(processor.EntityProcessed);
}
public void ExtraElementsSerializationIntegrationTest()
{
EntityMapping.AddMappingProcessor(new CollectionNameProcessor());
EntityMapping.AddMappingProcessor(new ExtraElementsProcessor());
EntityMapping.RegisterType(typeof(ExtraElementsAttrModel));
EntityMapping.RegisterType(typeof(ModelWithExtraElements));
var connection = TestConfiguration.GetConnection();
var modelWithExtraPropertiesDbSet = new MongoDbSet <ModelWithExtraElements>();
modelWithExtraPropertiesDbSet.SetConnection(connection);
var entity = new ModelWithExtraElements
{
PropertyOne = "ModelWithExtraElements",
PropertyTwo = 123
};
modelWithExtraPropertiesDbSet.Add(entity);
modelWithExtraPropertiesDbSet.SaveChanges();
var extraElementsAttrModelDbSet = new MongoDbSet <ExtraElementsAttrModel>();
extraElementsAttrModelDbSet.SetConnection(connection);
var dbEntity = extraElementsAttrModelDbSet.Where(e => e.Id == entity.Id).FirstOrDefault();
Assert.AreEqual("ModelWithExtraElements", dbEntity.AdditionalElements[nameof(ModelWithExtraElements.PropertyOne)]);
Assert.AreEqual(123, dbEntity.AdditionalElements[nameof(ModelWithExtraElements.PropertyTwo)]);
}
public void WithoutAttribute()
{
EntityMapping.AddMappingProcessor(new BsonKnownTypesProcessor());
Assert.IsFalse(BsonClassMap.IsClassMapRegistered(typeof(UnknownTypesChildModel)));
EntityMapping.RegisterType(typeof(UnknownTypesBaseModel));
Assert.IsFalse(BsonClassMap.IsClassMapRegistered(typeof(UnknownTypesChildModel)));
}
public void EntityProcessorsFiresOnEnumerationOfTEntity()
{
EntityMapping.RegisterType(typeof(MongoFrameworkQueryableModel));
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var provider = new MongoFrameworkQueryProvider <MongoFrameworkQueryableModel>(connection);
var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel>(provider);
var processor = new TestProcessor <MongoFrameworkQueryableModel>();
provider.EntityProcessors.Add(processor);
context.ChangeTracker.SetEntityState(new MongoFrameworkQueryableModel {
Title = "EntityProcessorFireTest"
}, EntityEntryState.Added);
context.SaveChanges();
foreach (var dbEntity in queryable)
{
//Do nothing
}
Assert.IsTrue(processor.EntityProcessed);
}
public void DeserializeDictionaryForUnknownPropertyType()
{
EntityMapping.AddMappingProcessor(new TypeDiscoveryProcessor());
EntityMapping.RegisterType(typeof(UnknownPropertyTypeSerializationModel));
var document = new BsonDocument
{
{ "_t", "UnknownPropertyTypeSerializationModel" },
{
"UnknownPropertyType",
new BsonDocument
{
{ "ThisIsA", "Dictionary" }
}
}
};
var deserializedResult = BsonSerializer.Deserialize <UnknownPropertyTypeSerializationModel>(document);
Assert.IsInstanceOfType(deserializedResult.UnknownPropertyType, typeof(Dictionary <string, object>));
var dictionary = deserializedResult.UnknownPropertyType as Dictionary <string, object>;
Assert.IsTrue(dictionary.ContainsKey("ThisIsA"));
Assert.AreEqual("Dictionary", dictionary["ThisIsA"]);
}
public void DeserializeUnknownTypesInDictionary()
{
EntityMapping.AddMappingProcessor(new TypeDiscoveryProcessor());
EntityMapping.RegisterType(typeof(UnknownDictionaryValueModel));
var document = new BsonDocument
{
{ "_t", "UnknownDictionaryValueModel" },
{
"Dictionary",
new BsonDocument
{
{ "String", "ObjectValueAsString" },
{ "Number", 1 },
{ "Date", new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc) },
{ "Boolean", true },
{ "Array", new BsonArray(new int[] { 10, 20, 30 }) },
{ "ObjectId", ObjectId.Parse("507f1f77bcf86cd799439011") }
}
}
};
var result = BsonSerializer.Deserialize <UnknownDictionaryValueModel>(document);
Assert.IsNotNull(result.Dictionary);
Assert.AreEqual("ObjectValueAsString", result.Dictionary["String"]);
Assert.AreEqual(1, result.Dictionary["Number"]);
Assert.AreEqual(new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc), result.Dictionary["Date"]);
Assert.AreEqual(true, result.Dictionary["Boolean"]);
Assert.AreEqual(20, ((object[])result.Dictionary["Array"])[1]);
Assert.AreEqual(ObjectId.Parse("507f1f77bcf86cd799439011"), result.Dictionary["ObjectId"]);
}
public void DeserializeCollection()
{
EntityMapping.AddMappingProcessor(new TypeDiscoveryProcessor());
EntityMapping.RegisterType(typeof(CollectionBaseModel));
var document = new BsonDocument
{
{ "_t", "CollectionBaseModel" },
{
"KnownList",
new BsonArray
{
new BsonDocument
{
{ "_t", "KnownBaseModel" }
},
new BsonDocument
{
{ "_t", "UnknownChildModel" }
},
new BsonDocument
{
{ "_t", new BsonArray(new [] { "KnownBaseModel", "UnknownChildModel", "UnknownGrandChildModel" }) }
}
}
}
};
var deserializedResult = BsonSerializer.Deserialize <CollectionBaseModel>(document);
Assert.IsInstanceOfType(deserializedResult.KnownList[0], typeof(KnownBaseModel));
Assert.IsInstanceOfType(deserializedResult.KnownList[1], typeof(UnknownChildModel));
Assert.IsInstanceOfType(deserializedResult.KnownList[2], typeof(UnknownGrandChildModel));
}
public void ReserializationWithoutDataLoss()
{
EntityMapping.AddMappingProcessor(new TypeDiscoveryProcessor());
EntityMapping.RegisterType(typeof(CollectionBaseModel));
var initialEntity = new CollectionBaseModel
{
KnownList = new List <KnownBaseModel>
{
new KnownBaseModel(),
new UnknownChildModel(),
new UnknownGrandChildModel()
}
};
var document = new BsonDocument();
using (var writer = new BsonDocumentWriter(document))
{
BsonSerializer.Serialize(writer, initialEntity);
}
var deserializedResult = BsonSerializer.Deserialize <CollectionBaseModel>(document);
Assert.AreEqual(3, deserializedResult.KnownList.Count);
Assert.IsInstanceOfType(deserializedResult.KnownList[0], typeof(KnownBaseModel));
Assert.IsInstanceOfType(deserializedResult.KnownList[1], typeof(UnknownChildModel));
Assert.IsInstanceOfType(deserializedResult.KnownList[2], typeof(UnknownGrandChildModel));
}
public async Task AnyAsync_WithPredicate()
{
EntityMapping.RegisterType(typeof(QueryableAsyncModel));
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var provider = new MongoFrameworkQueryProvider <QueryableAsyncModel>(connection);
var queryable = new MongoFrameworkQueryable <QueryableAsyncModel>(provider);
context.ChangeTracker.SetEntityState(new QueryableAsyncModel {
Title = "AnyAsync_WithPredicate.1"
}, EntityEntryState.Added);
context.ChangeTracker.SetEntityState(new QueryableAsyncModel {
Title = "AnyAsync_WithPredicate.2"
}, EntityEntryState.Added);
context.SaveChanges();
var resultOne = await queryable.AnyAsync(e => e.Title == "AnyAsync_WithPredicate.2");
Assert.IsTrue(resultOne);
var resultTwo = await queryable.AnyAsync(e => e.Title == "AnyAsync_WithPredicate.3");
Assert.IsFalse(resultTwo);
}
public void AdapterRequiresParameterlessConstructor()
{
EntityMapping.AddMappingProcessor(new CollectionNameProcessor());
EntityMapping.AddMappingProcessor(new PropertyMappingProcessor());
EntityMapping.AddMappingProcessor(new EntityIdProcessor());
EntityMapping.AddMappingProcessor(new MappingAdapterProcessor());
Assert.ThrowsException <MissingMethodException>(() => EntityMapping.RegisterType(typeof(AdapterTestModelConstructor)));
}
public void GetIdNameChecksInheritence()
{
var definition = EntityMapping.RegisterType(typeof(IdNameChildModel));
var parentDefinition = EntityMapping.GetOrCreateDefinition(typeof(IdNameParentModel));
Assert.AreEqual("Id", definition.GetIdName());
Assert.AreEqual("Id", parentDefinition.GetIdName());
}
public void GetAllPropertiesTakesBaseProperties()
{
var definition = EntityMapping.RegisterType(typeof(OverridePropertyChildModel));
var allProperties = definition.GetAllProperties().ToArray();
Assert.AreEqual(1, allProperties.Length);
Assert.AreEqual(typeof(OverridePropertyBaseModel), allProperties[0].EntityType);
}
public void IdMapsOnAttribute()
{
EntityMapping.AddMappingProcessor(new PropertyMappingProcessor());
EntityMapping.AddMappingProcessor(new EntityIdProcessor());
var definition = EntityMapping.RegisterType(typeof(IdByAttributeTestModel));
Assert.AreEqual("MyCustomId", definition.GetIdName());
}
public void MapsNestedStandardPropertyModel()
{
EntityMapping.AddMappingProcessor(new PropertyMappingProcessor());
EntityMapping.AddMappingProcessor(new NestedTypeProcessor());
Assert.IsFalse(BsonClassMap.IsClassMapRegistered(typeof(PropertyNestedModel)));
EntityMapping.RegisterType(typeof(PropertyBaseModel));
Assert.IsTrue(BsonClassMap.IsClassMapRegistered(typeof(PropertyNestedModel)));
}