Unit Tests

Testing custom operators

RxSwift uses RxTests for all operator tests, located in the AllTests-* target inside the project Rx.xcworkspace.

This is an example of a typical RxSwift operator unit test:

  1. func testMap_Range() {
  2.         // Initializes test scheduler.
  3.         // Test scheduler implements virtual time that is
  4.         // detached from local machine clock.
  5.         // This enables running the simulation as fast as possible
  6.         // and proving that all events have been handled.
  7.         let scheduler = TestScheduler(initialClock: 0)
  9.         // Creates a mock hot observable sequence.
  10.         // The sequence will emit events at desginated
  11.         // times, no matter if there are observers subscribed or not.
  12.         // (that's what hot means).
  13.         // This observable sequence will also record all subscriptions
  14.         // made during its lifetime (`subscriptions` property).
  15.         let xs = scheduler.createHotObservable([
  16.             next(150, 1),  // first argument is virtual time, second argument is element value
  17.             next(210, 0),
  18.             next(220, 1),
  19.             next(230, 2),
  20.             next(240, 4),
  21.             completed(300) // virtual time when completed is sent
  22.             ])
  24.         // `start` method will by default:
  25.         // * Run the simulation and record all events
  26.         //   using observer referenced by `res`.
  27.         // * Subscribe at virtual time 200
  28.         // * Dispose subscription at virtual time 1000
  29.         let res = scheduler.start { xs.map { $0 * 2 } }
  31.         let correctMessages = [
  32.             next(210, 0 * 2),
  33.             next(220, 1 * 2),
  34.             next(230, 2 * 2),
  35.             next(240, 4 * 2),
  36.             completed(300)
  37.         ]
  39.         let correctSubscriptions = [
  40.             Subscription(200, 300)
  41.         ]
  43.         XCTAssertEqual(res.events, correctMessages)
  44.         XCTAssertEqual(xs.subscriptions, correctSubscriptions)
  45.     }

Testing operator compositions (view models, components)

Examples of how to test operator compositions are contained inside Rx.xcworkspace > RxExample-iOSTests target.

It’s easy to define RxTests extensions so you can write your tests in a readable way. Provided examples inside RxExample-iOSTests are just suggestions on how you can write those extensions, but there are a lot of possibilities on how to write those tests.

  1.     // expected events and test data
  2.     let (
  3.         usernameEvents,
  4.         passwordEvents,
  5.         repeatedPasswordEvents,
  6.         loginTapEvents,
  8.         expectedValidatedUsernameEvents,
  9.         expectedSignupEnabledEvents
  10.     ) = (
  11.         scheduler.parseEventsAndTimes("e---u1----u2-----u3-----------------", values: stringValues).first!,
  12.         scheduler.parseEventsAndTimes("e----------------------p1-----------", values: stringValues).first!,
  13.         scheduler.parseEventsAndTimes("e---------------------------p2---p1-", values: stringValues).first!,
  14.         scheduler.parseEventsAndTimes("------------------------------------", values: events).first!,
  16.         scheduler.parseEventsAndTimes("e---v--f--v--f---v--o----------------", values: validations).first!,
  17.         scheduler.parseEventsAndTimes("f--------------------------------t---", values: booleans).first!
  18.     )

Integration tests

It is also possible to write integration tests by using RxBlocking operators.

Importing operators from RxBlocking library will enable blocking the current thread and wait for sequence results.

  1. let result = try fetchResource(location)
  2.         .toBlocking()
  3.         .toArray()
  5. XCTAssertEqual(result, expectedResult)