Exemplo n.º 1
0
            public async Task DirectoryAdded_ThenRemoved(string[] addedDirectories, string[] deletedDirectories, string[] expectedAdded, string[] expectedRemoved)
            {
                using (_taskScheduler.Pause()) {
                    foreach (var path in addedDirectories)
                    {
                        DirectoryInfoStubFactory.Create(_fileSystem, path);
                    }

                    RaiseCreated(_directoryWatcher, addedDirectories);
                    _taskScheduler.ScheduledTasksCount.Should().Be(1);
                }

                await Task.Delay(20);

                foreach (var path in deletedDirectories)
                {
                    DirectoryInfoStubFactory.Delete(_fileSystem, path);
                }

                RaiseDeleted(_directoryWatcher, deletedDirectories);

                await _taskScheduler;

                _changeset.Should().NotBeNull();
                _changeset.AddedDirectories.Should().Equal(expectedAdded);
                _changeset.RemovedDirectories.Should().Equal(expectedRemoved);
            }
            public async Task DirectoryAdded_ThenRemoved(string[] addedDirectories, string[] deletedDirectories, string[] expectedAdded, string[] expectedRemoved)
            {
                await InjectDirectoriesIntoWatcher(_directoryWatcher, _fileSystem, deletedDirectories, _taskScheduler);

                using (_taskScheduler.Pause()) {
                    foreach (var path in addedDirectories)
                    {
                        DirectoryInfoStubFactory.Create(_fileSystem, path);
                    }

                    RaiseCreated(_directoryWatcher, addedDirectories);

                    foreach (var path in deletedDirectories)
                    {
                        DirectoryInfoStubFactory.Delete(_fileSystem, path);
                    }

                    RaiseDeleted(_directoryWatcher, deletedDirectories);

                    _taskScheduler.ScheduledTasksCount.Should().Be(1);
                }

                await _taskScheduler;

                _changeset.Should().NotBeNull()
                .And.HaveAddedDirectories(expectedAdded)
                .And.HaveRemovedDirectories(expectedRemoved)
                .And.NoOtherChanges();
            }
        private static async Task InjectDirectoriesIntoWatcher(IFileSystemWatcher fileWatcher, IFileSystem fileSystem, IEnumerable <string> fullPaths, ControlledTaskScheduler taskScheduler)
        {
            var directories = fullPaths.AsList();

            foreach (var path in directories)
            {
                DirectoryInfoStubFactory.Create(fileSystem, path);
            }
            RaiseCreated(fileWatcher, directories);
            await taskScheduler;

            foreach (var path in directories)
            {
                DirectoryInfoStubFactory.Delete(fileSystem, path);
            }
        }
            public async Task DirectoryAdded(string[] addedDirectories, string[] expected)
            {
                using (_taskScheduler.Pause()) {
                    foreach (var path in addedDirectories)
                    {
                        DirectoryInfoStubFactory.Create(_fileSystem, path);
                        RaiseCreated(_directoryWatcher, path);
                    }

                    _taskScheduler.ScheduledTasksCount.Should().Be(1);
                }

                await _taskScheduler;

                _changeset.Should().NotBeNull()
                .And.HaveAddedDirectories(expected)
                .And.NoOtherChanges();
            }
            public async Task DirectoryRemoved_SomeStillExists(string[] deletedDirectories, string[] existingDirectories, string[] expected)
            {
                await InjectDirectoriesIntoWatcher(_directoryWatcher, _fileSystem, deletedDirectories, _taskScheduler);

                foreach (var path in existingDirectories)
                {
                    DirectoryInfoStubFactory.Create(_fileSystem, path);
                }

                using (_taskScheduler.Pause()) {
                    RaiseDeleted(_directoryWatcher, deletedDirectories);
                    _taskScheduler.ScheduledTasksCount.Should().Be(1);
                }

                await _taskScheduler;

                _changeset.Should().NotBeNull()
                .And.HaveRemovedDirectories(expected)
                .And.NoOtherChanges();
            }
            public NoDelayNoFiltering()
            {
                _fileSystem = Substitute.For <IFileSystem>();
                _fileSystem.GetFileAttributes(Arg.Any <string>()).Throws <FileNotFoundException>();
                var watchers = GetWatchersFromMsBuildFileSystemWatcher(_fileSystem);

                var fileSystemFilter = Substitute.For <IMsBuildFileSystemFilter>();

                fileSystemFilter.IsFileAllowed(Arg.Any <string>(), Arg.Any <FileAttributes>()).ReturnsForAnyArgs(true);
                fileSystemFilter.IsDirectoryAllowed(Arg.Any <string>(), Arg.Any <FileAttributes>()).ReturnsForAnyArgs(true);

                _taskScheduler = new ControlledTaskScheduler(SynchronizationContext.Current);

                DirectoryInfoStubFactory.Create(_fileSystem, ProjectDirectory);
                _fileSystemWatcher = new MsBuildFileSystemWatcher(ProjectDirectory, "*", 0, 0, _fileSystem, fileSystemFilter, _taskScheduler, NullLog.Instance);
                _fileSystemWatcher.Start();

                _fileWatcher       = watchers.FileWatcher;
                _directoryWatcher  = watchers.DirectoryWatcher;
                _attributesWatcher = watchers.AttributesWatcher;
            }