public void Setup()
        {
            _persistenceClient = A.Fake <IEventPersistenceClient>();
            _streamingClient   = A.Fake <IEventStreamingClient>();

            A.CallTo(() => _streamingClient.GetAllEventsStream())
            .Returns(_allEventsSubject.AsObservable());

            A.CallTo(() => _streamingClient.ConnectionStateChanged)
            .Returns(Observable.Return(StreamingConnectionState.Connected));
        }
        private async Task Initialize()
        {
            // Initialize the streaming subscription
            _eventSubscription.Disposable = _eventStreamingClient.GetAllEventsStream()
                                            .Where(ev => SubscribedEventTypes.ContainsKey(ev.Type))
                                            .Subscribe(async e =>
            {
                _bufferedEvents.Push(e);

                if (_retrievedStateOfTheWorld)
                {
                    await ProcessBufferedEvents();
                }
            });

            // Retrieve the state of the world & process its events
            var events = await RetrievePersistedEvents();

            events.ForEach(async e => await ProcessEvent(e));

            // Process any streamed events that were buffered meanwhile
            _retrievedStateOfTheWorld = true;
            await ProcessBufferedEvents();
        }