public void When_Path_Has_Null_Intermediary_Node_Then_Propagates_ProvertyValueChanged_With_HasValue_False()
{
// Arrange
var childOne = new TestObservableObject {Age = 5};
var childTwo = new TestObservableObject {Age = 17};
var obj = new TestObservableObject {ObservableChild = childOne};
var scheduler = new TestScheduler();
var observer = scheduler.CreateObserver<IPropertyValueChanged<int>>();
var expected = new[]
{
OnNext(000, PropertyValueChanged.CreateWithValue(childOne, "Age", childOne.Age)),
OnNext(000, PropertyValueChanged.CreateWithValue(childOne, "Age", 20)),
OnNext(100, PropertyValueChanged.CreateWithoutValue<TestObservableObject, int>(null, "Age")),
OnNext(300, PropertyValueChanged.CreateWithValue(childTwo, "Age", childTwo.Age)),
};
var sut = obj.When(x => x.ObservableChild.Age);
// Act
sut.Subscribe(observer);
obj.ObservableChild.Age = 20;
scheduler.AdvanceTo(100);
obj.ObservableChild = null;
scheduler.AdvanceTo(300);
obj.ObservableChild = childTwo;
// Assert
Assert.AreEqual(expected, observer.Messages);
}
public void AddSource()
{
source.OnNext(0);
source.OnNext(1);
scheduler.AdvanceTo(1000);
target.Is(0, 1);
}
public static void Testing_ExceptionFlow_InjectingControllingSchedulers(Form form, Action <string> notify)
{
var modelMock = new Mock <Model>();
var prices = new ObservableCollection <decimal>();
modelMock.SetupGet(m => m.Prices).Returns(prices);
modelMock.Setup(m => m.GetPriceStream(notify)).Returns(Observable.Never <decimal>());
var uiScheduler = new TestScheduler();
var threadPoolScheduler = new TestScheduler();
modelMock.Object.Show(uiScheduler, threadPoolScheduler, notify);
var halfASecondLater = TimeSpan.FromMilliseconds(500).Ticks;
var twelveSecondsLater = TimeSpan.FromSeconds(12).Ticks;
threadPoolScheduler.AdvanceTo(halfASecondLater);
uiScheduler.AdvanceTo(halfASecondLater);
Assert.That(modelMock.Object.IsConnected, Is.True);
threadPoolScheduler.AdvanceTo(twelveSecondsLater);
uiScheduler.AdvanceTo(twelveSecondsLater);
Assert.That(modelMock.Object.IsConnected, Is.False);
}
public void ThroughputAnalyzerShouldCalculateThroughputCorrectly()
{
// given
var testScheduler = new TestScheduler();
var analysisResultsObserver = testScheduler.CreateObserver <IThroughputAnalysisResult>();
var interval = TimeSpan.FromMilliseconds(1);
var resolution = TimeSpan.FromMilliseconds(10);
using (Observable.Interval(interval, testScheduler).Take(20).AnalyzeThroughput(resolution, scheduler: testScheduler).Subscribe(analysisResultsObserver))
{
analysisResultsObserver.Messages.Count.Should().Be(0);
// when some time has passed
testScheduler.AdvanceTo(resolution + interval);
// then
analysisResultsObserver.Messages.Count.Should().Be(1);
analysisResultsObserver.Messages[0].Value.Value.ElapsedTime.Should().Be(resolution);
analysisResultsObserver.Messages[0].Value.Value.ThroughputPerMillisecond.Should().Be(analysisResultsObserver.Messages[0].Value.Value.Count / analysisResultsObserver.Messages[0].Value.Value.ElapsedTime.TotalMilliseconds);
// when
testScheduler.AdvanceTo(resolution + resolution + interval);
// then
analysisResultsObserver.Messages.Count.Should().Be(3);
analysisResultsObserver.Messages[1].Value.Value.ElapsedTime.Should().Be(resolution);
analysisResultsObserver.Messages[1].Value.Value.ThroughputPerMillisecond.Should().Be(analysisResultsObserver.Messages[1].Value.Value.Count / analysisResultsObserver.Messages[1].Value.Value.ElapsedTime.TotalMilliseconds);
analysisResultsObserver.Messages.Last().Value.Kind.Should().Be(NotificationKind.OnCompleted);
}
}
public void CharBufferUntilTest()
{
var str = "1234aa0000bbaa1111bb4321";
var list = new List <char>();
var ts = new TestScheduler();
var obs = Observable.Create <char>(x =>
{
foreach (var c in str)
{
x.OnNext(c);
}
return(Disposable.Empty);
});
//1
obs
.BufferUntil('a', 'b', 200)
.SelectMany(p => p)
.Subscribe(list.Add);
ts.AdvanceTo(str.Length);
new string(list.ToArray()).Should().Be("aa0000baa1111b");
//2
list.Clear();
obs
.BufferUntil('4', '3', 200)
.Retry()
.SelectMany(p => p)
.Subscribe(list.Add);
ts.AdvanceTo(str.Length);
new string(list.ToArray()).Should().Be("4aa0000bbaa1111bb43");
}
public void ThroughputAnalyzerShouldCalculateThroughputCorrectlyAndForwardSourceSequence()
{
// given
var testScheduler = new TestScheduler();
var sourceSequenceObserver = testScheduler.CreateObserver <long>();
var throughPutAnalysisResultsObserver = testScheduler.CreateObserver <IThroughputAnalysisResult>();
var interval = TimeSpan.FromMilliseconds(1);
var resolution = TimeSpan.FromMilliseconds(10);
using (Observable.Interval(interval, testScheduler).Take(20).AnalyzeThroughputWith(throughPutAnalysisResultsObserver, resolution, testScheduler).Subscribe(sourceSequenceObserver))
{
throughPutAnalysisResultsObserver.Messages.Count.Should().Be(0);
// when some time has passed
testScheduler.AdvanceTo(resolution + interval);
// then
throughPutAnalysisResultsObserver.Messages.Count.Should().Be(1);
throughPutAnalysisResultsObserver.Messages[0].Value.Value.ElapsedTime.Should().Be(resolution);
throughPutAnalysisResultsObserver.Messages[0].Value.Value.ThroughputPerMillisecond.Should().Be(throughPutAnalysisResultsObserver.Messages[0].Value.Value.Count / throughPutAnalysisResultsObserver.Messages[0].Value.Value.ElapsedTime.TotalMilliseconds);
// when
testScheduler.AdvanceTo(resolution + resolution + interval);
// then
throughPutAnalysisResultsObserver.Messages.Count.Should().Be(2);
throughPutAnalysisResultsObserver.Messages[1].Value.Value.ElapsedTime.Should().Be(resolution);
throughPutAnalysisResultsObserver.Messages[1].Value.Value.ThroughputPerMillisecond.Should().Be(throughPutAnalysisResultsObserver.Messages[1].Value.Value.Count / throughPutAnalysisResultsObserver.Messages[1].Value.Value.ElapsedTime.TotalMilliseconds);
}
}
public void When_Path_Has_Null_Intermediary_Node_Then_Skips_When_Invalid_Path()
{
// Arrange
var childOne = new TestObservableObject {Age = 5};
var childTwo = new TestObservableObject {Age = 17};
var obj = new TestObservableObject {ObservableChild = childOne};
var scheduler = new TestScheduler();
var observer = scheduler.CreateObserver<int>();
var expected = new[]
{
OnNext(000, childOne.Age),
OnNext(000, 20),
OnNext(300, childTwo.Age),
};
var sut = obj.WhenValue(x => x.ObservableChild.Age);
// Act
sut.Subscribe(observer);
obj.ObservableChild.Age = 20;
scheduler.AdvanceTo(100);
obj.ObservableChild = null;
scheduler.AdvanceTo(300);
obj.ObservableChild = childTwo;
// Assert
Assert.AreEqual(expected, observer.Messages);
}
public void SimpleDelayWithDrop()
{
var receivedSignals = new List <int>();
var subject = new Subject <int>();
var scheduler = new TestScheduler();
subject.UniqueThrottle(TimeSpan.FromTicks(25), scheduler).Subscribe(x => receivedSignals.Add(x));
subject.OnNext(1);
subject.OnNext(1);
subject.OnNext(1);
receivedSignals.Count.Should().Be(0);
scheduler.AdvanceTo(24);
subject.OnNext(1);
subject.OnNext(1);
subject.OnNext(1);
receivedSignals.Count.Should().Be(0);
scheduler.AdvanceTo(25);
receivedSignals.Count.Should().Be(1);
scheduler.AdvanceTo(50);
subject.OnNext(1);
receivedSignals.Count.Should().Be(1);
scheduler.AdvanceTo(100);
receivedSignals.Count.Should().Be(2);
}
public void When_Subscribed_Then_OnNext_Changes()
{
// Arrange
var obj = new TestObservableObject {ObservableChild = new TestObservableObject {Age = 3}};
var replacementChild = new TestObservableObject {Age = 5};
var scheduler = new TestScheduler();
var observer = scheduler.CreateObserver<TestObservableObject>();
var expected = new[]
{
OnNext(000, obj.ObservableChild),
OnNext(010, replacementChild),
OnNext(010, replacementChild),
OnNext(020, replacementChild),
};
var sut = obj.WhenAny(x => x.ObservableChild).ForProperty<TestObservableObject>("Age", "Name");
// Act
sut.Subscribe(observer);
scheduler.AdvanceTo(10);
obj.ObservableChild = replacementChild;
obj.ObservableChild.Age = 17;
scheduler.AdvanceTo(20);
obj.ObservableChild.Name = "Billy";
// Assert
Assert.AreEqual(expected, observer.Messages);
}
public void ShouldLimitSizeOfBoundCollection()
{
_scheduler.AdvanceTo(2);
_target.Count.Should().Be(2, "Should be 2 item in target collection");
_scheduler.AdvanceTo(3);
_scheduler.AdvanceBy(TimeSpan.FromMilliseconds(1).Ticks); //push time forward as size limit is checked for after the event
_target.Count.Should().Be(2, "Should be 2 item in target collection because of size limit");
}
public void ShouldLimitSizeOfBoundCollection()
{
_scheduler.AdvanceTo(2);
Assert.AreEqual(2, _target.Count, "Should be 2 item in target collection");
_scheduler.AdvanceTo(3);
Assert.AreEqual(2, _target.Count, "Should be 2 item in target collection because of size limit");
var expected = new[] { person2, person3 };
CollectionAssert.AreEquivalent(expected, _target);
}
public void ShouldLimitSizeOfBoundCollection()
{
_scheduler.AdvanceTo(2);
_target.Count.Should().Be(2, "Should be 2 item in target collection");
_scheduler.AdvanceTo(3);
_target.Count.Should().Be(2, "Should be 2 item in target collection because of size limit");
var expected = new[] { _person2, _person3 };
_target.Should().BeEquivalentTo(expected);
}
public void SendNotification_1EventAfter0SecondThen1After3Minutes_Expect1NotificationSentAfter5Minutes()
{
//Arrange
var eventEmitter = new MvvmLightMessenger();
var robot = Substitute.For <IRobot>();
robot.Messenger.Returns(eventEmitter);
var scheduler = new TestScheduler();
var jiraAggregator = new JiraAggregatorSut(robot, scheduler);
var user = new User {
displayName = "Laurent Kempé", name = "laurent"
};
var addCommentEvent1 = new JiraModel
{
issue = new Issue {
key = "LK-10", fields = new Fields {
reporter = user, assignee = user
}
},
webhookEvent = "jira:issue_created",
comment = new CommentDetails(),
user = user
};
var addCommentEvent2 = new JiraModel
{
issue = new Issue {
key = "LK-10", fields = new Fields {
reporter = user, assignee = user
}
},
webhookEvent = "jira:issue_updated",
comment = new CommentDetails(),
user = user
};
//Act
scheduler.Schedule(TimeSpan.FromSeconds(0), () => eventEmitter.Publish("JiraEvent", addCommentEvent1));
scheduler.Schedule(TimeSpan.FromSeconds(120), () => eventEmitter.Publish("JiraEvent", addCommentEvent2));
scheduler.AdvanceTo(TimeSpan.FromSeconds(181).Ticks);
robot.Received(0).SendNotification("", "", "Message", true);
scheduler.AdvanceTo(TimeSpan.FromMinutes(5).Ticks);
//Assert
robot.Received(1).SendNotification(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>(), true);
}
public void CreateDelay_EnsureTestHelperBehavesAsExpected()
{
CreateTimer(10).DoOnCompleted(() => _value = 123).ObserveOn(_scheduler).Subscribe();
AssertValue(0);
_scheduler.AdvanceTo(5);
AssertValue(0);
_scheduler.AdvanceTo(9);
AssertValue(0);
_scheduler.AdvanceBy(10);
AssertValue(123);
}
public void ShouldReturnValueAfterTime()
{
var expected = "FDA";
var scheduler = new TestScheduler();
var obs = Typing(expected, 5, scheduler);
string result = null;
obs.Subscribe(x => result = x);
scheduler.AdvanceTo(TimeSpan.FromSeconds(3).Ticks);
Assert.Equal(null, result);
scheduler.AdvanceTo(TimeSpan.FromSeconds(6).Ticks);
Assert.Equal(expected, result);
}
public void TimeSource100()
{
TestScheduler scheduler = new TestScheduler();
var xs = scheduler.CreateHotObservable(s_testData);
var timeSource = new TimeSource <long>(xs, x => new DateTimeOffset(x, TimeSpan.Zero));
timeSource.StartTime = new DateTimeOffset(100, TimeSpan.Zero);
var counts = from window in timeSource.Window(TimeSpan.FromTicks(5), timeSource.Scheduler)
from Count in window.Count()
select Count;
var list = new List <Timestamped <int> >();
counts
.Timestamp(timeSource.Scheduler)
.Subscribe(ts => list.Add(ts));
timeSource.Connect();
scheduler.AdvanceTo(120);
Assert.AreEqual(4, list.Count);
list.AssertEqual(
Result(105, 2),
Result(110, 3),
Result(115, 0),
Result(115, 1));
}
public void SelectDisposableShouldWork()
{
var scheduler = new TestScheduler();
var disposables = new List<BooleanDisposable>();
var list = new CompositeDisposable();
scheduler.CreateColdObservable(
new Recorded<Notification<long>>(100, Notification.CreateOnNext(0L)),
new Recorded<Notification<long>>(200, Notification.CreateOnNext(1L)),
new Recorded<Notification<long>>(300, Notification.CreateOnNext(2L)),
new Recorded<Notification<long>>(400, Notification.CreateOnNext(3L)),
new Recorded<Notification<long>>(400, Notification.CreateOnCompleted<long>())
)
.SelectDisposable(list, i => {
var d = new BooleanDisposable();
disposables.Add(d);
return d;
}, (i, _) => i)
.Subscribe()
.DisposeWith(list);
scheduler.AdvanceTo(300);
disposables.Count.Should().Be(3);
disposables.Select(d => d.IsDisposed).Should().NotContain(true);
list.Dispose();
disposables.Select(d => d.IsDisposed).Should().NotContain(false);
}
public void TimerTestStart2()
{
var testScheduler = new TestScheduler();
var recorder = testScheduler.CreateObserver<long>();
var timer = new ReactiveTimer(TimeSpan.FromSeconds(1), testScheduler);
timer.Subscribe(recorder);
timer.Start();
testScheduler.AdvanceTo(TimeSpan.FromSeconds(3).Ticks + 1);
recorder.Messages.Is(
OnNext(TimeSpan.FromSeconds(0).Ticks + 1, 0L),
OnNext(TimeSpan.FromSeconds(1).Ticks + 1, 1L),
OnNext(TimeSpan.FromSeconds(2).Ticks + 1, 2L),
OnNext(TimeSpan.FromSeconds(3).Ticks + 1, 3L));
timer.Stop();
recorder.Messages.Clear();
testScheduler.AdvanceBy(TimeSpan.FromSeconds(5).Ticks);
recorder.Messages.Count.Is(0);
}
public void TimeAutoStart()
{
TestScheduler scheduler = new TestScheduler();
var xs = scheduler.CreateHotObservable(s_testData);
var timeSource = new TimeSource <long>(xs, x => new DateTimeOffset(x, TimeSpan.Zero));
// Note: no start time specified, result should be the same as 101
var counts = from window in timeSource.Window(TimeSpan.FromTicks(5), timeSource.Scheduler)
from Count in window.Count()
select Count;
var list = new List <Timestamped <int> >();
counts
.Timestamp(timeSource.Scheduler)
.Subscribe(ts => list.Add(ts));
timeSource.Connect();
scheduler.AdvanceTo(120);
Assert.AreEqual(3, list.Count);
list.AssertEqual(
Result(106, 2),
Result(111, 3),
Result(115, 1));
}
public async Task LastCheckTimeHasToBeCorrect()
{
// Arrange
var testScheduler = new TestScheduler();
var startTime = DateTime.Parse("2017-08-13T11:10:00Z").ToUniversalTime();
testScheduler.AdvanceTo(startTime.Ticks);
mMockHttpGet.Version = 10001;
mMockHttpGet.Rules = new Dictionary <string, RuleDefinition> {
{ "test_rule", new RuleDefinition() }
};
mDriver = TweekManagementRulesDriver.StartNew(
mMockHttpGet.HttpGet,
new TweekManagementRulesDriverSettings {
SampleIntervalInMs = (int)TimeSpan.FromHours(0.9).TotalMilliseconds
},
null,
null,
testScheduler
);
// Act
testScheduler.AdvanceBy(TimeSpan.FromHours(1).Ticks);
await Task.Delay(10);
var result = await mDriver.GetAllRules();
// Assert
Assert.Equal("10001", mDriver.CurrentLabel);
Assert.Equal("test_rule", result.Keys.First());
Assert.Equal(startTime.Hour + 1, mDriver.LastCheckTime.Hour);
}
public void CancelTest()
{
var testScheduler = new TestScheduler();
var recorder = testScheduler.CreateObserver <int>();
var notifier = new ScheduledNotifier <int>(testScheduler);
notifier.Subscribe(recorder);
var noCancel1 = notifier.Report(10, TimeSpan.FromMinutes(1));
var cancel1 = notifier.Report(20, TimeSpan.FromMinutes(3));
cancel1.Dispose();
recorder.Messages.Count.Is(0);
testScheduler.AdvanceBy(TimeSpan.FromMinutes(5).Ticks);
recorder.Messages.Count.Is(1);
recorder.Messages[0].Is(OnNext(TimeSpan.FromMinutes(1).Ticks, 10));
var lastTime = recorder.Messages.Last().Time;
recorder.Messages.Clear();
var origin = new DateTimeOffset(1999, 1, 1, 1, 1, 1, TimeSpan.Zero);
var noCancel2 = notifier.Report(30, origin.AddMinutes(1));
var cancel2 = notifier.Report(40, origin.AddMinutes(3));
cancel2.Dispose();
testScheduler.AdvanceTo(origin.AddMinutes(5).Ticks);
recorder.Messages.Is(
OnNext(origin.AddMinutes(1).Ticks, 30));
}
public void TestFakeRunEveryHour()
{
// ARRANGE
FakeMockableAppImplementation app = new(Object);
app.Initialize();
// ACT
TestScheduler.AdvanceBy(TimeSpan.FromHours(1).Ticks);
var now = TestScheduler.Now;
var timeOfDayToTrigger = new DateTime(
now.Year,
now.Month,
now.Day,
2,
0,
0
);
TestScheduler.AdvanceTo(timeOfDayToTrigger.Ticks);
// ASSERT
VerifyEntityTurnOn("binary_sensor.fake_run_every_hour_happened", times: Times.Exactly(2));
}
public void AllExeptionsAreLogged()
{
// ARRANGE
var testScheduler = new TestScheduler();
var loggerMock = new Mock <ILogger <NetDaemonScheduler> >();
// sets the date to a specific time so we do not get errors in UTC
var dueTime = new DateTime(2021, 1, 1, 0, 0, 0);
testScheduler.AdvanceTo(dueTime.Ticks);
var netDaemonScheduler = new DisposableScheduler(testScheduler).WrapWithLogger(loggerMock.Object);
netDaemonScheduler.ScheduleCron("* * * * *", () => throw new Exception("hello"));
// ACT and ASSERT
testScheduler.AdvanceBy(TimeSpan.FromMinutes(5).Ticks);
// ASSERT that error is logged once
loggerMock.Verify(
x => x.Log(
LogLevel.Error,
It.IsAny <EventId>(),
It.Is <It.IsAnyType>((_, __) => true),
It.IsAny <Exception>(),
It.Is <Func <It.IsAnyType, Exception, string> >((_, _) => true)), Times.Exactly(5));
}
public void BufferLiveUntilHistoryCompletes()
{
var ts = new TestScheduler();
var history = ts.CreateColdObservable(
OnNext <ICacheNotification>(3, new DummyNotification {
EventId = 1
}),
OnCompleted <ICacheNotification>(5));
var live = ts.CreateHotObservable(
OnNext <ICacheNotification>(4, new DummyNotification {
EventId = 2
}));
var observer = ts.CreateObserver <ICacheNotification>();
history.Combine(live).Subscribe(observer);
ts.AdvanceTo(20);
ReactiveAssert.AreElementsEqual(
new[]
{
OnNext <ICacheNotification>(5, n => n.EventId == 1),
OnNext <ICacheNotification>(5, n => n.EventId == 2)
},
observer.Messages);
}
public void HistoryMultipleValues()
{
var ts = new TestScheduler();
var history = ts.CreateColdObservable(
OnNext <ICacheNotification>(1, new DummyNotification {
EventId = 1
}),
OnNext <ICacheNotification>(4, new DummyNotification {
EventId = 2
}),
OnNext <ICacheNotification>(9, new DummyNotification {
EventId = 3
}),
OnCompleted <ICacheNotification>(10));
var observer = ts.CreateObserver <ICacheNotification>();
history.Combine(Observable.Never <ICacheNotification>()).Subscribe(observer);
ts.AdvanceTo(20);
ReactiveAssert.AreElementsEqual(
new[]
{
OnNext <ICacheNotification>(10, n => n.EventId == 1),
OnNext <ICacheNotification>(10, n => n.EventId == 2),
OnNext <ICacheNotification>(10, n => n.EventId == 3)
},
observer.Messages);
}
public void ScheduleTask_Should_Call_Sample_On_Scheduler()
{
// Arrange
const int count = 5;
var scheduler = new TestScheduler();
var settings = new TaskSchedulerSettings
{
RequestDelay = TimeSpan.FromMilliseconds(250)
};
ITaskScheduler taskScheduler = new DelayTaskScheduler(settings, scheduler);
// Act
var tasks = Enumerable.Range(0, count + 1)
.Select(i => Task.Run(() => Task.FromResult(i)))
.Select(t => taskScheduler.ScheduleTask(() => t))
.ToArray();
scheduler.AdvanceTo(settings.RequestDelay.Ticks * count);
// Assert
tasks.Count(t => t.IsCompleted).Should().Be(count);
taskScheduler.Dispose();
}
public void UpToMaxEventsAreBuffered()
{
TimeSpan maxInterval = TimeSpan.FromTicks(200);
const int maxBufferSize = 2;
var scheduler = new TestScheduler();
var source = scheduler.CreateColdObservable(
OnNext(100, 1),
OnNext(200, 2),
OnNext(300, 3));
IList <int>[] expectedBuffers =
{
new[] { 1, 2 },
new[] { 3 }
};
var expectedTimes = new[]
{
200, /* Buffer cap reached */
maxInterval.Ticks + 300
};
var results = scheduler.CreateObserver <IList <int> >();
source.BufferNearEvents(maxInterval, maxBufferSize, scheduler)
.Subscribe(results);
scheduler.AdvanceTo(10000);
results.Messages.AssertEqual(
OnNext <IList <int> >(expectedTimes[0], buffer => CheckBuffer(expectedBuffers[0], buffer)),
OnNext <IList <int> >(expectedTimes[1], buffer => CheckBuffer(expectedBuffers[1], buffer)));
}
public void SendNotification_4SuccessfulAnd1FailedForSameBuildEventSent_ExpectFailedNotificationSentWithCorrectMessage()
{
//Arrange
var eventEmitter = new MvvmLightMessenger();
var robot = Substitute.For <IRobot>();
robot.EventEmitter.Returns(eventEmitter);
var scheduler = new TestScheduler();
var teamCityAggregator = new TeamCityAggregatorSut(robot, scheduler);
var successfulTeamCityBuildModel = new TeamCityModel {
build = new Build {
buildNumber = "10", buildResult = "success"
}
};
var failedTeamCityBuildModel = new TeamCityModel {
build = new Build {
buildNumber = "10", buildResult = "failed"
}
};
//Act
scheduler.Schedule(TimeSpan.FromMinutes(1), () => eventEmitter.Emit("TeamCityBuild", successfulTeamCityBuildModel));
scheduler.Schedule(TimeSpan.FromMinutes(1), () => eventEmitter.Emit("TeamCityBuild", successfulTeamCityBuildModel));
scheduler.Schedule(TimeSpan.FromMinutes(2), () => eventEmitter.Emit("TeamCityBuild", successfulTeamCityBuildModel));
scheduler.Schedule(TimeSpan.FromMinutes(3), () => eventEmitter.Emit("TeamCityBuild", failedTeamCityBuildModel));
scheduler.Schedule(TimeSpan.FromMinutes(4), () => eventEmitter.Emit("TeamCityBuild", successfulTeamCityBuildModel));
scheduler.AdvanceTo(TimeSpan.FromMinutes(5).Ticks);
//Assert
robot.Received(1).SendNotification(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>(), true);
}
public void TimeSource101()
{
TestScheduler scheduler = new TestScheduler();
var xs = scheduler.CreateHotObservable(s_testData);
var timeSource = new TimeSource<long>(xs, x => new DateTimeOffset(x, TimeSpan.Zero));
timeSource.StartTime = new DateTimeOffset(101, TimeSpan.Zero);
var counts = from window in timeSource.Window(TimeSpan.FromTicks(5), timeSource.Scheduler)
from Count in window.Count()
select Count;
var list = new List<Timestamped<int>>();
counts
.Timestamp(timeSource.Scheduler)
.Subscribe(ts => list.Add(ts));
timeSource.Connect();
scheduler.AdvanceTo(120);
Assert.AreEqual(3, list.Count);
list.AssertEqual(
Result(106, 2),
Result(111, 3),
Result(115, 1));
}
public void ObservePropertyException()
{
var testScheduler = new TestScheduler();
var recorder = testScheduler.CreateObserver <string>();
var commonEx = new Exception();
var m = new Model()
{
Name = "aaa"
};
m.ObserveProperty(x => x.Name)
.Do(x => recorder.OnNext(x))
.Do(_ => { throw commonEx; })
.OnErrorRetry((Exception e) => recorder.OnError(e))
.Subscribe();
testScheduler.AdvanceTo(1000);
m.Name = "bbb";
recorder.Messages.Is(
OnNext(0, "aaa"),
OnError <string>(0, commonEx),
OnNext(1000, "bbb"),
OnError <string>(1000, commonEx));
}
public void SelectDisposableShouldWork()
{
var scheduler = new TestScheduler();
var disposables = new List <BooleanDisposable>();
var list = new CompositeDisposable();
scheduler.CreateColdObservable(
new Recorded <Notification <long> >(100, Notification.CreateOnNext(0L)),
new Recorded <Notification <long> >(200, Notification.CreateOnNext(1L)),
new Recorded <Notification <long> >(300, Notification.CreateOnNext(2L)),
new Recorded <Notification <long> >(400, Notification.CreateOnNext(3L)),
new Recorded <Notification <long> >(400, Notification.CreateOnCompleted <long>())
)
.SelectDisposable(list, i => {
var d = new BooleanDisposable();
disposables.Add(d);
return(d);
}, (i, _) => i)
.Subscribe()
.DisposeWith(list);
scheduler.AdvanceTo(300);
disposables.Count.Should().Be(3);
disposables.Select(d => d.IsDisposed).Should().NotContain(true);
list.Dispose();
disposables.Select(d => d.IsDisposed).Should().NotContain(false);
}
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 void SetUp()
{
_diagnosticsViewModel = new Mock <IDiagnosticsViewModel>();
_data = new Subject <IEnumerable <DynamicData> >();
_tabularDataService = new Mock <ITabularDataService>();
_tabularDataService.Setup(x => x.GetAsync())
.Returns(_data);
_columnsChanged = new Subject <string>();
_columnsInitialised = new Subject <string>();
_columnsService = new Mock <IColumnsService>();
_columnsService.Setup(x => x.Changed)
.Returns(_columnsChanged);
_columnsService.Setup(x => x.Initialised)
.Returns(_columnsInitialised);
_columnsService.Setup(x => x.InitialiseColumns(It.IsAny <string>(), It.IsAny <IEnumerable <string> >()))
.Callback <string, IEnumerable <string> >((y, z) =>
{
_columnsService.Setup(x => x.VisibleColumns(It.IsAny <string>()))
.Returns(z);
});
_overlayService = new Mock <IOverlayService>();
_dateTimeService = new MockDateTimeService(TestScheduler);
TestScheduler.AdvanceTo(DateTime.Now.Ticks);
}
public void TimerTestStart2()
{
var testScheduler = new TestScheduler();
var recorder = testScheduler.CreateObserver <long>();
var timer = new ReactiveTimer(TimeSpan.FromSeconds(1), testScheduler);
timer.Subscribe(recorder);
timer.Start();
testScheduler.AdvanceTo(TimeSpan.FromSeconds(3).Ticks + 1);
recorder.Messages.Is(
OnNext(TimeSpan.FromSeconds(0).Ticks + 1, 0L),
OnNext(TimeSpan.FromSeconds(1).Ticks + 1, 1L),
OnNext(TimeSpan.FromSeconds(2).Ticks + 1, 2L),
OnNext(TimeSpan.FromSeconds(3).Ticks + 1, 3L));
timer.Stop();
recorder.Messages.Clear();
testScheduler.AdvanceBy(TimeSpan.FromSeconds(5).Ticks);
recorder.Messages.Count.Is(0);
}
static void TestSchedulerEx()
{
var scheduler = new TestScheduler();
scheduler.Schedule(() => Console.WriteLine("A")); //Schedule immediately
scheduler.Schedule(TimeSpan.FromTicks(10), () => Console.WriteLine("B"));
scheduler.Schedule(TimeSpan.FromTicks(20), () => Console.WriteLine("C"));
Console.WriteLine("scheduler.AdvanceTo(1);");
scheduler.AdvanceTo(1);
Console.WriteLine("scheduler.AdvanceTo(10);");
scheduler.AdvanceTo(10);
Console.WriteLine("scheduler.AdvanceTo(15);");
scheduler.AdvanceTo(15);
Console.WriteLine("scheduler.AdvanceTo(20);");
scheduler.AdvanceTo(20);
}
public async Task WorksIfProviderHasMultipleSuggestions()
{
var scheduler = new TestScheduler();
var provider = Substitute.For <ISuggestionProvider>();
var suggestions = new[]
{
createSuggestion("te1"),
createSuggestion("te2"),
createSuggestion("te3")
};
var observableContent = suggestions
.Select(suggestion => createRecorded(1, suggestion))
.ToArray();
var observable = scheduler
.CreateColdObservable(observableContent);
provider.GetSuggestions().Returns(observable);
var container = new SuggestionProviderContainer(provider);
var viewmodel = new SuggestionsViewModel(container);
await viewmodel.Initialize();
scheduler.AdvanceTo(1);
viewmodel.Suggestions.Should().HaveCount(suggestions.Length)
.And.Contain(suggestions);
}
public void B1E1ParsePackageTest()
{
var ts = new TestScheduler();
var source = new byte[]
{
0, 0, 11, 23, 12,
254, 0, 255,
254, 1, 1, 255,
22,
254, 2, 2, 2, 255, 33, 5, 0
};
var rst = new List <byte[]>();
source.ToObservable(ts)
.ParsePackage <byte>(254, 255)
.Subscribe(p => rst.Add(p));
ts.AdvanceTo(source.Length);
var expect = new List <byte[]>
{
new byte[] { 0 },
new byte[] { 1, 1 },
new byte[] { 2, 2, 2 }
};
rst.Should().BeEquivalentTo(expect);
}
public void SetUp()
{
testScheduler = new TestScheduler();
testScheduler.AdvanceTo(DateTimeOffset.UtcNow.Ticks);
nodes = TestNode.CreateCluster(scheduler: testScheduler);
nodes.Start();
leader = nodes.WaitForLeader(testScheduler).Result;
}
public void Clock()
{
var scheduler = new TestScheduler ();
Assert.AreEqual (0, scheduler.Clock, "#1"); // default
scheduler.AdvanceBy (TimeSpan.FromDays (1).Ticks);
Assert.AreEqual (TimeSpan.FromDays (1).Ticks, scheduler.Clock, "#2");
var dt = new DateTimeOffset (2012, 1, 1, 0, 0, 0, TimeSpan.Zero);
scheduler.AdvanceTo (dt.Ticks);
Assert.AreEqual (dt, new DateTimeOffset (scheduler.Clock, TimeSpan.Zero), "#3");
}
public void elections_are_ran_shortly_after_node_startup()
{
var testScheduler = new TestScheduler();
testScheduler.AdvanceTo(DateTimeOffset.UtcNow.Ticks);
var nodes = TestNode.CreateCluster(scheduler: testScheduler);
nodes.Start();
testScheduler.AdvanceBy(TestNode.ElectionTimeout.Ticks);
nodes.Should().ContainSingle(n => n.State == State.Leader || n.State == State.Candidate);
}
public void SetUp()
{
testScheduler = new TestScheduler();
testScheduler.AdvanceTo(DateTimeOffset.UtcNow.Ticks);
nodes = TestNode.CreateCluster(scheduler: testScheduler);
nodes.Start();
leader = nodes.WaitForLeader(testScheduler).Result;
darkNode = nodes.First(n => n != leader) as TestNode;
darkNode.SleepOnAppendEntries = true;
}
public void SimpleDelay()
{
var receivedSignals = new List<int>();
var subject = new Subject<int>();
var scheduler = new TestScheduler();
subject.UniqueThrottle(TimeSpan.FromTicks(25), scheduler).Subscribe(x => receivedSignals.Add(x));
subject.OnNext(1);
receivedSignals.Count.Should().Be(0);
scheduler.AdvanceTo(24);
receivedSignals.Count.Should().Be(0);
scheduler.AdvanceTo(25);
receivedSignals.Count.Should().Be(1);
scheduler.AdvanceTo(100);
receivedSignals.Count.Should().Be(1);
}
public void AsyncGetTest()
{
var input = new[] { 1, 1, 1, 1, 1 };
var sched = new TestScheduler();
var delay = TimeSpan.FromSeconds(1.0);
var fixture = new ObservableAsyncMRUCache<int, int>(x => Observable.Return(x*5).Delay(delay, sched), 5, 2, null, sched);
int result = 0;
input.ToObservable(sched).SelectMany<int, int>(x => (IObservable<int>)fixture.AsyncGet(x)).Subscribe(x => result += x);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(500)));
Assert.Equal(0, result);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1200)));
Assert.Equal(25, result);
sched.Start();
Assert.Equal(25, result);
}
public void SendNotification_1EventAfter0SecondThen1After3Minutes_Expect1NotificationSentAfter5Minutes()
{
//Arrange
var eventEmitter = new MvvmLightMessenger();
var robot = Substitute.For<IRobot>();
robot.EventEmitter.Returns(eventEmitter);
var scheduler = new TestScheduler();
var jiraAggregator = new JiraAggregatorSut(robot, scheduler);
var user = new User { displayName = "Laurent Kempé", name = "laurent" };
var addCommentEvent1 = new JiraModel
{
issue = new Issue { key = "LK-10", fields = new Fields { reporter = user, assignee = user } },
webhookEvent = "jira:issue_created",
comment = new CommentDetails(),
user = user
};
var addCommentEvent2 = new JiraModel
{
issue = new Issue { key = "LK-10", fields = new Fields { reporter = user, assignee = user } },
webhookEvent = "jira:issue_updated",
comment = new CommentDetails(),
user = user
};
//Act
scheduler.Schedule(TimeSpan.FromSeconds(0), () => eventEmitter.Emit("JiraEvent", addCommentEvent1));
scheduler.Schedule(TimeSpan.FromSeconds(120), () => eventEmitter.Emit("JiraEvent", addCommentEvent2));
scheduler.AdvanceTo(TimeSpan.FromSeconds(181).Ticks);
robot.Received(0).SendNotification("", "", "Message", true);
scheduler.AdvanceTo(TimeSpan.FromMinutes(5).Ticks);
//Assert
robot.Received(1).SendNotification(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), true);
}
public void EnsureCacheDoesNotBlockOnRelease()
{
var input = new[] { 1, 2 };
var sched = new TestScheduler();
var releaseCount = 0;
var delay = TimeSpan.FromSeconds(1.0);
//set the cache to only hold one value, which forces an eviction of an inflight request from the inner cache
var fixture = new ObservableAsyncMRUCache<int, int>(x => Observable.Return(x * 5).Delay(delay, sched), 1, 2, x=>releaseCount+=1, sched);
int result = 0;
input.ToObservable(sched).SelectMany<int, int>(x => (IObservable<int>)fixture.AsyncGet(x)).Subscribe(x => result += x);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1000)));
Assert.Equal(0,releaseCount);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1001)));
Assert.Equal(1, releaseCount);
}
public void SequenceValueIs8After8SimulatedSeconds()
{
var scheduler = new TestScheduler();
var seq = new MonotonicTick(scheduler);
int value = 0;
seq.Ticker.Subscribe(x => value = x);
scheduler.AdvanceTo(8500 * TimeSpan.TicksPerMillisecond);
Assert.Equal(8, value);
}
public void ObservePropertyFalse()
{
var testScheduler = new TestScheduler();
var recorder = testScheduler.CreateObserver<string>();
var m = new Model() { Name = "aaa" };
m.ObserveProperty(x => x.Name, false).Subscribe(recorder);
testScheduler.AdvanceTo(1000);
m.Name = "bbb";
recorder.Messages.Is(
OnNext(1000, "bbb"));
}
public void CacheShouldQueueOnceWeHitOurConcurrentLimit()
{
var input = new[] { 1, 2, 3, 4, 1 };
var sched = new TestScheduler();
var delay = TimeSpan.FromSeconds(1.0);
var fixture = new ObservableAsyncMRUCache<int, int>(x => Observable.Return(x*5).Delay(delay, sched), 5, 2, null, sched);
int result = 0;
input.ToObservable(sched).SelectMany<int, int>(x => (IObservable<int>)fixture.AsyncGet(x)).Subscribe(x => result += x);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(500)));
Assert.Equal(0, result);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1500)));
Assert.Equal(1*5 + 2*5 + 1*5, result);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(2500)));
Assert.Equal(1*5 + 2*5 + 3*5 + 4*5 + 1*5, result);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(5000)));
Assert.Equal(1*5 + 2*5 + 3*5 + 4*5 + 1*5, result);
}
public void When_Completed_Task_ToRex_Then_Projects_Results_Into_Rex()
{
// Arrange
var scheduler = new TestScheduler();
var observer = scheduler.CreateObserver<Rex<int>>();
// Act
scheduler.AdvanceTo(10);
TaskEx.FromResult(10).ToRex().Subscribe(observer);
scheduler.Start();
// Assert
observer.Messages.AssertEqual(
OnNext(10, Rex.Result(10)),
OnCompleted<Rex<int>>(10)
);
}
public void AcceptAsync_Success()
{
var sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var scheduler = new TestScheduler();
MAsyncSocketExtensions.AcceptAsObservableSocketEndPoint =
(t1, t2) => scheduler.CreateHotObservable(OnNext(10, sock));
var observer = scheduler.CreateObserver<Socket>();
var client = new TcpRosListener(0);
var result = client.AcceptAsync().Subscribe(observer);
scheduler.AdvanceTo(10);
observer.Messages.Is(OnNext(10, sock));
}
public void When_Subscribe_Via_Interface_To_Poco_Source_Then_OnNext_Initial_Value_Only()
{
// Arrange
var obj = new TestPoco {Age = 3} as ITestObject;
var scheduler = new TestScheduler();
var observer = scheduler.CreateObserver<IPropertyValueChanged<int>>();
var expected = new[]
{
OnNext(000, PropertyValueChanged.CreateWithValue(obj, "Age", 3)),
};
var sut = obj.When(x => x.Age);
// Act
sut.Subscribe(observer);
scheduler.AdvanceTo(10);
obj.Age = 5;
// Assert
Assert.AreEqual(expected, observer.Messages);
}
public void TimerTest1()
{
var testScheduler = new TestScheduler();
var recorder = testScheduler.CreateObserver<long>();
var timer = new ReactiveTimer(TimeSpan.FromSeconds(1), testScheduler);
timer.Subscribe(recorder);
timer.Start(TimeSpan.FromSeconds(10));
testScheduler.AdvanceTo(TimeSpan.FromSeconds(13).Ticks);
recorder.Messages.Is(
OnNext(TimeSpan.FromSeconds(10).Ticks, 0L),
OnNext(TimeSpan.FromSeconds(11).Ticks, 1L),
OnNext(TimeSpan.FromSeconds(12).Ticks, 2L),
OnNext(TimeSpan.FromSeconds(13).Ticks, 3L));
recorder.Messages.Clear();
timer.Stop();
testScheduler.AdvanceBy(TimeSpan.FromSeconds(5).Ticks);
recorder.Messages.Count.Is(0);
timer.Start();
var reStartClock = testScheduler.Clock + 1;
testScheduler.AdvanceBy(TimeSpan.FromSeconds(3).Ticks + 1);
recorder.Messages.Is(
OnNext(reStartClock, 4L),
OnNext(reStartClock + TimeSpan.FromSeconds(1).Ticks, 5L),
OnNext(reStartClock + TimeSpan.FromSeconds(2).Ticks, 6L),
OnNext(reStartClock + TimeSpan.FromSeconds(3).Ticks, 7L));
recorder.Messages.Clear();
timer.Reset();
testScheduler.AdvanceBy(TimeSpan.FromSeconds(5).Ticks);
recorder.Messages.Count.Is(0);
timer.Dispose();
recorder.Messages.Is(OnCompleted<long>(testScheduler.Clock));
timer.Dispose(); // dispose again
}
public void ObservePropertyException()
{
var testScheduler = new TestScheduler();
var recorder = testScheduler.CreateObserver<string>();
var commonEx = new Exception();
var m = new Model() { Name = "aaa" };
m.ObserveProperty(x => x.Name)
.Do(x => recorder.OnNext(x))
.Do(_ => { throw commonEx; })
.OnErrorRetry((Exception e) => recorder.OnError(e))
.Subscribe();
testScheduler.AdvanceTo(1000);
m.Name = "bbb";
recorder.Messages.Is(
OnNext(0, "aaa"),
OnError<string>(0, commonEx),
OnNext(1000, "bbb"),
OnError<string>(1000, commonEx));
}
public void CacheShouldEatExceptionsAndMarshalThemToObservable()
{
/* This is a bit tricky:
*
* 5,2 complete at t=1000 simultaneously
* 10,0 get queued up, 0 fails immediately (delay() doesn't delay the OnError),
* so 10 completes at t=2000
* The 7 completes at t=3000
*/
var input = new[] { 5, 2, 10, 0/*boom!*/, 7 };
var sched = new TestScheduler();
Observable.Throw<int>(new Exception("Foo")).Subscribe(x => {
Console.WriteLine(x);
}, ex => {
Console.WriteLine(ex);
}, () => {
Console.WriteLine("Completed");
});
var delay = TimeSpan.FromSeconds(1.0);
var fixture = new ObservableAsyncMRUCache<int, int>(x =>
(x == 0 ? Observable.Throw<int>(new Exception("Boom!")) : Observable.Return(10 * x)).Delay(delay, sched), 5, 2, null, sched);
Exception exception = null;
int completed = 0;
input.ToObservable()
.SelectMany(x => fixture.AsyncGet(x))
.Subscribe(x => {
this.Log().InfoFormat("Result = {0}", x);
completed++;
}, ex => exception = exception ?? ex);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(500)));
Assert.Null(exception);
Assert.Equal(0, completed);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1500)));
Assert.NotNull(exception);
Assert.Equal(2, completed);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(7500)));
Assert.NotNull(exception);
Assert.Equal(4, completed);
this.Log().Info(exception);
}
public void When_Subscribe_Then_Returns_Default_Value_At_Time_Of_Subscribe_And_Subsequent_Values()
{
// Arrange
var obj = new TestObservableObject() {Age = 2};
var scheduler = new TestScheduler();
var observer = scheduler.CreateObserver<IPropertyChanged<TestObservableObject>>();
var expected = new[]
{
OnNext(00, PropertyChanged.Create(obj)),
OnNext(20, PropertyChanged.Create(obj, "Age")),
OnNext(30, PropertyChanged.Create(obj, "Age")),
OnNext(40, PropertyChanged.Create(obj, "Name")),
};
var sut = new NotifyPropertyChangedObservable<TestObservableObject>(obj.ToPropertyValueChangedObservable());
// Act
sut.Subscribe(observer);
scheduler.AdvanceTo(20);
obj.Age = 3;
scheduler.AdvanceTo(30);
obj.Age = 7;
scheduler.AdvanceTo(40);
obj.Name = "Fi";
// Assert
Assert.AreEqual(expected, observer.Messages);
}
public void When_Subscribe_Twice_Then_Correct_Notifications_For_Both_Observers()
{
// Arrange
var obj = new TestObservableObject {Age = 3};
var scheduler = new TestScheduler();
var firstObserver = scheduler.CreateObserver<IPropertyChanged<TestObservableObject>>();
var secondObserver = scheduler.CreateObserver<IPropertyChanged<TestObservableObject>>();
var firstObservserExpected = new[]
{
OnNext(0, PropertyChanged.Create(obj)),
OnNext(0, PropertyChanged.Create(obj, "Age")),
OnNext(20, PropertyChanged.Create(obj, "Age")),
OnNext(50, PropertyChanged.Create(obj, "Age")),
};
var secondObservserExpected = new[]
{
OnNext(50, PropertyChanged.Create(obj)),
OnNext(50, PropertyChanged.Create(obj, "Age")),
};
var sut = new NotifyPropertyChangedObservable<TestObservableObject>(obj.ToPropertyValueChangedObservable());
// Act
sut.Subscribe(firstObserver);
obj.Age = 5;
scheduler.AdvanceTo(20);
obj.Age = 6;
scheduler.AdvanceTo(50);
sut.Subscribe(secondObserver);
obj.Age = 7;
// Assert
Assert.AreEqual(firstObservserExpected, firstObserver.Messages);
Assert.AreEqual(secondObservserExpected, secondObserver.Messages);
}
public void SendNotification_4SuccessfulAnd1FailedForSameBuildEventSent_ExpectFailedNotificationSentWithCorrectMessage()
{
//Arrange
var eventEmitter = new MvvmLightMessenger();
var robot = Substitute.For<IRobot>();
robot.EventEmitter.Returns(eventEmitter);
var scheduler = new TestScheduler();
var teamCityAggregator = new TeamCityAggregatorSut(robot, scheduler);
var successfulTeamCityBuildModel = new TeamCityModel { build = new Build { buildNumber = "10", buildResult = "success" } };
var failedTeamCityBuildModel = new TeamCityModel { build = new Build { buildNumber = "10", buildResult = "failed" } };
//Act
scheduler.Schedule(TimeSpan.FromMinutes(1), () => eventEmitter.Emit("TeamCityBuild", successfulTeamCityBuildModel));
scheduler.Schedule(TimeSpan.FromMinutes(1), () => eventEmitter.Emit("TeamCityBuild", successfulTeamCityBuildModel));
scheduler.Schedule(TimeSpan.FromMinutes(2), () => eventEmitter.Emit("TeamCityBuild", successfulTeamCityBuildModel));
scheduler.Schedule(TimeSpan.FromMinutes(3), () => eventEmitter.Emit("TeamCityBuild", failedTeamCityBuildModel));
scheduler.Schedule(TimeSpan.FromMinutes(4), () => eventEmitter.Emit("TeamCityBuild", successfulTeamCityBuildModel));
scheduler.AdvanceTo(TimeSpan.FromMinutes(5).Ticks);
//Assert
robot.Received(1).SendNotification(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), true);
}
public void when_user_login_fails_too_fast_then_locks_account ()
{
var seconds = TimeSpan.FromSeconds(1).Ticks;
var events = new EventStream();
// Here we use the test scheduler to simulate time passing by
// because we have a dependency on time because of the Buffer
// method.
var scheduler = new TestScheduler();
var observable = scheduler.CreateColdObservable(
// Two users attempt to log in, 4 times in a row
new Recorded<Notification<LoginFailure>>(10 * seconds, Notification.CreateOnNext(new LoginFailure { UserId = 1 })),
new Recorded<Notification<LoginFailure>>(10 * seconds, Notification.CreateOnNext(new LoginFailure { UserId = 2 })),
new Recorded<Notification<LoginFailure>>(20 * seconds, Notification.CreateOnNext(new LoginFailure { UserId = 1 })),
new Recorded<Notification<LoginFailure>>(20 * seconds, Notification.CreateOnNext(new LoginFailure { UserId = 2 })),
new Recorded<Notification<LoginFailure>>(30 * seconds, Notification.CreateOnNext(new LoginFailure { UserId = 1 })),
new Recorded<Notification<LoginFailure>>(30 * seconds, Notification.CreateOnNext(new LoginFailure { UserId = 2 })),
new Recorded<Notification<LoginFailure>>(40 * seconds, Notification.CreateOnNext(new LoginFailure { UserId = 1 })),
new Recorded<Notification<LoginFailure>>(40 * seconds, Notification.CreateOnNext(new LoginFailure { UserId = 2 })),
// User 2 attempts one more time within the 1' window
new Recorded<Notification<LoginFailure>>(45 * seconds, Notification.CreateOnNext(new LoginFailure { UserId = 2 })),
// User 1 pulls out the paper where he wrote his pwd ;), so he takes longer
new Recorded<Notification<LoginFailure>>(75 * seconds, Notification.CreateOnNext(new LoginFailure { UserId = 1 }))
);
// This subscription bridges the scheduler-driven
// observable with our event stream, causing us
// to publish events as they are "raised" by the
// test scheduler.
observable.Subscribe (failure => events.Push (failure));
var query = events.Of<LoginFailure>()
// Sliding windows 1' long, every 10''
.Buffer(TimeSpan.FromMinutes(1), TimeSpan.FromSeconds(10), scheduler)
// From all failure values
.SelectMany(failures => failures
// Group the failures by user
.GroupBy(failure => failure.UserId)
// Only grab those failures with more than 5 in the 1' window
.Where(group => group.Count() >= 5)
// Return the user id that failed to log in
.Select(group => group.Key));
var blocked = new List<int>();
using (var subscription = query.Subscribe (userId => blocked.Add (userId))) {
// Here we could advance the scheduler half way and test intermediate
// state if needed. We go all the way past the end of our login failures.
scheduler.AdvanceTo (100 * seconds);
}
// We should have only user # 2 in the list.
Assert.False (blocked.Contains (1));
Assert.True (blocked.Contains (2));
}
public void FilterBurstsWithATestObserver()
{
var scheduler = new TestScheduler();
var xs = scheduler.CreateHotObservable(
OnNext(250, 1),
OnNext(258, 2),
OnNext(262, 3),
OnNext(450, -1),
OnNext(451, -2),
OnNext(460, -3),
OnCompleted<int>(500)
);
var testObserver = scheduler.CreateObserver<int>();
scheduler.AdvanceTo(200);
xs.FilterBursts(TimeSpan.FromTicks(10), scheduler)
.Subscribe(testObserver);
scheduler.Start();
testObserver.Messages.AssertEqual(
OnNext(250, 1),
OnNext(450, -1),
OnCompleted<int>(500));
xs.Subscriptions.AssertEqual(
Subscribe(Subscribed, 500));
}