Тестирование Trainer Advisor: сетап набора тестов (test suite)/ тестируемой системы (system under test)

val pgContainer: PostgreSQLContainer<*> by lazy {
    PostgreSQLContainer("postgres:15.2")
        .withExposedPorts(5432)
        .withUsername("postgres")
        .withPassword("password")
        .withDatabaseName("postgres")
        .withTmpFs(mapOf("/var" to "rw"))
        .withEnv("PGDATA", "/var/lib/postgresql/data-no-mounted")
        .withReuse(true)
        .withInitScript("db/qyoga-db-init.sql")
        .apply {
            start()
            // Сначала подключаемся к postgres, пересоздаём qyoga для обнуления фикстуры и подключаемся к ней
            this.withDatabaseName("qyoga")
        }
}

val minioContainer: MinIOContainer by lazy {
    MinIOContainer("minio/minio")
        .withExposedPorts(9000)
        .withUserName("user")
        .withPassword("password")
        .withTmpFs(mapOf("/tmp" to "rw"))
        .withReuse(true)
        .withEnv("MINIO_VOLUMES", "/tmp/minio")
        .withCommand("server")
        .apply {
            start()
        }
}

# Проект test-инфраструктуры
# test-инфраструктура хранит данные на docker tmpfs volume (данные не переживают перезапуск контейнера)
# Тесты настроены таким образом, что на старте пытаются подключиться к тестовой инфраструктуре и
# запускают контейнеры через testcontainers только если не получается

version: '3.8'

name: qyoga-tests-infra

services:

  postgres:
    extends:
      file: docker-compose-infra-base.yml
      service: postgres

    container_name: qg-pg-tests

    environment:
      PGDATA: /tmp/pgdata

    tmpfs:
      - /tmp

    ports:
      - "54502:5432"

  minio:
    extends:
      file: docker-compose-infra-base.yml
      service: minio

    container_name: qg-minio-tests

    environment:
      MINIO_VOLUMES: /tmp/minio

    tmpfs:
      - /tmp

    ports:
      - "50001:9000"
      - "9020:9020"

    command: server --console-address ":9020"

const val PROVIDED_DB_URL = "jdbc:postgresql://localhost:54502/qyoga"

object TestDb

private val log = LoggerFactory.getLogger(TestDb::class.java)

private const val DB_USER = "postgres"
private const val DB_PASSWORD = "password"

val jdbcUrl: String by lazy {
    try {
        log.info("Checking for provided db")
        val con = DriverManager.getConnection(
            PROVIDED_DB_URL.replace("qyoga", DB_USER),
            DB_USER,
            DB_PASSWORD
        )
        log.info("Provided db found, recreating it")
        con.prepareStatement(
            """
                DROP DATABASE IF EXISTS qyoga;
                CREATE DATABASE qyoga;
            """.trimIndent()
        )
            .execute()
        log.info("Provided db found, recreated")
        PROVIDED_DB_URL
    } catch (e: SQLException) {
        log.info("Provided Db not found: ${e.message}")
        pgContainer.jdbcUrl
    }
}

val testDataSource by lazy {
    val config = HikariConfig().apply {
        this.jdbcUrl = pro.qyoga.tests.infra.db.jdbcUrl
        this.username = DB_USER
        this.password = DB_PASSWORD
    }
    HikariDataSource(config)
}

const val MINIO_URL = "http://localhost:50001"

object TestMinio

private val log = LoggerFactory.getLogger(TestMinio::class.java)

private const val MINIO_USER = "user"
private const val MINIO_PASSWORD = "password"

val minioUrl: String by lazy {
    try {
        log.info("Checking for provided minio")
        val con = MinioClient.builder()
            .endpoint(MINIO_URL)
            .credentials(MINIO_USER, MINIO_PASSWORD)
            .build()
        con.listBuckets()
        log.info("Provided minio found, cleaning it")
        dropBuckets(con)
        log.info("Provided minio cleaned")

        MINIO_URL
    } catch (e: ConnectException) {
        log.info("minio container not found: ${e.message}")
        log.info("http://" + minioContainer.host + ":" + minioContainer.firstMappedPort)

        log.info("Cleaning testcontainers minio")
        dropBuckets(
            MinioClient.builder()
                .endpoint(minioContainer.s3URL)
                .credentials(minioContainer.userName, minioContainer.password)
                .build()
        )
        log.info("Minio cleaned")

        "http://" + minioContainer.host + ":" + minioContainer.firstMappedPort
    }
}

