สัญญาของขอบ เขียนเป็นตาราง แล้วบังคับด้วยเทสต์

เจ็ดบทที่ผ่านมาให้ข้อเท็จจริงมาเป็นชุด · บทนี้รวบมันเป็นของชิ้นเดียวที่ส่งต่อได้

ตารางเดียวที่ตอบได้ทุกกรณี

ซ้ายมือคือเหตุการณ์ข้างใน ขวามือคือสิ่งที่ผู้เรียกได้รับ

เหตุการณ์ข้างใน	รหัส	content-type	body บอกอะไร	ลองใหม่ช่วยไหม
คำขอถูกต้อง	200	`application/json`	`id` ของใบที่จอง	—
ส่งซ้ำด้วยคีย์เดิม	200	`application/json`	`id` ตัวเดิม กับ `replayed`	ไม่ต้องลอง
กรอกผิด	400	`application/problem+json`	`errors` ครบทุกช่องที่ผิด	ต้องแก้ก่อน
ชนกับใบที่มีอยู่	409	`application/problem+json`	`retryable` เป็น false	ไม่ช่วย
ระบบพังจริง	500	`application/json`	ไม่บอกอะไรเกินรหัส	อาจช่วย

แถวสุดท้ายเป็นแถวเดียวที่เราไม่ได้แก้ · และนั่นคือความตั้งใจ

ความล้มเหลวที่เราไม่ได้คาดไว้ ไม่ควรพ่นรายละเอียดข้างในออกไปให้ใครก็ได้อ่าน · สิ่งที่ผู้เรียกต้องรู้จากแถวนั้นมีข้อเดียว คือปัญหาอยู่ฝั่งเรา

ตารางที่เขียนไว้เฉยๆ ไม่ใช่สัญญา

มันคือความตั้งใจ · และความตั้งใจไม่มีอะไรบังคับ

นี่คือคำถามเดียวกับที่คอร์สก่อนเปิดหัวไว้ · เอกสารออกแบบไม่บังคับอะไร

ตารางข้างบนจะเป็น boundary contract ก็ต่อเมื่อมีอะไรสักอย่างที่แดงขึ้นมา เมื่อมีคนทำให้มันไม่จริง

package clinic.http

import org.springframework.beans.factory.annotation.Value
import org.springframework.boot.test.context.SpringBootTest
import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue

/**
 * สัญญาของขอบ · หนึ่งแถวในตารางของบทที่ 8 คือหนึ่งข้อทดสอบ
 *
 * เทสต์นี้ไม่ได้ตรวจว่าระบบข้างในทำงานถูก · มันตรวจว่าสิ่งที่เราพูดกับผู้เรียก
 * ตรงกับที่สัญญาไว้ · ทุกข้อใช้ช่วงเวลาของตัวเอง จึงไม่ขึ้นกับลำดับที่ JUnit เลือกรัน
 */
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class BoundaryContractTest {

    @Value("\${local.server.port}")
    var port: Int = 0

    private fun post(json: String, key: String? = null): Pair<Int, String> {
        val b = HttpRequest.newBuilder(URI.create("http://127.0.0.1:" + port + "/bookings"))
            .header("content-type", "application/json")
        if (key != null) b.header("Idempotency-Key", key)
        val r = HttpClient.newHttpClient().send(
            b.POST(HttpRequest.BodyPublishers.ofString(json)).build(),
            HttpResponse.BodyHandlers.ofString(),
        )
        return r.statusCode() to r.body()
    }

    @Test
    fun `คำขอที่ถูกต้อง ได้ 200`() {
        val (status, _) = post("""{"doctorId":"d-contract","startMinute":700,"endMinute":730}""")
        assertEquals(200, status)
    }

    @Test
    fun `คำขอที่กรอกผิด ได้ 400 พร้อมชื่อช่องที่ผิด`() {
        val (status, body) = post("""{"doctorId":"","startMinute":-5,"endMinute":0}""")
        assertEquals(400, status)
        assertTrue(body.contains("\"errors\""), body)
        assertTrue(body.contains("doctorId"), body)
    }

    @Test
    fun `คำขอที่ชนของเดิม ได้ 409 และบอกว่าลองใหม่ไม่ช่วย`() {
        post("""{"doctorId":"d-contract","startMinute":800,"endMinute":830}""")
        val (status, body) =
            post("""{"doctorId":"d-contract","startMinute":810,"endMinute":840}""")
        assertEquals(409, status)
        assertTrue(body.contains("\"retryable\":false"), body)
    }

    @Test
    fun `คำขอเดิมที่ส่งซ้ำด้วยคีย์เดิม ได้ 200 และ id ตัวเดิม`() {
        val body = """{"doctorId":"d-contract","startMinute":900,"endMinute":930}"""
        val (firstStatus, first) = post(body, "contract-1")
        val (againStatus, again) = post(body, "contract-1")
        assertEquals(200, firstStatus)
        assertEquals(200, againStatus)
        assertEquals(first.substringAfter("\"id\":").substringBefore(","),
            again.substringAfter("\"id\":").substringBefore(","))
        assertTrue(again.contains("\"replayed\":true"), again)
    }
}

