public virtual void before_each() { autoSubstitute = new AutoSubstitute(); var testBuildManager = autoSubstitute.Resolve <IVsSolutionBuildManager2>(); uint unregisterToken = VSConstants.VSCOOKIE_NIL; uint dummyToken = 12345; testBuildManager.AdviseUpdateSolutionEvents(Arg.Any <IVsUpdateSolutionEvents2>(), out unregisterToken) .Returns(callInfo => { solutionUpdateEventSink = callInfo.Arg <IVsUpdateSolutionEvents2>(); callInfo[1] = dummyToken; return(VSConstants.S_OK); }); var solutionBuildManagerProvider = autoSubstitute.Resolve <ISolutionBuildManagerProvider>(); solutionBuildManagerProvider.Provide().Returns(testBuildManager); notifier = autoSubstitute.Resolve <ProjectBuildNotifier>(); buildObserver = new TestScheduler().CreateObserver <ProjectInfo>(); subscription = notifier.BuildStream.Subscribe(buildObserver); someHierarchy = autoSubstitute.Resolve <IVsHierarchy>(); }
public void Subscribe_LastPolled(int numberOfTicks) { var pollingInterval = TimeSpan.FromMilliseconds(100); if (numberOfTicks == 0) { numberOfTicks++; // Polling is executed before first tick } var subscriptionTime = pollingInterval.Ticks * (numberOfTicks > 0 ? numberOfTicks : 1); var scheduler = new TestScheduler(); int cont = 0; IObservable <int> source = Observable.Create <int>(x => { x.OnNext(Interlocked.Increment(ref cont)); x.OnCompleted(); return(Disposable.Empty); }); ITestableObserver <int> observer = scheduler.CreateObserver <int>(); using (var sut = new PollingObservable <int>(source, pollingInterval, scheduler)) { scheduler.AdvanceTo(subscriptionTime); using (sut.Subscribe(observer)) { scheduler.AdvanceBy(1); } } observer.Messages.AssertEqual( OnNext <int>(subscriptionTime + 1, x => x == numberOfTicks && cont == numberOfTicks + 1), OnCompleted <int>(subscriptionTime + 1)); }
public void Subscribe_WaitToFirstTick_OneMessage() { long executionTicks = TimeSpan.FromMilliseconds(100).Ticks + 1; var scheduler = new TestScheduler(); int cont = 0; IObservable <int> source = Observable.Create <int>(x => { scheduler.Sleep(executionTicks - 1); x.OnNext(Interlocked.Increment(ref cont)); x.OnCompleted(); return(Disposable.Empty); }); ITestableObserver <int> observer = scheduler.CreateObserver <int>(); using (var sut = new PollingObservable <int>(source, TimeSpan.FromHours(1), scheduler)) using (sut.Subscribe(observer)) { scheduler.AdvanceTo(executionTicks); } observer.Messages.AssertEqual( OnNext <int>(executionTicks, x => x == 1), OnCompleted <int>(executionTicks)); }
public virtual void before_each() { autoSubstitute = new AutoSubstitute(); solutionOpenedStream = new Subject <SolutionInfo>(); solutionClosingStream = new Subject <Unit>(); projectAddedStream = new Subject <ProjectInfo>(); projectRemovingtream = new Subject <ProjectInfo>(); var solutionNotifier = autoSubstitute.Resolve <ISolutionNotifier>(); solutionNotifier.SolutionOpenedStream.Returns(solutionOpenedStream); solutionNotifier.SolutionClosingStream.Returns(solutionClosingStream); solutionNotifier.ProjectAddedStream.Returns(projectAddedStream); solutionNotifier.ProjectRemovingtream.Returns(projectRemovingtream); projectEnumerator = autoSubstitute.Resolve <IProjectEnumerator>(); notifier = autoSubstitute.Resolve <ProjectNotifier>(); testProjectObserver = new TestScheduler().CreateObserver <IEnumerable <ProjectInfo> >(); subscription = notifier.ProjectStream.Subscribe(testProjectObserver); someSolution = new SolutionInfo(); someProjectInfos = new [] { new ProjectInfo(), new ProjectInfo(), new ProjectInfo(), }; }
public void Guessing_a_correct_letter_twice_counts_as_a_failure() { var scheduler = new TestScheduler(); IObservable <HangmanState> Create() { var hangman = new Hangman("foobar"); scheduler.Schedule(TimeSpan.FromTicks(100), () => hangman.GuessObserver.OnNext('b')); scheduler.Schedule(TimeSpan.FromTicks(200), () => hangman.GuessObserver.OnNext('b')); return(hangman.StateObservable); } var expected = new[] { OnNext <HangmanState>(100, hangmanState => hangmanState.RemainingGuesses == 9 && hangmanState.MaskedWord == "______"), OnNext <HangmanState>(200, hangmanState => hangmanState.RemainingGuesses == 9 && hangmanState.MaskedWord == "___b__"), OnNext <HangmanState>(300, hangmanState => hangmanState.RemainingGuesses == 8 && hangmanState.MaskedWord == "___b__") }; // +--b-b-> // +a-b-c-> ITestableObserver <HangmanState> testableObserver = scheduler.Start(Create, 100, 100, 3000); ReactiveAssert.AreElementsEqual(expected, testableObserver.Messages); }
public void Getting_all_the_letters_right_makes_for_a_win() { var scheduler = new TestScheduler(); IObservable <HangmanState> Create() { var hangman = new Hangman("hello"); scheduler.Schedule(TimeSpan.FromTicks(100), () => hangman.GuessObserver.OnNext('b')); scheduler.Schedule(TimeSpan.FromTicks(200), () => hangman.GuessObserver.OnNext('e')); scheduler.Schedule(TimeSpan.FromTicks(300), () => hangman.GuessObserver.OnNext('l')); scheduler.Schedule(TimeSpan.FromTicks(400), () => hangman.GuessObserver.OnNext('o')); scheduler.Schedule(TimeSpan.FromTicks(500), () => hangman.GuessObserver.OnNext('h')); return(hangman.StateObservable); } var expected = new[] { OnNext <HangmanState>(100, hangmanState => hangmanState.RemainingGuesses == 9 && hangmanState.MaskedWord == "_____"), OnNext <HangmanState>(200, hangmanState => hangmanState.RemainingGuesses == 8 && hangmanState.MaskedWord == "_____"), OnNext <HangmanState>(300, hangmanState => hangmanState.RemainingGuesses == 8 && hangmanState.MaskedWord == "_e___"), OnNext <HangmanState>(400, hangmanState => hangmanState.RemainingGuesses == 8 && hangmanState.MaskedWord == "_ell_"), OnNext <HangmanState>(500, hangmanState => hangmanState.RemainingGuesses == 8 && hangmanState.MaskedWord == "_ello"), OnCompleted <HangmanState>(600) }; // +--b-e-l-o-h-> // +a-b-c-d-e-| ITestableObserver <HangmanState> testableObserver = scheduler.Start(Create, 100, 100, 3000); ReactiveAssert.AreElementsEqual(expected, testableObserver.Messages); }
public void StartQueueingSavedImages_ImagesAreEnqueued() { var image1 = A.Dummy <ISavedImage>(); var image2 = A.Dummy <ISavedImage>(); var image3 = A.Dummy <ISavedImage>(); var savedImages = _testScheduler.CreateHotObservable( new Recorded <Notification <ISavedImage> >(10, Notification.CreateOnNext(image1)), new Recorded <Notification <ISavedImage> >(20, Notification.CreateOnNext(image2)), new Recorded <Notification <ISavedImage> >(30, Notification.CreateOnNext(image3))); _testScheduler.Schedule(TimeSpan.FromTicks(5), (s, t) => _sut.StartQueuingSavedImages(savedImages)); var imageQueueChangesCallback = A.Fake <Action <ImageQueueChangedEvent> >(); _sut.ImageQueueChanges.Subscribe(imageQueueChangesCallback); ITestableObserver <ImageQueueChangedEvent> imageQueueChanges = _testScheduler.Start(() => _sut.ImageQueueChanges, 0, 0, 100); A.CallTo(() => _innerQueue.Enqueue(A <IEnumerable <ISavedImage> > .That.IsSameSequenceAs(new[] { image1 }))).MustHaveHappened() .Then(A.CallTo(() => imageQueueChangesCallback(A <ImageQueueChangedEvent> ._)).MustHaveHappened()) .Then(A.CallTo(() => _innerQueue.Enqueue(A <IEnumerable <ISavedImage> > .That.IsSameSequenceAs(new[] { image2 }))).MustHaveHappened()) .Then(A.CallTo(() => imageQueueChangesCallback(A <ImageQueueChangedEvent> ._)).MustHaveHappened()) .Then(A.CallTo(() => _innerQueue.Enqueue(A <IEnumerable <ISavedImage> > .That.IsSameSequenceAs(new[] { image3 }))).MustHaveHappened()) .Then(A.CallTo(() => imageQueueChangesCallback(A <ImageQueueChangedEvent> ._)).MustHaveHappened()); imageQueueChanges.Messages.Should().HaveCount(3); }
public void Clear_ImageQueueChangesEventFired() { _testScheduler.ScheduleAsync(TimeSpan.FromTicks(5), (s, t) => _sut.Clear()); ITestableObserver <ImageQueueChangedEvent> imageQueueChanges = _testScheduler.Start(() => _sut.ImageQueueChanges, 0, 0, 100); imageQueueChanges.Messages.Should().HaveCount(1); A.CallTo(() => _innerQueue.Clear()).MustHaveHappened(); }
public void Setup() { _testScheduler = new TestScheduler(); _cache = new MemCache(10000, _testScheduler); _testObserver = _testScheduler.CreateObserver <string>(); _subscriptionHandler = new CacheEntrySubscriptionHandler(_cache, _testObserver); _client = new Client(_subscriptionHandler); }
public TheStartDateAndEndDateObservables() { startDateObserver = TestScheduler.CreateObserver <DateTimeOffset>(); endDateObserver = TestScheduler.CreateObserver <DateTimeOffset>(); ViewModel.StartDate.Subscribe(startDateObserver); ViewModel.EndDate.Subscribe(endDateObserver); }
protected override void EstablishContext() { _eventArgs = new DeviceMonitorExceptionEventArgs(new Exception()); _observer = _scheduler.CreateObserver <DeviceMonitorEvent>(); _subscription = _monitor .ObserveEvents() .Subscribe(_observer); }
public void Enqueue_ImageQueueChangesEventFired() { var savedImages = new[] { A.Dummy <ISavedImage>() }; _testScheduler.ScheduleAsync(TimeSpan.FromTicks(5), (s, t) => _sut.Enqueue(savedImages)); ITestableObserver <ImageQueueChangedEvent> imageQueueChanges = _testScheduler.Start(() => _sut.ImageQueueChanges, 0, 0, 100); imageQueueChanges.Messages.Should().HaveCount(1); A.CallTo(() => _innerQueue.Enqueue(savedImages)).MustHaveHappened(); }
public static void AssertAsExpected <T>( ITestableObservable <T> expected, ITestableObserver <T> actual) { ReactiveAssert.AreElementsEqual( expected: expected.Messages, actual: actual.Messages, message: debugElementsEqual(expected.Messages, actual.Messages) ); }
public void Rehydrate_ImageQueueChangesEventFired() { var fetchSavedImages = A.Fake <Func <SourceQualifiedImageId, ISavedImage> >(); _testScheduler.ScheduleAsync(TimeSpan.FromTicks(5), (s, t) => _sut.Rehydrade(fetchSavedImages)); ITestableObserver <ImageQueueChangedEvent> imageQueueChanges = _testScheduler.Start(() => _sut.ImageQueueChanges, 0, 0, 100); imageQueueChanges.Messages.Should().HaveCount(1); A.CallTo(() => _innerQueue.Rehydrade(fetchSavedImages)).MustHaveHappened(); }
public override void SetUp() { base.SetUp(); _observer = new TestScheduler().CreateObserver <CollectionChangedData <SampleDto> >(); _ageChanges.Subscribe(_observer); _expected = CreateJohn(); _sut.Add(_expected); _message = _observer.Messages.Single(); _data = _message.Value.Value; }
public override void SetUp() { base.SetUp(); _expected = 27; _sut.Add(_expected); _observer = new TestScheduler().CreateObserver <CollectionChangedData <int> >(); _changes.Subscribe(_observer); _sut.RemoveAt(0); _message = _observer.Messages.Single(); _data = _message.Value.Value; }
public ReactiveSpecs() { scheduler = new TestScheduler(); observer = scheduler.CreateObserver<int>(); source = new Subject<int>(); observedValues = observer.Messages .Where(x => x.Value.HasValue) .Select(x => x.Value.Value); observedErrors = observer.Messages .Where(x => x.Value.Kind == NotificationKind.OnError) .Select(x => x.Value.Exception); }
protected override void EstablishContext() { _eventArgs = new DeviceChangeEventArgs( new[] { READER_A, READER_B }, new[] { READER_B }, Enumerable.Empty <string>()); _observer = _scheduler.CreateObserver <DeviceMonitorEvent>(); _subscription = _monitor .ObserveEvents() .Subscribe(_observer); }
public static ITestableObserver <T> AssertExceptions <T>(this ITestableObserver <T> observer) { var errors = observer.Errors(); if (errors.Any()) { Assert.True(false, string.Format("An exception occured in the observable sequence : {0}, {1}\n{2}", errors.First().GetType(), errors.First().Message, errors.First().StackTrace)); } return(observer); }
private void prepareTest(bool stepShouldBeVisible, bool wasDismissed) { var shouldBeVisibleObservable = Scheduler.CreateColdObservable( OnNext(1, stepShouldBeVisible) ); observer = Scheduler.CreateObserver <bool>(); OnboardingStep.ShouldBeVisible.Returns(shouldBeVisibleObservable); OnboardingStorage.WasDismissed(Arg.Any <IDismissable>()).Returns(wasDismissed); PrepareDismissableStep(); DismissableStep.ShouldBeVisible.Subscribe(observer); Scheduler.AdvanceTo(1); }
public void Stream() { ITestableObserver <RatingRecord> observer = scheduler.CreateObserver <RatingRecord>(); instance.Ratings.Subscribe(observer); instance.AddRating(new RatingRecord { Id = "1", Date = new DateTime(2016, 01, 10), Rating = 10 }); scheduler.AdvanceBy(100); instance.Dispose(); observer.Messages.AssertEqual( OnNext <RatingRecord>(0, item => true), OnCompleted <RatingRecord>(100)); }
public void h_returns_help() { var scheduler = new TestScheduler(); var plugin = new CountdownTimer(scheduler); var pl = new ParsedLine("!countdown -h", "Bob"); IObservable <string> results = plugin.Evaluate(pl); ITestableObserver <string> obs = scheduler.Start(() => results); obs.Messages.First().Value.Value.Should().Contain("!countdown -d <duration> -i <interval> [options]"); }
public void ShouldBeTrueRegardlessOfWhetherOrNotAProjectWithTheSameNameExistsInTheSameWorkspace(bool configureForSameWorkspace) { saveEnabledObserver = TestScheduler.CreateObserver <bool>(); SetupDataSourceToReturnExistingProjectsAndDefaultWorkspace(dataSourceProjectIsInSameWorkspace: configureForSameWorkspace); var viewModel = CreateViewModel(); viewModel.Save.Enabled.Subscribe(saveEnabledObserver); TestScheduler.Start(); viewModel.Name.Accept(ProjectName); TestScheduler.Start(); saveEnabledObserver.LastEmittedValue().Should().Be(true); }
public override void SetUp() { base.SetUp(); _expected = CreateJohn(); _sut.Add(_expected); _observer = new TestScheduler().CreateObserver <CollectionChangedData <SampleDto> >(); _subscription = _changes.Subscribe(_observer); Assume.That(_sut[0].Age != _expectedAge); _sut[0].Reset(); _message = _observer.Messages.Single(); _data = _message.Value.Value; }
public override void SetUp() { base.SetUp(); _expected = new[] { 27, 12, 79 }; foreach (var i in _expected) { _sut.Add(i); } _observer = new TestScheduler().CreateObserver <CollectionChangedData <int> >(); _changes.Subscribe(_observer); _sut.Clear(); _message = _observer.Messages.Single(); _data = _message.Value.Value; }
public void ShouldAlwaysReturnTrueEvenWhenWorkspaceChanges(string projectName) { saveEnabledObserver = TestScheduler.CreateObserver <bool>(); SetupDataSourceToReturnMultipleWorkspaces(); var viewModel = CreateViewModel(); viewModel.Save.Enabled.Subscribe(saveEnabledObserver); TestScheduler.Start(); viewModel.Name.Accept(projectName); TestScheduler.Start(); viewModel.PickWorkspace.Execute(); TestScheduler.Start(); saveEnabledObserver.LastEmittedValue().Should().Be(true); }
public async Task ETW_Send_Receive_Test() { const int count = 4; // arrange using (var listener = new VisualRxEtwListener()) { // listen IObservable <Marble> listenStream = await listener.GetStreamAsync(); listenStream = listenStream.Replay().RefCount(); ITestableObserver <Marble> listenObserver = _scheduler.CreateObserver <Marble>(); listenStream .Subscribe(listenObserver); // publish var channel = new EtwVisualRxChannel(); await PublisherSetting.TryAddChannels(channel); PublisherSetting.AddFilter((key, provider) => true); // act var xs = Observable.Range(0, count, _scheduler) .Select(i => new Person(i)) .Monitor("Test", PublisherSetting); xs.Subscribe(v => { }); _scheduler.AdvanceBy(5); await listenStream //.Do(v => { },() => { }) .Take(count + 1); for (int i = 0; i < count; i++) { Assert.AreEqual(NotificationKind.OnNext, listenObserver.Messages[i].Value.Kind); var marble = listenObserver.Messages[i].Value.Value; var p = marble.GetValue <Person>(); Assert.AreEqual(i, p.Id); } Marble lastMarble = listenObserver.Messages[count].Value.Value; Assert.AreEqual(NotificationKind.OnCompleted, lastMarble.Kind); } }
public void StartSavingImages_SubscribedToSavedImages_SubscribesAndSavesImages() { IEnumerable <ISavedImage> expectedSavedImages = _imageFromSources.Select(_ => A.Fake <ISavedImage>()).ToList(); foreach (var sourceAndSaved in _imageFromSources.Zip(expectedSavedImages, (source, saved) => new { Source = source, Saved = saved })) { A.CallTo(() => _imageRepository.SaveImage( A <SourceQualifiedImageId> .That.Matches( id => id.ImageId.Equals(sourceAndSaved.Source.Image.GetId().Result) && id.SourceId.Equals(sourceAndSaved.Source.SourceId)), sourceAndSaved.Source.Image.GetImageStream)) .Returns(sourceAndSaved.Saved); } ITestableObserver <ISavedImage> savedImages = _testScheduler.Start(() => _sut.StartSavingImages(_imageSources), 0, 0, 10); savedImages.Messages.Select(m => m.Value.Value).Should().Equal(expectedSavedImages); }
public override void SetUp() { base.SetUp(); _expected = new[] { CreateJohn(), CreateJack(), new SampleDto() { Name = "Jill", Age = 19, FriendsCount = 30 } }; foreach (var i in _expected) { _sut.Add(i); } _observer = new TestScheduler().CreateObserver <CollectionChangedData <SampleDto> >(); _ageChanges.Subscribe(_observer); _sut.Clear(); _message = _observer.Messages.Single(); _data = _message.Value.Value; }
public void Dequeue_ImageWasNotDequeuedFromInnerQueue_ImageQueueChangesEventNotFired() { Option <ISavedImage> expectedDequeuedImage = Option.None <ISavedImage>(); A.CallTo(() => _innerQueue.Dequeue()).Returns(Option.None <ISavedImage>()); Option <ISavedImage> dequeuedImage = A.Dummy <ISavedImage>().Some(); _testScheduler.ScheduleAsync(TimeSpan.FromTicks(5), async(s, t) => { dequeuedImage = await _sut.Dequeue(); }); ITestableObserver <ImageQueueChangedEvent> imageQueueChanges = _testScheduler.Start(() => _sut.ImageQueueChanges, 0, 0, 100); imageQueueChanges.Messages.Should().BeEmpty(); dequeuedImage.HasValue.Should().BeFalse(); dequeuedImage.Should().Be(expectedDequeuedImage); }
public ThrottleData(int[] pattern, int[,] expectedPattern) { Scheduler = new TestScheduler(); CompletedEvent = new[] { ReactiveTest.OnCompleted(_COMPLETE, _COMPLETE) }; Observer = Scheduler.CreateObserver <int>(); Source = Scheduler.CreateColdObservable(pattern.Select(v => ReactiveTest.OnNext(v, v)) .Concat(CompletedEvent) .ToArray());; Pattern = pattern; ExpectedPattern = new int[expectedPattern.GetLength(0)]; ExpectedTimes = new int[expectedPattern.GetLength(0)]; for (int i = 0; i < expectedPattern.GetLength(0); i++) { ExpectedPattern[i] = expectedPattern[i, 0]; ExpectedTimes[i] = expectedPattern[i, 1]; } Expected = ExpectedPattern.Zip(ExpectedTimes, (v, t) => ReactiveTest.OnNext(t, v)).Concat(CompletedEvent).ToList(); }
public override void SetUp() { base.SetUp(); _sut.Add(CreateJohn()); _observer = new TestScheduler().CreateObserver<CollectionChangedData<SampleDto>>(); }
public override void SetUp() { base.SetUp(); _expected = new[] { 27, 12, 79 }; foreach (var i in _expected) { _sut.Add(i); } _observer = new TestScheduler().CreateObserver<CollectionChangedData<int>>(); _changes.Subscribe(_observer); _sut.Clear(); _message = _observer.Messages.Single(); _data = _message.Value.Value; }
public override void SetUp() { base.SetUp(); _expectedOld = CreateJohn(); _expectedNew = CreateJack(); _sut.Add(_expectedOld); _observer = new TestScheduler().CreateObserver<CollectionChangedData<SampleDto>>(); _ageChanges.Subscribe(_observer); _sut[0] = _expectedNew; _message = _observer.Messages.Single(); _data = _message.Value.Value; }
public override void SetUp() { base.SetUp(); _expected = new[] { CreateJohn(), CreateJack(), new SampleDto() { Name = "Jill", Age = 19, FriendsCount = 30 } }; foreach (var i in _expected) { _sut.Add(i); } _observer = new TestScheduler().CreateObserver<CollectionChangedData<SampleDto>>(); _ageChanges.Subscribe(_observer); _sut.Clear(); _message = _observer.Messages.Single(); _data = _message.Value.Value; }
public override void SetUp() { base.SetUp(); _expected = CreateJohn(); _sut.Add(_expected); _observer = new TestScheduler().CreateObserver<CollectionChangedData<SampleDto>>(); _subscription = _ageChanges.Subscribe(_observer); Assume.That(_sut[0].Age != _expectedAge); _sut[0].Age = _expectedAge; _message = _observer.Messages.Single(); _data = _message.Value.Value; }
public override void SetUp() { base.SetUp(); _expected = 27; _sut.Add(_expected); _observer = new TestScheduler().CreateObserver<CollectionChangedData<int>>(); _changes.Subscribe(_observer); _sut.RemoveAt(0); _message = _observer.Messages.Single(); _data = _message.Value.Value; }
void Go(long millisecondsToRun = 0) { var observableRequests = scheduler.CreateHotObservable(requests.ToArray()); var observableMessages = scheduler.CreateHotObservable(messages.ToArray()); var ticksToRun = millisecondsToRun > 0 ? TimeSpan.FromMilliseconds(millisecondsToRun).Ticks : Math.Max(requests.Max(x => (long?) x.Time) ?? 0, messages.Max(x => (long?) x.Time) ?? 0) + bufferTimeout.Ticks // The request needs its timeout before reponding + 100000; // And to give some slack observer = scheduler.Start( () => new Queue(observableRequests, observableMessages, messageTimeout, bufferTimeout, requestTimeout) .Listen(scheduler), ticksToRun); }