public async Task SavesDiffToDataDir(int diffId, DifferenceType type, int offset)
{
var content = new DifferenceContent
{
Type = type,
Details = new[] {
new DifferenceDetail {
LeftOffset = offset
},
new DifferenceDetail {
RightOffset = offset
},
}
};
var expectedFileName = Path.Combine(_DataDir,
string.Concat(diffId.ToString(), ".diff"));
File.Delete(expectedFileName);
var storage = new DiskStorage(_Options);
await storage.SaveDiffAsync(content.InDiffBag(diffId));
File.ReadAllText(expectedFileName)
.Should().Be(JsonConvert.SerializeObject(content));
}
public async Task LoadsReadyDiffFromDataDir(int diffId, DifferenceType type, int length)
{
var content = new DifferenceContent
{
Type = type,
Details = new[] {
new DifferenceDetail {
LeftLength = length
},
new DifferenceDetail {
RightLength = length
},
}
};
var expectedFileName = Path.Combine(_DataDir,
string.Concat(diffId.ToString(), ".diff"));
File.WriteAllText(expectedFileName, JsonConvert.SerializeObject(content));
try
{
var storage = new DiskStorage(_Options);
var(diff, readiness) = await storage.LoadDiffAsync(diffId);
readiness.Should().Be(DifferenceReadiness.Ready);
diff.Type.Should().Be(type);
diff.Details.ShouldAllBeEquivalentTo(content.Details,
opts => opts.WithStrictOrdering());
}
finally
{
File.Delete(expectedFileName);
}
}
public async Task GetReturnsOkObjectResultWithDifferenceContentWhenReadinessReady()
{
var content = new DifferenceContent
{
Type = DifferenceType.SizeDiffers
};
var service = Substitute.For <IDifferenceService>();
service.FindDiffAsync(10).Returns(
Task.FromResult((content, DifferenceReadiness.Ready)));
var controller = new DiffController(service);
var result = await controller.Get(10);
result.Should()
.BeOfType <OkObjectResult>()
.Which.Value.Should().Be(content);
}
public async Task SavesDifferenceContentInStorage()
{
var ready = new[]
{
new SourceContent
{
SourceSide = SourceSide.Left,
Data = new byte[] { 1, 2, 3 }
},
new SourceContent
{
SourceSide = SourceSide.Right,
Data = new byte[] { 3, 4, 5 }
}
}.AsEnumerable();
var diff = new DifferenceContent
{
Type = DifferenceType.Detailed,
Details = new[] {
new DifferenceDetail {
LeftOffset = 1, RightOffset = 2
},
new DifferenceDetail {
LeftLength = 3, RightLength = 4
},
}
};
var queue = Substitute.For <IDifferenceQueue>();
var storage = Substitute.For <IStorage>();
var algorithm = Substitute.For <IDifferenceAlgorithm>();
queue.ReadyContents.Returns(Observable.Return(ready.InDiffBag(5)));
algorithm.GetDiffAsync(ready).Returns(Task.FromResult(diff));
var consumer = new ReadyConsumer(queue, storage, algorithm);
await consumer.RunAsync(Scheduler.Immediate, CancellationToken.None);
await storage.Received().SaveDiffAsync(diff.InDiffBag(5));
}
public async Task FindsDiffInStorage(DifferenceType diffType,
DifferenceReadiness diffReadiness, int leftOffset)
{
var queue = Substitute.For <IDifferenceQueue>();
var storage = Substitute.For <IStorage>();
var diff = new DifferenceContent
{
Type = diffType,
Details = new[] { new DifferenceDetail {
LeftOffset = leftOffset
} },
};
storage.LoadDiffAsync(10).Returns(Task.FromResult((diff, diffReadiness)));
var service = new DifferenceService(queue, Enumerable.Empty <IQueueConsumer>(), storage);
var(found, readiness) = await service.FindDiffAsync(10);
found.Type.Should().Be(diffType);
found.Details.Should().ContainSingle(d => d.LeftOffset == leftOffset);
readiness.Should().Be(diffReadiness);
}
