public void AddEventToStoppedQueue()
{
using (SyncEventQueue queue = new SyncEventQueue(new Mock <SyncEventManager>().Object)){
queue.StopListener();
WaitFor(queue, (q) => { return(q.IsStopped); });
queue.AddEvent(new Mock <ISyncEvent>().Object);
}
}
public void EventlessStartStop()
{
using (SyncEventQueue queue = new SyncEventQueue(new Mock <ISyncEventManager>().Object)) {
WaitFor(queue, (q) => { return(!q.IsStopped); });
Assert.False(queue.IsStopped);
queue.StopListener();
WaitFor(queue, (q) => { return(q.IsStopped); });
Assert.True(queue.IsStopped);
}
}
public void SubscribeThrowsExceptionIfCategorizedObserverIsNull()
{
using (SyncEventQueue queue = new SyncEventQueue(Mock.Of <ISyncEventManager>())) {
Assert.Throws <ArgumentNullException>(
() => {
using (var unsubscriber = queue.CategoryCounter.Subscribe((IObserver <Tuple <EventCategory, int> >)null)) {
}
});
}
}
public void SubscribeThrowsExceptionIfAllObserverIsNull()
{
using (SyncEventQueue queue = new SyncEventQueue(Mock.Of <ISyncEventManager>())) {
Assert.Throws <ArgumentNullException>(
() => {
using (var unsubscriber = queue.FullCounter.Subscribe((IObserver <int>)null)) {
}
});
}
}
public void WaitForStop()
{
Task t;
using (SyncEventQueue queue = new SyncEventQueue(new Mock <ISyncEventManager>().Object)) {
t = Task.Factory.StartNew(() => { Thread.Sleep(100); queue.StopListener(); });
queue.WaitForStopped();
Assert.True(queue.IsStopped);
}
t.Wait();
}
public void AddEvent()
{
var managerMock = new Mock <SyncEventManager>();
var eventMock = new Mock <ISyncEvent>();
using (SyncEventQueue queue = new SyncEventQueue(managerMock.Object)){
queue.AddEvent(eventMock.Object);
queue.AddEvent(eventMock.Object);
queue.StopListener();
WaitFor(queue, (q) => { return(q.IsStopped); });
Assert.True(queue.IsStopped);
}
managerMock.Verify(foo => foo.Handle(eventMock.Object), Times.Exactly(2));
}
public void ExceptionsInManagerAreHandled()
{
var managerMock = new Mock <ISyncEventManager>();
managerMock.Setup(m => m.Handle(It.IsAny <ISyncEvent>())).Throws(new Exception("Generic Exception Message"));
var eventMock = new Mock <ISyncEvent>();
eventMock.Setup(e => e.ToString()).Returns("Mocked Event");
using (SyncEventQueue queue = new SyncEventQueue(managerMock.Object)) {
queue.AddEvent(eventMock.Object);
queue.StopListener();
WaitFor(queue, (q) => { return(q.IsStopped); });
Assert.True(queue.IsStopped);
}
}
/// <summary>
/// Constructor.
/// </summary>
public RepoBase(RepoInfo repoInfo, IActivityListener activityListener)
{
EventManager = new SyncEventManager();
EventManager.AddEventHandler(new DebugLoggingHandler());
EventManager.AddEventHandler(new GenericSyncEventHandler <RepoConfigChangedEvent>(0, RepoInfoChanged));
Queue = new SyncEventQueue(EventManager);
RepoInfo = repoInfo;
LocalPath = repoInfo.TargetDirectory;
Name = repoInfo.Name;
RemoteUrl = repoInfo.Address;
this.activityListener = activityListener;
if (repoInfo.IsSuspended)
{
Status = SyncStatus.Suspend;
}
// Folder lock.
// Disabled for now. Can be an interesting feature, but should be made opt-in, as
// most users would be surprised to see this file appear.
// folderLock = new FolderLock(LocalPath);
Watcher = new Watcher(LocalPath);
Watcher.EnableRaisingEvents = true;
// Main loop syncing every X seconds.
remote_timer.Elapsed += delegate
{
// Synchronize.
SyncInBackground();
};
remote_timer.AutoReset = true;
Logger.Info("Repo " + repoInfo.Name + " - Set poll interval to " + repoInfo.PollInterval + "ms");
remote_timer.Interval = repoInfo.PollInterval;
//Partial sync interval..
local_timer.Elapsed += delegate
{
// Run partial sync.
SyncInBackground(false);
};
local_timer.AutoReset = false;
local_timer.Interval = delay_interval;
}
public void PutConnectionEventToQueueIfConnectionExceptionOccursOnHandling()
{
var manager = new Mock <ISyncEventManager>();
var connectionRequiredEvent = Mock.Of <ISyncEvent>();
var connectionException = new CmisConnectionException("unknown host");
manager.Setup(m => m.Handle(connectionRequiredEvent)).Throws(connectionException);
using (var underTest = new SyncEventQueue(manager.Object)) {
var observer = new Mock <IObserver <int> >();
observer.Setup(o => o.OnNext(It.Is <int>(i => i == 0))).Callback(() => {
underTest.StopListener();
});
using (var unsubscriber = underTest.FullCounter.Subscribe(observer.Object)) {
underTest.AddEvent(connectionRequiredEvent);
Assert.That(underTest.WaitForStopped(10000), Is.True);
}
}
manager.Verify(m => m.Handle(It.Is <CmisConnectionExceptionEvent>(e => e.Exception == connectionException)), Times.Once());
}