🎯 ทุกข้อใช้ช่วงเวลาของตัวเอง

สี่ข้อนี้รันในลำดับไหนก็ได้ · JUnit ไม่รับประกันลำดับ และเราไม่ควรพึ่งมัน

ร่างแรกของเทสต์ชุดนี้ใช้ช่วงเวลาเดียวกันสองข้อ · ข้อที่รันทีหลังจึงชนกับแถวที่ ข้อแรกสร้างไว้ แล้วแดงด้วยเหตุผลที่ไม่เกี่ยวกับสิ่งที่มันตรวจ

เทสต์ที่แดงด้วยเหตุผลอื่น ไม่ได้บอกอะไรเกี่ยวกับสัญญาเลย

สิ่งที่สัญญานี้ไม่ครอบคลุม

ต้องเขียนไว้ให้ชัดพอกับสิ่งที่มันครอบคลุม

ใครเรียกได้บ้าง ทั้งคอร์สไม่แตะการยืนยันตัวตนกับสิทธิ์เลย · ตารางข้างบนบอกว่าเราตอบอะไร ไม่ได้บอกว่าเราควรตอบให้ใคร
คำตอบของครั้งแรกไม่ได้ถูกเก็บไว้ Idempotency-Key ในบทที่ 5 ใช้ค้นหาแถว แล้วประกอบคำตอบใหม่ · ถ้าคำขอแรกล้มกลางทาง คีย์นั้นจะไม่มีแถวให้ค้นเจอ
ช่องว่างระหว่างค้นกับบันทึก คำขอสองใบที่มีคีย์เดียวกันและเข้ามาพร้อมกันจริงๆ ใบหลังจะได้ 409 แทนที่จะได้ผลเดิม · unique index กันข้อมูลซ้ำได้ แต่กันคำตอบที่ ไม่สม่ำเสมอไม่ได้
ความเร็ว ทั้งคอร์สไม่มีหน่วยเวลาสักตัว ตามที่ประกาศไว้ตั้งแต่หน้าแรก

รายการนี้ไม่ใช่หนี้ที่ต้องรีบใช้ · มันคือขอบเขตที่ประกาศไว้ · สัญญาที่ไม่บอกว่าตัวเองไม่ครอบอะไร คือสัญญาที่ถูกอ่านกว้างเกินจริงเสมอ

กลับไปที่คำถามที่เปิดคอร์สไว้

ความถูกต้องที่คอร์สก่อนสร้างไว้ เหลืออะไรอยู่บ้างเมื่อออกไปถึงผู้เรียก

ตอนเริ่มคอร์ส คำตอบคือเกือบไม่เหลืออะไรเลย · คำขอที่ผิดกับระบบที่พังจริงมีรูปเดียวกัน และความขัดแย้งที่ฐานข้อมูลกันไว้ได้สำเร็จ ออกไปเป็นคำว่า “เราพัง”

ตอนนี้ทั้งห้าเหตุการณ์ในตารางแยกออกจากกันได้จากฝั่งผู้เรียก · และมีเทสต์ที่แดงเมื่อมีใครทำให้ข้อไหนไม่จริง

boundary ไม่ใช่ที่ที่ความรู้ของเราหยุดเดินทางอีกต่อไป · มันคือที่ที่เราเลือกว่าจะให้อะไรเดินทางต่อ

🔬 ทุกอย่างในคอร์สนี้ยืนยันซ้ำได้

npm run verify:clinic-http สร้างโปรเจกต์ทั้งใบขึ้นใหม่ วัดเจ็ดทรง แล้วเทียบทีละช่อง · อยู่นอก CI เพราะต้องใช้ Docker
รหัสออกของมันมีสามความหมาย · 0 ข้ออ้างยังจริง · 1 ข้ออ้างผิด · 2 วัดไม่ได้บนเครื่องนี้ · สองอย่างหลังต่างกันมาก และต้องอ่านออกจากกัน
เทสต์ในบทนี้รันอยู่ในทรงสุดท้ายของ probe จริง · ถ้ามันแดง probe ล้มทั้งตัว
Spring Boot 4.1.1 · Kotlin 2.4.10 · JDK 25 · PostgreSQL 18 · pg driver 42.7.13

เช็กความเข้าใจ — บทที่ 8

ข้อ 1 / 3

ทำไมแถวของ 500 ในตารางสัญญา จึงเป็นแถวเดียวที่คอร์สนี้ไม่แก้

สัญญา​ของ​ขอบ เขียน​เป็น​ตาราง แล้ว​บังคับ​ด้วย​เทสต์

ตาราง​เดียว​ที่​ตอบ​ได้​ทุก​กรณี

ตาราง​ที่​เขียน​ไว้​เฉยๆ ไม่ใช่​สัญญา