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