public void FolderMovedDetectionOnChangeEvent() { string folderName = "old"; string oldLocalPath = Path.Combine(Path.GetTempPath(), folderName); string remoteId = "remoteId"; string oldParentId = "oldParentId"; string newParentId = "newParentId"; var remoteFolder = new Mock <IFolder>(); remoteFolder.Setup(f => f.Name).Returns(folderName); remoteFolder.Setup(f => f.Path).Returns("/new/" + folderName); remoteFolder.Setup(f => f.Id).Returns(remoteId); remoteFolder.Setup(f => f.ParentId).Returns(newParentId); var mappedParentFolder = Mock.Of <IMappedObject>(p => p.RemoteObjectId == oldParentId && p.Type == MappedObjectType.Folder); var mappedFolder = this.storage.AddLocalFolder(oldLocalPath, remoteId); mappedFolder.Setup(f => f.Name).Returns(folderName); mappedFolder.Setup(f => f.ParentId).Returns(mappedParentFolder.RemoteObjectId); var folderEvent = new FolderEvent(remoteFolder: remoteFolder.Object) { Remote = MetaDataChangeType.CHANGED }; var underTest = new RemoteSituationDetection(); Assert.AreEqual(SituationType.MOVED, underTest.Analyse(this.storage.Object, folderEvent)); }
public void AddingEventBackToQueueOnRetryExceptionInSolverAndIncrementRetryCounter() { var localDetection = new Mock <ISituationDetection <AbstractFolderEvent> >(); var remoteDetection = new Mock <ISituationDetection <AbstractFolderEvent> >(); int numberOfSolver = Enum.GetNames(typeof(SituationType)).Length; ISolver[,] solver = new ISolver[numberOfSolver, numberOfSolver]; var retryProducer = new Mock <ISolver>(); retryProducer.Setup( r => r.Solve( It.IsAny <IFileSystemInfo>(), It.IsAny <IObjectId>(), It.IsAny <ContentChangeType>(), It.IsAny <ContentChangeType>())).Throws(new RetryException("reason")); solver[(int)SituationType.NOCHANGE, (int)SituationType.NOCHANGE] = retryProducer.Object; var mechanism = this.CreateMechanism(localDetection.Object, remoteDetection.Object, solver); localDetection.Setup(d => d.Analyse(this.storage.Object, It.IsAny <AbstractFolderEvent>())).Returns(SituationType.NOCHANGE); remoteDetection.Setup(d => d.Analyse(this.storage.Object, It.IsAny <AbstractFolderEvent>())).Returns(SituationType.NOCHANGE); var folderEvent = new FolderEvent(Mock.Of <IDirectoryInfo>(), Mock.Of <IFolder>()) { Local = MetaDataChangeType.NONE, Remote = MetaDataChangeType.NONE }; Assert.That(mechanism.Handle(folderEvent), Is.True); this.queue.Verify(q => q.AddEvent(folderEvent), Times.Once()); Assert.That(folderEvent.RetryCount, Is.EqualTo(1)); }
public void AccumulatesRemoteMovedFolderEvents() { var storage = new Mock <IMetaDataStorage>(); var storedObject = Mock.Of <IMappedObject>( o => o.ParentId == "oldParentId"); storage.Setup(s => s.GetObjectByRemoteId(this.remoteId)).Returns(storedObject); storage.Setup(s => s.GetLocalPath(storedObject)).Returns(this.localPath); var fsFactory = new Mock <IFileSystemInfoFactory>(); var localPathInfo = Mock.Of <IDirectoryInfo>(); fsFactory.Setup(f => f.CreateDirectoryInfo(this.localPath)).Returns(localPathInfo); var acc = new RemoteObjectMovedOrRenamedAccumulator(Mock.Of <ISyncEventQueue>(), storage.Object, fsFactory.Object); var remoteFolder = Mock.Of <IFolder>( f => f.Id == this.remoteId && f.ParentId == this.parentId); var folderEvent = new FolderEvent(remoteFolder: remoteFolder) { Remote = MetaDataChangeType.CREATED }; Assert.That(acc.Handle(folderEvent), Is.False); Assert.That(folderEvent.LocalFolder, Is.EqualTo(localPathInfo)); }
public void LocalFolderAddedSituation() { var localFolder = Mock.Of <IDirectoryInfo>(); var localFolderAddedSolver = new Mock <ISolver>(); var localDetection = new LocalSituationDetection(); var remoteDetection = new RemoteSituationDetection(); var folderEvent = new FolderEvent(localFolder: localFolder) { Local = MetaDataChangeType.CREATED, Remote = MetaDataChangeType.NONE }; var mechanism = this.CreateMechanism(localDetection, remoteDetection); mechanism.Solver[(int)SituationType.ADDED, (int)SituationType.NOCHANGE] = localFolderAddedSolver.Object; Assert.IsTrue(mechanism.Handle(folderEvent)); localFolderAddedSolver.Verify( s => s.Solve( It.IsAny <IFileSystemInfo>(), It.IsAny <IObjectId>(), It.IsAny <ContentChangeType>(), It.IsAny <ContentChangeType>()), Times.Once()); this.VerifyThatListenerIsInformed(); }
public void AddingInteractionNeededEventToQueueOnInteractionNeededException() { var localDetection = new Mock <ISituationDetection <AbstractFolderEvent> >(); var remoteDetection = new Mock <ISituationDetection <AbstractFolderEvent> >(); int numberOfSolver = Enum.GetNames(typeof(SituationType)).Length; ISolver[,] solver = new ISolver[numberOfSolver, numberOfSolver]; var interactionNeededProducer = new Mock <ISolver>(); var exception = new InteractionNeededException("reason"); interactionNeededProducer.Setup( r => r.Solve( It.IsAny <IFileSystemInfo>(), It.IsAny <IObjectId>(), It.IsAny <ContentChangeType>(), It.IsAny <ContentChangeType>())).Throws(exception); solver[(int)SituationType.NOCHANGE, (int)SituationType.NOCHANGE] = interactionNeededProducer.Object; var mechanism = this.CreateMechanism(localDetection.Object, remoteDetection.Object, solver); localDetection.Setup(d => d.Analyse(this.storage.Object, It.IsAny <AbstractFolderEvent>())).Returns(SituationType.NOCHANGE); remoteDetection.Setup(d => d.Analyse(this.storage.Object, It.IsAny <AbstractFolderEvent>())).Returns(SituationType.NOCHANGE); var folderEvent = new FolderEvent(Mock.Of <IDirectoryInfo>(), Mock.Of <IFolder>()) { Local = MetaDataChangeType.NONE, Remote = MetaDataChangeType.NONE }; Assert.That(mechanism.Handle(folderEvent), Is.True); this.queue.Verify(q => q.AddEvent(It.Is <InteractionNeededEvent>(e => e.Exception == exception)), Times.Once()); this.queue.VerifyThatNoOtherEventIsAddedThan <InteractionNeededEvent>(); }
private void HandleAsIFolder(ContentChangeEvent contentChangeEvent) { IFolder folder = contentChangeEvent.CmisObject as IFolder; IMappedObject dir = this.storage.GetObjectByRemoteId(folder.Id); IDirectoryInfo dirInfo = (dir == null) ? null : this.fsFactory.CreateDirectoryInfo(this.storage.GetLocalPath(dir)); var folderEvent = new FolderEvent(dirInfo, folder, this); switch (contentChangeEvent.Type) { case DotCMIS.Enums.ChangeType.Created: Logger.Debug("Created Folder Event"); folderEvent.Remote = MetaDataChangeType.CREATED; break; case DotCMIS.Enums.ChangeType.Updated: folderEvent.Remote = MetaDataChangeType.CHANGED; break; case DotCMIS.Enums.ChangeType.Security: folderEvent.Remote = MetaDataChangeType.CHANGED; break; } Queue.AddEvent(folderEvent); }
public void ConstructorWithLocalFolder() { var localFolder = Mock.Of <IDirectoryInfo>(); var underTest = new FolderEvent(localFolder); Assert.That(underTest.LocalFolder, Is.EqualTo(localFolder)); }
public void ConstructorWithRemoteFolder() { var remoteFolder = Mock.Of <IFolder>(); var underTest = new FolderEvent(null, remoteFolder); Assert.That(underTest.RemoteFolder, Is.EqualTo(remoteFolder)); }
public void IsIFilterableRemoteObjectEvent() { var remoteFolder = Mock.Of <IFolder>(); var underTest = new FolderEvent(null, remoteFolder); Assert.That(underTest is IFilterableRemoteObjectEvent); }
public void FolderAddedDetection() { var folderEvent = new FolderEvent(Mock.Of <IDirectoryInfo>()) { Local = MetaDataChangeType.CREATED }; Assert.That(new LocalSituationDetection().Analyse(Mock.Of <IMetaDataStorage>(), folderEvent), Is.EqualTo(SituationType.ADDED)); }
public void FolderRemoved() { var folderEvent = new FolderEvent(Mock.Of <IDirectoryInfo>()) { Local = MetaDataChangeType.DELETED }; Assert.That(this.underTest.Analyse(Mock.Of <IMetaDataStorage>(), folderEvent), Is.EqualTo(SituationType.REMOVED)); }
public void LocalPathReturnsNullIfLocalFolderIsNotSet() { var remoteFolder = Mock.Of <IFolder>(); var underTest = new FolderEvent(null, remoteFolder); Assert.That(underTest is IFilterableLocalPathEvent); Assert.That(underTest.LocalPath, Is.Null); }
public void LocalPathIsFilterable() { var path = "localpath"; var localFolder = Mock.Of <IDirectoryInfo>(f => f.FullName == path); var underTest = new FolderEvent(localFolder); Assert.That(underTest.LocalPath, Is.EqualTo(path)); }
public void FolderEventWithIFolder() { var session = new Mock <ISession>(); var fetcher = new RemoteObjectFetcher(session.Object, Mock.Of <IMetaDataStorage>()); var folderEvent = new FolderEvent(new Mock <IDirectoryInfo>().Object, new Mock <IFolder>().Object); fetcher.Handle(folderEvent); session.Verify(s => s.GetObject(It.IsAny <string>(), It.IsAny <IOperationContext>()), Times.Never()); }
public void DoNotFilterIgnoredLocalFolderAddEvent() { this.SetupMocks(); var folderEvent = new FolderEvent(Mock.Of <IDirectoryInfo>(d => d.FullName == this.ignoredPath), null) { Local = MetaDataChangeType.CREATED }; Assert.That(this.underTest.Handle(folderEvent), Is.False); }
public void ConstructorTakesLocalAndRemoteFolder() { var localFolder = Mock.Of <IDirectoryInfo>(); var remoteFolder = Mock.Of <IFolder>(); var underTest = new FolderEvent(localFolder, remoteFolder); Assert.That(underTest.LocalFolder, Is.EqualTo(localFolder)); Assert.That(underTest.RemoteFolder, Is.EqualTo(remoteFolder)); }
public void DoNotFilterIgnoredRemoteFolderAddedEvent() { this.SetupMocks(); var folderEvent = new FolderEvent(null, Mock.Of <IFolder>(f => f.Id == this.ignoredObjectId)) { Local = MetaDataChangeType.CREATED }; Assert.That(this.underTest.Handle(folderEvent), Is.False); }
/// <summary> /// Process individual subscription notifications /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private void Connection_OnNotificationEvent(object sender, NotificationEventArgs args) { var ewsService = args.Subscription.Service; var fromEmailAddress = args.Subscription.Service.ImpersonatedUserId.Id; _traceListener.Trace("SyncProgram", $"StreamingSubscriptionChangesAsync {fromEmailAddress} received {args.Events.Count()} notification(s)"); // Process all Events // New appt: ev.Type == Created // Del apt: ev.Type == Moved, IsCancelled == true // Move apt: ev.Type == Modified, IsUnmodified == false, foreach (NotificationEvent notification in args.Events) { if (string.IsNullOrEmpty(fromEmailAddress)) { fromEmailAddress = "Unknown mailbox"; } string sEvent = fromEmailAddress + ": "; if (notification is ItemEvent) { ItemEvent ev = (ItemEvent)notification; var itemId = ev.ItemId; sEvent += $"Item {ev.EventType.ToString()}: "; sEvent += $"ItemId = {ev.ItemId.UniqueId}"; _traceListener.Trace("SyncProgram", $"Processing event {sEvent} at {DateTime.UtcNow}"); try { var task = System.Threading.Tasks.Task.Run(async() => { // Send an item event you can bind to await Messenger.SendQueueO365ChangesAsync(queueSubscription, fromEmailAddress, ev); }); task.Wait(CancellationTokenSource.Token); } catch (ServiceResponseException ex) { _traceListener.Trace("SyncProgram", $"ServiceException: {ex.Message}"); continue; } } else if (notification is FolderEvent) { FolderEvent ev = (FolderEvent)notification; sEvent += $"Folder {ev.EventType.ToString()}: "; sEvent += $"FolderId = {ev.FolderId.UniqueId}"; _traceListener.Trace("SyncProgram", $"Processing event {sEvent} at {DateTime.UtcNow}"); } } }
public void FolderAddedDetection() { var remoteObject = new Mock <IFolder>(); var folderEvent = new FolderEvent(remoteFolder: remoteObject.Object); folderEvent.Remote = MetaDataChangeType.CREATED; var detector = new RemoteSituationDetection(); Assert.AreEqual(SituationType.ADDED, detector.Analyse(this.storageMock.Object, folderEvent)); }
public void NoChangeDetectedForFolder() { var remoteObject = new Mock <IFolder>(); var folderEvent = new FolderEvent(remoteFolder: remoteObject.Object); folderEvent.Remote = MetaDataChangeType.NONE; var underTest = new RemoteSituationDetection(); Assert.AreEqual(SituationType.NOCHANGE, underTest.Analyse(this.storage.Object, folderEvent)); }
public void FolderRemovedDetection() { var remoteObject = new Mock <IFolder>(); var folderEvent = new FolderEvent(remoteFolder: remoteObject.Object); folderEvent.Remote = MetaDataChangeType.DELETED; var underTest = new RemoteSituationDetection(); Assert.AreEqual(SituationType.REMOVED, underTest.Analyse(this.storage.Object, folderEvent)); }
static void OnEvent(object sender, NotificationEventArgs args) { StreamingSubscription subscription = args.Subscription; // Loop through all item-related events. foreach (NotificationEvent notification in args.Events) { switch (notification.EventType) { case EventType.NewMail: Console.WriteLine("\n{0}: Mail created:", DateTime.Now.ToString()); break; case EventType.Created: Console.WriteLine("\n{0} Item or folder created:", DateTime.Now.ToString()); break; case EventType.Deleted: Console.WriteLine("\n{0} Item or folder deleted:", DateTime.Now.ToString()); break; case EventType.Moved: Console.WriteLine("\n{0} Item moved:", DateTime.Now.ToString()); break; } // Display the notification identifier. if (notification is ItemEvent) { // The NotificationEvent for an e-mail message is an ItemEvent. ItemEvent itemEvent = (ItemEvent)notification; //Console.WriteLine("\nItemId: " + itemEvent.ItemId.UniqueId); // Get the details of the item EmailMessage email = EmailMessage.Bind(service, new ItemId(itemEvent.ItemId.UniqueId)); Console.WriteLine("Subject: '{0}', Received: {1}, Sender '{2}'", email.Subject, email.DateTimeReceived.ToString(), email.Sender.Address); //old parent folder Folder oldParentFolder = Folder.Bind(service, new FolderId(itemEvent.OldParentFolderId.UniqueId)); Console.WriteLine("Source: {0}", oldParentFolder.DisplayName); //new parent folder Folder newParentFolder = Folder.Bind(service, new FolderId(itemEvent.ParentFolderId.UniqueId)); Console.WriteLine("Destination: {0}", newParentFolder.DisplayName); } else { // The NotificationEvent for a folder is an FolderEvent. FolderEvent folderEvent = (FolderEvent)notification; Console.WriteLine("\nFolderId: " + folderEvent.FolderId.UniqueId); } } }
public void FetchOnlyIfLocalFolderNull() { var matcher = new Mock <IPathMatcher>(); var remoteFolder = new Mock <IFolder>(); var folder = new Mock <IDirectoryInfo>(); var folderEvent = new FolderEvent(remoteFolder: remoteFolder.Object, localFolder: folder.Object); var fetcher = new LocalObjectFetcher(matcher.Object); Assert.That(fetcher.Handle(folderEvent), Is.False); Assert.That(folderEvent.LocalFolder, Is.EqualTo(folder.Object)); }
public void NotifyOneLocalFolderCreatedEventToQueue() { var dir = Mock.Of <IDirectoryInfo>(); var dirEvent = new FolderEvent(dir, null) { Local = MetaDataChangeType.CREATED }; this.collection.creationEvents.Add(dirEvent); this.underTest.MergeEventsAndAddToQueue(this.collection); this.queue.VerifyThatNoOtherEventIsAddedThan <FolderEvent>(); this.queue.Verify(q => q.AddEvent(dirEvent), Times.Once()); this.queue.Verify(q => q.AddEvent(It.IsAny <ISyncEvent>()), Times.Exactly(1)); }
public void NotifyOneRemoteFolderCreatedEventToQueue() { var folder = Mock.Of <IFolder>(); var folderEvent = new FolderEvent(null, folder) { Remote = MetaDataChangeType.CREATED }; this.collection.creationEvents.Add(folderEvent); this.underTest.MergeEventsAndAddToQueue(this.collection); this.queue.VerifyThatNoOtherEventIsAddedThan <FolderEvent>(); this.queue.Verify(q => q.AddEvent(folderEvent), Times.Once()); this.queue.Verify(q => q.AddEvent(It.IsAny <ISyncEvent>()), Times.Exactly(1)); }
public void OnEvent(object sender, NotificationEventArgs args) { StreamingSubscription subscription = args.Subscription; index++; blockCol.Add(index); //// Loop through all item-related events. foreach (NotificationEvent notification in args.Events) { switch (notification.EventType) { case EventType.NewMail: LoggerHelper.Logger.Info("\n-------------Mail created:-------------"); break; case EventType.Created: LoggerHelper.Logger.Info("\n-------------Item or folder created:-------------"); break; case EventType.Deleted: LoggerHelper.Logger.Info("\n-------------Item or folder deleted:-------------"); break; } // Display the notification identifier. if (notification is ItemEvent) { // The NotificationEvent for an email message is an ItemEvent. ItemEvent itemEvent = (ItemEvent)notification; LoggerHelper.Logger.Info("\nItemId: " + itemEvent.ItemId.UniqueId); } else { // The NotificationEvent for a folder is a FolderEvent. FolderEvent folderEvent = (FolderEvent)notification; LoggerHelper.Logger.Info("\nFolderId: " + folderEvent.FolderId.UniqueId); } } //System.Timers.Timer timer = new System.Timers.Timer(5 * 1000 * new Random().Next(1, 10)); //timer.Elapsed += delegate (object send, System.Timers.ElapsedEventArgs e) //{ // ReceiveEmailFromServer(exchangeService); //}; //timer.Enabled = true; //ReceiveEmailFromServer(exchangeService); // AsyncReceiveEmailFromServer(); }
public void FolderChangedDetection() { var storage = new Mock <IMetaDataStorage>(); Guid guid = Guid.NewGuid(); var dirInfo = Mock.Of <IDirectoryInfo>( d => d.Name == "Name" && d.FullName == Path.Combine(Path.GetTempPath(), "Name") && d.Uuid == guid); storage.Setup(s => s.GetObjectByLocalPath(dirInfo)).Returns(Mock.Of <IMappedObject>()); var folderEvent = new FolderEvent(dirInfo) { Local = MetaDataChangeType.CHANGED }; Assert.That(new LocalSituationDetection().Analyse(storage.Object, folderEvent), Is.EqualTo(SituationType.CHANGED)); }
public void RemoteFolderSecurity() { var storage = new Mock <IMetaDataStorage>(); storage.AddLocalFolder("path", Id); FolderEvent folderEvent = null; var queue = new Mock <ISyncEventQueue>(); queue.Setup(h => h.AddEvent(It.IsAny <FolderEvent>())) .Callback <ISyncEvent>(e => folderEvent = e as FolderEvent); var transformer = new ContentChangeEventTransformer(queue.Object, storage.Object); var contentChangeEvent = this.PrepareFolderEvent(DotCMIS.Enums.ChangeType.Security); Assert.That(transformer.Handle(contentChangeEvent), Is.True); queue.Verify(q => q.AddEvent(It.IsAny <FolderEvent>()), Times.Once()); Assert.That(folderEvent.Remote, Is.EqualTo(MetaDataChangeType.CHANGED)); }
public void DropFolderEventIfPathMatcherCannotCreateLocalPath() { var remotePath = Path.Combine(Path.GetTempPath(), "a"); var matcher = new Mock <IPathMatcher>(); matcher.Setup(m => m.CanCreateLocalPath(remotePath)).Returns(false); var remoteFolder = new Mock <IFolder>(); remoteFolder.Setup(f => f.Path).Returns(remotePath); var folderEvent = new FolderEvent(remoteFolder: remoteFolder.Object); var fetcher = new LocalObjectFetcher(matcher.Object); Assert.That(fetcher.Handle(folderEvent), Is.True); Assert.That(folderEvent.LocalFolder, Is.Null); }
private void HandleFolderEvents(IFSEvent e) { var movedEvent = e as IFSMovedEvent; FolderEvent folderEvent; if (movedEvent != null) { folderEvent = new FolderMovedEvent( this.fsFactory.CreateDirectoryInfo(movedEvent.OldPath), this.fsFactory.CreateDirectoryInfo(movedEvent.LocalPath), null, null, this) { Local = MetaDataChangeType.MOVED }; } else { folderEvent = new FolderEvent(this.fsFactory.CreateDirectoryInfo(e.LocalPath), null, this); switch (e.Type) { case WatcherChangeTypes.Created: folderEvent.Local = MetaDataChangeType.CREATED; break; case WatcherChangeTypes.Changed: folderEvent.Local = MetaDataChangeType.CHANGED; break; case WatcherChangeTypes.Deleted: folderEvent.Local = MetaDataChangeType.DELETED; break; default: // This should never ever happen return; } } Queue.AddEvent(folderEvent); }