Micronaut mongo test resources doesn't start docker container

Question

I have a project of the following structure:

gradle.properties:

group=pal.quest
rootProject.name=quests
version=0.0.1-SNAPSHOT
#
micronautVersion=3.7.3
#
kotlinVersion=1.6.21
kotlin.code.style=official

settings.gradle.kts:

dependencyResolutionManagement {
    repositories {
        mavenCentral()
    }
}
pluginManagement {
    plugins {
        id("org.jetbrains.kotlin.jvm") version "1.6.21"
        id("org.jetbrains.kotlin.kapt") version "1.6.21"
        id("org.jetbrains.kotlin.plugin.allopen") version "1.6.21"

        id("io.micronaut.application") version "3.6.3"

        id("io.micronaut.test-resources") version "3.6.3"

        id("com.github.johnrengelman.shadow") version "7.1.2"
    }
}
include("quests-entity")
include("quests-repository")

root build.gradle.kts is empty.
quests-entity:build.gradle.kts:

plugins {
    java
    `java-library`

    id("org.jetbrains.kotlin.jvm")
    id("org.jetbrains.kotlin.kapt")

    id("io.micronaut.application")
}

dependencies {
    implementation("jakarta.annotation:jakarta.annotation-api")
    api("io.micronaut.data:micronaut-data-mongodb")
}

PalQuestQuestsEntityConfig:

package pal.quest;

import io.micronaut.core.annotation.Introspected;

@Introspected
class PalQuestQuestsEntityConfig

PalQuestQuestsQuestEntity:

package pal.quest.entity;

import io.micronaut.core.annotation.NonNull
import io.micronaut.data.annotation.GeneratedValue
import io.micronaut.data.annotation.Id
import io.micronaut.data.annotation.MappedEntity
import org.bson.codecs.pojo.annotations.BsonId
import org.bson.codecs.pojo.annotations.BsonProperty
import org.bson.types.ObjectId

@MappedEntity
data class PalQuestQuestsQuestEntity(
    @field:Id
    @field:BsonId
    @field:GeneratedValue
    @field:BsonProperty("_id")
    var id: ObjectId? = null,

    @NonNull
    @field:BsonProperty("title")
    val title: String,

    @field:BsonProperty("description")
    var description: String = "",

    @field:BsonProperty("assigner_id")
    val assignerId: String,

    @field:BsonProperty("status")
    val status: String,

    @field:BsonProperty("assigner_ids")
    var assignedIds: MutableSet<String> = HashSet()
)

quests-repository:build.gradle.kts

plugins {
    id("org.jetbrains.kotlin.jvm")
    id("org.jetbrains.kotlin.kapt")
    id("org.jetbrains.kotlin.plugin.allopen")
    id("io.micronaut.application")
    id("io.micronaut.test-resources")
}

val kotlinVersion = project.properties["kotlinVersion"]
dependencies {
    api(project(":quests-entity"))

    kapt("io.micronaut.data:micronaut-data-document-processor")

    api("io.micronaut.kotlin:micronaut-kotlin-runtime")

    api("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}")
    api("org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlinVersion}")

    api("org.jetbrains.kotlinx:kotlinx-coroutines-core")
    api("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")

    runtimeOnly("org.mongodb:mongodb-driver-reactivestreams")
    testResourcesRuntimeOnly("org.mongodb:mongodb-driver-reactivestreams")

    testApi("org.testcontainers:junit-jupiter")
    testApi("org.testcontainers:mongodb")
    testApi("org.testcontainers:testcontainers")

}

micronaut {
    testRuntime("junit5")
    processing {
        incremental(true)
        annotations("pal.*")
    }
}

PalQuestRepositoryConfig:

package pal.quest

import io.micronaut.context.annotation.Bean
import io.micronaut.context.annotation.Factory
import io.micronaut.context.annotation.Import
import jakarta.inject.Singleton
import org.bson.codecs.configuration.CodecRegistries
import org.bson.codecs.configuration.CodecRegistry
import org.bson.codecs.pojo.PojoCodecProvider


@Import(
    classes = [PalQuestQuestsEntityConfig::class]
)
@Factory
class PalQuestRepositoryConfig {
    @Bean
    @Singleton
    fun mapper(): CodecRegistry = CodecRegistries.fromRegistries(
        CodecRegistries.fromProviders(
            PojoCodecProvider.builder()
                .automatic(true)
                .build()
        )
    )
}

PalQuestQuestsQuestRepository:

package pal.quest.repository

import io.micronaut.data.mongodb.annotation.MongoRepository
import io.micronaut.data.repository.kotlin.CoroutineCrudRepository
import org.bson.types.ObjectId
import pal.quest.entity.PalQuestQuestsQuestEntity

@MongoRepository
interface PalQuestQuestsQuestRepository : CoroutineCrudRepository<PalQuestQuestsQuestEntity, ObjectId>

PalQuestQuestsQuestRepositoryTest:

package pal.quest.repository

import io.micronaut.test.extensions.junit5.annotation.MicronautTest
import jakarta.inject.Inject
import kotlinx.coroutines.flow.count
import kotlinx.coroutines.runBlocking
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test

@MicronautTest(transactional = false)
class PalQuestQuestsQuestRepositoryTest @Inject constructor(
    private val palQuestQuestsQuestRepository: PalQuestQuestsQuestRepository,
) {
    @Test
    fun empty_zeroFound() {
        runBlocking {
            val count = palQuestQuestsQuestRepository.findAll()
                .count()
            Assertions.assertEquals(0, count)
        }
    }
}

When I run this test, I get the following error:

Sessions are not supported by the MongoDB cluster to which this client is connected
com.mongodb.MongoClientException: Sessions are not supported by the MongoDB cluster to which this client is connected...

Docker version 20.10.17, build 100c701.

I tried to set configure rest-resources in application-test.yaml, that didn't help. How should I fix that error?