How we can mock a CoroutineDatabase in ktor?

Question

I use the KMongo tool How we can mock a Coroutine Database? How can we mock our database in a koin module?

Is there a way to do this? Thanks for guiding me

Methods I have tried and it has not worked:

The first method:

  single<CoroutineDatabase> {
      val client = Mockito.mock(CoroutineClient::class.java)
      client.getDatabase(CoreConstants.DATABASE_NAME)
  }

The second method:

    single<CoroutineDatabase> {
        val client = declareMock<CoroutineClient> {  }
        client.getDatabase(CoreConstants.DATABASE_NAME)
    }

I'm using https://www.testcontainers.org to create a database test container and that works pretty well for my Ktor project. There's a MongoDB module https://www.testcontainers.org/modules/databases/mongodb. Not sure if that works if you use KMongo on top of MongoDB. Also it's not multiplatform but my assumption is that the tests can run as JVM tests so this should be possible. Injecting the test database using Koin is straight forward assuming you're injecting the real database with Koin too. — Emanuel Moecklin, Nov 18 '21 at 17:58
Injection with Koin works well on a driver basis (inject the real driver or the test container driver). I just read up on KMongo. I'm not sure if you can configure a different driver than the two mentioned in the docs (sync/async driver). Worst case you could take the source code and add the testcontainers driver as a third option. — Emanuel Moecklin, Nov 18 '21 at 18:03

chriptus13 · Answer 1 · 2022-04-26T15:15:39.430

I've managed to get this working with MockK with the following approach.

TLDR

Just use a mock of MongoDatabase/MongoCollection<T> and make their coroutine extension property return a mocked CoroutineDatabase/CoroutineCollection<T>. Also need to mock the actual MongoDatabase::getCollection to return the respective MongoCollection<T>.

Suppose we have this scenario.

data class User(val id: Int, val name: String)

class Service(private val myDatabase: CoroutineDatabase) {
    private val userCollection: CoroutineCollection<User> = myDatabase.getCollection("users")
    suspend fun getById(id: Int): User? = userCollection.findOneById(id)
}

Since userCollection is acquired by calling the inline method CoroutineDatabase::getCollection we need to mock all the code inside that inline because inline methods cannot be mocked with MockK (at the time of writing). Looking at the method code

inline fun <reified TDocument : Any> getCollection(
        collectionName: String = KMongoUtil.defaultCollectionName(TDocument::class)
    ): CoroutineCollection<TDocument> =
        database.getCollection(collectionName, TDocument::class.java).coroutine

It just calls com.mongodb.reactivestreams.client.MongoDatabase::getCollection and then uses this extension property to map it to a CoroutineCollection. Notice it uses the field database from CoroutineDatabase which is a MongoDatabase (The CoroutineDatabase was previously obtain via a similar extension property for MongoDatabase).

val <T : Any> MongoCollection<T>.coroutine: CoroutineCollection<T> get() = CoroutineCollection(this)

val MongoDatabase.coroutine: CoroutineDatabase get() = CoroutineDatabase(this)

Having all of this we need to mock:

Both coroutine extension properties on MongoDatabase and MongoCollection<T> (see mocking extension properties with MockK)
The actual MongoDatabase::getCollection because CoroutineDatabase::getCollection is an inline function

// Arrange
val mockedMongoDd: MongoDatabase = mockk<MongoDatabase> {
    mockkStatic(MongoDatabase::coroutine)
    val that = this
    every { coroutine } returns mockk {
        every { database } returns that
    }
}

val mockedMongoCol: MongoCollection<User> = mockk<MongoCollection<User>> {
    mockkStatic(MongoCollection<T>::coroutine)
    val that = this
    every { ofType<MongoCollection<T>>().coroutine } returns mockk {
        every { collection } returns that
    }
}

every {
    mockedMongoDb.getCollection("users", User::class.java)
} returns mockedMongoCol

val mockedCoroutineDb = mockedMongoDb.coroutine
val mockedCoroutineCol = mockedMongoCol.coroutine

val service = Service(mockedCoroutineDb)
val expectedUser = User(2, "Joe")

coEvery {
    mockedCoroutineCol.findOneById(2)
} returns expectedUser

// Act
val actualUser = service.getById(2)

// Assert
assertEquals(expectedUser, actualUser)

Finally, one could make some methods like the following to hide this details from the test.

inline fun <reified T : Any> mockkCoroutineCollection(
    name: String? = null,
    relaxed: Boolean = false,
    vararg moreInterfaces: KClass<*>,
    relaxUnitFun: Boolean = false,
    block: MongoCollection<T>.() -> Unit = {}
): MongoCollection<T> = mockk(name, relaxed, *moreInterfaces, relaxUnitFun = relaxUnitFun) {
    mockkStatic(MongoCollection<*>::coroutine)
    val that = this
    every { coroutine } returns mockk(name, relaxed, *moreInterfaces, relaxUnitFun = relaxUnitFun) {
        every { collection } returns that
    }
    block()
}

inline fun mockkCoroutineDatabase(
    name: String? = null,
    relaxed: Boolean = false,
    vararg moreInterfaces: KClass<*>,
    relaxUnitFun: Boolean = false,
    block: MongoDatabase.() -> Unit = {}
): MongoDatabase = mockk(name, relaxed, *moreInterfaces, relaxUnitFun = relaxUnitFun) {
    mockkStatic(MongoDatabase::coroutine)
    val that = this
    every { coroutine } returns mockk(name, relaxed, *moreInterfaces, relaxUnitFun = relaxUnitFun) {
        every { database } returns that
    }
    block()
}

This would reduce the first lines to

val mockedMongoDb: MongoDatabase = mockkCoroutineDatabase()
val mockedMongoCol: MongoCollection<User> = mockkCoroutineCollection<User>()
// ...

How we can mock a CoroutineDatabase in ktor?

1 Answers1

TLDR