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 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 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 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 IQueryable <TEntity> AsQueryable()
{
var underlyingQueryable = GetCollection().AsQueryable();
var queryable = new MongoFrameworkQueryable <TEntity, TEntity>(underlyingQueryable);
queryable.EntityProcessors.Add(new EntityMutationProcessor <TEntity>(Database));
return(queryable);
}
public void ValidToQuery()
{
var collection = TestConfiguration.GetDatabase().GetCollection <LinqExtensionsModel>("LinqExtensionsModel");
var underlyingQueryable = collection.AsQueryable();
var queryable = new MongoFrameworkQueryable <LinqExtensionsModel, LinqExtensionsModel>(underlyingQueryable);
var result = LinqExtensions.ToQuery(queryable);
Assert.AreEqual("db.LinqExtensionsModel.aggregate([])", result);
}
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 void ValidToQuery()
{
EntityMapping.RegisterType(typeof(LinqExtensionsModel));
var connection = TestConfiguration.GetConnection();
var collection = connection.GetDatabase().GetCollection <LinqExtensionsModel>(nameof(LinqExtensionsModel));
var underlyingQueryable = collection.AsQueryable();
var queryable = new MongoFrameworkQueryable <LinqExtensionsModel, LinqExtensionsModel>(connection, underlyingQueryable);
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 async Task AnyAsync_HasValues()
{
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_HasValues.1"
}, EntityEntryState.Added);
context.SaveChanges();
var result = await queryable.AnyAsync();
Assert.IsTrue(result);
}
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 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 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 ToListAsync()
{
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 = "ToListAsync"
}, EntityEntryState.Added);
context.SaveChanges();
var result = await queryable.ToListAsync();
Assert.AreEqual(1, result.Count);
Assert.AreEqual("ToListAsync", result[0].Title);
}
public async Task SumAsync_Int32_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_Int32_HasValue.1", Int32Number = 5
}, EntityEntryState.Added);
context.ChangeTracker.SetEntityState(new QueryableAsyncSumModel {
Title = "SumAsync_Int32_HasValue.2", Int32Number = 9
}, EntityEntryState.Added);
context.SaveChanges();
var result = await queryable.Select(e => e.Int32Number).SumAsync();
Assert.AreEqual(14, result);
}
public async Task SingleOrDefaultAsync_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 = "SingleOrDefaultAsync_WithPredicate.1"
}, EntityEntryState.Added);
context.ChangeTracker.SetEntityState(new QueryableAsyncModel {
Title = "SingleOrDefaultAsync_WithPredicate.2"
}, EntityEntryState.Added);
context.SaveChanges();
var result = await queryable.SingleOrDefaultAsync(e => e.Title == "SingleOrDefaultAsync_WithPredicate.2");
Assert.AreEqual("SingleOrDefaultAsync_WithPredicate.2", result.Title);
}
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 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 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 EnumerateQueryable()
{
var database = TestConfiguration.GetDatabase();
new EntityMapper <MongoFrameworkQueryableModel>();
var collection = database.GetCollection <MongoFrameworkQueryableModel>("MongoFrameworkQueryableModel");
var underlyingQueryable = collection.AsQueryable();
var queryable = new MongoFrameworkQueryable <MongoFrameworkQueryableModel, MongoFrameworkQueryableModel>(underlyingQueryable);
var entityContainer = new DbEntityCollection <MongoFrameworkQueryableModel>();
var writer = new DbEntityWriter <MongoFrameworkQueryableModel>(database);
entityContainer.Update(new MongoFrameworkQueryableModel {
Title = "EnumerateQueryable"
}, DbEntityEntryState.Added);
writer.Write(entityContainer);
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);
}
