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); } }