เครื่องมือ CLI โอเพนซอร์ส ฟรี สำหรับ API จำลอง

เมื่อคุณจำลอง API จากบรรทัดคำสั่ง ใบอนุญาตมีความสำคัญเท่ากับรายการคุณสมบัติ เซิร์ฟเวอร์จำลองที่คุณสามารถอ่านซอร์สโค้ดได้ โฮสต์เองได้ และรันใน CI ได้โดยไม่ต้องนับจำนวนที่นั่ง นั้นแตกต่างอย่างมากจากเซิร์ฟเวอร์จำลอง SaaS ที่โฮสต์อยู่เบื้องหลังการเข้าสู่ระบบ คู่มือนี้ครอบคลุมด้านโอเพนซอร์ส: เครื่องมือที่คุณสามารถโคลน ตรวจสอบ และรันได้ฟรี

เครื่องมือทุกชิ้นในที่นี้มีซอร์สโค้ดเปิดเผยภายใต้ใบอนุญาตแบบเปิดกว้าง (MIT หรือ Apache-2.0) อยู่ในที่เก็บ GitHub สาธารณะ และสามารถโฮสต์เองได้โดยไม่ต้องมีบัญชี นี่คือตัวกรองของเรา หากคุณต้องการตัวเลือกที่เล็กกว่าแบบไบนารีเดียวที่จัดอันดับตามความเร็วในการเริ่มต้นและการติดตั้ง ให้ไปอ่าน ตัวเลือกเซิร์ฟเวอร์จำลองน้ำหนักเบา แทน รายการนี้เกี่ยวกับซอร์สโค้ดและการโฮสต์เอง ดังนั้นแพลตฟอร์มที่โฮสต์เองได้แต่หนักกว่าก็ยังสามารถอยู่ในรายการได้

สำหรับแต่ละเครื่องมือ คุณจะได้รับใบอนุญาต คำสั่งติดตั้งและรันเดียวที่พิสูจน์ว่าใช้งานได้ สิ่งที่ดีที่สุดของมัน และข้อจำกัดของมัน หากคุณต้องการข้อมูลที่กว้างขึ้นรวมถึงตัวเลือกเชิงพาณิชย์ โปรดดูที่ บทสรุปเครื่องมือจำลอง API ที่ดีที่สุด และ ภาพรวมเครื่องมือจำลอง REST API

ข้อสังเกตสั้นๆ อย่างตรงไปตรงมาก่อนเข้าสู่รายการ Apidog ไม่ใช่โอเพนซอร์ส แต่เป็นแพลตฟอร์มเชิงพาณิชย์แบบฟรีเมียม มันจะปรากฏขึ้นหนึ่งครั้งในตอนท้ายในฐานะทางเลือกแบบครบวงจรสำหรับเครื่องมือเหล่านี้ โดยมีการระบุไว้อย่างชัดเจน ไม่ใช่ในฐานะรายการโอเพนซอร์ส ทุกสิ่งในส่วนที่มีหมายเลขด้านล่างนี้เป็นโอเพนซอร์สอย่างแท้จริง

อะไรที่ทำให้เครื่องมือจำลอง CLI เป็นโอเพนซอร์ส

สามสิ่งที่เป็นตัวตัดสินว่าเครื่องมือใดจะอยู่ในรายการนี้

ใบอนุญาต ซอร์สโค้ดต้องเป็นสาธารณะภายใต้ใบอนุญาตแบบเปิดกว้าง ทุกตัวเลือกในที่นี้คือ MIT หรือ Apache-2.0 ดังนั้นคุณสามารถอ่าน คัดลอก และนำไปใช้ในผลิตภัณฑ์ของคุณเองได้โดยไม่มีค่าธรรมเนียมใบอนุญาตหรือการนับจำนวนที่นั่ง

โฮสต์เองได้ คุณรันมันบนแล็ปท็อป ในคอนเทนเนอร์ หรือบนเซิร์ฟเวอร์ของคุณเอง ไม่มีระบบควบคุมแบบโฮสต์ ไม่มีฟังก์ชันโทรกลับหาผู้พัฒนา ไม่มีประตูบัญชี นี่คือสิ่งที่ทำให้การจำลองสามารถใช้งานได้ใน CI runner ที่แยกเครือข่าย

ดูแลรักษาแบบเปิดเผย ที่เก็บ GitHub สาธารณะพร้อมประวัติการคอมมิตจริง ปัญหา และการเผยแพร่ ดาวเป็นสัญญาณคร่าวๆ การคอมมิตล่าสุดและการเผยแพร่ที่มีแท็กเป็นสัญญาณที่ดีกว่า

