Unit testing for an event using Reactive Extensions

Question

I'm using Reactive Extensions for .NET (Rx) to expose events as IObservable<T>. I want to create an unit test where I assert that a particular event is fired. Here is a simplified version of the class I want to test:

public sealed class ClassUnderTest : IDisposable {

  Subject<Unit> subject = new Subject<Unit>();

  public IObservable<Unit> SomethingHappened {
    get { return this.subject.AsObservable(); }
  }

  public void DoSomething() {
    this.subject.OnNext(new Unit());
  }

  public void Dispose() {
    this.subject.OnCompleted();
  }

}

Obviously my real classes are more complex. My goal is to verify that performing some actions with the class under test leads to a sequence of events signaled on the IObservable. Luckily the classes I want to test implement IDisposable and calling OnCompleted on the subject when the object is disposed makes it much easier to test.

Here is how I test:

// Arrange
var classUnderTest = new ClassUnderTest();
var eventFired = false;
classUnderTest.SomethingHappened.Subscribe(_ => eventFired = true);

// Act
classUnderTest.DoSomething();

// Assert
Assert.IsTrue(eventFired);

Using a variable to determine if an event is fired isn't too bad, but in more complex scenarios I may want to verify that a particular sequence of events are fired. Is that possible without simply recording the events in variables and then doing assertions on the variables? Being able to use a fluent LINQ-like syntax to make assertions on an IObservable would hopefully make the test more readable.

BTW, I think having a variable is perfectly good. The code above is easy to read, which is most important. The @PL's answer is nice and elegant, but you have to strain to understand what is going on... Maybe transform it to an extension FailIfNothingHappened() — Sergey Aldoukhov
– Sergey Aldoukhov, Commented Oct 15, 2010 at 15:33
@Sergey Aldoukhov: I agree, but PL's answer learned me how I can use Materialize to reason about how my IObservable behaves. And for more complex tests using variables to capture what happened may be harder to understand. Also, creating an extension as you suggest will probably make it easier to understand what is going on. — Martin Liversage
– Martin Liversage, Commented Oct 15, 2010 at 16:01
I have edited my question to make it more clear what I want. — Martin Liversage
– Martin Liversage, Commented Oct 29, 2010 at 11:59

Martin Liversage · Accepted Answer · 2012-08-22 21:00:49Z

This answer has been updated to the now released version 1.0 of Rx.

Official documentation is still scant but Testing and Debugging Observable Sequences on MSDN is a good starting place.

The test class should derive from ReactiveTest in the Microsoft.Reactive.Testing namespace. The test is based around a TestScheduler that provides virtual time for the test.

The TestScheduler.Schedule method can be used to queue up activities at certain points (ticks) in virtual time. The test is executed by TestScheduler.Start. This will return an ITestableObserver<T> that can be used for asserting for instance by using the ReactiveAssert class.

public class Fixture : ReactiveTest {

  public void SomethingHappenedTest() {
    // Arrange 
    var scheduler = new TestScheduler();
    var classUnderTest = new ClassUnderTest();

    // Act 
    scheduler.Schedule(TimeSpan.FromTicks(20), () => classUnderTest.DoSomething());
    var actual = scheduler.Start(
      () => classUnderTest.SomethingHappened,
      created: 0,
      subscribed: 10,
      disposed: 100
    );

    // Assert
    var expected = new[] { OnNext(20, new Unit()) };
    ReactiveAssert.AreElementsEqual(expected, actual.Messages);
  }

}

TestScheduler.Schedule is used to schedule a call to DoSomething at time 20 (measured in ticks).

Then TestScheduler.Start is used to perform the actual test on the observable SomethingHappened. The lifetime of the subscription is controlled by the arguments to the call (again measured in ticks).

Finally ReactiveAssert.AreElementsEqual is used to verify that OnNext was called at time 20 as expected.

The test verifies that calling DoSomething immediately fires the observable SomethingHappened.

Joe · Accepted Answer · 2021-03-13 08:21:20Z

8

