public void Create_InvalidFileSize_ErrorReturned(long size)
{
var result = DocumentEntity.Create(ValidFileName, size, null);
result.Successful.Should().BeFalse();
result.Errors.Should().NotBeEmpty();
}
public void Create_Successful_EntityCreated(string fileName, long fileSize)
{
var result = DocumentEntity.Create(fileName, fileSize, null);
result.Successful.Should().BeTrue();
result.Result.Name.Should().BeEquivalentTo(fileName);
result.Result.FileSize.Should().Be(fileSize);
result.Result.Order.Should().Be(0);
result.Result.Location.Should().BeNull();
}
public async Task <OperationResult> UpploadAsync(IFormFile file)
{
var operatinoResult = DocumentEntity.Create(file.FileName, file.Length, null);
if (!operatinoResult.Successful)
{
return(operatinoResult);
}
return(await documentStore.UploadAsync(operatinoResult.Result.Name, file.OpenReadStream()));
}
public async Task ReorderAsync_NoDocument_ErrorResultReturned()
{
var name = CreateFileName();
var content = fixture.Create <string>();
var entityResult = DocumentEntity.Create(name, content.Length, new Uri($"{containerUri}/{name}"), 5);
var result = await store.ReorderAsync(entityResult.Result);
result.Successful.Should().BeFalse();
}
/// <inheritdoc/>
public async Task <OperationResult <IReadOnlyCollection <DocumentEntity> > > GetAllAsync()
{
var documents = new List <DocumentEntity>();
await foreach (var blob in container.GetBlobsAsync(BlobTraits.Metadata))
{
var order = long.Parse(blob.Metadata[nameof(DocumentEntity.Order)], new NumberFormatInfo());
var uri = $"{container.Uri.AbsoluteUri}/{blob.Name}";
var operationResult = DocumentEntity.Create(blob.Name, (long)blob.Properties.ContentLength, new Uri(uri), order);
documents.Add(operationResult.Result);
}
return(new OperationResult <IReadOnlyCollection <DocumentEntity> >(documents));
}
public async Task <OperationResult> ReorderAsync([FromBody] OrderedDocument[] documents)
{
const long fakeSize = 1;
var entities = documents.Select(s => DocumentEntity.Create(s.Name, fakeSize, null, s.Order))
.ToArray();
if (entities.Any(s => !s.Successful))
{
var errors = entities
.Aggregate(Enumerable.Empty <string>(), (ac, next) => next.Successful ? ac : ac.Union(next.Errors))
.ToArray();
return(new OperationResult(errors));
}
return(await documentStore.ReorderAsync(entities.Select(s => s.Result).ToArray()));
}
public async Task ReorderAsync_SigleDocument_DocumentReordered()
{
var name = CreateFileName();
var content = fixture.Create <string>();
byte[] byteArray = Encoding.ASCII.GetBytes(content);
using var stream = new MemoryStream(byteArray);
var entityResult = DocumentEntity.Create(name, content.Length, new Uri($"{containerUri}/{name}"), 5);
await store.UploadAsync(name, stream);
await store.ReorderAsync(entityResult.Result);
var result = await store.GetAllAsync();
result.Result.Should().ContainSingle()
.Which.Should().BeEquivalentTo(entityResult.Result);
}
public async Task GetAllAsync_TwoDocuments_DocumentsRetrieved()
{
var content = fixture.Create <string>();
var entities = fixture.CreateMany <string>(2)
.Select(s => string.Concat(s, ".pdf"))
.Select(name => DocumentEntity.Create(name, content.Length, new Uri($"{containerUri}/{name}")))
.Select(s => s.Result)
.ToArray();
byte[] byteArray = Encoding.ASCII.GetBytes(content);
using var stream1 = new MemoryStream(byteArray);
using var stream2 = new MemoryStream(byteArray);
await store.UploadAsync(entities[0].Name, stream1);
await store.UploadAsync(entities[1].Name, stream2);
var result = await store.GetAllAsync();
result.Result.Should().BeEquivalentTo(entities);
}