CmisSync.Lib.Producer.Crawler.LocalEventGenerator.CreateEvents C# (CSharp) Метод

        public List<AbstractFolderEvent> CreateEvents(
            List<IMappedObject> storedObjects,
            IObjectTree<IFileSystemInfo> localTree,
            Dictionary<string, Tuple<AbstractFolderEvent, AbstractFolderEvent>> eventMap,
            ISet<IMappedObject> handledStoredObjects)
        {
            List<AbstractFolderEvent> creationEvents = new List<AbstractFolderEvent>();
            var parent = localTree.Item;
            IMappedObject storedParent = null;
            Guid? guid = parent.Uuid;

            if (guid != null) {
                storedParent = storedObjects.Find(o => o.Guid.Equals((Guid)guid));
            }

            foreach (var child in localTree.Children) {
                IMappedObject storedMappedChild = this.FindStoredObjectByFileSystemInfo(storedObjects, child.Item);
                if (storedMappedChild != null) {
                    var localPath = this.storage.GetLocalPath(storedMappedChild);
                    if (localPath == null) {
                        continue;
                    }

                    #if __COCOA__
                    if ((!localPath.Normalize(NormalizationForm.FormD).Equals(child.Item.FullName.Normalize(NormalizationForm.FormD))) && this.fsFactory.IsDirectory(localPath) != null) {
                    #else
                    if ((!localPath.Equals(child.Item.FullName)) && this.fsFactory.IsDirectory(localPath) != null) {
                    #endif
                        // Copied
                        creationEvents.Add(this.GenerateCreatedEvent(child.Item));
                    } else {
                        // Moved, Renamed, Updated or Equal
                        AbstractFolderEvent correspondingRemoteEvent = GetCorrespondingRemoteEvent(eventMap, storedMappedChild);
                        AbstractFolderEvent createdEvent = this.CreateLocalEventBasedOnStorage(child.Item, storedParent, storedMappedChild);

                        eventMap[storedMappedChild.RemoteObjectId] = new Tuple<AbstractFolderEvent, AbstractFolderEvent>(createdEvent, correspondingRemoteEvent);
                        handledStoredObjects.Add(storedMappedChild);
                    }
                } else {
                    // Added
                    creationEvents.Add(this.GenerateCreatedEvent(child.Item));
                }

                creationEvents.AddRange(this.CreateEvents(storedObjects, child, eventMap, handledStoredObjects));
            }

            return creationEvents;
        }

        public void RenameOnSubFolder() {
            var storage = new Mock<IMetaDataStorage>();
            var fsFactory = new Mock<IFileSystemInfoFactory>();
            var underTest = new LocalEventGenerator(storage.Object, fsFactory.Object);
            Dictionary<string, Tuple<AbstractFolderEvent, AbstractFolderEvent>> eventMap = new Dictionary<string, Tuple<AbstractFolderEvent, AbstractFolderEvent>>();

            Guid rootGuid = Guid.NewGuid();
            var rootName = "root";
            var rootPath = Path.Combine(Path.GetTempPath(), rootName);
            var rootObjectId = "rootId";
            ObjectTree<IFileSystemInfo> rootTree = this.CreateTreeFromPathAndGuid(rootName, rootPath, rootGuid);

            Guid subFolderGuid = Guid.NewGuid();
            var subName = "A";
            var subPath = Path.Combine(rootPath, subName);
            var subFolderId = "subId";
            ObjectTree<IFileSystemInfo> subFolder = this.CreateTreeFromPathAndGuid(subName, subPath, subFolderGuid);
            rootTree.Children.Add(subFolder);

            Guid subSubFolderGuid = Guid.NewGuid();
            var subSubName = "B";
            var subSubPath = Path.Combine(subPath, subSubName);
            var subSubFolderId = "subId";
            ObjectTree<IFileSystemInfo> subSubFolder = this.CreateTreeFromPathAndGuid(subSubName, subSubPath, subSubFolderGuid);
            subFolder.Children.Add(subSubFolder);

            List<IMappedObject> storedObjectsForLocal = new List<IMappedObject>();
            var rootMappedObject = this.CreateStoredObjectMock(rootGuid, rootObjectId, rootName, null);
            storedObjectsForLocal.Add(rootMappedObject);
            var subMappedObject = this.CreateStoredObjectMock(subFolderGuid, subFolderId, subName, rootObjectId);
            storedObjectsForLocal.Add(subMappedObject);
            var subSubMappedObject = this.CreateStoredObjectMock(subSubFolderGuid, subSubFolderId, "oldsubsubName", subSubFolderId);
            storedObjectsForLocal.Add(subSubMappedObject);

            storage.Setup(s => s.GetLocalPath(rootMappedObject)).Returns(rootPath);
            storage.Setup(s => s.GetLocalPath(subMappedObject)).Returns(subPath);
            storage.Setup(s => s.GetLocalPath(subSubMappedObject)).Returns(subSubPath);

            ISet<IMappedObject> handledLocalStoredObjects = new HashSet<IMappedObject>();
            List<AbstractFolderEvent> creationEvents = underTest.CreateEvents(storedObjectsForLocal, rootTree, eventMap, handledLocalStoredObjects);
            foreach (var handledObjects in handledLocalStoredObjects) {
                storedObjectsForLocal.Remove(handledObjects);
            }

            storedObjectsForLocal.Remove(rootMappedObject);
            Assert.That(creationEvents, Is.Empty);
            Assert.That(storedObjectsForLocal, Is.Empty);
            Assert.That(eventMap.Count, Is.EqualTo(1));
            Assert.That(eventMap[subSubFolderId], Is.Not.Null);
            Assert.That(eventMap[subSubFolderId].Item1.Local, Is.EqualTo(MetaDataChangeType.CHANGED));
        }