public async Task Correct_Entity_Is_Inserted_When_Called()
{
// Arrange
var expected = new OutcomeEntity
{
FileType = "docx",
FileStatus = "rebuilt",
RowKey = "1234567",
PartitionKey = "durablefileprocessing"
};
OutcomeEntity actualEntity = null;
_mockCloudTable.Setup(s => s.ExecuteAsync(It.IsAny <TableOperation>())).Callback <TableOperation>((op) =>
{
actualEntity = (OutcomeEntity)op.Entity;
});
var cacheManager = new TableStorageCacheManager(_mockCacheClient.Object, _mockConfigurationSettings.Object);
// Act
await cacheManager.InsertEntityAsync(expected);
// Assert
Assert.That(actualEntity.FileType, Is.EqualTo(expected.FileType));
Assert.That(actualEntity.FileStatus, Is.EqualTo(expected.FileStatus));
Assert.That(actualEntity.RowKey, Is.EqualTo(expected.RowKey));
Assert.That(actualEntity.PartitionKey, Is.EqualTo(expected.PartitionKey));
}
public async Task HandleAsync(OutcomeCreated payload)
{
using (ReadModelContext db = readModelContextFactory.Create())
{
db.Outcomes.Add(new OutcomeEntity(
new OutcomeModel(
payload.AggregateKey,
payload.Amount,
payload.When,
payload.Description,
Enumerable.Empty <IKey>()
)
).SetUserKey(payload.UserKey));
await db.SaveChangesAsync();
OutcomeEntity entity = await db.Outcomes.FindAsync(payload.AggregateKey.AsGuidKey().Guid);
if (entity != null)
{
db.OutcomeCategories.Add(new OutcomeCategoryEntity()
{
OutcomeId = payload.AggregateKey.AsGuidKey().Guid,
CategoryId = payload.CategoryKey.AsGuidKey().Guid
});
await db.SaveChangesAsync();
}
}
}
public async Task Entity_Is_Inserted_When_Called()
{
// Arrange
const string fileHash = "IAMHASH";
const string fileStatus = "rebuilt";
const string fileType = "pdf";
const string partitionKey = "durablefileprocessing";
var actual = new OutcomeEntity();
var mockCacheManager = new Mock <ICacheManager <OutcomeEntity> >();
var mockContext = new Mock <IDurableActivityContext>();
var mockLogger = new Mock <ILogger>();
mockContext.Setup(s => s.GetInput <(string, string, string)>()).Returns((fileHash, fileStatus, fileType));
mockCacheManager.Setup(s => s.InsertEntityAsync(It.IsAny <OutcomeEntity>())).Callback <OutcomeEntity>((entity) =>
{
actual = entity;
});
var activityFunction = new InsertEntityIntoCache(mockCacheManager.Object);
// Act
await activityFunction.Run(mockContext.Object, mockLogger.Object);
// Assert
Assert.That(actual.FileType, Is.EqualTo(fileType));
Assert.That(actual.FileStatus, Is.EqualTo(fileStatus));
Assert.That(actual.RowKey, Is.EqualTo(fileHash));
Assert.That(actual.PartitionKey, Is.EqualTo(partitionKey));
}
public async Task HandleAsync(OutcomeDeleted payload)
{
using (ReadModelContext db = readModelContextFactory.Create())
{
OutcomeEntity entity = await db.Outcomes.FindAsync(payload.AggregateKey.AsGuidKey().Guid);
if (entity != null)
{
db.Outcomes.Remove(entity);
await db.SaveChangesAsync();
}
}
}
public async Task HandleAsync(OutcomeWhenChanged payload)
{
using (ReadModelContext db = new ReadModelContext())
{
OutcomeEntity entity = await db.Outcomes.FindAsync(payload.AggregateKey.AsGuidKey().Guid);
if (entity != null)
{
entity.When = payload.When;
await db.SaveChangesAsync();
}
}
}
public async Task HandleAsync(OutcomeDescriptionChanged payload)
{
using (ReadModelContext db = dbFactory.Create())
{
OutcomeEntity entity = await db.Outcomes.FindAsync(payload.AggregateKey.AsGuidKey().Guid);
if (entity != null)
{
entity.Description = payload.Description;
await db.SaveChangesAsync();
}
}
}
public async Task HandleAsync(OutcomeAmountChanged payload)
{
using (ReadModelContext db = readModelContextFactory.Create())
{
OutcomeEntity entity = await db.Outcomes.FindAsync(payload.AggregateKey.AsGuidKey().Guid);
if (entity != null)
{
entity.Amount = payload.NewValue.Value;
entity.Currency = payload.NewValue.Currency;
await db.SaveChangesAsync();
}
}
}
public async Task Run([ActivityTrigger] IDurableActivityContext context, ILogger log)
{
(string fileHash, string fileStatus, string fileType) = context.GetInput <(string, string, string)>();
var entry = new OutcomeEntity
{
PartitionKey = "durablefileprocessing",
RowKey = fileHash,
FileStatus = fileStatus,
FileType = fileType
};
await _cacheManager.InsertEntityAsync(entry);
}
public async Task HandleAsync(OutcomeCategoryAdded payload)
{
using (ReadModelContext db = readModelContextFactory.Create())
{
OutcomeEntity entity = await db.Outcomes.FindAsync(payload.AggregateKey.AsGuidKey().Guid);
if (entity != null)
{
db.OutcomeCategories.Add(new OutcomeCategoryEntity()
{
OutcomeId = payload.AggregateKey.AsGuidKey().Guid,
CategoryId = payload.CategoryKey.AsGuidKey().Guid
});
await db.SaveChangesAsync();
}
}
}
public async Task Entity_Is_Returned_When_Called()
{
// Arrange
const string fileHash = "IAMHASH";
const string partitionKey = "durablefileprocessing";
var expected = new OutcomeEntity
{
FileStatus = "rebuilt",
FileType = "Pdf",
RowKey = fileHash,
PartitionKey = "durablefileprocessing"
};
var mockCacheManager = new Mock <ICacheManager <OutcomeEntity> >();
var mockContext = new Mock <IDurableActivityContext>();
var mockLogger = new Mock <ILogger>();
mockCacheManager.Setup(s => s.GetEntityAsync(
It.Is <string>(name => name == partitionKey),
It.Is <string>(hash => hash == fileHash)))
.ReturnsAsync(expected);
mockContext.Setup(s => s.GetInput <string>()).Returns(fileHash);
var activityFunction = new GetEntityFromCache(mockCacheManager.Object);
// Act
var result = await activityFunction.Run(mockContext.Object, mockLogger.Object);
// Assert
Assert.That(result.FileType, Is.EqualTo(expected.FileType));
Assert.That(result.FileStatus, Is.EqualTo(expected.FileStatus));
Assert.That(result.RowKey, Is.EqualTo(expected.RowKey));
Assert.That(result.PartitionKey, Is.EqualTo(expected.PartitionKey));
}
public async Task Result_Is_Returned_When_Entity_Is_Found()
{
// Arrange
var expected = new OutcomeEntity
{
FileType = "docx",
FileStatus = "rebuilt",
RowKey = "1234567"
};
_mockCloudTable.Setup(s => s.ExecuteAsync(It.IsAny <TableOperation>())).ReturnsAsync(new TableResult {
Result = expected
});
var cacheManager = new TableStorageCacheManager(_mockCacheClient.Object, _mockConfigurationSettings.Object);
// Act
var result = await cacheManager.GetEntityAsync("partitionKey", "rowKey");
// Assert
Assert.That(result.FileType, Is.EqualTo(expected.FileType));
Assert.That(result.FileStatus, Is.EqualTo(expected.FileStatus));
Assert.That(result.RowKey, Is.EqualTo(expected.RowKey));
}