สังเกตว่าสิ่งใดไม่อยู่ในรายการ: ความเร็วดิบหรือขนาดการติดตั้ง สิ่งเหล่านี้คือ มุมมองแบบน้ำหนักเบา ที่นี่ แพลตฟอร์มขนาดใหญ่ที่ใช้คอนเทนเนอร์และโฮสต์เองได้ ถือว่ายุติธรรมตราบใดที่ซอร์สโค้ดเปิดและใบอนุญาตฟรี

Prism (Stoplight)

Prism แปลงไฟล์ OpenAPI หรือ Postman ให้เป็นเซิร์ฟเวอร์จำลองแบบสด ชี้ไปที่สเปก แล้วมันจะให้บริการตอบกลับตัวอย่าง ตรวจสอบคำขอที่เข้ามากับสคีมา และสามารถรันเป็น validation proxy อยู่หน้า API จริงได้ ใบอนุญาต: Apache-2.0. ที่เก็บ: stoplightio/prism.

npm install -g @stoplight/prism-cli
prism mock https://raw.githubusercontent.com/stoplightio/prism/master/examples/petstore.oas2.yaml

คำสั่งนั้นจะเปิดเซิร์ฟเวอร์จำลองบน http://127.0.0.1:4010 ซึ่งขับเคลื่อนโดยสเปกทั้งหมด GET /pets จะส่งคืนตัวอย่างจากเอกสาร OpenAPI ของคุณ หากส่งเพย์โหลดที่ไม่ถูกต้อง Prism จะแจ้งให้คุณทราบว่าคุณละเมิดส่วนใดของสคีมา

เหมาะที่สุดสำหรับ: การจำลองสัญญาที่ขับเคลื่อนด้วยสเปก โดยไฟล์ OpenAPI เป็นแหล่งความจริง โหมด validation proxy เป็นจุดเด่น; มันตรวจจับความคลาดเคลื่อนระหว่างสเปกของคุณกับ API จริงของคุณ

ข้อจำกัด: การตอบกลับมาจากตัวอย่างและสคีมาของคุณ ดังนั้นการจำลองจะมีความสมบูรณ์เท่ากับสเปกเท่านั้น ไม่มีพฤติกรรมแบบ stateful ในตัว (ไม่มี "สร้างแล้วอ่านกลับมา") เป็นเครื่องมือ Node ดังนั้นคุณต้องมี Node runtime

Mockoon CLI

Mockoon เป็นที่รู้จักกันดีจากแอปพลิเคชันเดสก์ท็อป แต่ CLI มาพร้อมกับเอนจินเดียวกันที่ไม่มี GUI สร้างขึ้นสำหรับ CI และการโฮสต์เอง คุณออกแบบสภาพแวดล้อม (ในแอปหรือด้วยตนเอง) หรือป้อนไฟล์ OpenAPI ให้ แล้วมันจะให้บริการการจำลองนั้น ใบอนุญาต: MIT. ที่เก็บ: mockoon/mockoon.

npm install -g @mockoon/cli
mockoon-cli start --data ./environment.json --port 3000

คุณยังสามารถเริ่มต้นโดยตรงจากไฟล์ OpenAPI ด้วย --data ./openapi.yaml เพิ่ม --watch เพื่อรีโหลดเมื่อไฟล์มีการเปลี่ยนแปลง และ --log-transaction เพื่อพิมพ์บันทึกคำขอ/การตอบกลับฉบับเต็ม

เหมาะที่สุดสำหรับ: การตอบกลับที่ซับซ้อนตามกฎโดยไม่ต้องเขียนโค้ด Mockoon รองรับการสร้างเทมเพลตการตอบกลับ กฎแบบมีเงื่อนไข และโหมดพร็อกซี ดังนั้นเอนด์พอยต์เดียวสามารถส่งคืนข้อมูลที่แตกต่างกันตามคำขอ การออกแบบด้วยภาพในแอปและรันแบบ Headless ผ่าน CLI เป็นการแยกส่วนที่ชัดเจน

ข้อจำกัด: วิธีการสร้างที่ดีที่สุดคือผ่านแอปพลิเคชันเดสก์ท็อป ดังนั้นการแก้ไขไฟล์ JSON ของสภาพแวดล้อมด้วยตนเองจึงค่อนข้างยุ่งยาก ไวยากรณ์การสร้างเทมเพลตแบบไดนามิกก็มีช่วงการเรียนรู้ของตัวเอง

