We can test what we get by simply subscribing to the source Observable instance and collecting all of the incoming notifications. In order to demonstrate that, we'll develop a factory method for creating a new Observable instance and will test its behavior.

The method will receive a Comparator instance and multiple items, and will return Observable instance, emitting these items as a sorted sequence. The items will be sorted according to the Comparator instance passed.

We can develop the method using TDD. Let's first define the test as follows:

public class SortedObservableTest {
  private Observable<String> tested;
  private List<String> expected;
  @Before
  public void before() {
    tested = CreateObservable.<String>sorted(
      (a, b) -> a.compareTo(b),
      "Star", "Bar", "Car", "War", "Far", "Jar");
    expected = Arrays.asList(
      "Bar", "Car", "Far", "Jar", "Star", "War"
    );
  }
  TestData data = new TestData();
  tested.subscribe(
    (v) -> data.getResult().add(v),
    (e) -> data.setError(e),
    () -> data.setCompleted(true)
  );
  Assert.assertTrue(data.isCompleted());
  Assert.assertNull(data.getError());
  Assert.assertEquals(expected, data.getResult());
}

The test uses two variables to store the predefined reusable state. The first one is the Observable instance we use as source—tested. In the setup @Before method, it is assigned to the result of our method CreateObservable.sorted(Comparator, T...), which is not implemented yet. We compare a set of String instances and expect them to be received in the order they are stored in the expected variable—the second reusable field.

The test itself is quite verbose. It uses an instance of the TestData class to store the notifications incoming from the tested Observable instances.

If there is an OnCompleted notification, the data.completed field is set to True. We expect this to happen, and that's why we assert it at the end of the test method. If there is an OnError notification, the data.error field is set to the error. We don't expect that to happen, so we assert it to be null.

Every incoming item emitted by the Observable instances is added to the data.resultList field. At the end, it should be equal to the expected List variable, and we assert that.

However, this test fails, of course, because the CreateObservable.sorted(Comparator, T...) method is not implemented yet. Let's implement it and run the test again:

@SafeVarargs
public static <T> Observable<T> sorted(
  Comparator<? super T> comparator,
  T... data) {
    List<T> listData = Arrays.asList(data);
    listData.sort(comparator);
  return Observable.from(listData);
}

It's that simple! It just turns the passed varargs array into a List variable and uses its sort() method to sort it with the passed Comparator instance. Then, using the Observable.from(Iterable) method, we return the desired Observable instance.

If we run the test now, it will pass. This is good! We've got our first test! But writing tests similar to this requires a lot of boilerplate code. We always need these three state variables and we always need to assert the same things. And what about asynchronous Observable instances, such as the ones created by interval() and timer() methods?

There are some techniques for removing the boilerplate variables, and later, we'll look at how to test asynchronous behavior as well. For now, we'll introduce one new type of observable.