public async Task <IActionResult> Upload(UploadZipFileModel uploadZipFileModel)
{
if (ModelState.IsValid)
{
var result = ZipFileProcessor.Process(uploadZipFileModel.ZipFile);
if (result.IsFailure)
{
Logger.LogError(result.Error);
ModelState.AddModelError("ZipFile", result.Error);
return(View(uploadZipFileModel));
}
var auth = new AuthCredential
{
Password = uploadZipFileModel.Password,
Username = uploadZipFileModel.Username
};
var responseMessage = await ZipContentStorageHelper.SendContent(result.Value, auth);
if (responseMessage.IsFailure)
{
Logger.LogError(responseMessage.Error, result.Value);
ModelState.AddModelError("ZipFile", responseMessage.Error);
return(View(uploadZipFileModel));
}
return(RedirectToAction("Success"));
}
return(View(uploadZipFileModel));
}
public void ValidateFormat_Failed_With_NullFormFile()
{
var zipFileProcessor = new ZipFileProcessor(MockAesEncryptionHelper.Object, MockZipArchivePathsResolver.Object, MockZipArchiveFactory.Object);
var result = zipFileProcessor.ValidateFormat(null);
result.IsFailure.Should().Be(true);
}
public void FormJSON_Success()
{
var zipFileProcessor = new ZipFileProcessor(MockAesEncryptionHelper.Object, MockZipArchivePathsResolver.Object, MockZipArchiveFactory.Object);
var zipArchiveEntryItem = new ZipArchiveEntryItem {
Name = "decrypted"
};
zipArchiveEntryItem.Files = new List <string>()
{
"decrypted", "decrypted", "decrypted"
};
var expected = JsonConvert.SerializeObject(zipArchiveEntryItem);
var formJson = zipFileProcessor.FormJSON(zipArchiveEntryItem);
Assert.Equal(expected, formJson);
}
public void PopulatePaths_Success()
{
//Due to readonlycollection, Zip entries can't be mocked!
using (FileStream zipToOpen = new FileStream("../../../Data/FakeArchive.zip", FileMode.Open))
{
using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Update))
{
MockZipArchiveFactory.Setup(x => x.CreateZipArchive(It.IsAny <Stream>())).Returns(archive);
var zipFileProcessor = new ZipFileProcessor(MockAesEncryptionHelper.Object, MockZipArchivePathsResolver.Object, MockZipArchiveFactory.Object);
var fileMock = new Mock <IFormFile>();
fileMock.Setup(_ => _.OpenReadStream()).Returns(zipToOpen);
fileMock.Setup(_ => _.FileName).Returns("FakeArchive.zip");
fileMock.Setup(_ => _.Length).Returns(zipToOpen.Length);
var result = zipFileProcessor.PopulatePaths(fileMock.Object);
}
}
}
public void ValidateFormat_Failed_With_WrongFormat()
{
var content = "test/Readme.txt";
var fileName = "Archive.png";
var fileMock = new Mock <IFormFile>();
var ms = new MemoryStream();
var writer = new StreamWriter(ms);
writer.Write(content);
writer.Flush();
ms.Position = 0;
fileMock.Setup(_ => _.OpenReadStream()).Returns(ms);
fileMock.Setup(_ => _.FileName).Returns(fileName);
fileMock.Setup(_ => _.Length).Returns(ms.Length);
var zipFileProcessor = new ZipFileProcessor(MockAesEncryptionHelper.Object, MockZipArchivePathsResolver.Object, MockZipArchiveFactory.Object);
var result = zipFileProcessor.ValidateFormat(fileMock.Object);
result.IsFailure.Should().Be(true);
}
public void EncryptPaths_Success()
{
MockAesEncryptionHelper.Setup(x => x.Encrypt(It.IsAny <string>())).Returns("encrypted");
var zipFileProcessor = new ZipFileProcessor(MockAesEncryptionHelper.Object, MockZipArchivePathsResolver.Object, MockZipArchiveFactory.Object);
var zipArchiveEntryItem = new ZipArchiveEntryItem {
Name = "decrypted"
};
zipArchiveEntryItem.Files = new List <string>()
{
"decrypted", "decrypted", "decrypted"
};
var subZipArchiveEntryItem = new ZipArchiveEntryItem {
Name = "decrypted"
};
subZipArchiveEntryItem.Files = new List <string>()
{
"decrypted", "decrypted", "decrypted"
};
zipArchiveEntryItem.Folders = new List <ZipArchiveEntryItem>
{
subZipArchiveEntryItem
};
var encryptedPaths = zipFileProcessor.EncryptPaths(zipArchiveEntryItem);
encryptedPaths.Name.Should().Be("encrypted");
encryptedPaths.Files.First().Should().Be("encrypted");
encryptedPaths.Folders.First().Name.Should().Be("encrypted");
encryptedPaths.Folders.First().Files.First().Should().Be("encrypted");
}
