public void WatchFolder_Typical(
DirectoryPath existingDir,
FilePath existingFile,
[Frozen] MockFileSystemWatcher mockFileWatcher,
[Frozen] MockFileSystem fs)
{
FilePath fileB = Path.Combine(existingDir.Path, "FileB");
fs.File.WriteAllText(existingFile, string.Empty);
var live = ObservableExt.WatchFolderContents(existingDir.Path, fileSystem: fs)
.RemoveKey();
var list = live.AsObservableList();
list.Count.Should().Be(1);
list.Items.ToExtendedList()[0].Should().Be(existingFile);
fs.File.WriteAllText(fileB, string.Empty);
mockFileWatcher.MarkCreated(fileB);
list = live.AsObservableList();
list.Count.Should().Be(2);
list.Items.ToExtendedList()[0].Should().Be(existingFile);
list.Items.ToExtendedList()[1].Should().Be(fileB);
fs.File.Delete(existingFile);
mockFileWatcher.MarkDeleted(existingFile);
list = live.AsObservableList();
list.Count.Should().Be(1);
list.Items.ToExtendedList()[0].Should().Be(fileB);
}
public void FileIsCreated(
[Frozen] FilePath path,
[Frozen] MockFileSystemWatcher fileChanges,
[Frozen] MockFileSystem fs)
{
var listingA = new ModListing("ModA.esp", true);
var reader = Substitute.For <ICreationClubRawListingsReader>();
reader.Read(Arg.Any <Stream>()).Returns(listingA.AsEnumerable());
var list = new CreationClubLiveListingsFileReader(
fs,
reader,
new CreationClubListingsPathInjection(path))
.Get(out var state)
.AsObservableList();
list.Items.Should().HaveCount(0);
var scheduler = new TestScheduler();
var stateTest = scheduler.Start(() => state);
stateTest.Messages.Should().HaveCount(1);
stateTest.Messages[0].Value.Kind.Should().Be(NotificationKind.OnNext);
stateTest.Messages[0].Value.Value.Succeeded.Should().BeFalse();
fs.File.WriteAllText(path, string.Empty);
fileChanges.MarkCreated(path);
list.Items.Should().HaveCount(1);
list.Items.First().Should().Be(listingA);
stateTest = scheduler.Start(() => state);
stateTest.Messages[^ 1].Value.Kind.Should().Be(NotificationKind.OnNext);
public void ShouldRaiseDeletedIfInternalRaisesDeleted()
{
AutoResetEvent raisedEvent = new AutoResetEvent(false);
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int DeletedRaised = 0;
tested.Deleted += (s, e) =>
{
DeletedRaised++;
raisedEvent.Set();
};
string fileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(fileName))
file.WriteLine("somedata");
mockInternal.RaiseDeleted(fileName);
raisedEvent.WaitOne(TimeSpan.FromSeconds(1));
Assert.AreEqual(1, DeletedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void ShouldWaitRaisingChangedUntilFileIsUnlocked()
{
AutoResetEvent raisedEvent = new AutoResetEvent(false);
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int ChangedRaised = 0;
tested.Changed += (s, e) =>
{
ChangedRaised++;
raisedEvent.Set();
};
string fileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(fileName))
{
file.WriteLine("somedata");
mockInternal.RaiseChanged(fileName);
raisedEvent.WaitOne(TimeSpan.FromSeconds(1));
Thread.Sleep(500);
Assert.AreEqual(0, ChangedRaised);
}
raisedEvent.WaitOne(TimeSpan.FromSeconds(1));
Assert.AreEqual(1, ChangedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void ShouldOnlyRaiseChangedOnceIfSeveralIsPending()
{
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int ChangedRaised = 0;
tested.Changed += (s, e) => ChangedRaised++;
string fileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(fileName))
{
file.WriteLine("somedata");
mockInternal.RaiseChanged(fileName);
mockInternal.RaiseChanged(fileName);
mockInternal.RaiseChanged(fileName);
}
Thread.Sleep(500);
Assert.AreEqual(1, ChangedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void ShouldDelayRaiseRenamedUntilFileIsUnlocked()
{
AutoResetEvent raisedEvent = new AutoResetEvent(false);
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int RenamedRaised = 0;
tested.Renamed += (s, e) =>
{
RenamedRaised++;
raisedEvent.Set();
};
string fileName = Guid.NewGuid().ToString();
string newFileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(newFileName))
{
file.WriteLine("somedata");
mockInternal.RaiseRenamed(fileName, newFileName);
Assert.AreEqual(0, RenamedRaised);
raisedEvent.WaitOne(500);
}
raisedEvent.WaitOne(500);
Assert.AreEqual(1, RenamedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void RaiseEventRequiresArgument()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
DoAssert.Throws <ArgumentNullException>(() => tested.RaiseEvent(null));
}
public void RaseEventThrowsArgumentExceptionOnUnknownEvent()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
var evt = new FileSystemEventArgs((WatcherChangeTypes)666, "", "");
DoAssert.Throws <ArgumentException>(() => tested.RaiseEvent(evt));
}
}
public void ShouldUpdatePathOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.Path = "FAKEPATH";
Assert.AreEqual("FAKEPATH", mockWatcher.Path);
}
}
public void ShouldUpdateFilterOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.Filter = "FAKEFILTER";
Assert.AreEqual("FAKEFILTER", mockWatcher.Filter);
}
}
public void ShouldNotDisposeExternalIFileSystemWatcher()
{
MockFileSystemWatcher mockwatcher = new MockFileSystemWatcher();
IPluginDirectory tested = new PluginDirectory(mockwatcher);
bool wasDisposed = false;
mockwatcher.Disposed += (s, e) => wasDisposed = true;
tested.Dispose();
Assert.IsFalse(wasDisposed);
}
public void ShouldLogToDebugWhenRaisingFileLost()
{
string expected = "SomePath";
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
PluginDirectory tested = new PluginDirectory(mockWatcher);
MockLog mockLog = new MockLog(tested);
mockWatcher.RaiseDeleted(expected);
Assert.IsTrue(mockLog.Any(x => x.Level == MockLog.Level.Debug && x.Message.Contains(expected)));
}
public void DeletedShouldRaiseFileLost()
{
MockFileSystemWatcher fsw = new MockFileSystemWatcher();
PluginDirectory tested = new PluginDirectory(fsw);
int FileLostRaised = 0;
tested.FileLost += (s, e) => FileLostRaised++;
fsw.RaiseDeleted(GetType().Assembly.Location);
Assert.AreEqual(1, FileLostRaised);
}
public void ShouldDisposeOwnedFileSystemWatcher()
{
MockFileSystemWatcher mockwatcher = new MockFileSystemWatcher();
PluginDirectory tested = new PluginDirectory(new MockFileSystemWatcher());
bool wasDisposed = false;
tested.WatcherConnect(mockwatcher, true);
mockwatcher.Disposed += (s, e) => wasDisposed = true;
tested.Dispose();
Assert.IsTrue(wasDisposed);
}
public void ShouldUpdateIncludeSubdirectoriesOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.IncludeSubdirectories = false;
Assert.AreEqual(false, mockWatcher.IncludeSubdirectories);
tested.IncludeSubdirectories = true;
Assert.AreEqual(true, mockWatcher.IncludeSubdirectories);
}
}
public void GetOrAddFilePathChangeToken_DoesNotAddsPollingChangeTokenWhenCallbackIsDisabled()
{
using (var root = new DisposableFileSystem())
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
var changeToken = physicalFilesWatcher.GetOrAddFilePathChangeToken("some-path");
Assert.IsType <CancellationChangeToken>(changeToken);
Assert.Empty(physicalFilesWatcher.PollingChangeTokens);
}
}
public void ShouldUpdateNotifyFilterOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.NotifyFilter = NotifyFilters.DirectoryName;
Assert.AreEqual(NotifyFilters.DirectoryName, mockWatcher.NotifyFilter);
tested.NotifyFilter = NotifyFilters.LastAccess;
Assert.AreEqual(NotifyFilters.LastAccess, mockWatcher.NotifyFilter);
}
}
public void ShouldUpdateEnableRaisingEventsOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.EnableRaisingEvents = false;
Assert.AreEqual(false, mockWatcher.EnableRaisingEvents);
tested.EnableRaisingEvents = true;
Assert.AreEqual(true, mockWatcher.EnableRaisingEvents);
}
}
public void ShouldExposeEnableRaisingEventsFromInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
mockWatcher.EnableRaisingEvents = true;
Assert.AreEqual(true, tested.EnableRaisingEvents);
mockWatcher.EnableRaisingEvents = false;
Assert.AreEqual(false, tested.EnableRaisingEvents);
}
}
public void DisposeShouldDisposeInnerFileSystemWatcher()
{
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
bool wasDisposed = false;
mockInternal.Disposed += (s, e) => wasDisposed = true;
tested.Dispose();
Assert.IsTrue(wasDisposed);
}
}
public void ShouldListenToAllEventsOnInternalWatcher()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
Assert.AreEqual(1, mockWatcher.CreatedListeners().Length);
Assert.AreEqual(1, mockWatcher.ChangedListeners().Length);
Assert.AreEqual(1, mockWatcher.DeletedListeners().Length);
Assert.AreEqual(1, mockWatcher.RenamedListeners().Length);
}
}
public void FileLostShouldNotBeRasedForNonDlls()
{
MockFileSystemWatcher fsw = new MockFileSystemWatcher();
PluginDirectory tested = new PluginDirectory(fsw);
int FileLostRaised = 0;
tested.FileLost += (s, e) => FileLostRaised++;
fsw.RaiseDeleted(@"file.img");
Assert.AreEqual(0, FileLostRaised);
}
public void FileFoundShouldReportCurrentFilesFlatOnAdd()
{
MockFileSystemWatcher fsw = new MockFileSystemWatcher();
fsw.Path = new FileInfo(GetType().Assembly.Location).Directory.FullName;
PluginDirectory tested = new PluginDirectory(fsw);
int FileFoundRaised = 0;
tested.FileFound += (s, e) => FileFoundRaised++;
Assert.AreNotEqual(0, FileFoundRaised);
}
public void FileFoundShouldBeRasedForDlls()
{
MockFileSystemWatcher fsw = new MockFileSystemWatcher();
PluginDirectory tested = new PluginDirectory(fsw);
int FileFoundRaised = 0;
tested.FileFound += (s, e) => FileFoundRaised++;
fsw.RaiseCreated(@"file.dll");
Assert.AreEqual(1, FileFoundRaised);
}
public void RenamedShouldRaiseFileLostFollowedByFileFound()
{
MockFileSystemWatcher fsw = new MockFileSystemWatcher();
PluginDirectory tested = new PluginDirectory(fsw);
DateTime FileFoundRaised = DateTime.MinValue;
DateTime FileLostRaised = DateTime.MinValue;
tested.FileFound += (s, e) => { FileFoundRaised = DateTime.Now; Thread.Sleep(1); };
tested.FileLost += (s, e) => { FileLostRaised = DateTime.Now; Thread.Sleep(1); };
fsw.RaiseRenamed(GetType().Assembly.Location, GetType().Assembly.Location);
Assert.AreNotEqual(DateTime.MinValue, FileFoundRaised);
Assert.AreNotEqual(DateTime.MinValue, FileLostRaised);
Assert.IsTrue(FileLostRaised < FileFoundRaised);
}
public void WatchFile_Typical(
[Frozen] FilePath path,
[Frozen] MockFileSystemWatcher mockFileWatcher,
[Frozen] MockFileSystem fs)
{
int count = 0;
using var sub = ObservableExt.WatchFile(path, fileWatcherFactory: fs.FileSystemWatcher)
.Subscribe(x => count++);
count.Should().Be(0);
fs.File.WriteAllText(path, string.Empty);
mockFileWatcher.MarkCreated(path);
count.Should().Be(1);
}
public void Integration(
[Frozen] FilePath pluginsTxt,
[Frozen] MockFileSystemWatcher watcher,
[Frozen] MockFileSystem fs)
{
fs.File.WriteAllLines(pluginsTxt,
new string[]
{
TestConstants.PluginModKey.ToString(),
TestConstants.PluginModKey2.ToString(),
TestConstants.PluginModKey3.ToString(),
});
var live = PluginListings.GetLiveLoadOrder(
GameRelease.SkyrimLE,
pluginsTxt,
public void WatchFile_MovedIn(
FilePath path,
FileName name,
[Frozen] MockFileSystemWatcher mockFileWatcher,
[Frozen] MockFileSystem fs)
{
int count = 0;
using var sub = ObservableExt.WatchFile(Path.Combine(path.Directory !.Value, name.String), fileWatcherFactory: fs.FileSystemWatcher)
.Subscribe(x => count++);
fs.File.WriteAllText(path, string.Empty);
count.Should().Be(0);
mockFileWatcher.MarkRenamed(path, name);
count.Should().Be(1);
}
public void FileFoundShouldNotBeReportedAfterRemoval()
{
MockFileSystemWatcher fsw = new MockFileSystemWatcher();
PluginDirectory tested = new PluginDirectory(fsw);
int FileFoundRaised = 0;
EventHandler <PluginDirectoryEventArgs> handler = ((s, e) => FileFoundRaised++);
tested.FileFound += handler;
tested.FileFound -= handler;
fsw.RaiseCreated(@"file.dll");
Assert.AreEqual(0, FileFoundRaised);
}
public void CreateFileChangeToken_DoesNotAllowPathsAboveRoot()
{
using (var root = new DisposableFileSystem())
using (var fileSystemWatcher = new MockFileSystemWatcher(root.RootPath))
using (var physicalFilesWatcher = new PhysicalFilesWatcher(root.RootPath + Path.DirectorySeparatorChar, fileSystemWatcher, pollForChanges: false))
{
var token = physicalFilesWatcher.CreateFileChangeToken(Path.GetFullPath(Path.Combine(root.RootPath, "..")));
Assert.IsType <NullChangeToken>(token);
token = physicalFilesWatcher.CreateFileChangeToken(Path.GetFullPath(Path.Combine(root.RootPath, "../")));
Assert.IsType <NullChangeToken>(token);
token = physicalFilesWatcher.CreateFileChangeToken("..");
Assert.IsType <NullChangeToken>(token);
}
}
