public void PermissionDeniedOnModificationDateSavesTheLocalDate() { Guid uuid = Guid.NewGuid(); var modificationDate = DateTime.UtcNow; var localFolder = new Mock <IDirectoryInfo>(); localFolder.SetupProperty(f => f.LastWriteTimeUtc, modificationDate.AddMinutes(1)); localFolder.Setup(f => f.FullName).Returns("path"); localFolder.SetupGuid(uuid); localFolder.Setup(f => f.Exists).Returns(true); var mappedObject = new MappedObject( "name", "remoteId", MappedObjectType.Folder, "parentId", "changeToken") { Guid = uuid, LastRemoteWriteTimeUtc = modificationDate.AddMinutes(1), LastLocalWriteTimeUtc = modificationDate, }; this.storage.AddMappedFolder(mappedObject, "path"); var remoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock("remoteId", "name", "path", "parentId"); remoteFolder.Setup(r => r.UpdateProperties(It.IsAny <IDictionary <string, object> >(), true)).Throws(new CmisPermissionDeniedException()); this.underTest.Solve(localFolder.Object, remoteFolder.Object); this.storage.VerifySavedMappedObject(MappedObjectType.Folder, "remoteId", "name", "parentId", "changeToken", true, localFolder.Object.LastWriteTimeUtc, remoteFolder.Object.LastModificationDate); remoteFolder.Verify(r => r.UpdateProperties(It.IsAny <IDictionary <string, object> >(), true)); }
public void RunFSEventFolderDeleted() { var storage = this.GetInitializedStorage(); var path = new Mock <IFileInfo>(); var name = "a"; path.Setup(p => p.FullName).Returns(Path.Combine(this.localRoot, name)); string id = "id"; var mappedObject = new MappedObject(name, id, MappedObjectType.Folder, null, null); storage.SaveMappedObject(mappedObject); var session = new Mock <ISession>(); session.SetupTypeSystem(); session.SetupSessionDefaultValues(); session.SetupChangeLogToken("default"); IFolder remote = MockOfIFolderUtil.CreateRemoteFolderMock(id, name, (string)null).Object; session.Setup(s => s.GetObject(id, It.IsAny <IOperationContext>())).Returns(remote); var myEvent = new FSEvent(WatcherChangeTypes.Deleted, path.Object.FullName, true); var queue = this.CreateQueue(session, storage); queue.AddEvent(myEvent); queue.Run(); Mock.Get(remote).Verify(d => d.DeleteTree(false, UnfileObject.DeleteSinglefiled, true), Times.Once()); Assert.That(storage.GetObjectByRemoteId(id), Is.Null); }
public void LocalAndRemoteFolderAreChanged([Values(true, false)] bool childrenAreIgnored) { this.InitMocks(); string folderName = "folderName"; DateTime lastLocalModification = DateTime.UtcNow.AddDays(1); DateTime lastRemoteModification = DateTime.UtcNow.AddHours(1); var localFolder = Mock.Of <IDirectoryInfo>(f => f.LastWriteTimeUtc == lastLocalModification); var remoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock(this.remoteId, folderName, "path", this.parentId, this.newChangeToken, childrenAreIgnored); remoteFolder.Setup(f => f.LastModificationDate).Returns(lastRemoteModification); var mappedFolder = Mock.Of <IMappedObject>( o => o.Name == folderName && o.RemoteObjectId == this.remoteId && o.LastChangeToken == this.oldChangeToken && o.LastLocalWriteTimeUtc == DateTime.UtcNow && o.LastRemoteWriteTimeUtc == DateTime.UtcNow && o.ParentId == this.parentId && o.Type == MappedObjectType.Folder && o.Guid == Guid.NewGuid() && o.LastContentSize == -1); this.storage.AddMappedFolder(mappedFolder); this.underTest.Solve(localFolder, remoteFolder.Object, ContentChangeType.NONE, ContentChangeType.NONE); this.storage.VerifySavedMappedObject(MappedObjectType.Folder, this.remoteId, folderName, this.parentId, this.newChangeToken, lastLocalModification: lastLocalModification, lastRemoteModification: lastRemoteModification, ignored: childrenAreIgnored); }
public void PermissionDeniedLeadsToNoOperation() { var remoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock("folderId", "folder", "/folder", this.rootId); var remoteTargetFolder = MockOfIFolderUtil.CreateRemoteFolderMock("targetId", "target", "/target", this.rootId); this.session.AddRemoteObjects(remoteFolder.Object, remoteTargetFolder.Object); var localTargetFolder = MockOfIFileSystemInfoFactoryUtil.CreateLocalFolder(Path.Combine(Path.GetTempPath(), "target")); var localFolder = MockOfIFileSystemInfoFactoryUtil.CreateLocalFolder(Path.Combine(Path.GetTempPath(), "target", "folder")); localFolder.Setup(f => f.Parent).Returns(localTargetFolder.Object); var mappedFolder = new MappedObject("folder", "folderId", MappedObjectType.Folder, this.rootId, "changetoken") { Guid = Guid.NewGuid() }; var mappedTargetFolder = new MappedObject("target", "targetId", MappedObjectType.Folder, this.rootId, "changetoken") { Guid = Guid.NewGuid() }; this.storage.Setup(s => s.GetObjectByLocalPath(It.Is <IDirectoryInfo>(d => d.Equals(localTargetFolder.Object)))).Returns(mappedTargetFolder); this.storage.Setup(s => s.GetObjectByRemoteId("folderId")).Returns(mappedFolder); remoteFolder.Setup(f => f.Move(this.remoteRootFolder.Object, remoteTargetFolder.Object)).Throws(new CmisPermissionDeniedException()); this.underTest.Solve(localFolder.Object, remoteFolder.Object); remoteFolder.Verify(f => f.Move(this.remoteRootFolder.Object, remoteTargetFolder.Object), Times.Once()); this.storage.VerifyThatNoObjectIsManipulated(); }
public void LocalFolderMovedAndRenamed([Values(true, false)] bool childrenAreIgnored) { this.SetUpMocks(); string oldDirName = "oldName"; string newDirName = "newName"; var dir = Mock.Of <IDirectoryInfo>( d => d.FullName == Path.Combine(Path.GetTempPath(), this.newParentsName, newDirName) && d.Name == newDirName && d.Parent.Uuid == this.parentUuid); var folder = MockOfIFolderUtil.CreateRemoteFolderMock(this.remoteObjectId, oldDirName, "path", this.oldParentsId, ignored: childrenAreIgnored); folder.Setup(d => d.Move(It.IsAny <IObjectId>(), It.IsAny <IObjectId>())).Returns(folder.Object); var obj = new MappedObject(oldDirName, this.remoteObjectId, MappedObjectType.Folder, this.oldParentsId, this.changeToken) { Guid = Guid.NewGuid() }; this.storage.AddMappedFolder(obj); this.underTest.Solve(dir, folder.Object, ContentChangeType.NONE, ContentChangeType.NONE); this.storage.VerifySavedMappedObject(MappedObjectType.Folder, this.remoteObjectId, newDirName, this.newParentsId, this.changeToken, Times.Exactly(2), ignored: childrenAreIgnored); folder.Verify(d => d.Move(It.Is <IObjectId>(o => o.Id == this.oldParentsId), It.Is <IObjectId>(o => o.Id == this.newParentsId))); this.renameSolver.Verify(s => s.Solve(dir, folder.Object, ContentChangeType.NONE, ContentChangeType.NONE), Times.Once()); this.changeSolver.Verify(s => s.Solve(It.IsAny <IFileSystemInfo>(), It.IsAny <IObjectId>(), It.IsAny <ContentChangeType>(), It.IsAny <ContentChangeType>()), Times.Never); }
public void CreateMockObjects() { this.storageEngine = new DBreezeEngine(new DBreezeConfiguration { Storage = DBreezeConfiguration.eStorage.MEMORY }); this.localRootPath = Path.Combine(Path.GetTempPath(), Path.GetTempFileName()); this.matcher = new PathMatcher(this.localRootPath, this.remoteRootPath); this.queue = new Mock <ISyncEventQueue>(); this.remoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock(this.remoteRootId, this.remoteRootPath, this.remoteRootPath); this.remoteFolder.SetupDescendants(); this.localFolder = new Mock <IDirectoryInfo>(); this.localFolder.Setup(f => f.FullName).Returns(this.localRootPath); this.localFolder.Setup(f => f.Exists).Returns(true); this.localFolder.Setup(f => f.IsExtendedAttributeAvailable()).Returns(true); this.localFolder.SetupGuid(this.rootGuid); this.localFolder.Setup(f => f.LastWriteTimeUtc).Returns(this.lastLocalWriteTime); this.fsFactory = new Mock <IFileSystemInfoFactory>(); this.fsFactory.AddIDirectoryInfo(this.localFolder.Object); this.mappedRootObject = new MappedObject( this.remoteRootPath, this.remoteRootId, MappedObjectType.Folder, null, "changeToken") { Guid = this.rootGuid, LastLocalWriteTimeUtc = this.lastLocalWriteTime }; this.storage = new MetaDataStorage(this.storageEngine, this.matcher); this.storage.SaveMappedObject(this.mappedRootObject); this.filter = MockOfIFilterAggregatorUtil.CreateFilterAggregator().Object; this.listener = new Mock <IActivityListener>(); }
public void OneRemoteFolderRenamed() { DateTime modification = DateTime.UtcNow; string oldFolderName = "folderName"; string newFolderName = "newfolderName"; string folderId = "folderId"; var localGuid = Guid.NewGuid(); var oldLocalFolder = this.fsFactory.AddDirectory(Path.Combine(this.localRootPath, oldFolderName)); oldLocalFolder.Setup(f => f.LastWriteTimeUtc).Returns(modification); oldLocalFolder.SetupGuid(localGuid); var storedFolder = new MappedObject(oldFolderName, folderId, MappedObjectType.Folder, this.remoteRootId, "changeToken") { Guid = localGuid, LastLocalWriteTimeUtc = modification }; this.localFolder.SetupDirectories(oldLocalFolder.Object); this.storage.SaveMappedObject(storedFolder); var renamedRemoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock(folderId, newFolderName, this.remoteRootPath + newFolderName, this.remoteRootId, "newChangeToken"); this.remoteFolder.SetupDescendants(renamedRemoteFolder.Object); Assert.That(this.CreateCrawler().Handle(new StartNextSyncEvent()), Is.True); this.queue.Verify( q => q.AddEvent( It.Is <FolderEvent>( e => e.Remote == MetaDataChangeType.CHANGED && e.Local == MetaDataChangeType.NONE && e.RemoteFolder.Equals(renamedRemoteFolder.Object))), Times.Once()); this.VerifyThatCountOfAddedEventsIsLimitedTo(Times.Once()); this.VerifyThatListenerHasBeenUsed(); }
public void OneLocalFolderRenamed() { var uuid = Guid.NewGuid(); var oldLocalFolder = this.fsFactory.AddDirectory(Path.Combine(this.localRootPath, "oldFolder")); var newLocalFolder = this.fsFactory.AddDirectory(Path.Combine(this.localRootPath, "newFolder")); oldLocalFolder.Setup(f => f.Exists).Returns(false); newLocalFolder.SetupGuid(uuid); var remoteSubFolder = MockOfIFolderUtil.CreateRemoteFolderMock("oldFolderId", "oldFolder", this.remoteRootPath + "oldFolder", this.remoteRootId, "oldChange"); var storedFolder = new MappedObject("oldFolder", "oldFolderId", MappedObjectType.Folder, this.remoteRootId, "oldChange") { Guid = uuid }; this.storage.SaveMappedObject(storedFolder); this.remoteFolder.SetupDescendants(remoteSubFolder.Object); this.localFolder.SetupDirectories(newLocalFolder.Object); var crawler = this.CreateCrawler(); Assert.That(crawler.Handle(new StartNextSyncEvent()), Is.True); this.queue.Verify( q => q.AddEvent( It.Is <FolderEvent>( e => e.LocalFolder.Equals(newLocalFolder.Object) && e.Local.Equals(MetaDataChangeType.CHANGED))), Times.Once()); this.VerifyThatCountOfAddedEventsIsLimitedTo(Times.Once()); this.VerifyThatListenerHasBeenUsed(); }
public void MoveObjectToSubfolder() { var remoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock("folderId", "folder", "/folder", this.rootId); var remoteTargetFolder = MockOfIFolderUtil.CreateRemoteFolderMock("targetId", "target", "/target", this.rootId); this.session.AddRemoteObjects(remoteFolder.Object, remoteTargetFolder.Object); var localTargetFolder = MockOfIFileSystemInfoFactoryUtil.CreateLocalFolder(Path.Combine(Path.GetTempPath(), "target")); var localFolder = MockOfIFileSystemInfoFactoryUtil.CreateLocalFolder(Path.Combine(Path.GetTempPath(), "target", "folder")); localFolder.Setup(f => f.Parent).Returns(localTargetFolder.Object); var mappedFolder = new MappedObject("folder", "folderId", MappedObjectType.Folder, this.rootId, "changetoken") { Guid = Guid.NewGuid() }; var mappedTargetFolder = new MappedObject("target", "targetId", MappedObjectType.Folder, this.rootId, "changetoken") { Guid = Guid.NewGuid() }; this.storage.Setup(s => s.GetObjectByLocalPath(It.Is <IDirectoryInfo>(d => d.Equals(localTargetFolder.Object)))).Returns(mappedTargetFolder); this.storage.Setup(s => s.GetObjectByRemoteId("folderId")).Returns(mappedFolder); remoteFolder.Setup(f => f.Move(this.remoteRootFolder.Object, remoteTargetFolder.Object)).Callback(() => { remoteFolder.Setup(r => r.ChangeToken).Returns("new ChangeToken"); }).Returns(remoteFolder.Object); this.underTest.Solve(localFolder.Object, remoteFolder.Object); remoteFolder.Verify(f => f.Move(this.remoteRootFolder.Object, remoteTargetFolder.Object), Times.Once()); remoteFolder.VerifyUpdateLastModificationDate(localFolder.Object.LastWriteTimeUtc); this.storage.VerifySavedMappedObject(MappedObjectType.Folder, "folderId", "folder", "targetId", "new ChangeToken", true); }
public void LocalFolderRenamed([Values(true, false)] bool childrenAreIgnored) { var remoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock(this.id, this.oldName, "path", null, changetoken: null, ignored: childrenAreIgnored); remoteFolder.Setup(f => f.Rename(this.newName, true)).Callback( () => { remoteFolder.Setup(f => f.Name).Returns(this.newName); remoteFolder.Setup(f => f.ChangeToken).Returns(this.newChangeToken); remoteFolder.Setup(f => f.LastModificationDate).Returns(this.newModificationDate); }).Returns(Mock.Of <IObjectId>(o => o.Id == this.id)); var localFolder = new Mock <IDirectoryInfo>(); localFolder.SetupProperty(f => f.LastWriteTimeUtc, this.modificationDate); localFolder.Setup(f => f.Name).Returns(this.newName); var mappedFolder = new Mock <IMappedObject>(); mappedFolder.SetupAllProperties(); mappedFolder.SetupProperty(f => f.Guid, Guid.NewGuid()); mappedFolder.SetupProperty(f => f.Name, this.oldName); mappedFolder.SetupProperty(f => f.RemoteObjectId, this.id); mappedFolder.Setup(f => f.Type).Returns(MappedObjectType.Folder); mappedFolder.Setup(f => f.LastContentSize).Returns(-1); this.storage.AddMappedFolder(mappedFolder.Object); this.underTest.Solve(localFolder.Object, remoteFolder.Object); remoteFolder.Verify(f => f.Rename(It.Is <string>(s => s == this.newName), It.Is <bool>(b => b == true)), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.Folder, this.id, this.newName, null, this.newChangeToken, true, this.modificationDate, this.newModificationDate, ignored: childrenAreIgnored); }
public void Utf8CharacterLeadsToNoSavings() { string newFolderName = @"ä".Normalize(System.Text.NormalizationForm.FormD); var remoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock("folderId", "folder", "/folder", this.rootId); var targetFolder = MockOfIFolderUtil.CreateRemoteFolderMock("targetId", "target", "/target", this.rootId); this.session.AddRemoteObjects(remoteFolder.Object, targetFolder.Object); var localTargetFolder = MockOfIFileSystemInfoFactoryUtil.CreateLocalFolder(Path.Combine(Path.GetTempPath(), "target")); var localFolder = MockOfIFileSystemInfoFactoryUtil.CreateLocalFolder(Path.Combine(Path.GetTempPath(), "target", newFolderName)); localFolder.Setup(f => f.Parent).Returns(localTargetFolder.Object); var mappedFolder = new MappedObject("folder", "folderId", MappedObjectType.Folder, this.rootId, "changetoken") { Guid = Guid.NewGuid() }; var mappedTargetFolder = new MappedObject("target", "targetId", MappedObjectType.Folder, this.rootId, "changetoken") { Guid = Guid.NewGuid() }; this.storage.Setup(s => s.GetObjectByLocalPath(It.Is <IDirectoryInfo>(d => d.Equals(localTargetFolder.Object)))).Returns(mappedTargetFolder); this.storage.Setup(s => s.GetObjectByRemoteId("folderId")).Returns(mappedFolder); remoteFolder.Setup(f => f.Move(this.remoteRootFolder.Object, targetFolder.Object)).Returns(remoteFolder.Object); remoteFolder.Setup(f => f.Rename(newFolderName, true)).Throws <CmisConstraintException>(); Assert.Throws <InteractionNeededException>(() => this.underTest.Solve(localFolder.Object, remoteFolder.Object)); remoteFolder.Verify(f => f.Move(this.remoteRootFolder.Object, targetFolder.Object), Times.Once()); remoteFolder.Verify(f => f.Rename(newFolderName, true), Times.Once()); remoteFolder.Verify(f => f.UpdateProperties(It.IsAny <System.Collections.Generic.IDictionary <string, object> >()), Times.Never()); this.storage.VerifyThatNoObjectIsManipulated(); }
private Mock <IFolder> CreateRemoteFolder(bool ignored) { var folder = MockOfIFolderUtil.CreateRemoteFolderMock(this.remoteId, this.newName, "path", this.oldParentId, ignored: ignored); folder.Setup( d => d.Move(It.Is <IObjectId>(o => o.Id == this.oldParentId), It.Is <IObjectId>(o => o.Id == this.newParentId))) .Returns(folder.Object); return(folder); }
public void OneRemoteFolderAdded() { IFolder newRemoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock("id", "name", "/name", this.remoteRootId).Object; this.remoteFolder.SetupDescendants(newRemoteFolder); var crawler = this.CreateCrawler(); Assert.That(crawler.Handle(new StartNextSyncEvent()), Is.True); this.queue.Verify(q => q.AddEvent(It.Is <FolderEvent>(e => e.RemoteFolder.Equals(newRemoteFolder))), Times.Once()); this.VerifyThatListenerHasBeenUsed(); }
public void MoveFolderToNewLocation([Values(true, false)] bool childrenAreIgnored) { DateTime modifiedDate = DateTime.UtcNow.AddMinutes(1); string oldFolderName = "a"; string subFolderName = "sub"; string subFolderId = "sub"; string newFolderName = "b"; string oldPath = Path.Combine(Path.GetTempPath(), oldFolderName); string oldRemotePath = "/" + oldFolderName; string newPath = Path.Combine(Path.GetTempPath(), subFolderName, newFolderName); string id = "id"; string parentId = "papa"; string lastChangeToken = "token"; var dirInfo = new Mock <IDirectoryInfo>(); dirInfo.Setup(d => d.FullName).Returns(oldPath); dirInfo.Setup(d => d.Name).Returns(oldFolderName); dirInfo.Setup(d => d.Parent).Returns(Mock.Of <IDirectoryInfo>(p => p.FullName == Path.GetTempPath())); Mock <IFolder> remoteObject = MockOfIFolderUtil.CreateRemoteFolderMock(id, newFolderName, newPath, subFolderId, lastChangeToken, childrenAreIgnored); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)modifiedDate); var mappedFolder = Mock.Of <IMappedObject>( f => f.Name == oldFolderName && f.RemoteObjectId == id && f.LastChangeToken == "oldToken" && f.LastRemoteWriteTimeUtc == DateTime.UtcNow && f.Type == MappedObjectType.Folder && f.ParentId == parentId && f.Guid == Guid.NewGuid() && f.LastContentSize == -1); var mappedSubFolder = Mock.Of <IMappedObject>( f => f.Name == subFolderName && f.RemoteObjectId == subFolderId && f.LastChangeToken == "oldToken" && f.Type == MappedObjectType.Folder && f.ParentId == parentId && f.Guid == Guid.NewGuid() && f.LastContentSize == -1); this.storage.AddMappedFolder(mappedFolder, oldPath, oldRemotePath); this.storage.AddMappedFolder(mappedSubFolder, Path.Combine(Path.GetTempPath(), subFolderName), "/" + subFolderName); this.matcher.Setup(m => m.CreateLocalPath(It.Is <IFolder>(f => f == remoteObject.Object))).Returns(newPath); this.underTest.Solve(dirInfo.Object, remoteObject.Object); dirInfo.Verify(d => d.MoveTo(It.Is <string>(p => p.Equals(newPath))), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.Folder, id, newFolderName, subFolderId, lastChangeToken, lastRemoteModification: modifiedDate, ignored: childrenAreIgnored); }
public void ChangedEventForUnchangedIgnoredStateObject() { this.SetUpMocks(); var changedObject = MockOfIFolderUtil.CreateRemoteFolderMock(this.folderId, this.folderName, this.remotePath, Guid.NewGuid().ToString()); var changeEvent = new ContentChangeEvent(ChangeType.Updated, this.folderId); this.session.Setup(s => s.GetObject(It.IsAny <string>(), It.IsAny <IOperationContext>())).Returns(changedObject.Object); changeEvent.UpdateObject(this.session.Object); Assert.That(this.underTest.Handle(changeEvent), Is.False); this.ignoreStorage.Verify(s => s.AddOrUpdateEntryAndDeleteAllChildrenFromStorage(It.IsAny <IIgnoredEntity>()), Times.Never()); this.queue.VerifyThatNoEventIsAdded(); }
public void SetUp() { this.storage = new Mock <IMetaDataStorage>(); this.session = new Mock <ISession>(); this.remoteRootFolder = MockOfIFolderUtil.CreateRemoteFolderMock(this.rootId, "/", "/", null); this.session.AddRemoteObject(this.remoteRootFolder.Object); this.localRootFolder = MockOfIFileSystemInfoFactoryUtil.CreateLocalFolder(Path.GetTempPath()); this.mappedRootFolder = new MappedObject("/", this.rootId, MappedObjectType.Folder, null, "changeToken") { Guid = Guid.NewGuid() }; this.storage.Setup(s => s.GetObjectByLocalPath(It.Is <IDirectoryInfo>(d => d.Equals(this.localRootFolder.Object)))).Returns(this.mappedRootFolder); this.underTest = new LocalObjectMoved(this.session.Object, this.storage.Object, true); }
public void RemoteFolderAdded( [Values(true, false)] bool childrenAreIgnored, [Values(true, false)] bool extendedAttributesAvailable, [Values(true, false)] bool throwExceptionOnUpdateModificationDate) { var localModificationDate = DateTime.Now - TimeSpan.FromDays(1); var dirInfo = new Mock <IDirectoryInfo>(); dirInfo.SetupAllProperties(); dirInfo.Setup(d => d.FullName).Returns(this.path); dirInfo.Setup(d => d.Name).Returns(this.objectName); dirInfo.Setup(d => d.Parent).Returns(Mock.Of <IDirectoryInfo>()); dirInfo.Setup(d => d.IsExtendedAttributeAvailable()).Returns(extendedAttributesAvailable); dirInfo.SetupProperty(dir => dir.LastWriteTimeUtc, localModificationDate); if (throwExceptionOnUpdateModificationDate) { dirInfo.SetupSet(d => d.LastWriteTimeUtc = It.IsAny <DateTime>()).Throws(new IOException("Another process is using this folder")); } Mock <IFolder> remoteObject = MockOfIFolderUtil.CreateRemoteFolderMock( this.id, this.objectName, this.path, this.parentId, this.lastChangeToken, ignored: childrenAreIgnored); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); this.underTest.Solve(dirInfo.Object, remoteObject.Object); dirInfo.Verify(d => d.Create(), Times.Once()); this.storage.VerifySavedMappedObject( MappedObjectType.Folder, this.id, this.objectName, this.parentId, this.lastChangeToken, extendedAttributesAvailable, lastLocalModification: throwExceptionOnUpdateModificationDate?localModificationDate: this.creationDate, lastRemoteModification: this.creationDate, ignored: childrenAreIgnored); dirInfo.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(this.creationDate)), Times.Once()); dirInfo.VerifySet(d => d.Uuid = It.IsAny <Guid?>(), extendedAttributesAvailable ? Times.Once() : Times.Never()); if (extendedAttributesAvailable) { dirInfo.VerifySet(d => d.Uuid = It.Is <Guid?>(uuid => uuid != null && !uuid.Equals(Guid.Empty)), Times.Once()); } }
public void DoNotMoveFolderToSameLocation() { DateTime modifiedDate = DateTime.UtcNow.AddMinutes(1); string oldFolderName = "a"; string subFolderName = "sub"; string subFolderId = "sub"; string newFolderName = "b"; string oldPath = Path.Combine(Path.GetTempPath(), oldFolderName); string oldRemotePath = "/" + oldFolderName; string id = "id"; string parentId = "papa"; string lastChangeToken = "token"; var dirInfo = new Mock <IDirectoryInfo>(); dirInfo.Setup(d => d.FullName).Returns(oldPath); dirInfo.Setup(d => d.Name).Returns(oldFolderName); dirInfo.Setup(d => d.Parent).Returns(Mock.Of <IDirectoryInfo>(p => p.FullName == Path.GetTempPath())); Mock <IFolder> remoteObject = MockOfIFolderUtil.CreateRemoteFolderMock(id, newFolderName, oldPath, subFolderId, lastChangeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)modifiedDate); var mappedFolder = Mock.Of <IMappedObject>( f => f.Name == oldFolderName && f.RemoteObjectId == id && f.LastChangeToken == "oldToken" && f.LastRemoteWriteTimeUtc == DateTime.UtcNow && f.Type == MappedObjectType.Folder && f.ParentId == parentId); var mappedSubFolder = Mock.Of <IMappedObject>( f => f.Name == subFolderName && f.RemoteObjectId == subFolderId && f.LastChangeToken == "oldToken" && f.Type == MappedObjectType.Folder && f.ParentId == parentId); this.storage.AddMappedFolder(mappedFolder, oldPath, oldRemotePath); this.storage.AddMappedFolder(mappedSubFolder, Path.Combine(Path.GetTempPath(), subFolderName), "/" + subFolderName); this.matcher.Setup(m => m.CreateLocalPath(It.Is <IFolder>(f => f == remoteObject.Object))).Returns(oldPath); this.underTest.Solve(dirInfo.Object, remoteObject.Object); dirInfo.Verify(d => d.MoveTo(It.IsAny <string>()), Times.Never()); this.storage.Verify(s => s.SaveMappedObject(It.IsAny <IMappedObject>()), Times.Never()); }
public void PermissionDeniedOnModificationDateSavesTheLocalDate() { this.SetUpMocks(); var localFolder = this.CreateLocalDirectory(this.modificationDate.AddMinutes(1)); var mappedObject = this.CreateMappedObject(false, this.modificationDate.AddMinutes(1)); this.storage.AddMappedFolder(mappedObject); var remoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock(this.remoteId, this.objectName, this.remotePath, this.parentId, this.oldChangeToken); remoteFolder.Setup(r => r.UpdateProperties(It.IsAny <IDictionary <string, object> >(), true)).Throws(new CmisPermissionDeniedException()); this.underTest.Solve(localFolder.Object, remoteFolder.Object); this.VerifySavedFolder(this.oldChangeToken, localFolder.Object.LastWriteTimeUtc, remoteFolder.Object.LastModificationDate); remoteFolder.Verify(r => r.UpdateProperties(It.IsAny <IDictionary <string, object> >(), true)); }
public void SimpleRemoteFolderHierarchyAdded() { var newRemoteSubFolder = MockOfIFolderUtil.CreateRemoteFolderMock("remoteSubFolder", "sub", "/name/sub", "remoteFolder"); var newRemoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock("remoteFolder", "name", "/name", this.remoteRootId); newRemoteFolder.SetupDescendants(newRemoteSubFolder.Object); this.remoteFolder.SetupDescendants(newRemoteFolder.Object); var crawler = this.CreateCrawler(); Assert.That(crawler.Handle(new StartNextSyncEvent()), Is.True); this.queue.Verify(q => q.AddEvent(It.Is <FolderEvent>(e => e.RemoteFolder.Equals(newRemoteFolder.Object))), Times.Once()); this.queue.Verify(q => q.AddEvent(It.Is <FolderEvent>(e => e.RemoteFolder.Equals(newRemoteSubFolder.Object))), Times.Once()); this.VerifyThatCountOfAddedEventsIsLimitedTo(Times.Exactly(2)); this.VerifyThatListenerHasBeenUsed(); }
public void FolderMovedToEqualFolderAndNamesAreEqual() { this.SetupOldMappedFolder(); this.remoteModification = this.localModification - TimeSpan.FromMinutes(30); var newLocalParent = this.CreateNewLocalParent(this.newParentUuid); var localFolder = this.CreateLocalFolder(this.oldName, newLocalParent, this.localModification); var remoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock(this.remoteObjectId, this.oldName, "/" + this.oldName, this.newRemoteParentId, this.newChangeToken); remoteFolder.SetupLastModificationDate(remoteModification); this.underTest.Solve(localFolder.Object, remoteFolder.Object, ContentChangeType.NONE, ContentChangeType.NONE); remoteFolder.VerifyUpdateLastModificationDate(this.localModification); this.VerifySavedFolder(this.oldName, this.localModification); }
public void IFolderConstructor() { string folderName = "a"; string path = Path.Combine(Path.GetTempPath(), folderName); string id = "id"; string parentId = "papa"; string lastChangeToken = "token"; Mock <IFolder> remoteObject = MockOfIFolderUtil.CreateRemoteFolderMock(id, folderName, path, parentId, lastChangeToken); MappedObject mappedObject = new MappedObject(remoteObject.Object); Assert.That(mappedObject.RemoteObjectId, Is.EqualTo(id), "RemoteObjectId incorrect"); Assert.That(mappedObject.Name, Is.EqualTo(folderName), "Name incorrect"); Assert.That(mappedObject.ParentId, Is.EqualTo(parentId), "ParentId incorrect"); Assert.That(mappedObject.LastChangeToken, Is.EqualTo(lastChangeToken), "LastChangeToken incorrect"); Assert.That(mappedObject.Type, Is.EqualTo(MappedObjectType.Folder), "Type incorrect"); }
public void FolderMovedToEqualFolderAndBothNamesAreChangedAndRemoteModificationIsNewer() { this.SetupOldMappedFolder(); this.localModification = this.remoteModification - TimeSpan.FromMinutes(30); var newLocalParent = this.CreateNewLocalParent(this.newParentUuid, this.newParentPath); var localFolder = this.CreateLocalFolder(this.newLocalName, newLocalParent, localModification); var remoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock(this.remoteObjectId, this.newRemoteName, "/" + this.oldName, this.newRemoteParentId, this.newChangeToken); remoteFolder.SetupLastModificationDate(remoteModification); this.underTest.Solve(localFolder.Object, remoteFolder.Object, ContentChangeType.NONE, ContentChangeType.NONE); remoteFolder.Verify(r => r.Rename(It.IsAny <string>(), It.IsAny <bool>()), Times.Never()); localFolder.Verify(f => f.MoveTo(Path.Combine()), Times.Never()); this.VerifySavedFolder(this.newRemoteName, remoteModification); }
public void ChangeEventForFormerIgnoredObjectAndNowNotIgnoredObject() { this.SetUpMocks(); var changedObject = MockOfIFolderUtil.CreateRemoteFolderMock(this.folderId, this.folderName, this.remotePath, Guid.NewGuid().ToString()); var changeEvent = new ContentChangeEvent(ChangeType.Updated, this.folderId); this.session.Setup(s => s.GetObject(It.IsAny <string>(), It.IsAny <IOperationContext>())).Returns(changedObject.Object); this.ignoreStorage.Setup(i => i.IsIgnoredId(this.folderId)).Returns(IgnoredState.IGNORED); changeEvent.UpdateObject(this.session.Object); Assert.That(this.underTest.Handle(changeEvent), Is.False); this.ignoreStorage.Verify(s => s.AddOrUpdateEntryAndDeleteAllChildrenFromStorage(It.IsAny <IIgnoredEntity>()), Times.Never()); this.ignoreStorage.Verify(s => s.Remove(this.folderId)); this.queue.Verify(q => q.AddEvent(It.Is <StartNextSyncEvent>(e => e.FullSyncRequested == true)), Times.Once()); this.queue.VerifyThatNoOtherEventIsAddedThan <StartNextSyncEvent>(); }
public void RenameFolderToLowerCaseAndIOExceptionIsHandled() { this.SetUpMocks(); DateTime modifiedDate = DateTime.UtcNow.AddMinutes(1); string oldFolderName = "A"; string newFolderName = "a"; string oldPath = Path.Combine(Path.GetTempPath(), oldFolderName); string oldRemotePath = "/" + oldFolderName; string newPath = Path.Combine(Path.GetTempPath(), newFolderName); string id = "id"; string parentId = "papa"; string lastChangeToken = "token"; var dirInfo = new Mock <IDirectoryInfo>(); dirInfo.Setup(d => d.FullName).Returns(oldPath); dirInfo.Setup(d => d.Name).Returns(oldFolderName); dirInfo.SetupProperty(d => d.LastWriteTimeUtc); dirInfo.Setup(d => d.Parent).Returns(Mock.Of <IDirectoryInfo>(p => p.FullName == Path.GetTempPath())); Mock <IFolder> remoteObject = MockOfIFolderUtil.CreateRemoteFolderMock(id, newFolderName, newPath, parentId, lastChangeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)modifiedDate); var mappedFolder = Mock.Of <IMappedObject>( f => f.Name == oldFolderName && f.RemoteObjectId == id && f.LastChangeToken == "oldToken" && f.LastRemoteWriteTimeUtc == DateTime.UtcNow && f.Type == MappedObjectType.Folder && f.ParentId == parentId); this.storage.AddMappedFolder(mappedFolder, oldPath, oldRemotePath); dirInfo.Setup(d => d.MoveTo(It.Is <string>(p => p.Equals(newPath)))).Throws <IOException>(); this.underTest.Solve(dirInfo.Object, remoteObject.Object); dirInfo.Verify(d => d.MoveTo(It.Is <string>(p => p.Equals(newPath))), Times.Once()); dirInfo.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(modifiedDate)), Times.Once()); this.storage.Verify( s => s.SaveMappedObject( It.Is <IMappedObject>(f => this.VerifySavedObject(f, MappedObjectType.Folder, id, oldFolderName, parentId, lastChangeToken, modifiedDate))), Times.Once()); }
public void FolderMovedToEqualFolderAndRemoteNameChanged([Values(true, false)] bool childrenAreIgnored) { this.SetupOldMappedFolder(); this.remoteModification = this.localModification - TimeSpan.FromMinutes(30); var newLocalParent = this.CreateNewLocalParent(this.newParentUuid, this.newParentPath); var localFolder = this.CreateLocalFolder(this.oldName, newLocalParent, this.localModification); localFolder.SetupMoveTo(Path.Combine(this.newParentPath, this.newRemoteName)); var remoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock(this.remoteObjectId, this.newRemoteName, "/" + this.newRemoteName, this.newRemoteParentId, this.newChangeToken, ignored: childrenAreIgnored); remoteFolder.SetupLastModificationDate(this.remoteModification); this.underTest.Solve(localFolder.Object, remoteFolder.Object, ContentChangeType.NONE, ContentChangeType.NONE); remoteFolder.Verify(r => r.Rename(It.IsAny <string>(), It.IsAny <bool>()), Times.Never()); remoteFolder.VerifyUpdateLastModificationDate(this.localModification); this.VerifySavedFolder(this.newRemoteName, this.localModification, childrenAreIgnored); }
public void CreatedEventForIgnoredObject() { this.SetUpMocks(); var createdObject = MockOfIFolderUtil.CreateRemoteFolderMock(this.folderId, this.folderName, this.remotePath, Guid.NewGuid().ToString()); createdObject.SetupIgnore("*"); var createdEvent = new ContentChangeEvent(ChangeType.Created, this.folderId); this.session.Setup(s => s.GetObject(It.IsAny <string>(), It.IsAny <IOperationContext>())).Returns(createdObject.Object); createdEvent.UpdateObject(this.session.Object); this.matcher.Setup(m => m.CanCreateLocalPath(createdObject.Object)).Returns(true); this.matcher.Setup(m => m.CreateLocalPath(createdObject.Object)).Returns(this.localPath); Assert.That(this.underTest.Handle(createdEvent), Is.False); this.ignoreStorage.Verify(s => s.AddOrUpdateEntryAndDeleteAllChildrenFromStorage(It.Is <IIgnoredEntity>(e => e.LocalPath == this.localPath && e.ObjectId == this.folderId))); this.queue.VerifyThatNoEventIsAdded(); }
public void RenameFolder([Values(true, false)] bool childrenAreIgnored) { this.SetUpMocks(); var dir = Mock.Of <IDirectoryInfo>( f => f.Name == "newName"); var folder = MockOfIFolderUtil.CreateRemoteFolderMock("remoteId", "oldName", "path", ignored: childrenAreIgnored); var obj = new MappedObject("oldName", "remoteId", MappedObjectType.Folder, "parentId", "changeToken") { Guid = Guid.NewGuid() }; this.storage.AddMappedFolder(obj); this.underTest.Solve(dir, folder.Object, ContentChangeType.NONE, ContentChangeType.NONE); folder.Verify(f => f.Rename("newName", true), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.Folder, "remoteId", "newName", "parentId", "changeToken", ignored: childrenAreIgnored); this.changeSolver.Verify(s => s.Solve(dir, folder.Object, ContentChangeType.NONE, ContentChangeType.NONE)); }
public void RemoteFolderAddedAndExtendedAttributesAreAvailable() { var dirInfo = new Mock <IDirectoryInfo>(); dirInfo.SetupAllProperties(); dirInfo.Setup(d => d.FullName).Returns(this.path); dirInfo.Setup(d => d.Name).Returns(this.objectName); dirInfo.Setup(d => d.Parent).Returns(Mock.Of <IDirectoryInfo>()); dirInfo.Setup(d => d.IsExtendedAttributeAvailable()).Returns(true); Mock <IFolder> remoteObject = MockOfIFolderUtil.CreateRemoteFolderMock(this.id, this.objectName, this.path, this.parentId, this.lastChangeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); this.underTest.Solve(dirInfo.Object, remoteObject.Object); dirInfo.Verify(d => d.Create(), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.Folder, this.id, this.objectName, this.parentId, this.lastChangeToken, true, this.creationDate); dirInfo.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(this.creationDate)), Times.Once()); dirInfo.VerifySet(d => d.Uuid = It.Is <Guid?>(uuid => uuid != null && !uuid.Equals(Guid.Empty)), Times.Once()); }
public void RemoteFolderChangedAndModificationDateCouldNotBeSet() { DateTime creationDate = DateTime.UtcNow; string folderName = "a"; string path = Path.Combine(Path.GetTempPath(), folderName); string id = "id"; string parentId = "papa"; string lastChangeToken = "token"; string newChangeToken = "newToken"; DateTime modification = DateTime.UtcNow; var dirInfo = new Mock <IDirectoryInfo>(); dirInfo.Setup(d => d.FullName).Returns(path); dirInfo.Setup(d => d.Name).Returns(folderName); dirInfo.Setup(d => d.Parent).Returns(Mock.Of <IDirectoryInfo>()); dirInfo.SetupGet(d => d.LastWriteTimeUtc).Returns(modification); dirInfo.SetupSet(d => d.LastWriteTimeUtc = It.IsAny <DateTime>()).Throws(new IOException("Another process is using this folder")); var mappedObject = new MappedObject( folderName, id, MappedObjectType.Folder, parentId, lastChangeToken) { Guid = Guid.NewGuid() }; this.storage.AddMappedFolder(mappedObject); Mock <IFolder> remoteObject = MockOfIFolderUtil.CreateRemoteFolderMock(id, folderName, path, parentId, newChangeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)creationDate); this.underTest.Solve(dirInfo.Object, remoteObject.Object); this.storage.VerifySavedMappedObject(MappedObjectType.Folder, id, folderName, parentId, newChangeToken, lastLocalModification: modification); dirInfo.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(creationDate)), Times.Once()); this.queue.Verify(q => q.AddEvent(It.IsAny <ISyncEvent>()), Times.Never()); }