หากคุณเคยค้นหาวิธีที่จะได้รับการทดสอบ API โดยไม่ต้องเขียนด้วยตัวเอง คุณน่าจะเคยเจอ Keploy มันให้สัญญาที่ฟังดูสะดวกสบายเกินจริง: แค่ชี้ไปที่แอปพลิเคชันที่กำลังทำงานอยู่ ปล่อยให้มันเฝ้าดูทราฟฟิกจริง แล้วคุณก็จะได้รับชุดทดสอบกลับมา แล้ว Keploy กำลังทำอะไรอยู่เบื้องหลังจริงๆ และมันจะเข้ากับสแต็กการทดสอบของคุณได้อย่างไร?
คู่มือนี้จะอธิบายว่า Keploy คืออะไร, กลไกการบันทึกและเล่นซ้ำของมันทำงานอย่างไรที่เลเยอร์เครือข่าย eBPF, เวิร์กโฟลว์ทั้งสองที่นำเสนอ, วิธีการติดตั้งและเรียกใช้, และข้อจำกัดที่แท้จริงที่คุณควรรู้ก่อนนำไปใช้
Keploy คืออะไร
Keploy เป็นแพลตฟอร์มโอเพนซอร์ส (ภายใต้ใบอนุญาต Apache-2.0) สำหรับสร้างแซนด์บ็อกซ์การผลิตที่ปลอดภัยและแยกจากกันสำหรับการทดสอบ API, การผสานรวม และแบบ End-to-End แนวคิดหลักคือแอปพลิเคชันจริงของคุณแสดงพฤติกรรมที่คุณต้องการทดสอบอยู่แล้ว แทนที่จะขอให้คุณอธิบายพฤติกรรมนั้นในโค้ดทดสอบ Keploy จะสังเกตการณ์และเปลี่ยนให้เป็นการทดสอบที่สามารถทำซ้ำได้
มันให้คุณทำได้สองวิธี:
- บันทึกและเล่นซ้ำ บันทึกการโต้ตอบ API จริงและส่วนที่เกี่ยวข้อง จากนั้นเล่นซ้ำอย่างแม่นยำ
- การสร้างการทดสอบด้วย AI สร้างชุดทดสอบ API ที่ผ่านการตรวจสอบจากข้อกำหนด, คอลเล็กชัน, คำสั่ง cURL หรือปลายทางที่ใช้งานจริง
ทั้งสองวิธีสร้างการทดสอบที่รันได้พร้อมกับ mocks ที่จำเป็นในการรันโดยไม่ต้องเรียกใช้ส่วนที่เกี่ยวข้องจริง โปรเจกต์นี้เป็นโอเพนซอร์ส ดังนั้นคุณสามารถอ่านโค้ดและโฮสต์เองได้ Repository อยู่ที่ github.com/keploy/keploy และเอกสารอย่างเป็นทางการอยู่ที่ keploy.io/docs
กลไกการบันทึกของ Keploy ทำงานอย่างไรที่เลเยอร์ eBPF
นี่คือส่วนที่ทำให้ Keploy แตกต่าง เมื่อคุณรัน keploy record มันไม่ได้ขอให้คุณเพิ่ม SDK หรือเปลี่ยนโค้ดแอปพลิเคชันของคุณแม้แต่บรรทัดเดียว มันบันทึกทราฟฟิกที่เลเยอร์เครือข่ายโดยใช้ eBPF ซึ่งเป็นเทคโนโลยีเคอร์เนล Linux ที่ช่วยให้โปรแกรมสามารถสังเกตและดำเนินการกับเหตุการณ์ระบบได้อย่างปลอดภัย
นี่คือสิ่งที่คุณจะได้รับจากการใช้งานจริง:
- การบันทึกโดยไม่ต้องเขียนโค้ด ไม่มีเครื่องมือวัด, ไม่มีฮาร์เนสทดสอบ, ไม่มีตัวตกแต่งในตัวจัดการของคุณ Keploy ทำงานอยู่ใต้แอปพลิเคชันของคุณและเฝ้าดูข้อมูลที่เข้าและออก
- การบันทึกที่ไม่ขึ้นกับภาษา เนื่องจากการบันทึกเกิดขึ้นที่เลเยอร์เครือข่ายเคอร์เนล แทนที่จะเป็นภายในรันไทม์ มันจึงทำงานได้เหมือนกันไม่ว่าบริการของคุณจะเขียนด้วย Go, Python หรือ Rust
- การบันทึกส่วนที่เกี่ยวข้อง Keploy ไม่ได้บันทึกแค่การเรียก API ขาเข้าและการตอบกลับเท่านั้น มันยังบันทึกการเรียกออกที่บริการของคุณทำไปยังส่วนที่เกี่ยวข้อง เช่น การสอบถามฐานข้อมูลและเหตุการณ์เครือข่ายหรือสตรีมมิ่ง
ประเด็นสุดท้ายมีความสำคัญ เมื่อ Keploy บันทึกคำขอ มันจะบันทึกภาพรวมทั้งหมด: คำขอ API, การตอบกลับ API และการเรียกส่วนที่เกี่ยวข้องทุกครั้งที่เกิดขึ้นระหว่างนั้น จากนั้นมันจะสร้างอาร์ติแฟกต์สองชิ้นจากการโต้ตอบที่สังเกตได้เพียงครั้งเดียว:
- กรณีทดสอบ ที่อธิบายคำขอและการตอบกลับที่คาดหวัง
- Mocks และ Stubs สำหรับการเรียกส่วนที่เกี่ยวข้องแต่ละครั้ง เพื่อให้การทดสอบสามารถเล่นซ้ำได้โดยไม่มีฐานข้อมูลจริงหรือบริการดาวน์สตรีม
การเล่นซ้ำเป็นการปิดวงจร เมื่อคุณรัน keploy test มันจะส่งคำขอที่บันทึกไว้กลับไปยังแอปพลิเคชันของคุณ ให้บริการการตอบกลับส่วนที่เกี่ยวข้องที่บันทึกไว้จาก mocks ที่สร้างขึ้น และเปรียบเทียบการตอบกลับใหม่กับที่บันทึกไว้ หากไม่ตรงกันแสดงว่ามีบางอย่างเปลี่ยนแปลง นี่คือเหตุผลที่วิธีการนี้เรียกว่าการบันทึกและเล่นซ้ำ: คุณบันทึกพฤติกรรมรันไทม์จริงหนึ่งครั้ง จากนั้นเล่นซ้ำอย่างแม่นยำเป็นการทดสอบการถดถอยทุกครั้งที่มีการเปลี่ยนแปลง
เวิร์กโฟลว์ Keploy สองแบบ
บันทึกและเล่นซ้ำ
ใช้สิ่งนี้เมื่อคุณมีแอปพลิเคชันที่ทำงานอยู่แล้วและต้องการความครอบคลุมการถดถอยอย่างรวดเร็ว คุณรันแอปภายใต้ Keploy, ทดสอบการทำงานเหมือนที่ผู้ใช้จริงหรือลูกค้าจะทำ (การเรียกด้วยตนเอง, การทดสอบการผสานรวมที่มีอยู่, หรือทราฟฟิกจริง) และ Keploy จะบันทึกการโต้ตอบแต่ละครั้งเป็นกรณีทดสอบพร้อมกับ mocks ของมัน การรันในภายหลังจะเล่นซ้ำการโต้ตอบเหล่านั้นและแจ้งเตือนหากมีพฤติกรรมที่เปลี่ยนแปลงไป
การสร้างการทดสอบด้วย AI
ใช้สิ่งนี้เมื่อคุณต้องการความครอบคลุมที่กว้างขึ้นกว่าที่คุณทำด้วยตนเอง หรือเมื่อคุณเริ่มต้นจากสัญญา (contract) แทนที่จะเป็นโฟลว์ที่กำลังทำงานอยู่ Keploy สามารถสร้างชุดทดสอบ API ที่ผ่านการตรวจสอบจากข้อกำหนด OpenAPI, คอลเล็กชัน Postman, คำสั่ง cURL หรือปลายทางที่ใช้งานจริง มันจำลองส่วนที่เกี่ยวข้องโดยอัตโนมัติและดำเนินการทำความสะอาดอัตโนมัติเพื่อให้คุณไม่มีกรณีที่ซ้ำซ้อน
เวิร์กโฟลว์ทั้งสองเสริมซึ่งกันและกัน การบันทึกและเล่นซ้ำจะยึดการทดสอบไว้กับพฤติกรรมจริงที่สังเกตได้; การสร้างการทดสอบด้วย AI จะเติมเต็มช่องว่างจากข้อกำหนดของคุณ หากคุณกำลังประเมินเครื่องมือที่สร้างการทดสอบจาก schema บทสรุปของเราเกี่ยวกับ เครื่องมือสร้างกรณีทดสอบ AI ที่ดีที่สุด และคู่มือ การสร้างสคริปต์ทดสอบจาก OpenAPI เป็นคู่หูที่ดี
การติดตั้ง Keploy
Keploy มาพร้อมกับสคริปต์การติดตั้ง ในระบบที่รองรับคุณสามารถรัน:
curl --silent -O -L https://keploy.io/install.sh && source install.sh
สิ่งนี้จะดึงไบนารีและตั้งค่าคำสั่ง keploy จากนั้นคุณจะควบคุมทุกอย่างผ่านสองคำสั่งหลัก
คำสั่งหลักของ Keploy
มีสองคำสั่งที่คุณจะใช้บ่อยที่สุด คำสั่งแรกคือการบันทึก:
keploy record -c "CMD_TO_RUN_APP"
คุณส่งคำสั่งที่แน่นอนที่ใช้เริ่มต้นแอปพลิเคชันของคุณผ่าน -c Keploy จะเปิดแอปของคุณ ตรวจสอบทราฟฟิกในขณะที่คุณใช้งาน และบันทึกกรณีทดสอบและ mocks ที่ถูกบันทึกไว้
คำสั่งที่สองคือการเล่นซ้ำ:
keploy test -c "CMD_TO_RUN_APP" --delay 10
แฟล็ก --delay 10 บอก Keploy ให้รอสิบวินาทีก่อนที่จะเริ่มส่งคำขอที่บันทึกไว้ ซึ่งทำให้บริการที่ช้ากว่ามีเวลาเพียงพอที่จะเริ่มต้นการทำงานให้เสร็จสมบูรณ์ก่อนที่จะเริ่มการเล่นซ้ำ หากแอปของคุณต้องใช้เวลานานขึ้นในการเริ่มต้น ให้เพิ่มตัวเลข; หากเริ่มต้นเร็ว คุณสามารถลดลงได้
เซสชันแรกทั่วไปมีลักษณะดังนี้:
# 1. บันทึกขณะที่คุณเรียกใช้ API ของคุณ
keploy record -c "node server.js"
# 2. เล่นซ้ำกรณีที่บันทึกไว้และตรวจสอบการเปลี่ยนแปลง
keploy test -c "node server.js" --delay 10
นั่นคือวงจรทั้งหมด บันทึกหนึ่งครั้งจากบิลด์ที่ใช้งานได้ดี จากนั้นรัน keploy test ใน CI ทุกครั้งที่มีการเปลี่ยนแปลง
ภาษา โปรโตคอล และที่เก็บข้อมูลที่รองรับ
เนื่องจากการบันทึกเกิดขึ้นที่เลเยอร์เครือข่าย Keploy จึงครอบคลุมพื้นที่กว้าง:
| หมวดหมู่ | รองรับ |
|---|---|
| ภาษา | Go, Java, Node.js, Python, Rust, C#, C/C++, TypeScript และอื่นๆ |
| โปรโตคอล | HTTP/REST, gRPC, GraphQL, Kafka, RabbitMQ |
| ที่เก็บข้อมูล | PostgreSQL, MySQL, MongoDB, Redis |
ความกว้างขวางเป็นผลโดยตรงจากการออกแบบ eBPF Keploy กำลังอ่านการสนทนาเครือข่าย ดังนั้นภาษาหรือเฟรมเวิร์กใหม่ไม่จำเป็นต้องมีปลั๊กอินใหม่ ตราบใดที่มันสื่อสารด้วยหนึ่งในโปรโตคอลเหล่านี้
การรัน Keploy ใน CI
คำสั่งทั้งสองสร้างขึ้นสำหรับการทำงานอัตโนมัติ ใน pipeline คุณจะคอมมิตกรณีทดสอบและ mocks ที่บันทึกไว้พร้อมกับโค้ดของคุณ จากนั้นรัน keploy test -c "..." เป็นขั้นตอน เนื่องจาก mocks แทนที่ส่วนที่เกี่ยวข้องจริง การเล่นซ้ำจึงไม่จำเป็นต้องมีฐานข้อมูลจริงหรือบริการดาวน์สตรีมใน CI runner ซึ่งทำให้งานรวดเร็วและแม่นยำ การเล่นซ้ำที่ล้มเหลวจะทำให้บิลด์ล้มเหลว เช่นเดียวกับการทดสอบหน่วย
ข้อจำกัดที่ควรพิจารณาอย่างตรงไปตรงมา
Keploy เก่งในสิ่งที่มันทำ แต่มันไม่เหมาะกับทุกสถานการณ์ การประเมินที่เป็นธรรมควรรวมถึงข้อแลกเปลี่ยน:
- มันมักจะทำงานบน Linux และต้องการสิทธิ์ระดับสูง eBPF เป็นฟีเจอร์เคอร์เนลของ Linux และการบันทึกที่เลเยอร์นั้นโดยทั่วไปแล้วต้องการสิทธิ์ระดับสูง นั่นกำหนดว่าคุณสามารถรันได้ที่ไหนและอย่างไร
- การทดสอบที่สร้างขึ้นจำเป็นต้องมีการจัดการ การทดสอบที่สร้างขึ้นจากทราฟฟิกจริงหรือการสร้างด้วย AI เป็นจุดเริ่มต้น ไม่ใช่ชุดที่สมบูรณ์ คุณยังคงต้องตรวจสอบมัน กำจัดสิ่งรบกวน และตัดสินใจว่าพฤติกรรมที่บันทึกไว้นั้นเป็นสัญญาที่ควรบังคับใช้จริงหรือไม่
- มันเป็นเครื่องมือทดสอบและสร้างการทดสอบ ไม่ใช่แพลตฟอร์มวงจรชีวิต API เต็มรูปแบบ Keploy มุ่งเน้นไปที่การบันทึก สร้าง และเล่นซ้ำการทดสอบ ไม่ได้ออกแบบมาเพื่อจัดการการออกแบบ API, เอกสาร, การเผยแพร่ mock-server สำหรับผู้บริโภค หรือการทำงานร่วมกันของทีมรอบข้อกำหนด API
สิ่งเหล่านี้ไม่ใช่ข้อเสียของ Keploy มันเป็นขอบเขตธรรมชาติของหมวดหมู่ของมัน การรู้สิ่งเหล่านี้ช่วยให้คุณตัดสินใจได้ว่ามันแก้ปัญหาของคุณได้ทั้งหมดหรือเพียงบางส่วนเท่านั้น
Apidog เหมาะสมอย่างไรในฐานะทางเลือกการทดสอบที่ออกแบบมา
หากความต้องการของคุณกว้างกว่า “เปลี่ยนทราฟฟิกที่สังเกตได้ให้เป็นการทดสอบการถดถอย” ก็ควรพิจารณาแพลตฟอร์มวงจรชีวิตเต็มรูปแบบ Apidog เป็นแพลตฟอร์ม API แบบครบวงจรที่ครอบคลุมการออกแบบ, การดีบัก, การ mock, เอกสาร และการทดสอบในที่เดียว ความแตกต่างในปรัชญาคือสิ่งสำคัญที่ต้องเข้าใจ เพราะ Apidog และ Keploy อยู่ในหมวดหมู่ที่แตกต่างกัน
Keploy บันทึกและเล่นซ้ำพฤติกรรมรันไทม์จริง รวมถึง mocks ของส่วนที่เกี่ยวข้อง โดยไม่ต้องเขียนโค้ด Apidog ใช้เส้นทางตรงกันข้าม: คุณออกแบบและสร้างสถานการณ์การทดสอบที่ดูแลรักษาง่าย จากนั้นรันจากเทอร์มินัลและ CI ด้วย Apidog CLI CLI รันคอลเล็กชันที่คุณสร้างขึ้นด้วย การทดสอบที่ขับเคลื่อนด้วยข้อมูล ผ่าน CSV หรือ JSON, การสลับสภาพแวดล้อม และ รายงาน CLI, HTML และ JSON Apidog ยังเสนอ การสร้างกรณีทดสอบด้วย AI จากสคีมา API และปลายทางของคุณ ซึ่งสร้างขึ้นภายในแอป ซึ่งเป็นจุดที่เครื่องมือทั้งสองทับซ้อนกัน
เพื่อให้ชัดเจนเกี่ยวกับขอบเขต: Apidog ไม่ได้บันทึกทราฟฟิกสดผ่าน eBPF และไม่ได้สร้างการทดสอบอัตโนมัติโดยการบันทึกการเรียกใช้จริงรวมถึง mocks ของส่วนที่เกี่ยวข้อง ความสามารถในการบันทึกจากทราฟฟิกจริงนั้นเป็นของ Keploy อย่างแท้จริง การวางกรอบอย่างตรงไปตรงมาคือคุณเลือกตามงาน ใช้ Keploy เมื่อคุณต้องการการบันทึกและเล่นซ้ำรันไทม์โดยไม่ต้องเขียนโค้ด ใช้ Apidog เมื่อคุณต้องการชุดทดสอบที่ออกแบบมาและดูแลรักษาง่ายภายในแพลตฟอร์มที่จัดการวงจรชีวิต API ที่เหลือด้วย สำหรับการเปรียบเทียบแบบเจาะลึก โปรดดู Apidog vs Keploy และหากคุณตัดสินใจที่จะเปลี่ยน คู่มือ การย้ายข้อมูล จะครอบคลุมการย้ายการทดสอบของคุณ
หากคุณกำลังมองหาการทดสอบ API ที่ดูแลรักษาง่ายและสร้างขึ้นเอง คุณสามารถ ดาวน์โหลด Apidog และเริ่มต้นด้วยคู่มือ การทดสอบ API ด้วย Apidog
คำถามที่พบบ่อย
Keploy ฟรีและเป็นโอเพนซอร์สหรือไม่? ใช่ Keploy เป็นโอเพนซอร์สภายใต้ใบอนุญาต Apache-2.0 และโค้ดอยู่ใน GitHub คุณสามารถโฮสต์เองได้
Keploy ต้องเปลี่ยนโค้ดแอปพลิเคชันของฉันหรือไม่? ไม่ เวิร์กโฟลว์การบันทึกและเล่นซ้ำจะบันทึกทราฟฟิกที่เลเยอร์เครือข่าย eBPF ดังนั้นจึงไม่มี SDK ให้เพิ่มและไม่มีการเปลี่ยนแปลงโค้ด นี่คือเหตุผลที่มันทำงานได้กับหลายภาษา
แฟล็ก --delay ใน keploy test ทำหน้าที่อะไร? มันกำหนดจำนวนวินาทีที่ Keploy จะรอก่อนที่จะส่งคำขอที่บันทึกไว้ เพื่อให้แอปของคุณมีเวลาเริ่มต้นทำงาน --delay 10 จะรอสิบวินาที; เพิ่มขึ้นสำหรับบริการที่เริ่มต้นช้า
Keploy สามารถจำลองฐานข้อมูลของฉันระหว่างการทดสอบได้หรือไม่? ใช่ เมื่อบันทึกการโต้ตอบ มันจะบันทึกการเรียกส่วนที่เกี่ยวข้อง (เช่น การสอบถามฐานข้อมูล) และสร้าง mocks สำหรับสิ่งเหล่านั้น ดังนั้นการเล่นซ้ำจึงทำงานได้โดยไม่ต้องมีฐานข้อมูลจริง
Keploy เป็นสิ่งทดแทนเครื่องมือออกแบบและจัดทำเอกสาร API หรือไม่? ไม่ Keploy เป็นเครื่องมือทดสอบและสร้างการทดสอบ สำหรับการออกแบบ API, เอกสาร, การจำลองสำหรับผู้บริโภค และการทำงานร่วมกันพร้อมกับการทดสอบ แพลตฟอร์มวงจรชีวิตเต็มรูปแบบอย่าง Apidog จะเหมาะสมกว่า
สรุปโดยย่อ
Keploy เป็นเครื่องมือโอเพนซอร์สที่เปลี่ยนพฤติกรรม API จริงให้เป็นการทดสอบ กลไกการบันทึกและเล่นซ้ำของมันใช้ eBPF เพื่อบันทึกคำขอ การตอบกลับ และการเรียกส่วนที่เกี่ยวข้องที่เลเยอร์เครือข่ายโดยไม่มีการเปลี่ยนแปลงโค้ด จากนั้นเล่นซ้ำสิ่งเหล่านั้นเป็นการทดสอบการถดถอยที่แม่นยำ การสร้างการทดสอบด้วย AI สร้างชุดทดสอบจากข้อกำหนดหรือปลายทาง มันปรับใช้งานได้รวดเร็วและไม่ขึ้นกับภาษา โดยมีข้อแลกเปลี่ยนคือเป็นโมเดลการบันทึกที่เน้น Linux การทดสอบที่ต้องมีการตรวจสอบ และขอบเขตที่จำกัดเฉพาะการทดสอบ หากคุณต้องการชุดทดสอบที่สร้างขึ้นเองและดูแลรักษาง่ายภายในแพลตฟอร์ม API ที่สมบูรณ์ Apidog คือทางเลือกที่จะนำมาเปรียบเทียบ