public void AgainTellsQueueToStartSyncAfterCompletingPreviousPushSync()
{
Queue.StartNextQueuedState(Orchestrator).Returns(Pull);
SyncManager.PushSync();
Queue.StartNextQueuedState(Orchestrator).Returns(Sleep);
OrchestratorSyncComplete.OnNext(Push);
Queue.ClearReceivedCalls();
CallMethod();
Queue.Received().StartNextQueuedState(Orchestrator);
}
public void AgainTellsQueueToStartSyncAfterCompletingPreviousFullSync()
{
Queue.Dequeue().Returns(Pull);
SyncManager.ForceFullSync();
Queue.Dequeue().Returns(Sleep);
OrchestratorSyncComplete.OnNext(new Success(Pull));
Queue.ClearReceivedCalls();
CallMethod();
Queue.Received().Dequeue();
}
public void EmitsSyncedWhenSyncCompletesAndQueueIsEmpty()
{
SyncProgress?emitted = null;
Queue.Dequeue().Returns(Sleep);
OrchestratorSyncComplete.OnNext(new Success(Pull));
SyncManager.ProgressObservable.Subscribe(progress => emitted = progress);
emitted.Should().NotBeNull();
emitted.Should().Be(SyncProgress.Synced);
}
public void DoesNotEmitSyncedWhenSyncCompletesButAnotherSyncIsQueued(SyncState queuedState)
{
SyncProgress?emitted = null;
Queue.Dequeue().Returns(queuedState);
OrchestratorSyncComplete.OnNext(new Success(Pull));
SyncManager.ProgressObservable.Subscribe(progress => emitted = progress);
Orchestrator.Received().Start(queuedState);
emitted.Should().NotBe(SyncProgress.Synced);
}
public void PerformsThreadSafeClearingOfTheQueue()
{
var startQueueing = new AutoResetEvent(false);
var startClearing = new AutoResetEvent(false);
var queueCleared = new AutoResetEvent(false);
int iterator = 0;
int queued = -1;
int cleared = -1;
Queue.When(q => q.QueuePullSync()).Do(_ =>
{
startClearing.Set();
Task.Delay(10).Wait();
queued = Interlocked.Increment(ref iterator);
});
Queue.When(q => q.Clear()).Do(_ =>
{
cleared = Interlocked.Increment(ref iterator);
queueCleared.Set();
});
Task.Run(() =>
{
startQueueing.WaitOne();
SyncManager.ForceFullSync();
});
Task.Run(() =>
{
startClearing.WaitOne();
OrchestratorSyncComplete.OnNext(new Error(new Exception()));
});
startQueueing.Set();
queueCleared.WaitOne();
queued.Should().BeLessThan(cleared);
}
public void GoesToSleepAfterAnErrorIsReported()
{
OrchestratorSyncComplete.OnNext(new Error(new Exception()));
Orchestrator.Received().Start(Arg.Is(Sleep));
}
public void UpdatesInternalStateSoItIsNotLockedForFutureSyncsAfterAnErrorIsReported()
{
OrchestratorSyncComplete.OnNext(new Error(new Exception()));
SyncManager.IsRunningSync.Should().BeFalse();
}
public void ClearsTheSyncQueueWhenAnErrorIsReported()
{
OrchestratorSyncComplete.OnNext(new Error(new Exception()));
Queue.Received().Clear();
}
public void FreezesTheSyncManagerWhenAKnownClientErrorExceptionIsReported(ClientErrorException exception)
{
OrchestratorSyncComplete.OnNext(new Error(exception));
Orchestrator.Received().Freeze();
}
protected SyncManagerTestBase()
{
Orchestrator.SyncCompleteObservable.Returns(OrchestratorSyncComplete.AsObservable());
Orchestrator.StateObservable.Returns(OrchestratorStates.AsObservable());
SyncManager = new SyncManager(Queue, Orchestrator, AnalyticsService, LastTimeUsageStorage, TimeService, AutomaticSyncingService);
}
public void ThrowsWhenAnUnsupportedSyncResultIsEmittedByTheOrchestrator()
{
Action emittingUnsupportedResult = () => OrchestratorSyncComplete.OnNext(new UnsupportedResult());
emittingUnsupportedResult.Should().Throw <ArgumentException>();
}
protected override void CallMethod() => OrchestratorSyncComplete.OnNext(new Success(0));
public async Task DoesNotQueueUntilOtherCompletedEventReturns()
{
await ensureMethodIsThreadSafeWith(() => OrchestratorSyncComplete.OnNext(new Success(0)));
}
protected SyncManagerTestBase()
{
Orchestrator.SyncCompleteObservable.Returns(OrchestratorSyncComplete.AsObservable());
Orchestrator.StateObservable.Returns(OrchestratorStates.AsObservable());
SyncManager = new SyncManager(Queue, Orchestrator, AnalyticsService);
}
