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