public static void TestWatchedFolders()
{
using (FileSystemState state = new FileSystemState())
{
IRuntimeFileInfo stateInfo = OS.Current.FileInfo(_mystateXmlPath);
state.Load(stateInfo);
Assert.That(state.WatchedFolders, Is.Not.Null, "There should be a Watched Folders instance.");
Assert.That(state.WatchedFolders.Count(), Is.EqualTo(0), "There should be no Watched folders.");
state.AddWatchedFolder(new WatchedFolder(_rootPath));
Assert.That(state.WatchedFolders.Count(), Is.EqualTo(1), "There should be one Watched Folder.");
state.AddWatchedFolder(new WatchedFolder(_rootPath));
Assert.That(state.WatchedFolders.Count(), Is.EqualTo(1), "There should still only be one Watched Folder.");
state.Save();
}
using (FileSystemState state = new FileSystemState())
{
IRuntimeFileInfo stateInfo = OS.Current.FileInfo(_mystateXmlPath);
state.Load(stateInfo);
Assert.That(state.WatchedFolders.Count(), Is.EqualTo(1), "There should be one Watched Folder.");
Assert.That(state.WatchedFolders.First(), Is.EqualTo(new WatchedFolder(_rootPath)), "The Watched Folder should be equal to this.");
state.RemoveWatchedFolder(new WatchedFolder(_mystateXmlPath));
Assert.That(state.WatchedFolders.Count(), Is.EqualTo(1), "There should still be one Watched folders.");
state.RemoveWatchedFolder(new WatchedFolder(_rootPath));
Assert.That(state.WatchedFolders.Count(), Is.EqualTo(0), "There should still be no Watched folders now.");
}
}
public static void Setup()
{
SetupAssembly.AssemblySetup();
_fileSystemState = new FileSystemState();
_fileSystemState.Load(OS.Current.FileInfo(_fileSystemStateFilePath));
}
public static void TestDecryptedActiveFiles()
{
using (FileSystemState state = new FileSystemState())
{
state.Load(OS.Current.FileInfo(_mystateXmlPath));
ActiveFile decryptedFile1 = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted, null);
state.Add(decryptedFile1);
ActiveFile decryptedFile2 = new ActiveFile(OS.Current.FileInfo(_encrypted2AxxPath), OS.Current.FileInfo(_decrypted2TxtPath), new AesKey(), ActiveFileStatus.DecryptedIsPendingDelete, null);
state.Add(decryptedFile2);
ActiveFile notDecryptedFile = new ActiveFile(OS.Current.FileInfo(_encrypted3AxxPath), OS.Current.FileInfo(_decrypted3TxtPath), new AesKey(), ActiveFileStatus.NotDecrypted, null);
state.Add(notDecryptedFile);
ActiveFile errorFile = new ActiveFile(OS.Current.FileInfo(_encrypted4AxxPath), OS.Current.FileInfo(_decrypted4TxtPath), new AesKey(), ActiveFileStatus.Error, null);
state.Add(errorFile);
IList <ActiveFile> decryptedFiles = state.DecryptedActiveFiles;
Assert.That(decryptedFiles.Count, Is.EqualTo(2), "There should be two decrypted files.");
Assert.That(decryptedFiles.Contains(decryptedFile1), "A file marked as AssumedOpenAndDecrypted should be found.");
Assert.That(decryptedFiles.Contains(decryptedFile2), "A file marked as DecryptedIsPendingDelete should be found.");
Assert.That(decryptedFiles.Contains(notDecryptedFile), Is.Not.True, "A file marked as NotDecrypted should not be found.");
}
}
public static void Initialize()
{
fileSystemState = new FileSystemState();
fileSystemState.Load(FileSystemState.DefaultPathInfo);
OS.Current.KeyWrapIterations = fileSystemState.KeyWrapIterations;
OS.Current.ThumbprintSalt = fileSystemState.ThumbprintSalt;
fileSystemState.KnownKeys.Changed += delegate { OS.Current.NotifyWorkFolderStateChanged(); };
}
public static void TestLoadNew()
{
using (FileSystemState state = new FileSystemState())
{
state.Load(OS.Current.FileInfo(_mystateXmlPath));
Assert.That(state, Is.Not.Null, "An instance should always be instantiated.");
Assert.That(state.ActiveFiles.Count(), Is.EqualTo(0), "A new state should not have any active files.");
}
}
public static void Setup()
{
SetupAssembly.AssemblySetup();
FakeRuntimeFileInfo.AddFile(_davidCopperfieldTxtPath, FakeRuntimeFileInfo.TestDate4Utc, FakeRuntimeFileInfo.TestDate5Utc, FakeRuntimeFileInfo.TestDate6Utc, FakeRuntimeFileInfo.ExpandableMemoryStream(Encoding.GetEncoding(1252).GetBytes(Resources.david_copperfield)));
FakeRuntimeFileInfo.AddFile(_uncompressedAxxPath, FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.uncompressable_zip));
FakeRuntimeFileInfo.AddFile(_helloWorldAxxPath, FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt));
_fileSystemState = new FileSystemState();
_fileSystemState.Load(FileSystemState.DefaultPathInfo);
}
public static void Setup()
{
SetupAssembly.AssemblySetup();
FakeRuntimeFileInfo.AddFile(_testTextPath, FakeRuntimeFileInfo.TestDate1Utc, FakeRuntimeFileInfo.TestDate2Utc, FakeRuntimeFileInfo.TestDate1Utc, FakeRuntimeFileInfo.ExpandableMemoryStream(Encoding.UTF8.GetBytes("This is a short file")));
FakeRuntimeFileInfo.AddFile(_davidCopperfieldTxtPath, FakeRuntimeFileInfo.TestDate4Utc, FakeRuntimeFileInfo.TestDate5Utc, FakeRuntimeFileInfo.TestDate6Utc, FakeRuntimeFileInfo.ExpandableMemoryStream(Encoding.GetEncoding(1252).GetBytes(Resources.david_copperfield)));
FakeRuntimeFileInfo.AddFile(_uncompressedAxxPath, FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.uncompressable_zip));
FakeRuntimeFileInfo.AddFile(_helloWorldAxxPath, FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt));
_fileSystemState = new FileSystemState();
_fileSystemState.Load(OS.Current.FileInfo(Path.Combine(Path.GetTempPath(), "FileSystemState.xml")));
}
public static void TestForEach()
{
bool changedEventWasRaised = false;
using (FileSystemState state = new FileSystemState())
{
state.Load(OS.Current.FileInfo(_mystateXmlPath));
state.Changed += ((object sender, ActiveFileChangedEventArgs e) =>
{
changedEventWasRaised = true;
});
ActiveFile activeFile;
activeFile = new ActiveFile(OS.Current.FileInfo(_encrypted1AxxPath), OS.Current.FileInfo(_decrypted1TxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, null);
state.Add(activeFile);
activeFile = new ActiveFile(OS.Current.FileInfo(_encrypted2AxxPath), OS.Current.FileInfo(_decrypted2TxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, null);
state.Add(activeFile);
activeFile = new ActiveFile(OS.Current.FileInfo(_encrypted3AxxPath), OS.Current.FileInfo(_decrypted3TxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, null);
state.Add(activeFile);
Assert.That(changedEventWasRaised, Is.True, "The change event should have been raised by the adding of active files.");
changedEventWasRaised = false;
Assert.That(state.ActiveFiles.Count(), Is.EqualTo(3), "There should be three.");
int i = 0;
state.ForEach(ChangedEventMode.RaiseOnlyOnModified, (ActiveFile activeFileArgument) =>
{
++i;
return(activeFileArgument);
});
Assert.That(i, Is.EqualTo(3), "The iteration should have visited three active files.");
Assert.That(changedEventWasRaised, Is.False, "No change event should have been raised.");
i = 0;
state.ForEach(ChangedEventMode.RaiseAlways, (ActiveFile activeFileArgument) =>
{
++i;
return(activeFileArgument);
});
Assert.That(i, Is.EqualTo(3), "The iteration should have visited three active files.");
Assert.That(changedEventWasRaised, Is.True, "The change event should have been raised.");
changedEventWasRaised = false;
i = 0;
state.ForEach(ChangedEventMode.RaiseAlways, (ActiveFile activeFileArgument) =>
{
++i;
return(new ActiveFile(activeFileArgument, activeFile.Status | ActiveFileStatus.Error));
});
Assert.That(i, Is.EqualTo(3), "The iteration should have visited three active files.");
Assert.That(changedEventWasRaised, Is.True, "The change event should have been raised.");
}
}
public static void TestStatusMaskAtLoad()
{
using (FileSystemState state = new FileSystemState())
{
state.Load(OS.Current.FileInfo(_mystateXmlPath));
ActiveFile activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, null);
state.Add(activeFile);
state.Save();
FileSystemState reloadedState = new FileSystemState();
reloadedState.Load(OS.Current.FileInfo(_mystateXmlPath));
Assert.That(reloadedState, Is.Not.Null, "An instance should always be instantiated.");
Assert.That(reloadedState.ActiveFiles.Count(), Is.EqualTo(1), "The reloaded state should have one active file.");
Assert.That(reloadedState.ActiveFiles.First().Status, Is.EqualTo(ActiveFileStatus.AssumedOpenAndDecrypted), "When reloading saved state, some statuses should be masked away.");
}
}
public static void TestArgumentNull()
{
using (FileSystemState state = new FileSystemState())
{
ActiveFile nullActiveFile = null;
string nullPath = null;
Func <ActiveFile, ActiveFile> nullAction = null;
IRuntimeFileInfo nullFileInfo = null;
Assert.Throws <ArgumentNullException>(() => { state.Remove(nullActiveFile); });
Assert.Throws <ArgumentNullException>(() => { state.Add(nullActiveFile); });
Assert.Throws <ArgumentNullException>(() => { state.FindEncryptedPath(nullPath); });
Assert.Throws <ArgumentNullException>(() => { state.FindDecryptedPath(nullPath); });
Assert.Throws <ArgumentNullException>(() => { state.ForEach(ChangedEventMode.RaiseAlways, nullAction); });
Assert.Throws <ArgumentNullException>(() => { state.Load(nullFileInfo); });
}
}
public static void TestUpdateActiveFileWithKeyIfKeyMatchesThumbprintWithMatchingThumbprint()
{
IRuntimeFileInfo encryptedFileInfo = OS.Current.FileInfo(_encryptedFile1);
IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(_decryptedFile1);
AesKey key = new AesKey();
ActiveFile activeFile = new ActiveFile(encryptedFileInfo, decryptedFileInfo, key, ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.NotShareable, null);
_fileSystemState.Add(activeFile);
_fileSystemState.Save();
_fileSystemState.Dispose();
_fileSystemState = new FileSystemState();
_fileSystemState.Load(OS.Current.FileInfo(_fileSystemStateFilePath));
bool updateWasMade = _fileSystemState.UpdateActiveFileWithKeyIfKeyMatchesThumbprint(key);
Assert.That(updateWasMade, Is.True, "Since there is an ActiveFile with the right thumbprint in the list, an update should be made.");
}
public static void TestChangedEvent()
{
using (FileSystemState state = new FileSystemState())
{
state.Load(OS.Current.FileInfo(_mystateXmlPath));
bool wasHere;
state.Changed += new EventHandler <ActiveFileChangedEventArgs>((object sender, ActiveFileChangedEventArgs e) => { wasHere = true; });
ActiveFile activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted, null);
wasHere = false;
state.Add(activeFile);
Assert.That(state.ActiveFiles.Count(), Is.EqualTo(1), "After the Add() the state should have one active file.");
Assert.That(wasHere, Is.True, "After the Add(), the changed event should have been raised.");
wasHere = false;
state.Remove(activeFile);
Assert.That(wasHere, Is.True, "After the Remove(), the changed event should have been raised.");
Assert.That(state.ActiveFiles.Count(), Is.EqualTo(0), "After the Remove() the state should have no active files.");
}
}
public static void TestCheckActiveFilesKeyIsNotSetWithoutKnownKey()
{
DateTime utcNow = OS.Current.UtcNow;
FakeRuntimeFileInfo.AddFile(_encryptedFile1, utcNow, utcNow, utcNow, FakeRuntimeFileInfo.ExpandableMemoryStream(Resources.helloworld_key_a_txt));
Passphrase passphrase = new Passphrase("a");
AxCryptFile.Decrypt(OS.Current.FileInfo(_encryptedFile1), OS.Current.FileInfo(_decryptedFile1), passphrase.DerivedPassphrase, AxCryptOptions.None, new ProgressContext());
ActiveFile activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedFile1), OS.Current.FileInfo(_decryptedFile1), passphrase.DerivedPassphrase, ActiveFileStatus.AssumedOpenAndDecrypted, null);
_fileSystemState.Add(activeFile);
_fileSystemState.Save();
_fileSystemState.Dispose();
_fileSystemState = new FileSystemState();
_fileSystemState.Load(OS.Current.FileInfo(_fileSystemStateFilePath));
IRuntimeFileInfo decryptedFileInfo = OS.Current.FileInfo(_decryptedFile1);
decryptedFileInfo.SetFileTimes(utcNow.AddSeconds(30), utcNow.AddSeconds(30), utcNow.AddSeconds(30));
SetupAssembly.FakeRuntimeEnvironment.TimeFunction = (() => { return(utcNow.AddMinutes(1)); });
bool changedWasRaised = false;
_fileSystemState.Changed += ((object sender, ActiveFileChangedEventArgs e) =>
{
changedWasRaised = true;
});
activeFile = _fileSystemState.FindEncryptedPath(_encryptedFile1);
Assert.That(activeFile.Key, Is.Null, "The key should be null after loading of new FileSystemState");
_fileSystemState.CheckActiveFiles(ChangedEventMode.RaiseOnlyOnModified, new ProgressContext());
Assert.That(changedWasRaised, Is.False, "The ActiveFile should be not be modified because the file was modified as well and thus cannot be deleted.");
activeFile = _fileSystemState.FindEncryptedPath(_encryptedFile1);
Assert.That(activeFile.Key, Is.Null, "The key should still be null after the checking of active files.");
Assert.That(activeFile.Status.HasMask(ActiveFileStatus.AssumedOpenAndDecrypted), Is.True, "The file should still be there.");
Assert.That(activeFile.ThumbprintMatch(passphrase.DerivedPassphrase), Is.True, "The active file should still be known to be decryptable with the original passphrase.");
}
public static void TestFindEncryptedAndDecryptedPath()
{
using (FileSystemState state = new FileSystemState())
{
state.Load(OS.Current.FileInfo(_mystateXmlPath));
ActiveFile activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted | ActiveFileStatus.Error | ActiveFileStatus.IgnoreChange | ActiveFileStatus.NotShareable, null);
state.Add(activeFile);
ActiveFile byDecryptedPath = state.FindDecryptedPath(_decryptedTxtPath);
Assert.That(byDecryptedPath, Is.EqualTo(activeFile), "The search should return the same instance.");
ActiveFile byEncryptedPath = state.FindEncryptedPath(_encryptedAxxPath);
Assert.That(byEncryptedPath, Is.EqualTo(byDecryptedPath), "The search should return the same instance.");
ActiveFile notFoundEncrypted = state.FindEncryptedPath(Path.Combine(_rootPath, "notfoundfile.txt"));
Assert.That(notFoundEncrypted, Is.Null, "A search that does not succeed should return null.");
ActiveFile notFoundDecrypted = state.FindDecryptedPath(Path.Combine(_rootPath, "notfoundfile.txt"));
Assert.That(notFoundDecrypted, Is.Null, "A search that does not succeed should return null.");
}
}
public static void TestInvalidXml()
{
string badXml = @"<FileSystemState xmlns=""http://www.axantum.com/Serialization/"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">";
IRuntimeFileInfo stateInfo = OS.Current.FileInfo(_mystateXmlPath);
using (Stream stream = stateInfo.OpenWrite())
{
byte[] bytes = Encoding.UTF8.GetBytes(badXml);
stream.Write(bytes, 0, bytes.Length);
}
using (FileSystemState state = new FileSystemState())
{
Assert.DoesNotThrow(() => state.Load(stateInfo));
Assert.That(state.ActiveFileCount, Is.EqualTo(0), "After loading damaged state, the count should be zero.");
ActiveFile decryptedFile1 = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted, null);
state.Add(decryptedFile1);
Assert.That(state.ActiveFileCount, Is.EqualTo(1), "After adding a file, the count should be one.");
}
}
public static void TestLoadExisting()
{
ActiveFile activeFile;
using (FileSystemState state = new FileSystemState())
{
state.Load(OS.Current.FileInfo(_mystateXmlPath));
Assert.That(state, Is.Not.Null, "An instance should always be instantiated.");
Assert.That(state.ActiveFiles.Count(), Is.EqualTo(0), "A new state should not have any active files.");
activeFile = new ActiveFile(OS.Current.FileInfo(_encryptedAxxPath), OS.Current.FileInfo(_decryptedTxtPath), new AesKey(), ActiveFileStatus.AssumedOpenAndDecrypted, null);
state.Add(activeFile);
state.Save();
}
using (FileSystemState reloadedState = new FileSystemState())
{
reloadedState.Load(OS.Current.FileInfo(_mystateXmlPath));
Assert.That(reloadedState, Is.Not.Null, "An instance should always be instantiated.");
Assert.That(reloadedState.ActiveFiles.Count(), Is.EqualTo(1), "The reloaded state should have one active file.");
Assert.That(reloadedState.ActiveFiles.First().ThumbprintMatch(activeFile.Key), Is.True, "The reloaded thumbprint should match the key.");
}
}