public void TestFindEncryptedPath()
{
using (FileSystemState state = FileSystemState.Create(Resolve.WorkFolder.FileInfo.FileItemInfo("mystate.txt")))
{
ActiveFile activeFile = new ActiveFile(New <IDataStore>(_encryptedAxxPath), New <IDataStore>(_decryptedTxtPath), new LogOnIdentity("passphrase"), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, new V1Aes128CryptoFactory().CryptoId);
state.Add(activeFile);
ActiveFile byEncryptedPath = state.FindActiveFileFromEncryptedPath(_encryptedAxxPath);
Assert.That(byEncryptedPath.EncryptedFileInfo.FullName, Is.EqualTo(_encryptedAxxPath), "The search should return the same path.");
ActiveFile notFoundEncrypted = state.FindActiveFileFromEncryptedPath(Path.Combine(_rootPath, "notfoundfile.txt"));
Assert.That(notFoundEncrypted, Is.Null, "A search that does not succeed should return null.");
}
}
public virtual async Task <FileOperationContext> OpenAndLaunchApplication(IEnumerable <LogOnIdentity> identities, IDataStore encryptedDataStore, IProgressContext progress)
{
if (identities == null)
{
throw new ArgumentNullException(nameof(identities));
}
if (encryptedDataStore == null)
{
throw new ArgumentNullException(nameof(encryptedDataStore));
}
if (progress == null)
{
throw new ArgumentNullException(nameof(progress));
}
if (!encryptedDataStore.IsAvailable)
{
if (Resolve.Log.IsWarningEnabled)
{
Resolve.Log.LogWarning("Tried to open non-existing '{0}'.".InvariantFormat(encryptedDataStore.FullName));
}
return(new FileOperationContext(encryptedDataStore.FullName, ErrorStatus.FileDoesNotExist));
}
ActiveFile activeFile = _fileSystemState.FindActiveFileFromEncryptedPath(encryptedDataStore.FullName);
if (activeFile == null || !activeFile.DecryptedFileInfo.IsAvailable)
{
activeFile = TryDecryptToActiveFile(encryptedDataStore, identities);
}
else
{
activeFile = CheckKeysForAlreadyDecryptedFile(activeFile, identities, progress);
}
if (activeFile == null)
{
return(new FileOperationContext(encryptedDataStore.FullName, ErrorStatus.InvalidKey));
}
using (FileLock destinationLock = New <FileLocker>().Acquire(activeFile.DecryptedFileInfo))
{
if (!activeFile.DecryptedFileInfo.IsAvailable)
{
activeFile = Decrypt(activeFile.Identity, activeFile.EncryptedFileInfo, destinationLock, activeFile, progress);
}
_fileSystemState.Add(activeFile);
await _fileSystemState.Save();
if (encryptedDataStore.IsWriteProtected || !New <LicensePolicy>().Capabilities.Has(LicenseCapability.EditExistingFiles))
{
activeFile.DecryptedFileInfo.IsWriteProtected = true;
}
FileOperationContext status = await LaunchApplicationForDocument(activeFile, destinationLock);
return(status);
}
}
public void TestArgumentNull()
{
using (FileSystemState state = new FileSystemState())
{
ActiveFile nullActiveFile = null;
string nullPath = null;
Func <ActiveFile, Task <ActiveFile> > nullAction = null;
IDataStore nullFileInfo = null;
Assert.Throws <ArgumentNullException>(() => { state.RemoveActiveFile(nullActiveFile); });
Assert.Throws <ArgumentNullException>(() => { state.Add(nullActiveFile); });
Assert.Throws <ArgumentNullException>(() => { state.FindActiveFileFromEncryptedPath(nullPath); });
Assert.ThrowsAsync <ArgumentNullException>(async() => { await state.ForEach(nullAction); });
Assert.Throws <ArgumentNullException>(() => { FileSystemState.Create(nullFileInfo); });
}
}
public IEnumerable <ActiveFile> SelectedActiveFiles()
{
return(SelectedRecentFiles.Select(f => _fileSystemState.FindActiveFileFromEncryptedPath(f)).Where(af => af != null));
}
