Тестирование Trainer Advisor: сетап теста, подготовка тестовых дублей

fun WireMock.willSucceededOnIdentifyAccountRequest(
    oms: String,
    birthDate: LocalDate,
    statusCode: Int = 200,
    externalAccountId: String = randomExternalAccountId()
) {
    put {
        url like "$EXTERNAL_BASE_PATH/identifyPatient\\?birthDate=$birthDate&oms=$oms"
    } returns {
        statusCode = statusCode
        body = """
            {
                "remoteId": "$externalAccountId"
            }
            """
    }
}

fun WireMock.willFailOnIdentifyAccountRequest(
    oms: String,
    birthDate: LocalDate,
    statusCode: Int = 500,
    externalSystemErrorCode: String = randomExternalSystemErrorCode()
) {
    put {
        url like "$EXTERNAL_BASE_PATH/identifyPatient\\?birthDate=$birthDate&oms=$oms"
    } returns {
        statusCode = statusCode
        body = """
            {
                "code": "$externalSystemErrorCode"
            }
            """
    }
}

@Test
fun `links internal account to external system`(wm: WireMockRuntimeInfo) {
    // Given
    // ...
    wm.wireMock.willSucceededOnIdentifyAccountRequest(
        oms = linkAccountRequest.oms,
        birthDate = linkAccountRequest.birthDate
    )

    // When
    // Триггерим обращение к внешниму сервису

    response.Then {
        statusCode(204)
    }
}

@Test
fun `returns 400 when provided oms has no agreement to be used in external system`(wm: WireMockRuntimeInfo) {
    // Given
    // ...
    wm.wireMock.willFailOnIdentifyAccountRequest(
        oms = linkAccountRequest.oms,
        birthDate = linkAccountRequest.birthDate,
        externalSystemErrorCode = ExternalSystem.ErrorCodes.NO_AGREEMENT
    )

    // When
    // Триггерим обращение к внешниму сервису

    response.Then {
        statusCode(400)
        body("errorCode", equalTo("agreement-for-external-system-usage-not-found"))
    }
}

class TestRabbitMqListener<T : Any>(
    private val rabbitTemplate: RabbitTemplate,
    private val messageType: KClass<T>,
    private val queue: String,
) {

    private val log = LoggerFactory.getLogger(javaClass)

    fun receive(count: Int, timeout: Long = 2000): List<T> {
        val job = CompletableFuture.supplyAsync {
            val messagesSeq: Sequence<T?> =
                generateSequence {
                    rabbitTemplate.receiveAndConvert(
                        queue,
                        timeout,
                        ParameterizedTypeReference.forType(messageType.java)
                    )
                }

            messagesSeq
                .onEachIndexed { idx, msg -> log.info("Message #$idx received: {}", msg) }
                .takeWhile { msg: T? -> msg != null }
                .take(count)
                .filterNotNull()
                .toList()
        }

        return job.get()
    }

}

class RabbitMqFixtures(
    private val ampqAdmin: AmqpAdmin,
    private val rabbitTemplate: RabbitTemplate
) {

    val defaultExchange = DirectExchange("amq.direct")

    fun <T : Any> createListener(
        messageType: KClass<T>,
        routingKey: String,
        queueName: String = "",
        exchange: DirectExchange? = null,
    ): TestRabbitMqListener<T> {
        val queue = Queue(queueName, queueName.isNotEmpty(), false, false)
        ampqAdmin.declareQueue(queue)
        ampqAdmin.declareBinding(
            BindingBuilder.bind(queue).to(exchange ?: defaultExchange).with(
                routingKey
            )
        )
        return TestRabbitMqListener(rabbitTemplate, messageType, queue.actualName)
    }

}

@Test
fun `Project E publishes DiaryEventCreated domain events when diary events are created`() {
    // Given
    // ...
    val eventsListener = rabbitMqFixtures.createListener(
        DiaryEventCreated::class,
        DIARY_EVENT_CREATED
    )

    // When
    // Триггерим код отправки сообщения в Кролика

    // Then
    val messages = eventsListener.receive(msgCount)
    // Верифицируем сообщения
}

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


    @BeforeEach
    fun setUp() {
        testKafkaListener.clearEvents()
    }

    private val tenMillis = Duration.ofMillis(10)

    @Test
    fun `send measurements event`() {
        // Given
        // ...

        // When
        // Триггерим код отправки сообщения в Кафку

        // Then
        val events = await
            .withPollDelay(tenMillis)
            .untilCallTo { testKafkaListener.getEvents() }
            .has { size == 1 }

        // Верифицируем сообщения
    }
}

class TestingMqttClient(
    private val mqttProps: mqttProps,
) {

    private val log = LoggerFactory.getLogger(javaClass)

    private val mqttClient = setupMqttClient()

    val receivedMessages = mutableListOf<String>()

    fun subscribeToServer() {
        mqttClient.subscribe(
            MqttSubscription(mqttProps.topic, 2),
            null,
            null,
            { _, message ->
                val msg = String(message.payload)
                log.info("Message received: {}", msg)
                receivedMessages += msg
                mqttClient.messageArrivedComplete(message.id, 2)
            },
            MqttProperties().apply {
                setSubscriptionIdentifiers(listOf(0))
                setSubscriptionIdentifier(1)
            }
        )
        log.info("Mqtt subscribed")
    }

    private fun setupMqttClient(): MqttAsyncClient {
        val mqttClient = MqttAsyncClient(
            mqttProps.address,
            "myServer",
            MemoryPersistence()
        )
        mqttClient.connect(mqttConnectOptions()).waitForCompletion()
        log.info("Mqtt client connected")
        return mqttClient
    }

    private fun mqttConnectOptions(): MqttConnectionOptions {
        return MqttConnectionOptions().apply {
            this.isCleanStart = false
            this.isAutomaticReconnect = false
            this.userName = mqttProps.username
            this.password = mqttProps.password.toByteArray()
            this.keepAliveInterval = 60
        }
    }
}

class MqttTest(
    @Autowired mqttProps: mqttProps
) : ProjectEIntegrationTest() {

    val mqttClient = TestingMqttClient(mqttProps)
        .apply { subscribeToServer() }

    @BeforeEach
    fun cleanupMqtt() {
        mqttClient.receivedMessages.clear()
    }

    @Test
    fun `sends events to mqtt server`(): Unit = runTest {
        // Given
        // ..

        // When
        // Триггерим отправку сообщений в MQTT

        eventually(20.milliseconds) {
            val messages = listOf(mqttClient.receivedMessages)
            // Верифицируем сообщения
        }
    }
}