val testMinioClient: MinioClient by lazy {
    MinioClient.builder()
        .endpoint(minioUrl)
        .credentials(MINIO_USER, MINIO_PASSWORD)
        .build()
}

fun dropBuckets(client: MinioClient) {
    client.listBuckets().forEach { bucket ->
        client.listObjects(ListObjectsArgs.builder().bucket(bucket.name()).build()).forEach {
            client.removeObject(
                RemoveObjectArgs.builder().bucket(bucket.name()).`object`(it.get().objectName())
                    .build()
            )
        }
    }
}

@Import(
    QYogaApp::class,
    BackgroundsConfig::class,
    TestPasswordEncoderConfig::class,
    TestDataSourceConfig::class,
    TestMinioConfig::class,
    FailingController::class
)
@Configuration
class TestsConfig

val context: ConfigurableApplicationContext by lazy {
    SpringApplicationBuilder(TestsConfig::class.java)
        .profiles("test")
        .build()
        .run()
}

open class QYogaAppBaseTest {

    private val dataSource: DataSource = context.getBean(DataSource::class.java)

    protected val port: Int = context.getBean(ServerProperties::class.java).port

    protected val backgrounds: Backgrounds = context.getBean(Backgrounds::class.java)

    inline fun <reified T> getBean(): T =
        context.getBean(T::class.java)

    @BeforeEach
    fun setupTestData() {
        dataSource.setupDb()
    }

}

open class MinioFilesStorage(
    // ...
    private val bucket: String
) : FilesStorage {

    @PostConstruct
    fun init() {
        if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucket).build())) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucket).build())
        }
    }

    // ...

}

smtp:
  base-url: http://localhost:8081
  from: no-reply@project-e.com
  api-key: api-key

@WireMockTest(httpPort = 8081)
@ActiveProfiles("test")
class SmtpBzTest {
    // ...
}

@Test
fun `EmailSender should send correct http request to SmtpBz`(wm: WireMockRuntimeInfo) {
    // Given
    wm.register(SMTPBZ_POST_EMAIL_URL, HttpStatus.OK)
    // ...
}

val rabbitMqContainer by lazy {
    with(RabbitMQContainer("rabbitmq:3-management-alpine")) {
        withAdminPassword("password")
        withExposedPorts(5672)
        withReuse(reuse)
        withEnv(
            mapOf(
                // Это не получается задать через АПИ
                "RABBITMQ_DEFAULT_USER" to "eventbus",
                "RABBITMQ_DEFAULT_VHOST" to "eventbus",
            )
        )
    }
    .apply { start() }
}

class TestContainerMqContextInitializer : ApplicationContextInitializer<ConfigurableApplicationContext> {

    override fun initialize(applicationContext: ConfigurableApplicationContext) {
        applicationContext.environment.propertySources.addFirst(
            MapPropertySource(
                "Integration rabbit mq test properties",
                mapOf(
                    "spring.rabbitmq.port" to rabbitMqContainer.getMappedPort(5672),
                    "spring.rabbitmq.host" to rabbitMqContainer.host,
                    "spring.rabbitmq.password" to "password",
                    "spring.rabbitmq.virtual-host" to "eventbus",
                    "spring.rabbitmq.username" to "eventbus",
                )
            )
        )
    }
}

@ContextConfiguration(
    classes = [ProjectEApp::class, /* ... */],
    initializers = [TestContainerDbContextInitializer::class, TestContainerMqContextInitializer::class]
)
@SpringBootTest(
    webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT
)
class ProjectEBaseTest(/* ... */) { /* ... */ }

val kafkaContainer by lazy {
    KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:6.2.1"))
        .apply {
            withReuse(true)
            start()
        }
}

