Skip to main content

Room and coroutines testing


My last article covered some simple example about Room and RxJava instrumentation testing code. Coroutines also have great support in unit testing even though todays topic has nothing to do with it.  What I mean is that we are not going to cover runBlockingTest this time. Android doesn't support that (correct me if I'm wrong please) yet. However, I could schedule a topic about that because it really makes me excited. You can also check this awesome talk from Sean McQuillan, which I found pretty helpful.

Comparing to the last gists, we will try to jump from Rx to coroutines (without implementation) and write test class about it.  Instead of RxJava components, we can just mark methods as suspended:

This looks easier (or better say less confusing).

Two small notes that might be needed: 
Looking the code in the previous article, notice that you won't be needing the InstantTaskExecutorRule() and suddenly we won't be running the queries on the Main thread. That's because we can't do that if methods are marked as suspended.

Let's start testing:


Notice that we dropped the allowMainThreadQueries().

And now the queries:

Something too familiar? The key ingredient here is just a runBlocking keyword, which makes sure to run your suspending methods. I guess there is no need to add code for the update or delete part of testing. It's just super imperative and there is no secret here which could make you lose your mind (referring to the Rx-Javas blockingawait()) because a coroutine makes sure that the insertion is executed before the code below.


Not a small comparison:

I love both. But I think that Rx is really redundant when we are inside the Kotlin (especially coroutines) context.

Conclusion

Coroutines are being every day more supported by Google Android team and that's really great. New libraries are being written in Kotlin and coroutines are part of them. What I really like about Room and coroutines in testing is that I never deliberately forget to test Daos on my project, I'm always ready to write tests (even though I haven't been around testing in more than 8 months).

Note: If you want to know more about Room + coroutines, here is a nice article from Florina Muntenescu also covering some deep dive and behind the scenes on how Room Coroutine support has been build.

Stavro Xhardha

Popular posts from this blog

Modularizing your Android app, breaking the monolith (Part 1)

Inspired by a Martin Fowlers post about Micro Frontends, I decided to break my monolithic app into a modular app. I tried to read a little more about breaking monolithic apps in Android, and as far as I got, I felt confident to share my experience with you. This will be some series of blog posts where we actually try to break a simple app into a modularized Android app.

Note: You should know that I am no expert in this, so if there are false statements or mistakes please feel free to criticize, for the sake of a better development. 

What do you benefit from this approach:
Well, people are moving pretty fast nowadays and delivery is required faster and faster. So, in order to achieve this, modularising Android apps is really necessary.You can share features across different apps. Independent teams and less problems per each.Conditional features update.Quicker debugging and fixing.A feature delay doesn't delay the whole app. As per writing tests, there is not too much difference about…

What I learned from Kotlin Flow API

I used to check the docs and just read a lot about flows but didn't implement anything until yesterday. However, the API tasted really cool (even though some operations are still in Experimental state).Prerequisites: If you don't know RxJava it's fine. But a RxJava recognizer would read this faster.Cold vs Hot streamsWell, I really struggled with this concept because it is a little bit tricky. The main difference between cold and hot happened to be pretty simple: Hot streams produce when you don't care while in cold streams, if you don't collect() (or RxJava-s equivalent subscribe()) the stream won't be activated at all. So, Flows are what we call cold streams. Removing the subscriber will not produce data at all, making the Flows one of the most sophisticated asynchronous stream API ever (in the JVM world). I tried to make a illustration of hot and cold streams: Since I mentioned the word asynchronous this implies that they do support coroutines also. Flows vs…

From Gson to Moshi, what I learned

There is no doubt that people are getting away from GSON and I agree with those reasons too. The only advantage GSON has over other parsing libraries is that it takes a really short amount of time to set up. Furthermore, the most important thing is that Moshi is embracing Kotlin support.

First let's implement the dependency:
implementation("com.squareup.moshi:moshi:1.8.0") It's not a struggle to migrate to Moshi. It's really Gson look-a-like. The only thing to do is annotate the object with @field:Json instead of @SerializedName (which is Gsons way for JS representation):

data class User( //GSON way @SerializedName("name") val name: String, @SerializedName("user_name") val userName: String, @SerializedName("last_name") val lastName: String, @SerializedName("email") val email: String ) data class User( //Moshi way @field:Json(name = "name") val name: String, @field:Json(name = "user_name…