public async Task <bool> UpdateEventWriteDataToStreamFails()
{
return(await WriteDataToStreamFails(
async() => await FileAuditWorker.UpdateEvent(ExpectedData, OldExpectedData),
x => x.UpdateLog(It.IsAny <AuditableData>(), It.IsAny <AuditableData>(), It.IsAny <AuditLog>()),
UpdateExpectedAuditLog, Times.Exactly(3), Times.Exactly(4)));
}
public async Task DiscardChanges()
{
await FileAuditWorker.DiscardEvents(ExpectedData);
MockFileStreamer.Verify(x => x.DisposeOfStream("Data\\AuditableData\\" + ExpectedData.Id + ".audit"));
MockFileStreamer.Verify(x => x.UnlockFile("Data\\AuditableData\\" + ExpectedData.Id + ".audit"));
}
public async Task <bool> RollbackEventWriteDataToStreamFailsDueToException()
{
return(await WriteDataToStreamFailsDueToException(
async() => await FileAuditWorker.RollbackEvent(ExpectedData),
x => x.RollbackLog(It.IsAny <AuditableData>(), It.IsAny <AuditLog>()),
RollbackExpectedAuditLog, Times.Exactly(3), Times.Exactly(4)));
}
public async Task <bool> UpdateEventGenerateAuditFailsDueToException()
{
return(await GenerateAuditFailsDueToException(
async() => await FileAuditWorker.UpdateEvent(ExpectedData, OldExpectedData),
x => x.UpdateLog(It.IsAny <AuditableData>(), It.IsAny <AuditableData>(), It.IsAny <AuditLog>()),
Times.Exactly(4)));
}
public async Task <bool> UpdateEventGetLockForFileFails()
{
return(await GetLockForFileFails(
async() => await FileAuditWorker.UpdateEvent(ExpectedData, OldExpectedData),
x => x.UpdateLog(It.IsAny <AuditableData>(), It.IsAny <AuditableData>(), It.IsAny <AuditLog>()),
Times.Exactly(6)));
}
public async Task <bool> CreationEventWriteDataToStreamFailsDueToException()
{
return(await WriteDataToStreamFailsDueToException(
async() => await FileAuditWorker.CreationEvent(ExpectedData),
x => x.NewLog(It.IsAny <AuditableData>()),
CreateExpectedAuditLog, Times.Exactly(3), Times.Exactly(3)));
}
public async Task ReadAllEventsSuccessful()
{
var result = await FileAuditWorker.ReadAllEvents <AuditableData>(ExpectedData.Id);
MockFileStreamer.Verify(x => x.GetLockForFile(It.IsAny <string>()), Times.Once);
MockFileStreamer.Verify(x => x.UnlockFile(It.IsAny <string>()), Times.Once);
MockFileStreamer.Verify(x => x.ReadDataFromStream <AuditLog>(It.IsAny <string>()), Times.Once);
Assert.AreSame(CreateExpectedAuditLog, result);
}
public async Task <bool> CommitEventsSuccess()
{
var result = await FileAuditWorker.CommitEvents(ExpectedData);
MockFileStreamer.Verify(x => x.DisposeOfStream(It.IsAny <string>()), Times.Never);
MockFileStreamer.Verify(x => x.UnlockFile("Data\\AuditableData\\" + ExpectedData.Id + ".audit"),
Times.Once);
return(result);
}
public async Task <AuditLog> ReadAllEventsReadDataFromStreamFailsDueToException()
{
MockFileStreamer
.Setup(x => x.ReadDataFromStream <AuditLog>(It.IsAny <string>()))
.Throws <Exception>();
var result = await FileAuditWorker.ReadAllEvents <AuditableData>(ExpectedData.Id);
MockFileStreamer.Verify(x => x.GetLockForFile(It.IsAny <string>()), Times.Exactly(3));
MockFileStreamer.Verify(x => x.UnlockFile(It.IsAny <string>()), Times.Exactly(3));
MockFileStreamer.Verify(x => x.ReadDataFromStream <AuditLog>(It.IsAny <string>()), Times.Exactly(3));
return(result);
}
public async Task <AuditLog> ReadAllEventsGetLockForFileFails()
{
MockFileStreamer
.Setup(x => x.GetLockForFile(It.IsAny <string>()))
.ReturnsAsync(false);
var result = await FileAuditWorker.ReadAllEvents <AuditableData>(ExpectedData.Id);
MockFileStreamer.Verify(x => x.GetLockForFile(It.IsAny <string>()), Times.Exactly(3));
MockFileStreamer.Verify(x => x.UnlockFile(It.IsAny <string>()), Times.Never);
MockFileStreamer.Verify(x => x.ReadDataFromStream <AuditLog>(It.IsAny <string>()), Times.Never);
return(result);
}
public void Setup()
{
Randomizer = Randomizer.CreateRandomizer();
ExpectedData = new AuditableData
{
Id = Randomizer.Next(),
Value1 = Randomizer.GetString(),
Value2 = Randomizer.Next()
};
OldExpectedData = new AuditableData
{
Id = Randomizer.Next(),
Value1 = Randomizer.GetString(),
Value2 = Randomizer.Next()
};
CreateExpectedAuditLog = new AuditLog();
UpdateExpectedAuditLog = new AuditLog();
DeleteExpectedAuditLog = new AuditLog();
UndeleteExpectedAuditLog = new AuditLog();
RollbackExpectedAuditLog = new AuditLog();
MockFileStreamer = new Mock <IFileStreamer>();
MockFileStreamer
.Setup(x => x.GetLockForFile("Data\\AuditableData\\" + ExpectedData.Id + ".audit"))
.ReturnsAsync(true);
MockFileStreamer
.Setup(x => x.Exists("Data\\AuditableData\\" + ExpectedData.Id + ".audit"))
.ReturnsAsync(true);
MockFileStreamer
.Setup(x => x.ReadDataFromStream <AuditLog>("Data\\AuditableData\\" + ExpectedData.Id + ".audit"))
.ReturnsAsync(CreateExpectedAuditLog);
MockFileStreamer
.Setup(x => x.CloseStream("Data\\AuditableData\\" + ExpectedData.Id + ".audit"))
.ReturnsAsync(true);
MockAuditGenerator = new Mock <IAuditGenerator>();
MockAuditGenerator
.Setup(x => x.NewLog(ExpectedData))
.Returns(CreateExpectedAuditLog);
MockAuditGenerator
.Setup(x => x.UpdateLog(ExpectedData, OldExpectedData, CreateExpectedAuditLog))
.Returns(UpdateExpectedAuditLog);
MockAuditGenerator
.Setup(x => x.DeleteLog(ExpectedData, CreateExpectedAuditLog))
.Returns(DeleteExpectedAuditLog);
MockAuditGenerator
.Setup(x => x.UndeleteLog(ExpectedData, CreateExpectedAuditLog))
.Returns(UndeleteExpectedAuditLog);
MockAuditGenerator
.Setup(x => x.RollbackLog(ExpectedData, CreateExpectedAuditLog))
.Returns(RollbackExpectedAuditLog);
FileAuditWorker = new FileAuditWorker(MockFileStreamer.Object, MockAuditGenerator.Object);
}
public async Task <bool> CommitEventsCloseStreamFailsDueToException()
{
MockFileStreamer
.Setup(x => x.CloseStream(It.IsAny <string>()))
.Throws <Exception>();
var result = await FileAuditWorker.CommitEvents(ExpectedData);
MockFileStreamer.Verify(x => x.DisposeOfStream("Data\\AuditableData\\" + ExpectedData.Id + ".audit"),
Times.Once);
MockFileStreamer.Verify(x => x.UnlockFile("Data\\AuditableData\\" + ExpectedData.Id + ".audit"),
Times.Once);
return(result);
}
public async Task <bool> RollbackEventSuccess()
{
return(await SuccessEvent(async() => await FileAuditWorker.RollbackEvent(ExpectedData),
x => x.RollbackLog(ExpectedData, CreateExpectedAuditLog),
RollbackExpectedAuditLog, Times.Exactly(2), Times.Once()));
}
public async Task <bool> UpdateEventSuccess()
{
return(await SuccessEvent(async() => await FileAuditWorker.UpdateEvent(ExpectedData, OldExpectedData),
x => x.UpdateLog(ExpectedData, OldExpectedData, CreateExpectedAuditLog),
UpdateExpectedAuditLog, Times.Exactly(2), Times.Once()));
}
public async Task <bool> CreationEventSuccess()
{
return(await SuccessEvent(async() => await FileAuditWorker.CreationEvent(ExpectedData),
x => x.NewLog(ExpectedData),
CreateExpectedAuditLog, Times.Once(), Times.Never()));
}
public async Task <bool> CreationEventGetLockForFileFails()
{
return(await GetLockForFileFails(async() => await FileAuditWorker.CreationEvent(ExpectedData),
x => x.NewLog(It.IsAny <AuditableData>()), Times.Exactly(3)));
}
