public void AddMixedTypeEntities()
{
var connection = TestConfiguration.GetConnection();
var entityCollection = new EntityCollection <TestModel>();
var pipeline = new EntityWriterPipeline <TestModel>(connection);
var reader = new EntityReader <TestModel>(connection);
pipeline.AddCollection(entityCollection);
var entities = new[]
{
new TestModel
{
Title = "DbEntityWriterTests.AddMixedTypeEntities"
},
new ExtendedTestModel
{
Title = "DbEntityWriterTests.AddMixedTypeEntities",
AdditionalField = "AdditionalFieldSet"
}
};
foreach (var entity in entities)
{
entityCollection.Update(entity, EntityEntryState.Added);
}
pipeline.Write();
Assert.IsTrue(reader.AsQueryable().OfType <TestModel>().Any(e => e.Title == "DbEntityWriterTests.AddMixedTypeEntities"));
Assert.IsTrue(reader.AsQueryable().OfType <ExtendedTestModel>().Any(e => e.AdditionalField == "AdditionalFieldSet"));
}
private IQueryable <EntityBucket <TGroup, TSubEntity> > GetQueryable()
{
var queryable = EntityReader.AsQueryable() as IMongoFrameworkQueryable <EntityBucket <TGroup, TSubEntity>, EntityBucket <TGroup, TSubEntity> >;
queryable.EntityProcessors.Add(new EntityTrackingProcessor <EntityBucket <TGroup, TSubEntity> >(ChangeTracker));
return(queryable);
}
public void ReadMixedEntities()
{
var connection = TestConfiguration.GetConnection();
var entityCollection = new EntityCollection <A>();
var reader = new EntityReader <A>(connection);
var writerPipeline = new EntityWriterPipeline <A>(connection);
writerPipeline.AddCollection(entityCollection);
entityCollection.Update(new A
{
Description = "DbEntityReaderTests.ReadMixedEntities"
}, EntityEntryState.Added);
entityCollection.Update(new B
{
BIsForBoolean = true,
Description = "DbEntityReaderTests.ReadMixedEntities"
}, EntityEntryState.Added);
writerPipeline.Write();
var readMixedEntitiesQuery =
reader.AsQueryable().Where(e => e.Description == "DbEntityReaderTests.ReadMixedEntities");
Assert.AreEqual(2, readMixedEntitiesQuery.Count());
Assert.AreEqual(2, readMixedEntitiesQuery.OfType <A>().Count());
Assert.AreEqual(1, readMixedEntitiesQuery.OfType <B>().Count());
}
private IQueryable <TEntity> GetQueryable()
{
var queryable = EntityReader.AsQueryable() as IMongoFrameworkQueryable <TEntity, TEntity>;
queryable.EntityProcessors.Add(new EntityTrackingProcessor <TEntity>(ChangeTracker));
return(queryable);
}
public void RemoveEntity()
{
var connection = TestConfiguration.GetConnection();
var writer = new CommandWriter <TestModel>(connection);
var reader = new EntityReader <TestModel>(connection);
var entity = new TestModel
{
Title = "RemoveEntityByIdCommandTests.RemoveEntity"
};
writer.Write(new[]
{
new AddEntityCommand <TestModel>(new EntityEntry <TestModel>(entity, EntityEntryState.Added))
});
writer.Write(new[]
{
new RemoveEntityByIdCommand <TestModel>(entity.Id)
});
var dbEntity = reader.AsQueryable().Where(e => e.Id == entity.Id).FirstOrDefault();
Assert.IsNull(dbEntity);
}
public void UpdateEntity()
{
var connection = TestConfiguration.GetConnection();
var writer = new CommandWriter <TestModel>(connection);
var reader = new EntityReader <TestModel>(connection);
var entity = new TestModel
{
Title = "UpdateEntityCommandTests.UpdateEntity"
};
writer.Write(new[]
{
new AddEntityCommand <TestModel>(new EntityEntry <TestModel>(entity, EntityEntryState.Added))
});
var updatedEntity = new TestModel
{
Id = entity.Id,
Title = "UpdateEntityCommandTests.UpdateEntity-Updated"
};
writer.Write(new[]
{
new UpdateEntityCommand <TestModel>(new EntityEntry <TestModel>(updatedEntity, EntityEntryState.Updated))
});
var dbEntity = reader.AsQueryable().Where(e => e.Id == entity.Id).FirstOrDefault();
Assert.AreEqual("UpdateEntityCommandTests.UpdateEntity-Updated", dbEntity.Title);
}
#pragma warning disable CRR0026 // Unused member - called through Reflection
private static void InitialiseSingleEntityRelationship <TRelatedEntity>(TEntity targetEntity, IEntityRelationship relationship, IMongoDbConnection connection) where TRelatedEntity : class
{
var dbEntityReader = new EntityReader <TRelatedEntity>(connection);
var relationshipIdValue = relationship.IdProperty.GetValue(targetEntity);
var loadedEntity = dbEntityReader.AsQueryable().WhereIdMatches(new[] { relationshipIdValue }).FirstOrDefault();
relationship.NavigationProperty.SetValue(targetEntity, loadedEntity);
}
public async Task MixedActionWriteAsync()
{
var connection = TestConfiguration.GetConnection();
var entityCollection = new EntityCollection <TestModel>();
var pipeline = new EntityWriterPipeline <TestModel>(connection);
var reader = new EntityReader <TestModel>(connection);
pipeline.AddCollection(entityCollection);
var updateEntity = new TestModel
{
Title = "EntityWriterPipelineTests.MixedActionWriteAsync-UpdateEntity"
};
var deleteEntity = new TestModel
{
Title = "EntityWriterPipelineTests.MixedActionWriteAsync-DeleteEntity"
};
entityCollection.Update(updateEntity, EntityEntryState.Added);
entityCollection.Update(deleteEntity, EntityEntryState.Added);
await pipeline.WriteAsync().ConfigureAwait(false);
entityCollection.Clear();
var addedEntity = new TestModel
{
Title = "EntityWriterPipelineTests.MixedActionWriteAsync-AddEntity"
};
updateEntity.Title = "EntityWriterPipelineTests.MixedActionWriteAsync-UpdateEntity-Updated";
entityCollection.Update(addedEntity, EntityEntryState.Added);
entityCollection.Update(updateEntity, EntityEntryState.Updated);
entityCollection.Update(deleteEntity, EntityEntryState.Deleted);
await pipeline.WriteAsync().ConfigureAwait(false);
Assert.IsTrue(reader.AsQueryable().Where(e => e.Id == addedEntity.Id).Any());
Assert.IsFalse(reader.AsQueryable().Where(e => e.Id == deleteEntity.Id).Any());
var dbEntity = reader.AsQueryable().Where(e => e.Id == updateEntity.Id).FirstOrDefault();
Assert.AreEqual("EntityWriterPipelineTests.MixedActionWriteAsync-UpdateEntity-Updated", dbEntity.Title);
}
public void RemoveEntities()
{
var connection = TestConfiguration.GetConnection();
var writer = new CommandWriter <TestModel>(connection);
var reader = new EntityReader <TestModel>(connection);
var entities = new[]
{
new TestModel
{
Title = "RemoveEntityRangeCommandTests.RemoveEntities",
DateTime = DateTime.UtcNow.AddDays(-1)
},
new TestModel
{
Title = "RemoveEntityRangeCommandTests.RemoveEntities",
DateTime = DateTime.UtcNow.AddDays(1)
}
};
writer.Write(new[]
{
new AddEntityCommand <TestModel>(new EntityEntry <TestModel>(entities[0], EntityEntryState.Added)),
new AddEntityCommand <TestModel>(new EntityEntry <TestModel>(entities[1], EntityEntryState.Added))
});
writer.Write(new[]
{
new RemoveEntityRangeCommand <TestModel>(e => e.DateTime < DateTime.UtcNow)
});
var removedEntity = reader.AsQueryable().Where(e => e.Id == entities[0].Id).FirstOrDefault();
Assert.IsNull(removedEntity);
var nonRemovedEntity = reader.AsQueryable().Where(e => e.Id == entities[1].Id).FirstOrDefault();
Assert.IsNotNull(nonRemovedEntity);
}
public async Task <CacheEntry <T> > GetAsync <T>(string cacheKey)
{
await TryConfigureIndexes();
var dbEntry = EntityReader.AsQueryable().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 virtual IQueryable <TSubEntity> WithGroup(TGroup group)
{
var totalItemCount = EntityReader.AsQueryable().Where(e => e.Group == group).Sum(e => e.ItemCount);
return(EntityReader.AsQueryable().Where(e => e.Group == group).OrderBy(e => e.Index).SelectMany(e => e.Items).Take(totalItemCount));
}
public virtual IQueryable <TGroup> Groups()
{
return(EntityReader.AsQueryable().Select(e => e.Group).Distinct());
}
private IQueryable <EntityBucket <TGroup, TSubEntity> > GetQueryable()
{
return(EntityReader.AsQueryable());
}
public virtual IQueryable <TSubEntity> WithGroup(TGroup group)
{
return(EntityReader.AsQueryable().Where(e => e.Group == group).OrderBy(e => e.Min).SelectMany(e => e.Items));
}
