public static void TestWriteToFileWithBackupWithCancel()
{
IRuntimeFileInfo destinationFileInfo = OS.Current.FileInfo(_rootPath.PathCombine("Written", "File.txt"));
using (MemoryStream inputStream = FakeRuntimeFileInfo.ExpandableMemoryStream(Encoding.UTF8.GetBytes("A string with some text")))
{
Assert.Throws <OperationCanceledException>(() => { AxCryptFile.WriteToFileWithBackup(destinationFileInfo, (Stream stream) => { throw new OperationCanceledException(); }, new ProgressContext()); });
string tempFilePath = _rootPath.PathCombine("Written", "File.bak");
IRuntimeFileInfo tempFileInfo = OS.Current.FileInfo(tempFilePath);
Assert.That(tempFileInfo.Exists, Is.False, "The .bak file should be removed.");
}
}
public static void TestInvalidArguments()
{
IRuntimeFileInfo sourceFileInfo = OS.Current.FileInfo(_testTextPath);
IRuntimeFileInfo destinationFileInfo = sourceFileInfo.CreateEncryptedName();
AxCryptDocument document = new AxCryptDocument();
IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(Path.Combine(_rootPath, "decrypted test.txt"));
AxCryptDocument nullDocument = null;
IRuntimeFileInfo nullFileInfo = null;
AesKey nullKey = null;
ProgressContext nullProgress = null;
Passphrase nullPassphrase = null;
Stream nullStream = null;
string nullString = null;
Action <Stream> nullStreamAction = null;
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(nullFileInfo, destinationFileInfo, new Passphrase("axcrypt"), AxCryptOptions.EncryptWithCompression, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, nullFileInfo, new Passphrase("axcrypt"), AxCryptOptions.EncryptWithCompression, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, destinationFileInfo, nullPassphrase, AxCryptOptions.EncryptWithCompression, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, destinationFileInfo, new Passphrase("axcrypt"), AxCryptOptions.EncryptWithCompression, nullProgress); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(nullFileInfo, new MemoryStream(), new AesKey(), AxCryptOptions.None, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, nullStream, new AesKey(), AxCryptOptions.None, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, new MemoryStream(), nullKey, AxCryptOptions.None, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Encrypt(sourceFileInfo, new MemoryStream(), new AesKey(), AxCryptOptions.None, nullProgress); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(nullDocument, decryptedFileInfo, AxCryptOptions.SetFileTimes, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(document, nullFileInfo, AxCryptOptions.SetFileTimes, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(document, decryptedFileInfo, AxCryptOptions.SetFileTimes, nullProgress); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(nullFileInfo, decryptedFileInfo, new AesKey(), AxCryptOptions.SetFileTimes, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, nullFileInfo, new AesKey(), AxCryptOptions.SetFileTimes, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, decryptedFileInfo, nullKey, AxCryptOptions.SetFileTimes, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, decryptedFileInfo, new AesKey(), AxCryptOptions.SetFileTimes, nullProgress); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(nullFileInfo, Path.Combine(_rootPath, "Directory"), new AesKey(), AxCryptOptions.SetFileTimes, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, nullString, new AesKey(), AxCryptOptions.SetFileTimes, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, Path.Combine(_rootPath, "Directory"), nullKey, AxCryptOptions.SetFileTimes, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Decrypt(sourceFileInfo, Path.Combine(_rootPath, "Directory"), new AesKey(), AxCryptOptions.SetFileTimes, nullProgress); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Document(nullFileInfo, new AesKey(), new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Document(sourceFileInfo, nullKey, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Document(sourceFileInfo, new AesKey(), nullProgress); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.WriteToFileWithBackup(null, (Stream stream) => { }, new ProgressContext()); });
IRuntimeFileInfo fileInfo = OS.Current.FileInfo(_testTextPath);
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.WriteToFileWithBackup(fileInfo, nullStreamAction, new ProgressContext()); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.MakeAxCryptFileName(nullFileInfo); });
Assert.Throws <ArgumentNullException>(() => { AxCryptFile.Wipe(nullFileInfo, new ProgressContext()); });
}
public static void TestWriteToFileWithBackup()
{
string destinationFilePath = _rootPath.PathCombine("Written", "File.txt");
using (MemoryStream inputStream = FakeRuntimeFileInfo.ExpandableMemoryStream(Encoding.UTF8.GetBytes("A string with some text")))
{
IRuntimeFileInfo destinationFileInfo = OS.Current.FileInfo(destinationFilePath);
AxCryptFile.WriteToFileWithBackup(destinationFileInfo, (Stream stream) => { inputStream.CopyTo(stream, 4096); }, new ProgressContext());
using (TextReader read = new StreamReader(destinationFileInfo.OpenRead()))
{
string readString = read.ReadToEnd();
Assert.That(readString, Is.EqualTo("A string with some text"), "Where expecting the same string to be read back.");
}
}
}
private static ActiveFile CheckIfTimeToUpdate(ActiveFile activeFile, ProgressContext progress)
{
if (!activeFile.Status.HasMask(ActiveFileStatus.AssumedOpenAndDecrypted) || activeFile.Status.HasMask(ActiveFileStatus.NotShareable))
{
return(activeFile);
}
if (activeFile.Key == null)
{
return(activeFile);
}
if (!activeFile.IsModified)
{
return(activeFile);
}
try
{
using (Stream activeFileStream = activeFile.DecryptedFileInfo.OpenRead())
{
AxCryptFile.WriteToFileWithBackup(activeFile.EncryptedFileInfo, (Stream destination) =>
{
AxCryptFile.Encrypt(activeFile.DecryptedFileInfo, destination, activeFile.Key, AxCryptOptions.EncryptWithCompression, progress);
}, progress);
}
}
catch (IOException)
{
if (OS.Log.IsWarningEnabled)
{
OS.Log.LogWarning("Failed exclusive open modified for '{0}'.".InvariantFormat(activeFile.DecryptedFileInfo.FullName));
}
activeFile = new ActiveFile(activeFile, activeFile.Status | ActiveFileStatus.NotShareable);
return(activeFile);
}
if (OS.Log.IsInfoEnabled)
{
OS.Log.LogInfo("Wrote back '{0}' to '{1}'".InvariantFormat(activeFile.DecryptedFileInfo.FullName, activeFile.EncryptedFileInfo.FullName));
}
activeFile = new ActiveFile(activeFile, activeFile.DecryptedFileInfo.LastWriteTimeUtc, ActiveFileStatus.AssumedOpenAndDecrypted);
return(activeFile);
}
public static void TestWriteToFileWithBackupWhenDestinationExists()
{
string destinationFilePath = _rootPath.PathCombine("Written", "AnExistingFile.txt");
IRuntimeFileInfo destinationFileInfo = OS.Current.FileInfo(destinationFilePath);
IRuntimeFileInfo bakFileInfo = OS.Current.FileInfo(_rootPath.PathCombine("Written", "AnExistingFile.bak"));
Assert.That(bakFileInfo.Exists, Is.False, "The file should not exist to start with.");
using (Stream writeStream = destinationFileInfo.OpenWrite())
{
byte[] bytes = Encoding.UTF8.GetBytes("A string");
writeStream.Write(bytes, 0, bytes.Length);
}
using (MemoryStream inputStream = FakeRuntimeFileInfo.ExpandableMemoryStream(Encoding.UTF8.GetBytes("A string with some text")))
{
AxCryptFile.WriteToFileWithBackup(destinationFileInfo, (Stream stream) => { inputStream.CopyTo(stream, 4096); }, new ProgressContext());
using (TextReader read = new StreamReader(destinationFileInfo.OpenRead()))
{
string readString = read.ReadToEnd();
Assert.That(readString, Is.EqualTo("A string with some text"), "Where expecting the same string to be read back.");
}
}
Assert.That(bakFileInfo.Exists, Is.False, "The file should not exist afterwards either.");
}
