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);
}