json-server

json-server เป็นวิธีที่เร็วที่สุดในการสร้าง REST API ปลอม คุณป้อนไฟล์ JSON ให้มัน แล้วมันจะสร้างเส้นทาง CRUD (GET, POST, PUT, PATCH, DELETE) ที่สมบูรณ์ พร้อมการคงอยู่จริงกลับไปยังไฟล์นั้น ใบอนุญาต: MIT. ที่เก็บ: typicode/json-server.

npx json-server db.json

ด้วยไฟล์ db.json ที่มีอาร์เรย์ "posts" อยู่ในระดับบนสุด คุณจะได้รับ GET /posts, GET /posts/1, POST /posts และอื่นๆ ทันที รวมถึงการกรอง การจัดเรียง และการแบ่งหน้าผ่านพารามิเตอร์การค้นหา เมื่อ POST เรคคอร์ดใหม่ มันจะถูกเขียนลงในไฟล์; อ่านกลับมาแล้วก็จะพบข้อมูลนั้น

เหมาะที่สุดสำหรับ: การพัฒนาส่วนหน้าก่อนที่ส่วนหลังจะพร้อมใช้งาน เป็นแบบ stateful โดยไม่ต้องตั้งค่าเพิ่มเติม ซึ่ง Prism และเซิร์ฟเวอร์จำลองส่วนใหญ่ที่ขับเคลื่อนด้วยสเปกไม่มี การตั้งค่าเป็นศูนย์ และ npx หมายความว่าคุณไม่จำเป็นต้องติดตั้งด้วยซ้ำ

ข้อจำกัด: มีความคิดเห็นที่แข็งกร้าวเกี่ยวกับรูปแบบ REST ดังนั้นจึงไม่สามารถตรงกับ API ที่กำหนดเองได้ ไม่มีการนำเข้า OpenAPI; ไฟล์ JSON คือสัญญา ไม่ได้มีไว้สำหรับการทดสอบโหลดหรือพฤติกรรมที่เหมือนการผลิต

WireMock

WireMock เป็นเครื่องมือจำลอง HTTP โอเพนซอร์สที่ใหญ่ที่สุด โดยมีการดาวน์โหลดหลายล้านครั้งต่อเดือน มันทำงานเป็นกระบวนการแบบสแตนด์อโลนที่กำหนดค่าผ่าน JSON admin API หรือจากไฟล์ JSON stub และจัดการการจับคู่คำขอ การสร้างเทมเพลตการตอบกลับ สถานการณ์แบบ stateful การฉีดข้อผิดพลาด และการบันทึกและเล่นซ้ำ ใบอนุญาต: Apache-2.0. ที่เก็บ: wiremock/wiremock.

docker run -it --rm -p 8080:8080 wiremock/wiremock:latest
curl -X POST http://localhost:8080/__admin/mappings \
  -H 'Content-Type: application/json' \
  -d '{"request":{"method":"GET","url":"/hello"},"response":{"status":200,"body":"world"}}'

บรรทัดแรกเริ่ม WireMock; บรรทัดที่สองลงทะเบียน stub ผ่าน admin API ของมัน ตอนนี้ curl http://localhost:8080/hello จะส่งคืน world คุณยังสามารถวางไฟล์ stub ในไดเรกทอรี mappings/ และเมาท์เข้าไปในคอนเทนเนอร์ได้

เหมาะที่สุดสำหรับ: สถานการณ์การทดสอบที่ซับซ้อน พฤติกรรมแบบ stateful การหน่วงเวลาและความผิดพลาดเพื่อจำลองบุคคลที่สามที่ไม่เสถียร และ proxy-plus-record เพื่อบันทึก API จริงและเล่นซ้ำในภายหลัง นี่คือเครื่องมือเมื่อการจำลองของคุณจำเป็นต้องมีพฤติกรรมเหมือนกับของจริงภายใต้การทดสอบ

ข้อจำกัด: เป็นเครื่องมือ JVM ดังนั้นคอนเทนเนอร์หรือ Java runtime จึงเป็นสิ่งที่ต้องมี พื้นผิวการกำหนดค่ามีขนาดใหญ่ การจำลองแบบง่ายๆ อาจดูเกินความจำเป็น ไม่มีคำสั่ง "อ่านสเปกแล้วไป" แบบเดียวกับที่ Prism มี

MockServer

