public void StorageExceptionTriggersNoOperation() { this.SetUpMocks(); int fileLength = 20; byte[] content = new byte[fileLength]; var localFile = this.CreateLocalFile(fileLength, this.modificationDate.AddMinutes(1)); using (var uploadedContent = new MemoryStream()) { localFile.Setup( f => f.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)).Returns(() => { return(new MemoryStream(content)); }); var mappedObject = this.CreateMappedFile(this.modificationDate.AddMinutes(1), fileLength, new byte[20]); this.storage.AddMappedFile(mappedObject); var remoteFile = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.remoteId, this.objectName, this.parentId, fileLength, new byte[20], this.oldChangeToken); remoteFile.Setup(r => r.SetContentStream(It.IsAny <IContentStream>(), true, true)).Throws(new CmisStorageException()); this.manager.SetupCreateTransmissionOnce(TransmissionType.UPLOAD_MODIFIED_FILE, localFile.Object.FullName); this.underTest.Solve(localFile.Object, remoteFile.Object); this.storage.Verify(s => s.SaveMappedObject(It.IsAny <IMappedObject>()), Times.Never()); remoteFile.VerifySetContentStream(); } }
private void RunSolverToDeleteLocalCacheBeforeContinue( AbstractEnhancedSolver solver, ContentChangeType localContent = ContentChangeType.NONE, ContentChangeType remoteContent = ContentChangeType.NONE) { this.cacheFile.Setup(f => f.Exists).Returns(false); Mock <MemoryStream> stream = new Mock <MemoryStream>(); stream.SetupAllProperties(); stream.Setup(f => f.CanWrite).Returns(true); // required for System.Security.Cryptography.CryptoStream this.localFileLength = 0; stream.Setup(f => f.Write(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>())).Callback((byte[] buffer, int offset, int count) => this.localFileLength += count); this.cacheFile.Setup(f => f.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)).Returns(() => { this.cacheFile.Setup(f => f.Exists).Returns(true); return(stream.Object); }); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.objectId, this.objectName, this.parentId, this.fileContent.Length, this.fileContent, this.changeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); solver.Solve(this.localFile.Object, remoteObject.Object, localContent, remoteContent); Assert.That(this.localFileLength, Is.EqualTo(this.fileContent.Length)); this.cacheFile.Verify(f => f.Open(It.IsAny <FileMode>(), It.IsAny <FileAccess>(), It.IsAny <FileShare>()), Times.Exactly(2)); // first open in SetupToAbortThePreviousDownload, second open to download this.localFile.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(this.creationDate)), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.File, this.objectId, this.objectName, this.parentId, this.changeToken, true, this.creationDate, this.creationDate, this.fileHash, this.fileContent.Length); this.transmissionStorage.Verify(f => f.GetObjectByRemoteObjectId(this.objectId), Times.Exactly(2)); this.transmissionStorage.Verify(f => f.SaveObject(It.IsAny <IFileTransmissionObject>()), Times.AtLeastOnce()); this.transmissionStorage.Verify(f => f.RemoveObjectByRemoteObjectId(this.objectId), Times.Once()); }
public void FileDeletedEventWithoutObjectId() { var session = new Mock <ISession>(); session.SetupSessionDefaultValues(); IDocument remote = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, Id, "name", (string)null).Object; session.Setup(s => s.GetObject(Id, It.IsAny <IOperationContext>())).Returns(remote); var storage = new Mock <IMetaDataStorage>(); storage.AddLocalFile(Path, Id, Uuid); var fileInfoMock = new Mock <IFileInfo>(); fileInfoMock.Setup(f => f.FullName).Returns(Path); var fileEvent = new FileEvent(fileInfoMock.Object) { Local = MetaDataChangeType.DELETED }; var fetcher = new RemoteObjectFetcher(session.Object, storage.Object); Assert.That(fetcher.Handle(fileEvent), Is.False); Assert.That(fileEvent.RemoteFile, Is.Not.Null); }
public void OneLocalFileCopied() { var uuid = Guid.NewGuid(); var oldFile = this.fsFactory.AddFile(Path.Combine(this.localRootPath, "old"), uuid); oldFile.Setup(f => f.LastWriteTimeUtc).Returns(this.lastLocalWriteTime); var newFile = this.fsFactory.AddFile(Path.Combine(this.localRootPath, "new"), uuid); var remoteSubFolder = MockOfIDocumentUtil.CreateRemoteDocumentMock("streamId", "oldId", oldFile.Object.Name, this.remoteFolder.Object, changeToken: "oldChange"); var storedFolder = new MappedObject(oldFile.Object.Name, "oldId", MappedObjectType.File, this.remoteRootId, "oldChange") { Guid = uuid, LastLocalWriteTimeUtc = this.lastLocalWriteTime }; this.storage.SaveMappedObject(storedFolder); this.remoteFolder.SetupDescendants(remoteSubFolder.Object); this.localFolder.SetupFiles(newFile.Object, oldFile.Object); var crawler = this.CreateCrawler(); Assert.That(crawler.Handle(new StartNextSyncEvent()), Is.True); this.queue.Verify( q => q.AddEvent( It.Is <FileEvent>( e => e.LocalFile.Equals(newFile.Object) && e.Local.Equals(MetaDataChangeType.CREATED))), Times.Once()); this.VerifyThatCountOfAddedEventsIsLimitedTo(Times.Once()); }
public void RunFSEventFileDeleted() { 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.File, null, null); storage.SaveMappedObject(mappedObject); var session = new Mock <ISession>(); session.SetupTypeSystem(); session.SetupSessionDefaultValues(); session.SetupChangeLogToken("default"); IDocument remote = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, 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, false); var queue = this.CreateQueue(session, storage); queue.AddEvent(myEvent); queue.Run(); session.Verify(f => f.Delete(It.Is <IObjectId>(i => i.Id == id), true), Times.Once()); Assert.That(storage.GetObjectByRemoteId(id), Is.Null); }
public void RemoteFileAddedAndExtendedAttributesAreAvailable() { var fileInfo = new Mock <IFileInfo>(); var cacheFileInfo = this.fsFactory.SetupDownloadCacheFile(); var parentDir = Mock.Of <IDirectoryInfo>(d => d.FullName == Path.GetTempPath()); fileInfo.SetupAllProperties(); fileInfo.Setup(f => f.FullName).Returns(this.path); fileInfo.Setup(f => f.Name).Returns(this.objectName); fileInfo.Setup(f => f.Directory).Returns(parentDir); byte[] content = Encoding.UTF8.GetBytes("content"); byte[] expectedHash = SHA1Managed.Create().ComputeHash(content); cacheFileInfo.SetupAllProperties(); cacheFileInfo.Setup(f => f.FullName).Returns(this.path + ".sync"); cacheFileInfo.Setup(f => f.Name).Returns(this.objectName + ".sync"); cacheFileInfo.Setup(f => f.Directory).Returns(parentDir); cacheFileInfo.Setup(f => f.IsExtendedAttributeAvailable()).Returns(true); using (var stream = new MemoryStream()) { cacheFileInfo.Setup(f => f.Open(FileMode.Create, FileAccess.Write, FileShare.Read)).Returns(stream); this.fsFactory.AddIFileInfo(cacheFileInfo.Object); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.id, this.objectName, this.parentId, content.Length, content, this.lastChangeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); this.underTest.Solve(fileInfo.Object, remoteObject.Object); cacheFileInfo.Verify(f => f.Open(FileMode.Create, FileAccess.Write, FileShare.Read), Times.Once()); cacheFileInfo.VerifySet(f => f.Uuid = It.Is <Guid?>(uuid => uuid != null && !uuid.Equals(Guid.Empty)), Times.Once()); cacheFileInfo.Verify(f => f.MoveTo(this.path), Times.Once()); fileInfo.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(this.creationDate)), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.File, this.id, this.objectName, this.parentId, this.lastChangeToken, true, this.creationDate, this.creationDate, expectedHash, content.Length); } }
public void LocalFileModificationDateNotWritableShallNotThrow() { this.SetUpMocks(); var newModificationDate = this.modificationDate.AddHours(1); int fileLength = 20; byte[] content = new byte[fileLength]; var localFile = this.CreateLocalFile(fileLength, this.modificationDate.AddMinutes(1)); using (var uploadedContent = new MemoryStream()) { localFile.Setup( f => f.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)).Returns(() => { return(new MemoryStream(content)); }); var mappedObject = this.CreateMappedObject(true, this.modificationDate.AddMinutes(1), fileLength, new byte[20]); this.storage.AddMappedFile(mappedObject); var remoteFile = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.remoteId, this.objectName, this.parentId, fileLength, new byte[fileLength], this.oldChangeToken); remoteFile.Setup(r => r.SetContentStream(It.IsAny <IContentStream>(), true, true)).Callback <IContentStream, bool, bool>( (s, o, r) => { s.Stream.CopyTo(uploadedContent); remoteFile.Setup(f => f.LastModificationDate).Returns(newModificationDate); remoteFile.Setup(f => f.ChangeToken).Returns(this.newChangeToken); }); this.manager.SetupCreateTransmissionOnce(TransmissionType.UPLOAD_MODIFIED_FILE, localFile.Object.FullName); this.underTest.Solve(localFile.Object, remoteFile.Object); } localFile.VerifyThatLocalFileObjectLastWriteTimeUtcIsNeverModified(); this.manager.VerifyThatTransmissionWasCreatedOnce(); }
public void MoveFileToNewLocation() { DateTime modifiedDate = DateTime.UtcNow.AddMinutes(1); string oldFileName = "a"; string subFolderName = "sub"; string subFolderId = "sub"; string newFileName = "b"; string oldPath = Path.Combine(Path.GetTempPath(), oldFileName); string oldRemotePath = "/" + oldFileName; string newPath = Path.Combine(Path.GetTempPath(), subFolderName, newFileName); string id = "id"; string parentId = "papa"; string lastChangeToken = "token"; var fileInfo = new Mock <IFileInfo>(); fileInfo.Setup(d => d.FullName).Returns(oldPath); fileInfo.Setup(d => d.Name).Returns(oldFileName); fileInfo.Setup(d => d.Directory).Returns(Mock.Of <IDirectoryInfo>(p => p.FullName == Path.GetTempPath())); var fileParents = new List <IFolder>(); fileParents.Add(Mock.Of <IFolder>(f => f.Id == subFolderId)); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, id, newFileName, (string)null, changeToken: lastChangeToken); remoteObject.Setup(f => f.Parents).Returns(fileParents); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)modifiedDate); var mappedFile = Mock.Of <IMappedObject>( f => f.Name == oldFileName && f.RemoteObjectId == id && f.LastChangeToken == "oldToken" && f.LastRemoteWriteTimeUtc == DateTime.UtcNow && f.Type == MappedObjectType.File && 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(mappedFile, oldPath, oldRemotePath); this.storage.AddMappedFolder(mappedSubFolder, Path.Combine(Path.GetTempPath(), subFolderName), "/" + subFolderName); this.matcher.Setup(m => m.CreateLocalPath(It.Is <IDocument>(f => f == remoteObject.Object))).Returns(newPath); this.underTest.Solve(fileInfo.Object, remoteObject.Object); fileInfo.Verify(d => d.MoveTo(It.Is <string>(p => p.Equals(newPath))), Times.Once()); this.storage.Verify( s => s.SaveMappedObject( It.Is <IMappedObject>(f => this.VerifySavedFolder(f, MappedObjectType.File, id, newFileName, subFolderId, lastChangeToken, modifiedDate))), Times.Once()); }
public void AbortThePreviousDownloadAndContinueTheNextDownload() { var fileInfo = new Mock <IFileInfo>(); var cacheFileInfo = this.fsFactory.SetupDownloadCacheFile(); byte[] content = new byte[1024 * 1024]; long length = 0; this.SetupToAbortThePreviousDownload(fileInfo, cacheFileInfo, content, out length); Mock <MemoryStream> stream = new Mock <MemoryStream>(); stream.SetupAllProperties(); stream.Setup(f => f.CanWrite).Returns(true); // required for System.Security.Cryptography.CryptoStream stream.Setup(f => f.Write(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>())).Callback((byte[] buffer, int offset, int count) => length += count); stream.Setup(f => f.Length).Returns(() => { return(length); }); long lengthRead = 0; stream.Setup(f => f.Seek(It.IsAny <long>(), It.IsAny <SeekOrigin>())).Callback((long offset, SeekOrigin loc) => lengthRead = offset); stream.Setup(f => f.Read(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>())).Returns((byte[] buffer, int offset, int count) => { if (lengthRead >= length) { return(0); } int countRead = count; if (countRead > (length - lengthRead)) { countRead = (int)(length - lengthRead); } Array.Copy(content, lengthRead, buffer, offset, countRead); lengthRead += countRead; stream.Object.Position = lengthRead; return(countRead); }); cacheFileInfo.Setup(f => f.Open(It.IsAny <FileMode>(), It.IsAny <FileAccess>(), It.IsAny <FileShare>())).Returns(stream.Object); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.id, this.objectName, this.parentId, content.Length, content, this.lastChangeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); this.underTest.Solve(fileInfo.Object, remoteObject.Object); Assert.That(length, Is.EqualTo(content.Length)); stream.Verify(f => f.Seek(0, SeekOrigin.Begin), Times.Once()); cacheFileInfo.Verify(f => f.Open(It.IsAny <FileMode>(), It.IsAny <FileAccess>(), It.IsAny <FileShare>()), Times.Exactly(3)); // first open in SetupToAbortThePreviousDownload, second open to validate checksum, third open to download cacheFileInfo.VerifySet(f => f.Uuid = It.Is <Guid?>(uuid => uuid != null && !uuid.Equals(Guid.Empty)), Times.Once()); cacheFileInfo.Verify(f => f.MoveTo(this.path), Times.Once()); fileInfo.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(this.creationDate)), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.File, this.id, this.objectName, this.parentId, this.lastChangeToken, true, this.creationDate, this.creationDate, SHA1Managed.Create().ComputeHash(content), content.Length); this.transmissionStorage.Verify(f => f.GetObjectByRemoteObjectId(this.id), Times.Exactly(2)); this.transmissionStorage.Verify(f => f.SaveObject(It.IsAny <IFileTransmissionObject>()), Times.AtLeastOnce()); this.transmissionStorage.Verify(f => f.RemoveObjectByRemoteObjectId(this.id), Times.Once()); }
public void OneRemoteFileAdded() { IDocument newRemoteDocument = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, "id", "name", this.remoteRootId).Object; this.remoteFolder.SetupDescendants(newRemoteDocument); var crawler = this.CreateCrawler(); Assert.That(crawler.Handle(new StartNextSyncEvent()), Is.True); this.queue.Verify(q => q.AddEvent(It.Is <FileEvent>(e => e.RemoteFile.Equals(newRemoteDocument))), Times.Once()); this.VerifyThatCountOfAddedEventsIsLimitedTo(Times.Once()); this.VerifyThatListenerHasBeenUsed(); }
private void RunSolverToContinueDownload( AbstractEnhancedSolver solver, ContentChangeType localContent = ContentChangeType.NONE, ContentChangeType remoteContent = ContentChangeType.NONE) { Mock <MemoryStream> stream = new Mock <MemoryStream>(); stream.SetupAllProperties(); stream.Setup(f => f.CanWrite).Returns(true); // required for System.Security.Cryptography.CryptoStream stream.Setup(f => f.Write(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>())).Callback((byte[] buffer, int offset, int count) => this.localFileLength += count); stream.Setup(f => f.Length).Returns(() => { return(this.localFileLength); }); long lengthRead = 0; stream.Setup(f => f.Seek(It.IsAny <long>(), It.IsAny <SeekOrigin>())).Callback((long offset, SeekOrigin loc) => lengthRead = offset); stream.Setup(f => f.Read(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>())).Returns((byte[] buffer, int offset, int count) => { if (lengthRead >= this.localFileLength) { return(0); } int countRead = count; if (countRead > (this.localFileLength - lengthRead)) { countRead = (int)(this.localFileLength - lengthRead); } Array.Copy(this.fileContent, lengthRead, buffer, offset, countRead); lengthRead += countRead; stream.Object.Position = lengthRead; return(countRead); }); this.cacheFile.Setup(f => f.Open(It.IsAny <FileMode>(), It.IsAny <FileAccess>(), It.IsAny <FileShare>())).Returns(stream.Object); this.cacheFile.Setup(f => f.Length).Returns(() => { return(this.localFileLength); }); var remoteDocument = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.objectId, this.objectName, this.parentId, this.fileContent.Length, this.fileContent, this.changeToken); remoteDocument.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); solver.Solve(this.localFile.Object, remoteDocument.Object, localContent, remoteContent); Assert.That(this.localFileLength, Is.EqualTo(this.fileContent.Length)); stream.Verify(f => f.Seek(0, SeekOrigin.Begin), Times.Once()); this.cacheFile.Verify(f => f.Open(It.IsAny <FileMode>(), It.IsAny <FileAccess>(), It.IsAny <FileShare>()), Times.Exactly(3)); // first open in SetupToAbortThePreviousDownload, second open to validate checksum, third open to download this.localFile.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(this.creationDate)), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.File, this.objectId, this.objectName, this.parentId, this.changeToken, true, this.creationDate, this.creationDate, this.fileHash, this.fileContent.Length); this.transmissionStorage.Verify(f => f.GetObjectByRemoteObjectId(this.objectId), Times.Exactly(2)); this.transmissionStorage.Verify(f => f.SaveObject(It.IsAny <IFileTransmissionObject>()), Times.AtLeastOnce()); this.transmissionStorage.Verify(f => f.RemoveObjectByRemoteObjectId(this.objectId), Times.Once()); }
public void LocalFileModificationDateNotWritableShallNotThrow() { var modificationDate = DateTime.UtcNow; var newModificationDate = modificationDate.AddHours(1); var newChangeToken = "newChangeToken"; int fileLength = 20; byte[] content = new byte[fileLength]; var localFile = new Mock <IFileInfo>(); localFile.SetupProperty(f => f.LastWriteTimeUtc, modificationDate.AddMinutes(1)); localFile.SetupSet(f => f.LastWriteTimeUtc = It.IsAny <DateTime>()).Throws(new IOException()); localFile.Setup(f => f.Length).Returns(fileLength); localFile.Setup(f => f.FullName).Returns("path"); localFile.Setup(f => f.Exists).Returns(true); using (var uploadedContent = new MemoryStream()) { localFile.Setup( f => f.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)).Returns(() => { return(new MemoryStream(content)); }); var mappedObject = new MappedObject( "name", "remoteId", MappedObjectType.File, "parentId", "changeToken", fileLength) { Guid = Guid.NewGuid(), LastRemoteWriteTimeUtc = modificationDate.AddMinutes(1), LastLocalWriteTimeUtc = modificationDate, LastChecksum = new byte[20], ChecksumAlgorithmName = "SHA-1" }; this.storage.AddMappedFile(mappedObject, "path"); var remoteFile = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, "remoteId", "name", "parentId", fileLength, new byte[20]); remoteFile.Setup(r => r.SetContentStream(It.IsAny <IContentStream>(), true, true)).Callback <IContentStream, bool, bool>( (s, o, r) => { s.Stream.CopyTo(uploadedContent); remoteFile.Setup(f => f.LastModificationDate).Returns(newModificationDate); remoteFile.Setup(f => f.ChangeToken).Returns(newChangeToken); }); this.underTest.Solve(localFile.Object, remoteFile.Object); } localFile.VerifyThatLocalFileObjectLastWriteTimeUtcIsNeverModified(); this.manager.Verify(m => m.AddTransmission(It.IsAny <FileTransmissionEvent>()), Times.Once()); }
public void FilesMovedToEqualFolderAndNamesAndContentAreEqual() { this.SetupOldMappedFile(); this.remoteModification = this.localModification - TimeSpan.FromMinutes(30); var newLocalParent = this.CreateNewLocalParent(this.newParentUuid); var localFile = this.CreateLocalFile(this.oldName, newLocalParent, this.localModification); var remoteFile = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.remoteObjectId, this.oldName, this.newRemoteParentId, 0, new byte[0], this.newChangeToken); remoteFile.SetupUpdateModificationDate(this.remoteModification); this.underTest.Solve(localFile.Object, remoteFile.Object, ContentChangeType.NONE, ContentChangeType.NONE); remoteFile.VerifyUpdateLastModificationDate(this.localModification); this.VerifySavedFile(this.oldName, this.localModification, 0); }
public void FilesMovedToEqualFolderAndBothNamesAreChangedAndLocalModificationIsNewerButContentStaysEqual() { this.SetupOldMappedFile(); this.remoteModification = this.localModification - TimeSpan.FromMinutes(30); var newLocalParent = this.CreateNewLocalParent(this.newParentUuid, this.newParentPath); var localFile = this.CreateLocalFile(this.newLocalName, newLocalParent, this.localModification); var remoteFile = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.remoteObjectId, this.newRemoteName, this.newRemoteParentId, 0, new byte[0], this.newChangeToken); remoteFile.SetupUpdateModificationDate(this.remoteModification); this.underTest.Solve(localFile.Object, remoteFile.Object, ContentChangeType.NONE, ContentChangeType.NONE); remoteFile.Verify(r => r.Rename(It.IsAny <string>(), It.IsAny <bool>()), Times.Once()); remoteFile.VerifyUpdateLastModificationDate(this.localModification); this.VerifySavedFile(this.newLocalName, this.localModification, 0); }
private ContentChangeEvent PrepareEvent(DotCMIS.Enums.ChangeType type, bool hasContentStream, byte[] contentHash = null) { var e = new ContentChangeEvent(type, Id); var remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(hasContentStream ? "streamId" : null, Id, "name", (string)null); if (contentHash != null) { remoteObject.SetupContentStreamHash(contentHash); } var session = new Mock <ISession>(); session.Setup(s => s.GetObject(It.IsAny <string>(), It.IsAny <IOperationContext>())).Returns(remoteObject.Object); e.UpdateObject(session.Object); return(e); }
public void PermissionDeniedTriggersNoOperation() { Guid uuid = Guid.NewGuid(); var modificationDate = DateTime.UtcNow; int fileLength = 20; byte[] content = new byte[fileLength]; var localFile = new Mock <IFileInfo>(); localFile.SetupProperty(f => f.LastWriteTimeUtc, modificationDate.AddMinutes(1)); localFile.Setup(f => f.Length).Returns(fileLength); localFile.Setup(f => f.FullName).Returns("path"); localFile.SetupGuid(uuid); localFile.Setup(f => f.Exists).Returns(true); using (var uploadedContent = new MemoryStream()) { localFile.Setup( f => f.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)).Returns(() => { return(new MemoryStream(content)); }); var mappedObject = new MappedObject( "name", "remoteId", MappedObjectType.File, "parentId", "changeToken", fileLength) { Guid = uuid, LastRemoteWriteTimeUtc = modificationDate.AddMinutes(1), LastLocalWriteTimeUtc = modificationDate, LastChecksum = new byte[20], ChecksumAlgorithmName = "SHA-1" }; this.storage.AddMappedFile(mappedObject, "path"); var remoteFile = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, "remoteId", "name", "parentId", fileLength, new byte[20]); remoteFile.Setup(r => r.SetContentStream(It.IsAny <IContentStream>(), true, true)).Throws(new CmisPermissionDeniedException()); this.underTest.Solve(localFile.Object, remoteFile.Object); this.storage.Verify(s => s.SaveMappedObject(It.IsAny <IMappedObject>()), Times.Never()); remoteFile.VerifySetContentStream(); } }
public void RenameFile() { this.SetUpMocks(); DateTime modifiedDate = DateTime.UtcNow.AddMinutes(1); string oldFileName = "a"; string newFileName = "b"; string oldPath = Path.Combine(Path.GetTempPath(), oldFileName); string oldRemotePath = "/" + oldFileName; string newPath = Path.Combine(Path.GetTempPath(), newFileName); string id = "id"; string parentId = "root"; string lastChangeToken = "token"; var fileInfo = new Mock <IFileInfo>(); fileInfo.Setup(f => f.FullName).Returns(oldPath); fileInfo.Setup(f => f.Name).Returns(oldFileName); fileInfo.SetupProperty(f => f.LastWriteTimeUtc); fileInfo.Setup(f => f.Directory).Returns(Mock.Of <IDirectoryInfo>(p => p.FullName == Path.GetTempPath())); var remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, id, newFileName, (string)null, changeToken: lastChangeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)modifiedDate); var mappedFile = Mock.Of <IMappedObject>( f => f.Name == oldFileName && f.RemoteObjectId == id && f.LastChangeToken == "oldToken" && f.LastRemoteWriteTimeUtc == DateTime.UtcNow && f.Type == MappedObjectType.File && f.ParentId == parentId); this.storage.AddMappedFolder(mappedFile, oldPath, oldRemotePath); this.underTest.Solve(fileInfo.Object, remoteObject.Object); fileInfo.Verify(d => d.MoveTo(It.Is <string>(p => p.Equals(newPath))), Times.Once()); fileInfo.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.File, id, newFileName, parentId, lastChangeToken, modifiedDate))), Times.Once()); }
public void RemoteFileAddedAndLocalFileIsCreatedWhileDownloadIsInProgress() { string conflictPath = this.path + ".conflict"; var conflictFileInfo = Mock.Of <IFileInfo>(i => i.FullName == conflictPath); var fileInfo = new Mock <IFileInfo>(); var cacheFileInfo = this.fsFactory.SetupDownloadCacheFile(); var parentDir = Mock.Of <IDirectoryInfo>(d => d.FullName == Path.GetTempPath()); fileInfo.SetupAllProperties(); fileInfo.Setup(f => f.FullName).Returns(this.path); fileInfo.Setup(f => f.Name).Returns(this.objectName); fileInfo.Setup(f => f.Directory).Returns(parentDir); fileInfo.Setup(f => f.Uuid).Returns(Guid.NewGuid()); byte[] content = Encoding.UTF8.GetBytes("content"); byte[] expectedHash = SHA1Managed.Create().ComputeHash(content); cacheFileInfo.SetupAllProperties(); cacheFileInfo.Setup(f => f.FullName).Returns(this.path + ".sync"); cacheFileInfo.Setup(f => f.Name).Returns(this.objectName + ".sync"); cacheFileInfo.Setup(f => f.Directory).Returns(parentDir); cacheFileInfo.Setup(f => f.IsExtendedAttributeAvailable()).Returns(true); cacheFileInfo.Setup(f => f.Replace(fileInfo.Object, conflictFileInfo, true)).Returns(fileInfo.Object); using (var stream = new MemoryStream()) { cacheFileInfo.Setup(f => f.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)).Returns(() => { cacheFileInfo.Setup(f => f.Exists).Returns(true); return(stream); }); cacheFileInfo.Setup(f => f.MoveTo(this.path)).Callback(() => fileInfo.Setup(file => file.Refresh()).Callback(() => fileInfo.Setup(newFile => newFile.Exists).Returns(true))).Throws(new IOException()); fileInfo.SetupStream(Encoding.UTF8.GetBytes("other content")); this.fsFactory.AddIFileInfo(cacheFileInfo.Object); this.fsFactory.Setup(f => f.CreateConflictFileInfo(fileInfo.Object)).Returns(conflictFileInfo); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.id, this.objectName, this.parentId, content.Length, content, this.lastChangeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); this.underTest.Solve(fileInfo.Object, remoteObject.Object); cacheFileInfo.Verify(f => f.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None), Times.Once()); cacheFileInfo.VerifySet(f => f.Uuid = It.Is <Guid?>(uuid => uuid != null && !uuid.Equals(Guid.Empty)), Times.Once()); cacheFileInfo.Verify(f => f.MoveTo(this.path), Times.Once()); cacheFileInfo.Verify(f => f.Replace(fileInfo.Object, conflictFileInfo, true), Times.Once()); fileInfo.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(this.creationDate)), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.File, this.id, this.objectName, this.parentId, this.lastChangeToken, true, this.creationDate, this.creationDate, expectedHash, content.Length); Mock.Get(conflictFileInfo).VerifySet(c => c.Uuid = null, Times.Once()); } }
private void RunSolverToAbortDownload( AbstractEnhancedSolver solver, ContentChangeType localContent = ContentChangeType.NONE, ContentChangeType remoteContent = ContentChangeType.NONE) { var stream = new Mock <MemoryStream>(); stream.SetupAllProperties(); stream.Setup(f => f.CanWrite).Returns(true); // required for System.Security.Cryptography.CryptoStream this.localFileLength = 0; stream.Setup(f => f.Write(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>())).Callback((byte[] buffer, int offset, int count) => { if (this.localFileLength > 0) { foreach (Transmission transmission in this.transmissionManager.ActiveTransmissions) { transmission.Abort(); } } this.localFileLength += count; }); stream.Setup(f => f.Length).Returns(() => { return(this.localFileLength); }); this.cacheFile.Setup(f => f.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)).Returns(() => { this.cacheFile.Setup(f => f.Exists).Returns(true); return(stream.Object); }); var remoteDocument = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.objectId, this.objectName, this.parentId, this.fileContent.Length, this.fileContent, this.changeToken); remoteDocument.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); Assert.Throws <AbortException>(() => solver.Solve(this.localFile.Object, remoteDocument.Object, localContent, remoteContent)); this.cacheFile.Verify(f => f.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None), Times.Once()); this.cacheFile.VerifySet(f => f.Uuid = It.Is <Guid?>(uuid => uuid != null && !uuid.Equals(Guid.Empty)), Times.Never()); this.cacheFile.Verify(f => f.MoveTo(this.localPath), Times.Never()); this.localFile.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(this.creationDate)), Times.Never()); this.transmissionStorage.Verify(f => f.GetObjectByRemoteObjectId(It.IsAny <string>()), Times.Once()); this.transmissionStorage.Verify(f => f.SaveObject(It.IsAny <IFileTransmissionObject>()), Times.AtLeastOnce()); this.transmissionStorage.Verify(f => f.RemoveObjectByRemoteObjectId(It.IsAny <string>()), Times.Never()); this.storage.Verify(f => f.SaveMappedObject(It.IsAny <IMappedObject>()), Times.Never()); }
public void RemoteDocumentsMetaDataChanged() { byte[] hash = new byte[20]; DateTime modificationDate = DateTime.UtcNow; string fileName = "a"; string path = Path.Combine(Path.GetTempPath(), fileName); string id = "id"; string parentId = "papa"; string lastChangeToken = "token"; string newChangeToken = "newToken"; var fileInfo = new Mock <IFileInfo>(); fileInfo.Setup(d => d.FullName).Returns(path); fileInfo.Setup(d => d.Name).Returns(fileName); fileInfo.Setup(d => d.Directory).Returns(Mock.Of <IDirectoryInfo>()); var mappedObject = new MappedObject( fileName, id, MappedObjectType.File, parentId, lastChangeToken) { Guid = Guid.NewGuid(), LastContentSize = 0, LastChecksum = hash, ChecksumAlgorithmName = "SHA-1" }; this.storage.AddMappedFile(mappedObject); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, id, fileName, parentId, changeToken: newChangeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)modificationDate); this.underTest.Solve(fileInfo.Object, remoteObject.Object, ContentChangeType.NONE, ContentChangeType.NONE); this.storage.VerifySavedMappedObject(MappedObjectType.File, id, fileName, parentId, newChangeToken, contentSize: 0, checksum: hash); fileInfo.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(modificationDate)), Times.Once()); this.queue.Verify(q => q.AddEvent(It.IsAny <ISyncEvent>()), Times.Never()); }
public void DoNotFetchIfExtendedAttributeIsMissing() { var session = new Mock <ISession>(); session.SetupSessionDefaultValues(); IDocument remote = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, Id, "name", (string)null).Object; session.Setup(s => s.GetObject(Id, It.IsAny <IOperationContext>())).Returns(remote); var storage = new Mock <IMetaDataStorage>(); storage.AddLocalFile(Path, Id, Uuid); var fileEvent = new FileEvent(Mock.Of <IFileInfo>()); var fetcher = new RemoteObjectFetcher(session.Object, storage.Object); fetcher.Handle(fileEvent); session.Verify(s => s.GetObject(It.IsAny <string>(), It.IsAny <IOperationContext>()), Times.Never()); }
public void OneRemoteFileRenamedAndContentHashIsAvailable() { byte[] checksum = new byte[20]; string type = "SHA-1"; string oldFileName = "fileName"; string newFileName = "newfileName"; string fileId = "fileId"; DateTime lastModification = DateTime.UtcNow; var localGuid = Guid.NewGuid(); var oldLocalFile = this.fsFactory.AddFile(Path.Combine(this.localRootPath, oldFileName)); oldLocalFile.SetupLastWriteTimeUtc(lastModification); oldLocalFile.SetupGuid(localGuid); var storedFile = new MappedObject(oldFileName, fileId, MappedObjectType.File, this.remoteRootId, "changeToken") { Guid = localGuid, ChecksumAlgorithmName = type, LastChecksum = checksum, LastLocalWriteTimeUtc = lastModification }; this.localFolder.SetupFiles(oldLocalFile.Object); this.storage.SaveMappedObject(storedFile); var renamedRemoteFile = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, fileId, newFileName, this.remoteRootId, changeToken: "newChangeToken"); renamedRemoteFile.SetupContentStreamHash(checksum, type); this.remoteFolder.SetupDescendants(renamedRemoteFile.Object); Assert.That(this.CreateCrawler().Handle(new StartNextSyncEvent()), Is.True); this.queue.Verify( q => q.AddEvent( It.Is <FileEvent>( e => e.Remote == MetaDataChangeType.CHANGED && e.RemoteContent == ContentChangeType.NONE && e.Local == MetaDataChangeType.NONE && e.RemoteFile.Equals(renamedRemoteFile.Object))), Times.Once()); this.VerifyThatCountOfAddedEventsIsLimitedTo(Times.Once()); this.VerifyThatListenerHasBeenUsed(); }
public void OneLocalFileRemoved() { var oldLocalFile = this.fsFactory.AddFile(Path.Combine(this.localRootPath, "oldFile")); oldLocalFile.Setup(f => f.Exists).Returns(false); var remoteFile = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, "oldFileId", "oldFile", this.remoteRootId, changeToken: "oldChange"); var storedFile = new MappedObject("oldFile", "oldFileId", MappedObjectType.File, this.remoteRootId, "oldChange") { Guid = Guid.NewGuid() }; this.storage.SaveMappedObject(storedFile); this.remoteFolder.SetupDescendants(remoteFile.Object); var crawler = this.CreateCrawler(); Assert.That(crawler.Handle(new StartNextSyncEvent()), Is.True); this.queue.Verify(q => q.AddEvent(It.Is <FileEvent>(e => e.LocalFile != null && e.LocalFile.Equals(oldLocalFile.Object) && e.Local.Equals(MetaDataChangeType.DELETED))), Times.Once()); this.VerifyThatCountOfAddedEventsIsLimitedTo(Times.Once()); this.VerifyThatListenerHasBeenUsed(); }
public void NoChangeOnExistingFileAndFolderCreatesNoEventsInQueue() { DateTime changeTime = DateTime.UtcNow; string changeToken = "token"; string fileName = "name"; string fileId = "fileId"; string folderName = "folder"; string folderId = "folderId"; Guid folderGuid = Guid.NewGuid(); Guid fileGuid = Guid.NewGuid(); var remoteFile = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, fileId, fileName, this.remoteRootId, changeToken: changeToken); var existingRemoteFolder = MockOfIFolderUtil.CreateRemoteFolderMock(folderId, folderName, this.remoteRootPath + folderName, this.remoteRootId, changeToken); var file = this.fsFactory.AddFile(Path.Combine(this.localRootPath, fileName), fileGuid); file.Setup(f => f.LastWriteTimeUtc).Returns(changeTime); var storedFile = new MappedObject(fileName, fileId, MappedObjectType.File, this.remoteRootId, changeToken) { Guid = fileGuid, LastLocalWriteTimeUtc = changeTime }; this.storage.SaveMappedObject(storedFile); var folder = this.fsFactory.AddDirectory(Path.Combine(this.localRootPath, folderName), folderGuid); folder.Setup(f => f.LastWriteTimeUtc).Returns(changeTime); var storedFolder = new MappedObject(folderName, folderId, MappedObjectType.Folder, this.remoteRootId, changeToken) { Guid = folderGuid, LastLocalWriteTimeUtc = changeTime }; this.storage.SaveMappedObject(storedFolder); this.remoteFolder.SetupDescendants(remoteFile.Object, existingRemoteFolder.Object); this.localFolder.SetupFilesAndDirectories(file.Object, folder.Object); var crawler = this.CreateCrawler(); Assert.That(crawler.Handle(new StartNextSyncEvent()), Is.True); this.queue.Verify(q => q.AddEvent(It.Is <AbstractFolderEvent>(e => e.Local == MetaDataChangeType.NONE && e.Remote == MetaDataChangeType.NONE)), Times.Never()); this.VerifyThatCountOfAddedEventsIsLimitedTo(Times.Never()); this.VerifyThatListenerHasBeenUsed(); }
private void RunSolverToChangeLocalCacheBeforeContinue( AbstractEnhancedSolver solver, ContentChangeType localContent = ContentChangeType.NONE, ContentChangeType remoteContent = ContentChangeType.NONE) { this.SetupToChangeLocalCache(); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.objectId, this.objectName, this.parentId, this.fileContent.Length, this.fileContent, this.changeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); solver.Solve(this.localFile.Object, remoteObject.Object, localContent, remoteContent); Assert.That(this.localFileLength, Is.EqualTo(this.fileContent.Length)); this.cacheFile.Verify(f => f.Open(It.IsAny <FileMode>(), It.IsAny <FileAccess>(), It.IsAny <FileShare>()), Times.Exactly(3)); // first open in SetupToAbortThePreviousDownload, second open to validate checksum, third open to download this.cacheFile.Verify(f => f.Delete(), Times.Once()); this.localFile.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(this.creationDate)), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.File, this.objectId, this.objectName, this.parentId, this.changeToken, true, this.creationDate, this.creationDate, this.fileHash, this.fileContent.Length); this.transmissionStorage.Verify(f => f.GetObjectByRemoteObjectId(this.objectId), Times.Exactly(2)); this.transmissionStorage.Verify(f => f.SaveObject(It.IsAny <IFileTransmissionObject>()), Times.AtLeastOnce()); this.transmissionStorage.Verify(f => f.RemoveObjectByRemoteObjectId(this.objectId), Times.Once()); }
public void LocalAndRemoteFilesAreSavedAsEqualIfTheContentIsEqual() { var fileInfo = new Mock <IFileInfo>(); var parentDir = Mock.Of <IDirectoryInfo>(d => d.FullName == Path.GetTempPath()); fileInfo.SetupAllProperties(); fileInfo.Setup(f => f.FullName).Returns(this.path); fileInfo.Setup(f => f.Name).Returns(this.objectName); fileInfo.Setup(f => f.Directory).Returns(parentDir); fileInfo.Setup(f => f.Exists).Returns(true); byte[] content = Encoding.UTF8.GetBytes("content"); fileInfo.SetupStream(content); byte[] expectedHash = SHA1Managed.Create().ComputeHash(content); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.id, this.objectName, this.parentId, content.Length, content, this.lastChangeToken); remoteObject.SetupContentStreamHash(expectedHash); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); this.underTest.Solve(fileInfo.Object, remoteObject.Object); fileInfo.VerifySet(f => f.Uuid = It.Is <Guid?>(uuid => uuid != null && !uuid.Equals(Guid.Empty)), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.File, this.id, this.objectName, this.parentId, this.lastChangeToken, true, this.creationDate, this.creationDate, expectedHash, content.Length); }
public void LocalFileContentChanged() { this.SetUpMocks(); var newModificationDateOnServerAfterUpload = this.modificationDate.AddHours(1); int fileLength = 20; byte[] content = new byte[fileLength]; byte[] expectedHash = SHA1Managed.Create().ComputeHash(content); var localFile = this.CreateLocalFile(fileLength, this.modificationDate.AddMinutes(1)); using (var uploadedContent = new MemoryStream()) { localFile.Setup( f => f.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)).Returns(() => { return(new MemoryStream(content)); }); var mappedObject = this.CreateMappedFile(this.modificationDate.AddMinutes(1), fileLength, new byte[20]); this.storage.AddMappedFile(mappedObject); var remoteFile = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.remoteId, this.objectName, this.parentId, fileLength, new byte[fileLength], this.oldChangeToken); remoteFile.Setup(r => r.SetContentStream(It.IsAny <IContentStream>(), true, true)).Callback <IContentStream, bool, bool>( (s, o, r) => { s.Stream.CopyTo(uploadedContent); remoteFile.Setup(f => f.LastModificationDate).Returns(newModificationDateOnServerAfterUpload); remoteFile.Setup(f => f.ChangeToken).Returns(this.newChangeToken); }); remoteFile.SetupUpdateModificationDate(); this.underTest.Solve(localFile.Object, remoteFile.Object); remoteFile.VerifyUpdateLastModificationDate(localFile.Object.LastWriteTimeUtc); remoteFile.VerifySetContentStream(); Assert.That(uploadedContent.ToArray(), Is.EqualTo(content)); localFile.VerifyThatLocalFileObjectLastWriteTimeUtcIsNeverModified(); this.manager.Verify(m => m.AddTransmission(It.IsAny <FileTransmissionEvent>()), Times.Once()); this.VerifySavedFile(this.newChangeToken, localFile.Object.LastWriteTimeUtc, localFile.Object.LastWriteTimeUtc, expectedHash, fileLength); } }
public void RemoteDocumentChangedAndLocalFileGotChangedWhileDownloadingCreatesAConfictFile() { DateTime creationDate = DateTime.UtcNow; string fileName = "a"; string path = Path.Combine(Path.GetTempPath(), fileName); string id = "id"; string parentId = "papa"; string lastChangeToken = "token"; string newChangeToken = "newToken"; string confictFilePath = Path.Combine(Path.GetTempPath(), fileName + ".conflict"); byte[] newContent = Encoding.UTF8.GetBytes("content"); byte[] oldContent = Encoding.UTF8.GetBytes("older content"); byte[] changedContent = Encoding.UTF8.GetBytes("change content"); long oldContentSize = oldContent.Length; long newContentSize = newContent.Length; byte[] expectedHash = SHA1Managed.Create().ComputeHash(newContent); byte[] oldHash = SHA1Managed.Create().ComputeHash(oldContent); var mappedObject = new MappedObject( fileName, id, MappedObjectType.File, parentId, lastChangeToken, oldContentSize) { Guid = Guid.NewGuid(), LastLocalWriteTimeUtc = new DateTime(0), LastRemoteWriteTimeUtc = new DateTime(0), LastChecksum = oldHash }; this.fsFactory.Setup(f => f.CreateConflictFileInfo(It.IsAny <IFileInfo>())).Returns(Mock.Of <IFileInfo>(i => i.FullName == confictFilePath)); using (var changedContentStream = new MemoryStream(changedContent)) using (var stream = new MemoryStream()) { var backupFile = this.fsFactory.AddFile(Path.Combine(Path.GetTempPath(), fileName + ".bak.sync"), false); this.storage.AddMappedFile(mappedObject, path); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, id, fileName, parentId, newContentSize, newContent, newChangeToken); remoteObject.Setup(r => r.LastModificationDate).Returns(creationDate); Mock <IFileInfo> localFile = new Mock <IFileInfo>(); localFile.SetupProperty(f => f.LastWriteTimeUtc, new DateTime(0)); localFile.Setup(f => f.FullName).Returns(path); var cacheFile = this.fsFactory.SetupDownloadCacheFile(localFile.Object); cacheFile.Setup(c => c.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)).Returns(stream); this.SetupContentWithCallBack(remoteObject, newContent, fileName).Callback( () => { localFile.Setup(f => f.LastWriteTimeUtc).Returns(creationDate); }); cacheFile.Setup( c => c.Replace(localFile.Object, backupFile.Object, It.IsAny <bool>())).Returns(localFile.Object).Callback( () => backupFile.Setup( b => b.Open(FileMode.Open, FileAccess.Read, FileShare.None)).Returns(changedContentStream)); this.underTest.Solve(localFile.Object, remoteObject.Object, remoteContent: ContentChangeType.CHANGED); this.storage.VerifySavedMappedObject(MappedObjectType.File, id, fileName, parentId, newChangeToken, true, creationDate, creationDate, expectedHash, newContent.Length); Assert.That(localFile.Object.LastWriteTimeUtc, Is.EqualTo(creationDate)); cacheFile.Verify(c => c.Replace(localFile.Object, backupFile.Object, true), Times.Once()); backupFile.Verify(b => b.MoveTo(confictFilePath), Times.Once()); backupFile.Verify(b => b.Delete(), Times.Never()); backupFile.VerifySet(b => b.Uuid = null, Times.Once()); } }
public void RemoteDocumentChangedAndSetUuidFailsOnLocalModificationDate() { DateTime creationDate = DateTime.UtcNow; string fileName = "a"; string path = Path.Combine(Path.GetTempPath(), fileName); string id = "id"; string parentId = "papa"; string lastChangeToken = "token"; string newChangeToken = "newToken"; byte[] newContent = Encoding.UTF8.GetBytes("content"); byte[] oldContent = Encoding.UTF8.GetBytes("older content"); long oldContentSize = oldContent.Length; long newContentSize = newContent.Length; byte[] expectedHash = SHA1Managed.Create().ComputeHash(newContent); byte[] oldHash = SHA1Managed.Create().ComputeHash(oldContent); var mappedObject = new MappedObject( fileName, id, MappedObjectType.File, parentId, lastChangeToken, oldContentSize) { Guid = Guid.NewGuid(), LastLocalWriteTimeUtc = new DateTime(0), LastRemoteWriteTimeUtc = new DateTime(0), LastChecksum = oldHash }; using (var oldContentStream = new MemoryStream(oldContent)) using (var stream = new MemoryStream()) { var backupFile = this.fsFactory.AddFile(Path.Combine(Path.GetTempPath(), fileName + ".bak.sync"), false); this.storage.AddMappedFile(mappedObject, path); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, id, fileName, parentId, newContentSize, newContent, newChangeToken); remoteObject.Setup(r => r.LastModificationDate).Returns(creationDate); Mock <IFileInfo> localFile = new Mock <IFileInfo>(); localFile.SetupProperty(f => f.LastWriteTimeUtc, new DateTime(0)); localFile.Setup(f => f.FullName).Returns(path); var cacheFile = this.fsFactory.SetupDownloadCacheFile(localFile.Object); cacheFile.Setup(c => c.Open(FileMode.Create, FileAccess.Write, FileShare.None)).Returns(stream); cacheFile.Setup( c => c.Replace(localFile.Object, backupFile.Object, It.IsAny <bool>())).Returns(localFile.Object).Callback( () => backupFile.Setup( b => b.Open(FileMode.Open, FileAccess.Read, FileShare.None)).Returns(oldContentStream)); localFile.SetupSet(l => l.Uuid = It.IsAny <Guid?>()).Throws <RestoreModificationDateException>(); this.underTest.Solve(localFile.Object, remoteObject.Object, remoteContent: ContentChangeType.CHANGED); this.storage.VerifySavedMappedObject(MappedObjectType.File, id, fileName, parentId, newChangeToken, true, creationDate, creationDate, expectedHash, newContent.Length); Assert.That(localFile.Object.LastWriteTimeUtc, Is.EqualTo(creationDate)); this.queue.Verify( q => q.AddEvent(It.Is <FileTransmissionEvent>( e => e.Type == FileTransmissionType.DOWNLOAD_MODIFIED_FILE && e.CachePath == cacheFile.Object.FullName && e.Path == localFile.Object.FullName)), Times.Once()); cacheFile.Verify(c => c.Replace(localFile.Object, backupFile.Object, true), Times.Once()); backupFile.Verify(b => b.Delete(), Times.Once()); } }
private void SetupToAbortThePreviousDownload(Mock <IFileInfo> fileInfo, Mock <IFileInfo> cacheFileInfo, byte[] content, out long lengthWrite) { var parentDir = Mock.Of <IDirectoryInfo>(d => d.FullName == Path.GetTempPath()); fileInfo.SetupAllProperties(); fileInfo.Setup(f => f.FullName).Returns(this.path); fileInfo.Setup(f => f.Name).Returns(this.objectName); fileInfo.Setup(f => f.Directory).Returns(parentDir); cacheFileInfo.SetupAllProperties(); cacheFileInfo.Setup(f => f.FullName).Returns(this.path + ".sync"); cacheFileInfo.Setup(f => f.Name).Returns(this.objectName + ".sync"); cacheFileInfo.Setup(f => f.Directory).Returns(parentDir); cacheFileInfo.Setup(f => f.IsExtendedAttributeAvailable()).Returns(true); this.fsFactory.AddIFileInfo(cacheFileInfo.Object); this.transmissionStorage.Setup(f => f.SaveObject(It.IsAny <IFileTransmissionObject>())).Callback <IFileTransmissionObject>((o) => { this.transmissionStorage.Setup(f => f.GetObjectByRemoteObjectId(It.IsAny <string>())).Returns(o); }); this.transmissionStorage.Setup(f => f.RemoveObjectByRemoteObjectId(It.IsAny <string>())).Callback(() => { this.transmissionStorage.Setup(f => f.GetObjectByRemoteObjectId(It.IsAny <string>())).Returns((IFileTransmissionObject)null); }); var stream = new Mock <MemoryStream>(); stream.SetupAllProperties(); stream.Setup(f => f.CanWrite).Returns(true); // required for System.Security.Cryptography.CryptoStream long length = 0; stream.Setup(f => f.Write(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>())).Callback((byte[] buffer, int offset, int count) => { if (length > 0) { foreach (Transmission transmission in this.manager.ActiveTransmissions) { transmission.Abort(); } } length += count; }); cacheFileInfo.Setup(f => f.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)).Returns(() => { cacheFileInfo.Setup(f => f.Exists).Returns(true); return(stream.Object); }); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.id, this.objectName, this.parentId, content.Length, content, this.lastChangeToken); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); Assert.Throws <AbortException>(() => this.underTest.Solve(fileInfo.Object, remoteObject.Object)); cacheFileInfo.Verify(f => f.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None), Times.Once()); cacheFileInfo.VerifySet(f => f.Uuid = It.Is <Guid?>(uuid => uuid != null && !uuid.Equals(Guid.Empty)), Times.Never()); cacheFileInfo.Verify(f => f.MoveTo(this.path), Times.Never()); fileInfo.VerifySet(d => d.LastWriteTimeUtc = It.Is <DateTime>(date => date.Equals(this.creationDate)), Times.Never()); this.transmissionStorage.Verify(f => f.GetObjectByRemoteObjectId(It.IsAny <string>()), Times.Once()); this.transmissionStorage.Verify(f => f.SaveObject(It.IsAny <IFileTransmissionObject>()), Times.AtLeastOnce()); this.transmissionStorage.Verify(f => f.RemoveObjectByRemoteObjectId(It.IsAny <string>()), Times.Never()); this.storage.Verify(f => f.SaveMappedObject(It.IsAny <IMappedObject>()), Times.Never()); lengthWrite = length; }