public void UpdateEntity()
{
var database = TestConfiguration.GetDatabase();
var entityContainer = new DbEntityCollection <EntityWriterModel>();
var writer = new DbEntityWriter <EntityWriterModel>(database);
var reader = new DbEntityReader <EntityWriterModel>(database);
//Get entity initially into the DB so we can update it
var entity = new EntityWriterModel
{
Title = "DbEntityWriterTests.UpdateEntity"
};
entityContainer.Update(entity, DbEntityEntryState.Added);
writer.Write(entityContainer);
entityContainer.Clear();
//Our updated entity with the same ID
var updatedEntity = new EntityWriterModel
{
Id = entity.Id,
Title = "DbEntityWriterTests.UpdateEntity-Updated"
};
entityContainer.Update(updatedEntity, DbEntityEntryState.Updated);
writer.Write(entityContainer);
var dbEntity = reader.AsQueryable().Where(e => e.Id == entity.Id).FirstOrDefault();
Assert.AreEqual("DbEntityWriterTests.UpdateEntity-Updated", dbEntity.Title);
}
public void ReadMixedEntities()
{
var database = TestConfiguration.GetDatabase();
var entityContainer = new DbEntityCollection <A>();
var reader = new DbEntityReader <A>(database);
var writer = new DbEntityWriter <A>(database);
entityContainer.Update(new A
{
Description = "DbEntityReaderTests.ReadMixedEntities"
}, DbEntityEntryState.Added);
entityContainer.Update(new B
{
BIsForBoolean = true,
Description = "DbEntityReaderTests.ReadMixedEntities"
}, DbEntityEntryState.Added);
writer.Write(entityContainer);
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());
}
#pragma warning disable CRR0026 // Unused member - called through Reflection
private static void InitialiseSingleEntityRelationship <TRelatedEntity>(TEntity targetEntity, EntityRelationship relationship, IMongoDatabase database)
{
var dbEntityReader = new DbEntityReader <TRelatedEntity>(database);
var relationshipIdValue = relationship.IdProperty.GetValue(targetEntity);
var loadedEntity = dbEntityReader.AsQueryable().WhereIdMatches(new[] { relationshipIdValue }).FirstOrDefault();
relationship.NavigationProperty.SetValue(targetEntity, loadedEntity);
}
/// <summary>
/// Initialise a new entity reader and writer to the specified database.
/// </summary>
/// <param name="database"></param>
public void SetDatabase(IMongoDatabase database)
{
Database = database;
var entityMapper = new EntityMapper <TEntity>();
EntityWriter = new DbEntityWriter <TEntity>(database, entityMapper);
EntityReader = new DbEntityReader <TEntity>(database, entityMapper);
//TODO: Look at this again in the future, this seems unnecessarily complex
var indexMapper = new EntityIndexMapper <TEntity>(entityMapper);
var collection = database.GetCollection <TEntity>(entityMapper.GetCollectionName());
EntityIndexWriter = new EntityIndexWriter <TEntity>(collection, indexMapper);
EntityRelationshipWriter = new EntityRelationshipWriter <TEntity>(database, entityMapper);
}
public void LoadEntities()
{
if (!UnloadedIds.Any())
{
return;
}
var dbEntityReader = new DbEntityReader <TEntity>(Database, EntityMapper);
var entities = dbEntityReader.AsQueryable().WherePropertyMatches(ForeignKey, ForeignPropertyMap.PropertyType, UnloadedIds);
foreach (var entity in entities)
{
Update(entity, DbEntityEntryState.NoChanges);
}
UnloadedIds.Clear();
}
public async Task MixedActionWriteAsync()
{
var database = TestConfiguration.GetDatabase();
var entityContainer = new DbEntityCollection <EntityWriterModel>();
var writer = new DbEntityWriter <EntityWriterModel>(database);
var reader = new DbEntityReader <EntityWriterModel>(database);
var updateEntity = new EntityWriterModel
{
Title = "DbEntityWriterTests.MixedActionWriteAsync-UpdateEntity"
};
var deleteEntity = new EntityWriterModel
{
Title = "DbEntityWriterTests.MixedActionWriteAsync-DeleteEntity"
};
entityContainer.Update(updateEntity, DbEntityEntryState.Added);
entityContainer.Update(deleteEntity, DbEntityEntryState.Added);
await writer.WriteAsync(entityContainer).ConfigureAwait(false);
entityContainer.Clear();
var addedEntity = new EntityWriterModel
{
Title = "DbEntityWriterTests.MixedActionWriteAsync-AddEntity"
};
updateEntity.Title = "DbEntityWriterTests.MixedActionWriteAsync-UpdateEntity-Updated";
entityContainer.Update(addedEntity, DbEntityEntryState.Added);
entityContainer.Update(updateEntity, DbEntityEntryState.Updated);
entityContainer.Update(deleteEntity, DbEntityEntryState.Deleted);
await writer.WriteAsync(entityContainer).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("DbEntityWriterTests.MixedActionWriteAsync-UpdateEntity-Updated", dbEntity.Title);
}
public void RemoveEntity()
{
var database = TestConfiguration.GetDatabase();
var entityContainer = new DbEntityCollection <EntityWriterModel>();
var writer = new DbEntityWriter <EntityWriterModel>(database);
var reader = new DbEntityReader <EntityWriterModel>(database);
//Get entity initially into the DB so we can remove it
var entity = new EntityWriterModel
{
Title = "DbEntityWriterTests.RemoveEntity"
};
entityContainer.Update(entity, DbEntityEntryState.Added);
writer.Write(entityContainer);
entityContainer.Clear();
//Remove the entity
entityContainer.Update(entity, DbEntityEntryState.Deleted);
writer.Write(entityContainer);
Assert.IsFalse(reader.AsQueryable().Any(e => e.Id == entity.Id));
}
public new IEnumerator <TEntity> GetEnumerator()
{
//Enumerate loaded entities
var result = Entries.Select(e => e.Entity);
using (var enumerator = result.GetEnumerator())
{
while (enumerator.MoveNext())
{
yield return(enumerator.Current);
}
}
//Enumerate list of unloaded IDs and load them in one at a time
if (UnloadedIds.Any())
{
var dbEntityReader = new DbEntityReader <TEntity>(Database, EntityMapper);
var unloadedEntities = dbEntityReader.AsQueryable().WherePropertyMatches(ForeignKey, ForeignPropertyMap.PropertyType, UnloadedIds);
using (var unloadedEnumerator = unloadedEntities.GetEnumerator())
{
while (unloadedEnumerator.MoveNext())
{
var loadedEntity = unloadedEnumerator.Current;
//Load the data into the collection so we don't need to query it again
Update(loadedEntity, DbEntityEntryState.NoChanges);
//Remove from unloaded entity collection
var foreignId = ForeignPropertyMap.Property.GetValue(loadedEntity);
UnloadedIds.Remove(foreignId);
yield return(loadedEntity);
}
}
}
}