MockServer เป็น mock และ proxy HTTP(S) บนพอร์ตเดียว โดยมุ่งเน้นไปที่การทดสอบการรวมระบบ มันจำลอง API สามารถพร็อกซีและบันทึกทราฟฟิกจริง และช่วยให้คุณฉีดข้อผิดพลาดเพื่อทดสอบว่าไคลเอ็นต์ของคุณจัดการกับสิ่งเหล่านั้นอย่างไร เวอร์ชันล่าสุดเพิ่มการรองรับ HTTP/2, gRPC และ WebSocket ใบอนุญาต: Apache-2.0. ที่เก็บ: mock-server/mockserver.

docker run -d --rm -p 1080:1080 mockserver/mockserver
curl -X PUT 'http://localhost:1080/mockserver/expectation' \
  -H 'Content-Type: application/json' \
  -d '{"httpRequest":{"path":"/order"},"httpResponse":{"body":"{\"status\":\"ok\"}"}}'

คำสั่ง PUT จะลงทะเบียน " expectation" หลังจากนั้น curl http://localhost:1080/order จะส่งคืน JSON ของคุณ ไคลเอ็นต์ของ MockServer (Java, JavaScript, Ruby และอื่นๆ) ช่วยให้คุณสามารถตั้งค่า expectation เดียวกันจากภายในโค้ดทดสอบของคุณได้ แทนที่จะใช้คำสั่ง curl

เหมาะที่สุดสำหรับ: การจำลองและการพร็อกซีในที่เดียวกัน รวมถึงการฉีดข้อผิดพลาด หากคุณต้องการยืนยันว่ามีการส่งคำขอที่เฉพาะเจาะจงจำนวนครั้งที่แน่นอน API การยืนยันของ MockServer ถูกสร้างมาเพื่อสิ่งนั้น เหมาะอย่างยิ่งสำหรับสแต็คที่เน้น JVM ดูบทความ ทางเลือก MockServer ของเรา หากมันไม่ตรงกับความต้องการของคุณ

ข้อจำกัด: เช่นเดียวกับ WireMock มันใช้ JVM และ expectation JSON มีความละเอียดซับซ้อน ความทับซ้อนกับ WireMock เป็นของจริง; เลือกอันใดอันหนึ่งตามไลบรารีไคลเอ็นต์ที่เข้ากับสแต็คการทดสอบของคุณ

Microcks

Microcks เป็นแพลตฟอร์มที่ได้รับเลือก และเป็นโปรเจกต์บ่มเพาะของ Cloud Native Computing Foundation มันแปลง OpenAPI, AsyncAPI, gRPC, GraphQL, Postman collections และโปรเจกต์ SoapUI ให้เป็น mock แบบสด และนำสัญญาเหล่านั้นกลับมาใช้ซ้ำเพื่อรันการทดสอบความสอดคล้องกับ implementation จริงของคุณ ครอบคลุมโปรโตคอลแบบ event-driven และ async ไม่ใช่แค่ HTTP เท่านั้น ใบอนุญาต: Apache-2.0. ที่เก็บ: microcks/microcks.

docker run -d --name microcks -p 8585:8080 quay.io/microcks/microcks-uber:latest

คำสั่งนั้นรันอิมเมจแบบ all-in-one; เปิด http://localhost:8585 และนำเข้าสเปกเพื่อรับ endpoint จำลอง microcks-cli ที่เป็นส่วนเสริมจะขับเคลื่อนเซิร์ฟเวอร์ที่กำลังทำงานจาก CI:

microcks-cli import 'petstore.yaml:true' \
  --microcksURL=http://localhost:8585/api \
  --keycloakClientId=... --keycloakClientSecret=...

เหมาะที่สุดสำหรับ: ทีมที่ต้องการแค็ตตาล็อกของ mock ที่ถูกควบคุมเพียงหนึ่งเดียวสำหรับ API และโปรโตคอลจำนวนมาก พร้อมการทดสอบสัญญาในตัว การจำลองแบบ async/event-driven (Kafka, MQTT และอื่นๆ) นั้นหาได้ยากในพื้นที่นี้

ข้อจำกัด: นี่คือเซิร์ฟเวอร์ ไม่ใช่ไบนารีเดียว ข้อควรระวังที่สำคัญ: microcks-cli จะกระตุ้นการทดสอบและนำเข้า artifacts กับอินสแตนซ์ Microcks ที่กำลังทำงานอยู่; มันไม่ได้ให้บริการ mock ด้วยตัวมันเอง ดังนั้น CLI จึงเป็นไคลเอ็นต์ และคุณยังคงต้องรันแพลตฟอร์ม สำหรับการจำลองในเครื่องแบบครั้งเดียว มันหนักกว่า Prism หรือ json-server