class TestContainerKafkaContextInitializer : ApplicationContextInitializer<ConfigurableApplicationContext> {

    override fun initialize(applicationContext: ConfigurableApplicationContext) {
        applicationContext.environment.propertySources.addFirst(
            MapPropertySource(
                "Integration kafka test properties",
                mapOf(
                    "external-system.client.kafka.broker" to kafkaContainer.bootstrapServers.substringAfterLast("//"),
                )
            )
        )
        AdminClient.create(mapOf(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG to kafkaContainer.bootstrapServers)).use {
            it.deleteTopics(listOf(applicationContext.environment.getProperty("external-system.client.kafka.topic")))
        }
    }

}

@Component
class TestKafkaListener(
    private val objectMapper: ObjectMapper
) {

    private val log = LoggerFactory.getLogger(javaClass)

    private val events = ConcurrentLinkedQueue<ExternalSystemEventMessage>()

    @KafkaListener(topics = ["\${external-system.client.kafka.topic}"])
    fun externalSystemEvents(@Payload message: String) {
        assertThat(message, matchesJsonSchemaInClasspath("kafka-message-scheme.json"))

        val event = objectMapper.readValue(message, ExternalSystemEventMessage::class.java)
        log.info("Consuming {}", event)
        events.add(event)
    }

    fun getEvents() = events.toList()

    fun clearEvents() {
        log.info("Clearing events")
        events.clear()
    }

}

@EnableKafka
@ComponentScan
class KafkaTestConfig(
    private val kafkaClientProps: ExternalSystemKafkaClientProps
) {
    @Bean
    fun kafkaListenerContainerFactory(
        consumerFactory: ConsumerFactory<String, String>
    ): KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> {
        val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
        factory.setConcurrency(1)
        factory.consumerFactory = consumerFactory
        factory.containerProperties.pollTimeout = 1000
        return factory
    }

    @Bean
    fun consumerFactory(map: Map<String, Any>): ConsumerFactory<String, String> {
        return DefaultKafkaConsumerFactory(map)
    }

    @Bean
    fun consumerConfigs(): Map<String, Any> {
        val props: MutableMap<String, Any> = java.util.HashMap()
        props[ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG] = kafkaClientProps.broker
        props[ConsumerConfig.GROUP_ID_CONFIG] = "the-only-group"
        props[ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG] = false
        props[ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG] = StringDeserializer::class.java
        props[ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG] = StringDeserializer::class.java
        return props
    }
}

@ContextConfiguration(
    classes = [KafkaTestConfig::class],
)
class SendEventsTest(
    @Autowired private val testKafkaListener: TestKafkaListener
) : ExternalSystemAppBaseTest() {
}

val mqttServerContainer by lazy {
    HiveMQContainer(DockerImageName.parse("hivemq/hivemq-ce:latest").withTag("2021.3"))
        .withReuse(true)
        .apply { start() }
}

class TestContainerMqttServerContextInitializer : ApplicationContextInitializer<ConfigurableApplicationContext> {

    override fun initialize(applicationContext: ConfigurableApplicationContext) {
        applicationContext.overrideProperties(
            "project-e.integrations.external-system.address" to "tcp://${mqttServerContainer.host}:${mqttServerContainer.mqttPort}",
            "project-e.integrations.external-system.enabled" to "true"
        )
    }
}

val internalServiceContainer by lazy {
    GenericContainer("project-docker-registry/project-e/internal-service:latest")
        .withExposedPorts(5000)
        .withReuse(true)
        .apply { start() }
}

class TestContainerInternalServiceContextInitializer : ApplicationContextInitializer<ConfigurableApplicationContext> {

    override fun initialize(applicationContext: ConfigurableApplicationContext) {
        applicationContext.overrideProperties(
            "project-e.internal-service.url" to internalServiceContainer.serviceUrl()
        )
    }

}

fun GenericContainer<*>.serviceUrl() =
    "http://${internalServiceContainer.host}:${getMappedPort(5000)}"

@ContextConfiguration(initializers = [TestContainerInternalServiceContextInitializer::class])
class ReportsServiceTest(/* ... */) : ProjectEAppWithFakeInfraBaseTest()