가치있는 테스트를 위한 전략과 구현

data class Member(
    val name: String,
    val age: Int,
) {

    fun canParticipatePromotion(): Boolean {
        return age <= MAX_PROMOTION_AGE
    }

    companion object {
        const val MAX_PROMOTION_AGE = 18
    }
}

class MemberTest : FunSpec({

    context("canParticipatePromotion") {
        test("프로모션 참가는 18세 이하까지 가능함") {
            listOf(12, 17, 18).forEach {
                val member = Member(
                    name = "MangKyu",
                    age = it,
                )

                member.canParticipatePromotion() shouldBe true
            }
        }

        test("프로모션 참가는 19세 이상부터 불가능함") {
            listOf(19, 20, 30).forEach {
                val member = Member(
                    name = "MangKyu",
                    age = it,
                )

                member.canParticipatePromotion() shouldBe false
            }
        }
    }
})

data class TossPoint(
    val amount: BigDecimal,
    val targetMember: Member,
) {

    fun getPointCode(): Long {
        if (targetMember.isChild()) {
            return 1523L
        }

        return 5823L
    }
}

class TossPointTest : FunSpec({

    // Classicist
    test("대상이 child일 경우 pointCode는 1523") {
        val tossPoint = TossPoint(
            amount = BigDecimal.ONE,
            targetMember = Member(
                name = "MangKyu",
                age = 19,
            )
        )

        tossPoint.getPointCode() shouldBe 1523L
    }

    // Mockist
    test("대상이 child가 아닐 경우 pointCode는 5823") {
        val member = mockk<Member>()
        every { member.isChild() } returns false

        val tossPoint = TossPoint(
            amount = BigDecimal.ONE,
            targetMember = member
        )

        tossPoint.getPointCode() shouldBe 5823L
    }
}

@AcceptanceTest(["acceptance/checkAccount.json"])
class CheckAccountControllerTest : FunSpec({
    
    context("수취성명조회") {
        test("1회 충전 한도를 초과한 경우") {
            val 수취성명조회결과 = 수취성명조회(amount = 200001)
            수취성명조회결과["resultCode"] shouldBe "DEPOSIT_LIMIT_EXCEEDED"
        }

        test("블랙리스트인 경우") {
            val 수취성명조회결과 = 수취성명조회(userId = 97687966, accountNo = 11503235)
            수취성명조회결과["resultCode"] shouldBe "VA_UNAVAILABLE"
        }

        test("성공") {
            val 수취성명조회결과 = 수취성명조회(amount = 20000)
            수취성명조회결과["resultCode"] shouldBe "OK"
        }
    }
    
    extension(SpringExtension)
})

private fun 수취성명조회(
    userId: Long = 1,
    accountNo: Long = 1283912,
    amount: Long = 10000L,
): Map<String, String> {
    return RestAssured
        .given().log().all().contentType(MediaType.APPLICATION_JSON_VALUE)
        .header(TossHeaders.USER_ID, userId)
        .`when`()
        .body(
            mapOf(
                "accountNo" to accountNo,
                "amount" to amount,
            )
        )
        .post("/internal/check-account")
        .then().log().all().extract()
        .jsonPath().getMap("success")
}

@Retention(AnnotationRetention.RUNTIME)
@ActiveProfiles("test")
@SpringBootTest(
    webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
    classes = [MainApplication::class],
    properties = ["spring.profiles.active=test"]
)
@AutoConfigureMetrics
@TestExecutionListeners(
    value = [AcceptanceTestExecutionListener::class],
    mergeMode = TestExecutionListeners.MergeMode.MERGE_WITH_DEFAULTS
)
@Import(LazyInitExcludeConfiguration::class)
annotation class AcceptanceTest(
    @get:AliasFor("setUpScripts")
    val value: Array<String> = [],
    val setUpScripts: Array<String> = []
)

@Profile("test")
@Configuration
private class LazyInitExcludeConfiguration {
    @Bean
    fun lazyInitializationExcludeFilter(): LazyInitializationExcludeFilter {
        return LazyInitializationExcludeFilter.forBeanTypes(
            AESCipherSupport::class.java,
        )
    }
}

{
  "charging_channel_transaction": [
    {
      "user_id": 1,
      "tx_no": 1,
      "tx_summary": "Pw/0EuV0TDxOQ1UPdY/t1A==",
      "amount": 1404,
      "tx_ts": "2022-03-22 21:02:27",
    }
  ],
  "charging_channel": [
    {
      "account_id": null,
      "user_id": 1,
      "expiration_date": "2033-01-01",
      "reg_ts": "2023-08-21 23:07:42"
    },
    {
      "account_id": 18389,
      "user_id": 1,
      "expiration_date": "2033-01-01",
      "reg_ts": "2023-08-21 23:07:42"
    }
  ]
}

@AcceptanceTest
@Sql(scripts = ["classpath:acceptance/checkAccount.sql"], config = SqlConfig(dataSource = "dataSource"))
class CheckAccountInternalControllerTest : FunSpec({
    
)}

class AcceptanceTestExecutionListener : AbstractTestExecutionListener() {

    override fun beforeTestClass(testContext: TestContext) {
        val serverPort = testContext.applicationContext.environment
            .getProperty("local.server.port", Int::class.java)
            ?: throw IllegalStateException("localServerPort cannot be null")

        RestAssured.port = serverPort
    }

    override fun beforeTestMethod(testContext: TestContext) {
        val jdbcTemplate = testContext.applicationContext.getBean(JdbcTemplate::class.java)
        val objectMapper = testContext.applicationContext.getBean(ObjectMapper::class.java)

        TestContextAnnotationUtils.getMergedRepeatableAnnotations(testContext.testClass, AcceptanceTest::class.java)
            .map { it.setUpScripts }
            .forEach { files ->
                files.forEach { file ->
                    setUpDatabase(jdbcTemplate, objectMapper, file)
                }
            }
    }

    private fun setUpDatabase(jdbcTemplate: JdbcTemplate, objectMapper: ObjectMapper, filePath: String) {
        val parsedJsonSql = objectMapper.readValue(
            StreamUtils.copyToString(ClassPathResource(filePath).inputStream, Charset.defaultCharset()),
            Map::class.java
        ) as Map<String, List<Map<String, String>>>

        createInsertQueries(parsedJsonSql).forEach { query ->
            jdbcTemplate.execute(query)
        }
    }

    private fun createInsertQueries(parsedJsonSql: Map<String, List<Map<String, Any>>>): List<String> {
        return parsedJsonSql.flatMap { (tableName, rows) ->
            rows.map { row ->
                val columns = row.keys.joinToString(", ")
                val values = row.values.joinToString(", ") { value: Any? ->
                    formatValue(value)
                }
                "INSERT INTO $tableName ($columns) VALUES ($values);"
            }
        }
    }

    private fun formatValue(value: Any?): String {
        return when {
            value == null -> "NULL"
            value is String && value.lowercase() == "now()" -> "now()"
            else -> "'$value'"
        }
    }

    override fun afterTestMethod(testContext: TestContext) {
        val jdbcTemplate = testContext.applicationContext.getBean(JdbcTemplate::class.java)
        val truncateQueries = getTruncateQueries(jdbcTemplate)
        truncateTables(jdbcTemplate, truncateQueries)
    }

    private fun getTruncateQueries(jdbcTemplate: JdbcTemplate): List<String> {
        return jdbcTemplate.queryForList(
            "SELECT Concat('TRUNCATE TABLE ', TABLE_NAME, ';') AS q FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = 'PUBLIC'",
            String::class.java
        )
    }

    private fun truncateTables(jdbcTemplate: JdbcTemplate, truncateQueries: List<String>) {
        jdbcTemplate.execute("SET FOREIGN_KEY_CHECKS = 0")
        truncateQueries.forEach { query -> jdbcTemplate.execute(query)}
        jdbcTemplate.execute("SET FOREIGN_KEY_CHECKS = 1")
    }
}

@TestExecutionListeners(
    value = [AcceptanceTestExecutionListener::class],
    mergeMode = TestExecutionListeners.MergeMode.MERGE_WITH_DEFAULTS
)

interface IsDirectIssueTargetPort {
    fun isTarget(request: IsDirectIssueTargetRequest): Boolean
}

@Component
@Profile("!test")
internal class IsDirectIssueTargetAdapter(
    private val telegramSendService: TelegramSendService,
) : IsDirectIssueTargetPort {

    override fun isTarget(
        request: IsDirectIssueTargetRequest,
    ): Boolean {
        return TelegramDeserializer.parseObject(
            telegramSendService.sendIssue(request),
            IsDirectIssueTarget::class.java
        ).isSuccess()
}

@Component
@Profile("test")
internal class TestIsDirectIssueTargetAdapter : IsDirectIssueTargetPort {

    override fun isTarget(request: IsDirectIssueTargetRequest): Boolean {
        return request.userNo != -1L
    }
}

@Profile("!test")
@Component
class MessengerAdapter(
    private val messengerProperties: MessengerProperties,
    private val webClient: WebClient,
) : SendMessagePort {

    override fun send(message: String) {
        webClient.call<String>(
            host = messengerProperties.host,
            method = HttpMethod.POST,
            uri = messengerProperties.alertUrl,
            requestBody = SendMessageAlertPayload(message),
        )
    }
}


@Profile("test")
@Component
class TestMessengerAdapter : SendMessagePort {

    override fun send(message: String) {
		    // Do nothing.
    }
}

@AcceptanceTest("acceptance/getIssueCardStatus.json")
@Import(CardAppControllerTestConfiguration::class)
class CardAppControllerTest(
    private val loadMinorPort: LoadMinorPort,
) : FunSpec({

    context("카드 발급 상태 조회") {
        test("발급없이 가입 이후 7일이 지나면 null 반환") {
            val minor = minor().copy(
                regTimestamp = LocalDateTime.now().minusDays(8L)
            )
            every { loadMinorPort.loadByUserIdOrThrow(minor.userId) } returns minor

            val 발급상태 = 발급상태조회(minor.userId)
            발급상태 shouldBe null
        }

        test("발급없이 가입 이후 7일 전에는 스킴으로 랜딩") {
            val minor = minor().copy(
                regTimestamp = LocalDateTime.now().minusDays(7L).plusHours(1L)
            )
            every { loadMinorPort.loadByUserIdOrThrow(minor.userId) } returns minor

            val 발급상태 = 발급상태조회(minor.userId)!!
            발급상태["landingScheme"] shouldBe "toss-scheme"
        }
    }

    extension(SpringExtension)
})

private fun 발급상태조회(userId: Long): Map<String, String>? {
    return RestAssured
        .given().log().all()
        .header(TossLoggingUtil.USER_ID, userId)
        .`when`()
        .get("/api/cards/status")
        .then().log().all().extract()
        .jsonPath().getMap("success")
}

private class CardAppControllerTestConfiguration {

    @Bean
    @Primary
    fun loadMinorPort(): LoadMinorPort {
        return mockk(relaxed = true)
    }
}

data class Member(
    val userId: Long,
    val name: String,
    val age: Int,
)

data class Member(
    val userNum: Long,
    val name: String,
    val age: Int,
)

class ChargingChannelApprovalTest {

    @Test
    fun chargingChannelApprovalTest() {
        val chargingChannel = ChargingChannel.create(
            userId = -1L,
            bankCode = 23,
            expirationDate = null,
        )
        
        val result = JsonUtil.writeValueAsString(chargingChannel)

        Approvals.verify(result)
    }
}

@Service
class CreateAccountUseCase(
    private val loadTossUserPort: LoadTossUserPort,
    private val accountEventPort: AccountEventPort,
    private val smallSavingProfile: SmallSavingProfile,
) {

    override fun execute(input: CreateAccountInput): CreateAccountOutput {
        val user = loadTossUserPort.findUser(input.userId)
        
        if (cannotCreateAccount(user)) {
            throw RuntimeException("계좌를 생성할 수 없는 사용자입니다.")
        }

        val id = createAccount(user)

        // 변경 전 코드
        if (cannotParticipateEvent()) {
            return CreateAccountOutput(id)
        }

        participateAccountEventPort.apply(user)
        return CreateAccountOutput(id)
    }


    private fun cannotParticipateEvent(): Boolean {
        val today = LocalDate.now()
        return today.isBefore(EVENT_START_DATE) || today.isAfter(EVENT_END_DATE)
    }

    companion object {
        val EVENT_START_DATE: LocalDate = LocalDate.of(2024, 9 ,14)
        val EVENT_END_DATE: LocalDate = LocalDate.of(2024, 9 ,18)
    }
}

@Service
class CreateAccountUseCase(
    private val loadTossUserPort: LoadTossUserPort,
    private val accountEventPort: AccountEventPort,
    private val smallSavingProfile: SmallSavingProfile,
) {

    fun execute(input: CreateAccountInput): CreateAccountOutput {
        val user = loadTossUserPort.findUser(input.userId)
        
        if (cannotCreateAccount(user)) {
            throw RuntimeException("계좌를 생성할 수 없는 사용자입니다.")
        }

        val id = createAccount(user)

        // 변경 후 코드
        if (cannotParticipateEvent(LocalDate.now())) {
            return CreateAccountOutput(id)
        }

        participateAccountEventPort.apply(user)
        return CreateAccountOutput(id)
    }

    @VisibleForTesting
    fun cannotParticipateEvent(today: LocalDate): Boolean {
        return today !in EVENT_START_DATE..EVENT_END_DATE
    }

    companion object {
        val EVENT_START_DATE: LocalDate = LocalDate.of(2024, 9 ,14)
        val EVENT_END_DATE: LocalDate = LocalDate.of(2024, 9 ,18)
    }
}

class ObjectMapperLearningTest {

    private val objectMapper = ObjectMapper()

    @Test
    fun `JSON 문자열을 객체로 변환하기`() {
        val json = """
            {
                "name": "MangKyu",
                "email": "mangkyu@example.com"
            }
        """.trimIndent()
        
        val user = objectMapper.readValue(json, User::class.java)
        
        assertThat(user.name).isEqualTo("MangKyu")
        assertThat(user.email).isEqualTo("mangkyu@example.com")
    }
}