ข้อสังเกตเพิ่มเติมอย่างตรงไปตรงมา: Apidog

Apidog ไม่ใช่โอเพนซอร์ส ดังนั้นจึงไม่ได้รับการจัดอันดับเป็นตัวเลขที่นี่ แต่ถ้าคุณสังเกตเห็นว่าเครื่องมือข้างต้นแก้ปัญหาที่แตกต่างกัน (การจำลองที่ขับเคลื่อนด้วยสเปก, CRUD แบบ stateful, การทดสอบสัญญา) และคุณไม่อยากนำมาต่อกันเอง ก็คุ้มค่าที่จะกล่าวถึง Apidog เป็นแพลตฟอร์ม freemium ที่มีบริการ mocking ในระดับฟรี และ apidog mock ใน apidog-cli ช่วยให้คุณจัดการ mock expectations จากเทอร์มินัลพร้อมกับการออกแบบ การทดสอบ และเอกสารประกอบในโปรเจกต์เดียว Smart mock จะสร้างค่าฟิลด์ที่สมจริงจากสคีมาของคุณโดยอัตโนมัติ ดังนั้นคุณจึงไม่ต้องเขียนตัวอย่าง bodies ด้วยตนเอง

ข้อแลกเปลี่ยนนั้นชัดเจน: คุณจะได้รับเวิร์กโฟลว์แบบครบวงจรและบริการฟรีแทนโอเพนซอร์สและการโฮสต์เอง หากโอเพนซอร์สหรือการโฮสต์เองแบบ air-gapped เป็นข้อกำหนดที่เข้มงวด เครื่องมือหนึ่งในหกรายการข้างต้นคือคำตอบของคุณ หากวงจรการออกแบบไปสู่การจำลองแบบครบวงจรมีความสำคัญมากกว่า Apidog คือทางเลือกในการรวมเครื่องมือหลายอย่างเข้าด้วยกัน

วิธีการเลือก

เลือกตามรูปแบบ ไม่ใช่ตามความนิยม สำหรับการจำลองที่อ่านไฟล์ OpenAPI ของคุณและบังคับใช้ ให้เริ่มต้นด้วย Prism สำหรับ CRUD แบบ stateful ก่อนที่ส่วนหลังจะพร้อมใช้งาน json-server ชนะด้านความเร็ว สำหรับสถานการณ์ทดสอบที่ซับซ้อนพร้อมข้อผิดพลาดและการบันทึกและเล่นซ้ำ ใช้ WireMock หรือ MockServer; เลือกตามไลบรารีไคลเอ็นต์ สำหรับแค็ตตาล็อกหลายโปรโตคอลที่ใช้ร่วมกันพร้อมการทดสอบสัญญา ใช้ Microcks สำหรับรูปแบบที่เหมาะกับสถานการณ์ใด โปรดดูคู่มือ กรณีการใช้งานการจำลอง API ที่เชื่อมโยงเครื่องมือเข้ากับสถานการณ์

สรุป

เครื่องมือจำลอง CLI โอเพนซอร์สช่วยให้คุณมีเซิร์ฟเวอร์จำลองที่คุณสามารถอ่าน โฮสต์เอง และรันใน CI ได้ฟรี Prism และ json-server ครอบคลุมกรณีทั่วไปด้วยคำสั่งเดียว; WireMock และ MockServer จัดการสถานการณ์ทดสอบที่ยาก; Microcks ปรับขนาดเป็นแค็ตตาล็อกที่ถูกควบคุมครอบคลุมโปรโตคอลทั้งหมด เครื่องมือทั้งหกนี้เป็น MIT หรือ Apache-2.0 ทั้งหมดสามารถโฮสต์เองได้ และทั้งหมดอยู่ใน GitHub สาธารณะ

หากคุณต้องการจัดการ mock ควบคู่ไปกับการออกแบบ API, การทดสอบ และเอกสารประกอบโดยไม่ต้องเชื่อมโยงเครื่องมือแยกกัน โปรด ดาวน์โหลด Apidog และลองใช้ apidog mock ในระดับฟรี มันไม่ใช่โอเพนซอร์ส แต่เป็นจุดเดียวในการรันวงจรทั้งหมดตั้งแต่บรรทัดคำสั่งไปจนถึง CI