Apologies for the long question, I have tried to reduce the problem to as small as I could think of while keeping relevant information in.
I have written 2 realm repositories, both of which follow the same pattern but just deal with different realm objects, I've then written tests for both repositories, both of which have an @After method for clearing realm before the next test is run.
The problem I am facing is that one test suite passes every time, whereas the other has a single failing test. In particular, the failing test should not be failing if the @After method is clearing realm. This is making me worry I am seeing a problem with asynchronous code in tests as my repositories use observables. I am getting round that by blocking in the tests to force waiting for observable terminal event.
As of now I am truly stumped, does anyone have any insight? Here are code excerpts of the problem (EDIT: added important missing bit of puzzle below, a simple helper method that is used to safely execute Realm transactions witohut having to write the boiler plate all the way through the repositories):
/**
* Provides underlying transaction implementation for realm repositories
*/
object RealmHelper {
fun <T> executeTransaction(realm: Realm, transaction: Callable<T>) : T {
realm.beginTransaction()
try {
val result = transaction.call()
realm.commitTransaction()
return result
} catch (ex: Exception) {
if (realm.isInTransaction) {
realm.cancelTransaction()
}
throw RealmRepositoryException(ex.message ?: "Realm transaction failed.")
} finally {
realm.close()
}
}
}
interface FloorRepository {
/**
* CRUD methods for floors
*/
fun hasFloor(id: Int) : Observable<Boolean>
fun deleteFloor(id: Int) : Observable<Unit>
fun insertFloor(floor: Model.Floor) : Observable<Unit>
fun updateFloor(floor: Model.Floor) : Observable<Unit>
fun getFloor(id: Int) : Observable<Model.Floor>
fun getFloorsForLocation(locationId: Int) : Observable<Collection<Model.Floor>>
}
interface LocationRepository {
/**
* CRUD methods for locations
*/
fun hasLocation(id: Int) : Observable<Boolean>
fun deleteLocation(id: Int) : Observable<Unit>
fun insertLocation(location: Model.Location) : Observable<Unit>
fun updateLocation(location: Model.Location) : Observable<Unit>
fun getLocation(id: Int) : Observable<Model.Location>
fun getLocationsForCountry(countryId: Int) : Observable<Collection<Model.Location>>
}
I will post excerpts of the implementations, I hope you can trust that I have triple checked for differences between them (as that may be pertinent to any answer):
class RealmFloorRepository : FloorRepository {
override fun hasFloor(id: Int): Observable<Boolean> =
Observable.fromCallable {
Realm.getDefaultInstance()
.where(DBFloor::class.java)
.equalTo("id", id)
.findFirst() != null
}
...
override fun getFloor(id: Int): Observable<Model.Floor> =
Observable.fromCallable {
val realm = Realm.getDefaultInstance()
val dbFloor =
realm.where(DBFloor::class.java)
.equalTo("id", id)
.findFirst() ?:
throw RealmRepositoryException(
"No DBFloor was found with id: $id")
try {
Model.Floor(dbFloor.id,
dbFloor.name,
dbFloor.floorNum,
dbFloor.locationId)
} catch (ex: Exception) {
throw RealmRepositoryException(ex.message ?: "Realm transaction failed.")
}
}
...
}
class RealmLocationRepository : LocationRepository {
override fun hasLocation(id: Int): Observable<Boolean> =
Observable.fromCallable {
Realm.getDefaultInstance()
.where(DBLocation::class.java)
.equalTo("id", id)
.findFirst() != null
}
...
override fun getLocation(id: Int): Observable<Model.Location> =
Observable.fromCallable {
val realm = Realm.getDefaultInstance()
val dbLocation =
realm.where(DBLocation::class.java)
.equalTo("id", id)
.findFirst() ?:
throw RealmRepositoryException(
"No DBLocation was found with id: $id")
try {
Model.Location(dbLocation.id,
dbLocation.name,
TimeZone.getTimeZone(dbLocation.timezone),
dbLocation.countryId)
} catch (ex: Exception) {
throw RealmRepositoryException(ex.message ?: "Realm transaction failed.")
}
}
...
}
Finally, I wrote android instrumentation tests for both implementations, which again follow exactly the same pattern:
/**
* Set of instrumentation tests for verifying the integrity of the RealmLocationRepository implementation
*/
@RunWith(AndroidJUnit4::class)
class RealmLocationRepositoryInstrumentationTests {
@After
fun teardown() {
val realm = Realm.getDefaultInstance()
RealmHelper.executeTransaction(realm, Callable<Unit> {
realm.deleteAll()
})
}
// Tests that hasLocation returns true if realm contains the location
@Test
@Throws(Exception::class)
fun hasLocationTrue() {
// ARRANGE
val location = Model.Location(0, "", TimeZone.getDefault(), 0)
val realmRepository = RealmLocationRepository()
// ACT
val testObservable = Environment.get().flatMap { _ ->
realmRepository.insertLocation(location).flatMap {
realmRepository.hasLocation(0)
}
}.subscribeOn(Schedulers.io()).test()
testObservable.awaitTerminalEvent(3, TimeUnit.SECONDS)
// ASSERT
testObservable.assertValue { value -> value }
}
// Test that hasLocation returns false if realm does not contain the location
@Test
@Throws(Exception::class)
fun hasLocationFalse() {
// ARRANGE
val realmRepository = RealmLocationRepository()
// ACT
val testObservable = Environment.get().flatMap { _ ->
realmRepository.hasLocation(0)
}.subscribeOn(Schedulers.io()).test()
testObservable.awaitTerminalEvent(3, TimeUnit.SECONDS)
// ASSERT
testObservable.assertValue { value -> !value }
}
...
// Tests that getLocation successfully returns a location from realm
@Test
@Throws(Exception::class)
fun getLocationSuccessful() {
// ARRANGE
val location = Model.Location(0, "", TimeZone.getDefault(), 0)
val realmRepository = RealmLocationRepository()
// ACT
val testObservable = Environment.get().flatMap { _ ->
realmRepository.insertLocation(location).flatMap { _ ->
realmRepository.getLocation(0)
}
}.subscribeOn(Schedulers.io()).test()
testObservable.awaitTerminalEvent(3, TimeUnit.SECONDS)
// ASSERT
testObservable.assertNoErrors()
testObservable.assertValue { value -> value.id == 0 }
testObservable.assertValue { value -> value.name == "" }
testObservable.assertValue { value -> value.timezone == TimeZone.getDefault() }
}
// Tests that getLocation throws an exception when trying to get
// a location that does not exist in realm
@Test
@Throws(Exception::class)
fun getLocationUnsuccessful() {
// ARRANGE
val realmRepository = RealmLocationRepository()
// ACT
val testObservable = Environment.get().flatMap { _ ->
realmRepository.getLocation(0)
}.subscribeOn(Schedulers.io()).test()
testObservable.awaitTerminalEvent(3, TimeUnit.SECONDS)
// ASSERT
testObservable.assertError { error -> error is RealmRepositoryException }
}
...
}
Failing test suite (fails on getFloorUnsuccessful). I've tried commenting out various configurations of other tests in this suite and found that getFloorUnsuccessful passes in several of these configuarations, surely it shouldn't make a difference if the @After method is clearing the state after every test):-
/**
* Set of instrumentation tests for verifying the integrity of the RealmFloorRepository implementation
*/
@RunWith(AndroidJUnit4::class)
class RealmFloorRepositoryInstrumentationTests {
@After
fun teardown() {
val realm = Realm.getDefaultInstance()
RealmHelper.executeTransaction(realm, Callable<Unit> {
realm.deleteAll()
})
}
// Tests that hasFloor returns true if realm contains the floor
@Test
@Throws(Exception::class)
fun hasFloorTrue() {
// ARRANGE
val floor = Model.Floor(0, "", 0, 0)
val realmRepository = RealmFloorRepository()
// ACT
val testObservable = Environment.get().flatMap { _ ->
realmRepository.insertFloor(floor).flatMap {
realmRepository.hasFloor(0)
}
}.subscribeOn(Schedulers.io()).test()
testObservable.awaitTerminalEvent(3, TimeUnit.SECONDS)
// ASSERT
testObservable.assertValue { value -> value }
}
// Test that hasFloor returns false if realm does not contain the floor
@Test
@Throws(Exception::class)
fun hasFloorFalse() {
// ARRANGE
val realmRepository = RealmFloorRepository()
// ACT
val testObservable = Environment.get().flatMap { _ ->
realmRepository.hasFloor(0)
}.subscribeOn(Schedulers.io()).test()
testObservable.awaitTerminalEvent(3, TimeUnit.SECONDS)
// ASSERT
testObservable.assertValue { value -> !value }
}
...
// Tests that getFloor successfully returns a floor from realm
@Test
@Throws(Exception::class)
fun getFloorSuccessful() {
// ARRANGE
val floor = Model.Floor(0, "", 0, 0)
val realmRepository = RealmFloorRepository()
// ACT
val testObservable = Environment.get().flatMap { _ ->
realmRepository.insertFloor(floor).flatMap { _ ->
realmRepository.getFloor(0)
}
}.subscribeOn(Schedulers.io()).test()
testObservable.awaitTerminalEvent(3, TimeUnit.SECONDS)
// ASSERT
testObservable.assertNoErrors()
testObservable.assertValue { value -> value.id == 0 }
testObservable.assertValue { value -> value.name == "" }
testObservable.assertValue { value -> value.floorNum == 0 }
testObservable.assertValue { value -> value.locationId == 0 }
}
// Tests that getFloor throws an exception when trying to get
// a floor that does not exist in realm
@Test
@Throws(Exception::class)
fun getFloorUnsuccessful() {
// ARRANGE
val realmRepository = RealmFloorRepository()
// ACT
val testObservable = Environment.get().flatMap { _ ->
realmRepository.getFloor(0)
}.subscribeOn(Schedulers.io()).test()
testObservable.awaitTerminalEvent(3, TimeUnit.SECONDS)
// ASSERT
testObservable.assertError { error -> error is RealmRepositoryException }
}
...
}