public void WhereIdMatchesStringIds()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var dbSet = new MongoDbSet <WhereIdMatchesStringModel>(context);
var entityCollection = new[]
{
new WhereIdMatchesStringModel {
Description = "1"
},
new WhereIdMatchesStringModel {
Description = "2"
},
new WhereIdMatchesStringModel {
Description = "3"
},
new WhereIdMatchesStringModel {
Description = "4"
}
};
dbSet.AddRange(entityCollection);
context.SaveChanges();
var provider = new MongoFrameworkQueryProvider <WhereIdMatchesStringModel>(connection);
var queryable = new MongoFrameworkQueryable <WhereIdMatchesStringModel>(provider);
var entityIds = entityCollection.Select(e => e.Id).Take(2);
var idMatchQueryable = LinqExtensions.WhereIdMatches(queryable, entityIds);
Assert.AreEqual(2, idMatchQueryable.Count());
Assert.IsTrue(idMatchQueryable.ToList().All(e => entityIds.Contains(e.Id)));
}
public void EntityProcessorsNotFiredWhenNotTEntity()
{
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 = "EntityProcessorNoFireTest"
}, EntityEntryState.Added);
writerPipeline.Write();
foreach (var titles in queryable.Select(e => e.Title))
{
//Do nothing
}
Assert.IsFalse(processor.EntityProcessed);
}
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 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 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 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 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 ReadMixedEntities()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var provider = new MongoFrameworkQueryProvider <MixedReadA>(connection);
var queryable = new MongoFrameworkQueryable <MixedReadA>(provider);
context.ChangeTracker.SetEntityState(new MixedReadA
{
Description = "MongoFrameworkQueryableTests.ReadMixedEntities"
}, EntityEntryState.Added);
context.ChangeTracker.SetEntityState <MixedReadA>(new MixedReadB
{
BIsForBoolean = true,
Description = "MongoFrameworkQueryableTests.ReadMixedEntities"
}, EntityEntryState.Added);
context.SaveChanges();
var readMixedEntitiesQuery = queryable.Where(e => e.Description == "MongoFrameworkQueryableTests.ReadMixedEntities");
Assert.AreEqual(2, readMixedEntitiesQuery.Count());
Assert.AreEqual(2, readMixedEntitiesQuery.OfType <MixedReadA>().Count());
Assert.AreEqual(1, readMixedEntitiesQuery.OfType <MixedReadB>().Count());
}
public void WhereIdMatchesGuids()
{
var connection = TestConfiguration.GetConnection();
var writerPipeline = new EntityWriterPipeline <WhereIdMatchesGuidModel>(TestConfiguration.GetConnection());
var entityCollection = new EntityCollection <WhereIdMatchesGuidModel>()
{
new WhereIdMatchesGuidModel {
Description = "1"
},
new WhereIdMatchesGuidModel {
Description = "2"
},
new WhereIdMatchesGuidModel {
Description = "3"
},
new WhereIdMatchesGuidModel {
Description = "4"
}
};
writerPipeline.AddCollection(entityCollection);
writerPipeline.Write();
var provider = new MongoFrameworkQueryProvider <WhereIdMatchesGuidModel>(connection);
var queryable = new MongoFrameworkQueryable <WhereIdMatchesGuidModel>(provider);
var entityIds = entityCollection.Select(e => e.Id).Take(2);
var idMatchQueryable = LinqExtensions.WhereIdMatches(queryable, entityIds);
Assert.AreEqual(2, idMatchQueryable.Count());
Assert.IsTrue(idMatchQueryable.ToList().All(e => entityIds.Contains(e.Id)));
}
public IQueryable <TEntity> AsQueryable()
{
var provider = new MongoFrameworkQueryProvider <TEntity>(Connection);
provider.EntityProcessors.Add(new EntityMutationProcessor <TEntity>());
var queryable = new MongoFrameworkQueryable <TEntity>(provider);
return(queryable);
}
public async Task SingleOrDefaultAsync_NoValue()
{
EntityMapping.RegisterType(typeof(QueryableAsyncModel));
var connection = TestConfiguration.GetConnection();
var provider = new MongoFrameworkQueryProvider <QueryableAsyncModel>(connection);
var queryable = new MongoFrameworkQueryable <QueryableAsyncModel>(provider);
Assert.IsNull(await queryable.SingleOrDefaultAsync());
}
public async Task FirstAsync_NoValue()
{
EntityMapping.RegisterType(typeof(QueryableAsyncModel));
var connection = TestConfiguration.GetConnection();
var provider = new MongoFrameworkQueryProvider <QueryableAsyncModel>(connection);
var queryable = new MongoFrameworkQueryable <QueryableAsyncModel>(provider);
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await queryable.FirstAsync());
}
public void ValidToQuery()
{
EntityMapping.RegisterType(typeof(LinqExtensionsModel));
var connection = TestConfiguration.GetConnection();
var provider = new MongoFrameworkQueryProvider <LinqExtensionsModel>(connection);
var queryable = new MongoFrameworkQueryable <LinqExtensionsModel>(provider);
var result = LinqExtensions.ToQuery(queryable);
Assert.AreEqual("db.LinqExtensionsModel.aggregate([])", result);
}
public async Task SumAsync_NullableLong_NoValue()
{
EntityMapping.RegisterType(typeof(QueryableAsyncSumModel));
var connection = TestConfiguration.GetConnection();
var provider = new MongoFrameworkQueryProvider <QueryableAsyncSumModel>(connection);
var queryable = new MongoFrameworkQueryable <QueryableAsyncSumModel>(provider);
var result = await queryable.Select(e => e.NullableLongNumber).SumAsync();
Assert.IsNull(result);
}
public async Task AnyAsync_NoValues()
{
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);
var result = await queryable.AnyAsync();
Assert.IsFalse(result);
}
public async Task MinAsync_NoValues()
{
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.SaveChanges();
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await queryable.Select(e => e.IntNumber).MinAsync());
}
public async Task CountAsync_NoValues()
{
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.SaveChanges();
var result = await queryable.CountAsync();
Assert.AreEqual(0, result);
}
/// <inheritdoc/>
public async ValueTask <CacheEntry <T>?> GetAsync <T>(string cacheKey)
{
await TryConfigureIndexes();
var provider = new MongoFrameworkQueryProvider <DbCachedEntry>(Connection);
var queryable = new MongoFrameworkQueryable <DbCachedEntry>(provider);
var dbEntry = queryable.Where(e => e.CacheKey == cacheKey).FirstOrDefault();
var cacheEntry = default(CacheEntry <T>);
if (dbEntry != default)
{
cacheEntry = new CacheEntry <T>((T)dbEntry.Value !, dbEntry.Expiry);
}
return(cacheEntry);
}
public static IQueryable <TEntity> SearchGeoNear <TEntity, TCoordinates>(this IMongoDbSet <TEntity> dbSet, Expression <Func <TEntity, object> > targetField, GeoJsonPoint <TCoordinates> point, Expression <Func <TEntity, object> > distanceResultField = null, double?maxDistance = null, double?minDistance = null) where TEntity : class where TCoordinates : GeoJsonCoordinates
{
var entitySerializer = BsonSerializer.LookupSerializer <TEntity>();
var keyExpressionField = new ExpressionFieldDefinition <TEntity>(targetField);
var keyStringField = keyExpressionField.Render(entitySerializer, BsonSerializer.SerializerRegistry);
var distanceFieldName = "Distance";
if (distanceResultField != null)
{
var distanceResultExpressionField = new ExpressionFieldDefinition <TEntity>(distanceResultField);
var distanceResultStringField = distanceResultExpressionField.Render(entitySerializer, BsonSerializer.SerializerRegistry);
distanceFieldName = distanceResultStringField.FieldName;
}
var geoNearSettings = new BsonDocument
{
{ "near", point.ToBsonDocument() },
{ "key", keyStringField.FieldName },
{ "distanceField", distanceFieldName },
//Note: Limit here is maxed as an operational courtesy as future versions will eliminate it (see Jira SERVER-22949)
// Additionally, $geoNear operations still have a 16MB document limit in aggregation (see Jira SERVER-18965)
{ "limit", int.MaxValue }
};
if (maxDistance.HasValue)
{
geoNearSettings.Add("maxDistance", maxDistance.Value);
}
if (minDistance.HasValue)
{
geoNearSettings.Add("minDistance", minDistance.Value);
}
var stage = new BsonDocument
{
{ "$geoNear", geoNearSettings }
};
var originalProvider = dbSet.Provider as IMongoFrameworkQueryProvider <TEntity>;
var provider = new MongoFrameworkQueryProvider <TEntity>(originalProvider, stage);
return(new MongoFrameworkQueryable <TEntity>(provider));
}
public async Task SingleOrDefaultAsync_HasValue()
{
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 = "SingleOrDefaultAsync_HasValue.1"
}, EntityEntryState.Added);
context.SaveChanges();
var result = await queryable.SingleOrDefaultAsync();
Assert.AreEqual("SingleOrDefaultAsync_HasValue.1", result.Title);
}
public void EnumerateQueryable()
{
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);
context.ChangeTracker.SetEntityState(new MongoFrameworkQueryableModel {
Title = "EnumerateQueryable"
}, EntityEntryState.Added);
context.SaveChanges();
foreach (var dbEntity in queryable)
{
Assert.AreEqual("EnumerateQueryable", dbEntity.Title);
}
}
public async Task ToArrayAsync()
{
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 = "ToArrayAsync"
}, EntityEntryState.Added);
context.SaveChanges();
var result = await queryable.ToArrayAsync();
Assert.AreEqual(1, result.Length);
Assert.AreEqual("ToArrayAsync", result[0].Title);
}
public async Task AsyncEnumeration()
{
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 = "EnumerateQueryableAsync"
}, EntityEntryState.Added);
context.SaveChanges();
await foreach (var entity in queryable.AsAsyncEnumerable())
{
Assert.AreEqual("EnumerateQueryableAsync", entity.Title);
}
}
public async Task SingleOrDefaultAsync_HasMoreThanOneValue()
{
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 = "SingleOrDefaultAsync_HasMoreThanOneValue.1"
}, EntityEntryState.Added);
context.ChangeTracker.SetEntityState(new QueryableAsyncModel {
Title = "SingleOrDefaultAsync_HasMoreThanOneValue.2"
}, EntityEntryState.Added);
context.SaveChanges();
await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() => await queryable.SingleOrDefaultAsync());
}
public static IQueryable <TEntity> SearchGeoNear <TEntity, TCoordinates>(this IMongoDbSet <TEntity> dbSet, Expression <Func <TEntity, object> > targetField, GeoJsonPoint <TCoordinates> point, Expression <Func <TEntity, object> > distanceResultField = null, double?maxDistance = null, double?minDistance = null) where TEntity : class where TCoordinates : GeoJsonCoordinates
{
var entitySerializer = BsonSerializer.LookupSerializer <TEntity>();
var keyExpressionField = new ExpressionFieldDefinition <TEntity>(targetField);
var keyStringField = keyExpressionField.Render(entitySerializer, BsonSerializer.SerializerRegistry);
var distanceFieldName = "Distance";
if (distanceResultField != null)
{
var distanceResultExpressionField = new ExpressionFieldDefinition <TEntity>(distanceResultField);
var distanceResultStringField = distanceResultExpressionField.Render(entitySerializer, BsonSerializer.SerializerRegistry);
distanceFieldName = distanceResultStringField.FieldName;
}
var geoNearSettings = new BsonDocument
{
{ "near", point.ToBsonDocument() },
{ "key", keyStringField.FieldName },
{ "distanceField", distanceFieldName }
};
if (maxDistance.HasValue)
{
geoNearSettings.Add("maxDistance", maxDistance.Value);
}
if (minDistance.HasValue)
{
geoNearSettings.Add("minDistance", minDistance.Value);
}
var stage = new BsonDocument
{
{ "$geoNear", geoNearSettings }
};
var originalProvider = dbSet.Provider as IMongoFrameworkQueryProvider <TEntity>;
var provider = new MongoFrameworkQueryProvider <TEntity>(originalProvider, stage);
return(new MongoFrameworkQueryable <TEntity>(provider));
}
public async Task MinAsync_WithSelector()
{
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 = "MinAsync_WithSelector.1", IntNumber = 20
}, EntityEntryState.Added);
context.ChangeTracker.SetEntityState(new QueryableAsyncModel {
Title = "MinAsync_WithSelector.2", IntNumber = 10
}, EntityEntryState.Added);
context.SaveChanges();
var result = await queryable.MinAsync(e => e.IntNumber);
Assert.AreEqual(10, result);
}
public async Task MinAsync_HasValues_Date()
{
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 = "MinAsync_HasValues_Date.1", Date = new DateTime(2020, 3, 10, 0, 0, 0, DateTimeKind.Utc)
}, EntityEntryState.Added);
context.ChangeTracker.SetEntityState(new QueryableAsyncModel {
Title = "MinAsync_HasValues_Date.2", Date = new DateTime(2020, 1, 10, 0, 0, 0, DateTimeKind.Utc)
}, EntityEntryState.Added);
context.SaveChanges();
var result = await queryable.Select(e => e.Date).MinAsync();
Assert.AreEqual(new DateTime(2020, 1, 10, 0, 0, 0, DateTimeKind.Utc), result);
}
public void EnumerateQueryable()
{
EntityMapping.RegisterType(typeof(MongoFrameworkQueryableModel));
var connection = TestConfiguration.GetConnection();
var provider = new MongoFrameworkQueryProvider <MongoFrameworkQueryableModel>(connection);
var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel>(provider);
var entityCollection = new EntityCollection <MongoFrameworkQueryableModel>();
var writerPipeline = new EntityWriterPipeline <MongoFrameworkQueryableModel>(connection);
writerPipeline.AddCollection(entityCollection);
entityCollection.Update(new MongoFrameworkQueryableModel {
Title = "EnumerateQueryable"
}, EntityEntryState.Added);
writerPipeline.Write();
foreach (var entity in queryable)
{
Assert.AreEqual("EnumerateQueryable", entity.Title);
}
}
public void EntityProcessorsNotFiredWhenNotTEntity_Any()
{
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_Any"
}, EntityEntryState.Added);
context.SaveChanges();
var result = queryable.Any(e => e.Title == "EntityProcessorsNotFiredWhenNotTEntity_Any");
Assert.IsTrue(result);
Assert.IsFalse(processor.EntityProcessed);
}
public void EntityProcessorsRunWhenToDictionaryIsUsed()
{
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 = "EntityProcessorsRunWithToDictionaryTest"
}, EntityEntryState.Added);
context.SaveChanges();
var result = queryable.ToDictionary(m => m.Id);
Assert.AreEqual("EntityProcessorsRunWithToDictionaryTest", result.FirstOrDefault().Value.Title);
Assert.IsTrue(processor.EntityProcessed);
}