This kind of testing for observables would be incomplete. Just recently, RX team published the test scheduler and some extensions (which BTW they use internally for testing the library). Using these, you can not only check if something happened or not, but also make sure the timing and order is correct. As a bonus the test scheduler allows you to run your tests in "virtual time", so the tests run instantly, no matter how big delays you're using inside.

Jeffrey van Gogh from RX team published an article on how to do such kind of testing.

The above test, using the mentioned approach, will look like this:

[TestMethod]
public void SimpleTest()
{
    var sched = new TestScheduler();
    var subject = new Subject<Unit>();
    var observable = subject.AsObservable();

    var o = sched.CreateHotObservable(OnNext(210, new Unit()), OnCompleted<Unit>(250));
    var results = sched.Run(() =>
    {
        o.Subscribe(subject);
        return observable;
    });

    results.AssertEqual(OnNext(210, new Unit()), OnCompleted<Unit>(250));
}

EDIT: You can also call .OnNext (or some other method) implicitly:

        var o = sched.CreateHotObservable(OnNext(210, new Unit()));
        var results = sched.Run(() =>
        {
            o.Subscribe(_ => subject.OnNext(new Unit()));
            return observable;
        });
        results.AssertEqual(OnNext(210, new Unit()));

My point is - in simplest situations, you need just to make sure the event is fired (f.e. you are checking your Where is working correctly). But then as you progress in complexity, you start testing for timing, or completion, or something else that requires the virtual scheduler. But the nature of the test using virtual scheduler, opposite to "normal" tests is to test the entire observable at once, not "atomic" operations.

So probably you would have to switch to the virtual scheduler somewhere down the road - why not start with it in the beginning?

P.S. Also, you would have to resort to a different logic for each test case - f.e. you would have very different observable for testing that something did not happen opposite to that something happened.

edited Mar 13, 2021 at 8:21

Joe

82.8k18 gold badges130 silver badges147 bronze badges

answered Oct 14, 2010 at 5:48

Sergey Aldoukhov

22.9k18 gold badges75 silver badges105 bronze badges

2 Comments

Martin Liversage Over a year ago

This approach seems very suitable to test something like Rx itself. However, I don't want to synthesize OnNext calls. Instead I want to assert that a call to method in the class I'm testing is in fact leading to a call to OnNext on an IObservable.

virtouso Over a year ago

what version of system.reactive did you use? it doesn't contain CreateHotObservable

PL. · Accepted Answer · 2010-10-13 16:34:21Z

1

Not sure about more fluent but this will do the trick without introducing a variable.

var subject = new Subject<Unit>();
subject
    .AsObservable()
    .Materialize()
    .Take(1)
    .Where(n => n.Kind == NotificationKind.OnCompleted)
    .Subscribe(_ => Assert.Fail());

subject.OnNext(new Unit());
subject.OnCompleted();

edited Oct 13, 2010 at 16:34

answered Oct 13, 2010 at 16:29

PL.

2,19512 silver badges10 bronze badges

3 Comments

Ana Betts Over a year ago

I'm fairly sure this won't work, Asserting in a Subscribe often results in weird things happening and the test still passing.

PL. Over a year ago

For test to fail you should comment out the line with OnNext call.

Lee Campbell Over a year ago

Just a point; AsObservable() serves no purpose in this example.

user3391690 · Accepted Answer · 2024-11-04 10:29:59Z

0

Maybe like this? And it is easy to read.

[Fact]
    public async Task MyTest()
    {
        await new TestScheduler().WithAsync(async scheduler =>
        {
            // Arrange
            var sut = new MyTestClass();
            var observer = scheduler.CreateObserver<bool>();
            sut.EnableLaser.CanExecute.Subscribe(observer);

            // Act
            sut.EnableLaser.Execute().Subscribe();

            // Assert
            observer.Messages.Should().HaveCount(2);
            observer.Messages.First().Value.Value.Should().BeTrue();
            observer.Messages.Last().Value.Value.Should().BeFalse();
        });
    }

answered Nov 4, 2024 at 10:29

user3391690

112 bronze badges

Collectives™ on Stack Overflow

Unit testing for an event using Reactive Extensions

4 Answers 4

Comments

2 Comments

3 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

2 Comments

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related