Robot Framework ทดสอบ API อัตโนมัติ: คู่มือฉบับปฏิบัติจริง

Robot Framework มีแนวทางที่แตกต่างจากเครื่องมือที่เน้นโค้ดเป็นหลัก แทนที่จะเขียนการทดสอบเป็นโค้ดโปรแกรม คุณจะเขียนมันเป็นตารางของคีย์เวิร์ดที่มนุษย์อ่านเข้าใจได้ การทดสอบจะอ่านได้เกือบเหมือนรายการตรวจสอบ ซึ่งหมายความว่านักวิเคราะห์ QA และวิศวกรสามารถสร้างและตรวจสอบชุดทดสอบเดียวกันได้ สำหรับการทดสอบ API นั้น RequestsLibrary จะเปลี่ยนการเรียก HTTP ให้เป็นคีย์เวิร์ดที่อ่านเข้าใจได้เหล่านั้น

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

Robot Framework คืออะไรและทำไมจึงเหมาะกับการทดสอบ API

Robot Framework เป็นเฟรมเวิร์กอัตโนมัติแบบโอเพนซอร์สและทั่วไปสำหรับการทำ Test Automation และ Robotic Process Automation คุณสมบัติเด่นของมันคือไวยากรณ์ที่ขับเคลื่อนด้วยคีย์เวิร์ด: การทดสอบถูกเขียนในรูปแบบตารางธรรมดา และพฤติกรรมที่ซับซ้อนถูกสร้างขึ้นจากไลบรารีของคีย์เวิร์ดที่ถูกนำไปใช้ใน Python หรือ Java

สำหรับการทดสอบ API สิ่งนี้มีข้อได้เปรียบที่สำคัญสองประการ ประการแรก การทดสอบสามารถอ่านเข้าใจได้โดยบุคคลที่ไม่เขียนโค้ด ดังนั้นผู้ทดสอบหรือเจ้าของผลิตภัณฑ์สามารถติดตามได้ว่าชุดทดสอบกำลังตรวจสอบอะไรอยู่ ประการที่สอง เฟรมเวิร์กสามารถขยายได้: RequestsLibrary ห่อหุ้มไลบรารี Python requests และเปิดเผยการทำงาน HTTP เป็นคีย์เวิร์ด ในขณะที่ไลบรารีอื่น ๆ ครอบคลุม JSON, ฐานข้อมูล และอื่น ๆ อีกมากมาย หากโครงสร้างที่ขับเคลื่อนด้วยคีย์เวิร์ดยังเป็นเรื่องใหม่สำหรับคุณ คู่มือ เฟรมเวิร์กการทดสอบอัตโนมัติ ที่ครอบคลุมของเราจะอธิบายว่ามันอยู่ตำแหน่งใดในบรรดาประเภทเฟรมเวิร์กอื่น ๆ

การติดตั้ง Robot Framework และไลบรารี

Robot Framework และไลบรารีของมันติดตั้งผ่าน pip ทำงานภายใน virtual environment เพื่อให้โปรเจกต์ของคุณสะอาด:

python -m venv .venv
source .venv/bin/activate
pip install robotframework
pip install robotframework-requests
pip install robotframework-jsonlibrary

แพ็คเกจทั้งสามครอบคลุมความต้องการส่วนใหญ่สำหรับการทดสอบ API:

• robotframework คือเอนจินหลักและตัวรันการทดสอบ
• robotframework-requests (RequestsLibrary) ส่งคำขอ HTTP ในรูปแบบคีย์เวิร์ด
• robotframework-jsonlibrary แยกและยืนยันค่าภายใน JSON responses

ยืนยันการติดตั้งด้วย robot --version คู่มือผู้ใช้ Robot Framework อย่างเป็นทางการคือแหล่งอ้างอิงสำหรับคำถามเกี่ยวกับไวยากรณ์เมื่อชุดทดสอบของคุณเติบโตขึ้น

มีรายละเอียดหนึ่งที่มือใหม่มักจะพลาด: Robot Framework อ่อนไหวต่อช่องว่าง (whitespace-sensitive) คีย์เวิร์ดและอาร์กิวเมนต์ของมันจะต้องถูกคั่นด้วยช่องว่างอย่างน้อยสองช่อง ไม่ใช่หนึ่งช่อง ช่องว่างหนึ่งช่องจะถูกถือว่าเป็นส่วนหนึ่งของโทเค็นเดียวกัน โปรแกรมแก้ไขส่วนใหญ่ที่มีปลั๊กอิน Robot Framework จะจัดการสิ่งนี้ให้คุณ แต่หากการทดสอบล้มเหลวในการแยกวิเคราะห์ (parse) อาร์กิวเมนต์ที่มีช่องว่างผิดพลาดเป็นสิ่งแรกที่ควรตรวจสอบ

การเขียน API test แรกของคุณ

ไฟล์ทดสอบของ Robot Framework ใช้ส่วนขยาย .robot และถูกแบ่งออกเป็นส่วนต่างๆ ที่ทำเครื่องหมายด้วย *** Settings ***, *** Variables *** และ *** Test Cases *** นี่คือไฟล์ที่สมบูรณ์ซึ่งตรวจสอบ endpoint ของผู้ใช้:

*** Settings ***
Library           RequestsLibrary
Library           Collections

*** Variables ***
${BASE_URL}       https://api.example.com/v1

*** Test Cases ***
Get User Returns 200
    Create Session    api    ${BASE_URL}
    ${response}=      GET On Session    api    /users/42
    Status Should Be  200    ${response}

Get User Returns Expected Email
    Create Session    api    ${BASE_URL}
    ${response}=      GET On Session    api    /users/42
    ${body}=          Set Variable    ${response.json()}
    Should Be Equal As Integers    ${body}[id]    42
    Should Be Equal    ${body}[status]    active

ส่วน *** Settings *** นำเข้าไลบรารี Create Session เปิด HTTP session ที่มีชื่อ GET On Session ส่งคำขอและคืนค่าออบเจกต์การตอบกลับ Status Should Be และ Should Be Equal เป็นคีย์เวิร์ดยืนยัน (assertion keywords) รันชุดทดสอบด้วย robot tests.robot แล้ว Robot Framework จะสร้างรายงาน HTML และ log โดยอัตโนมัติ

การทำงานกับเซสชัน

Create Session ทำได้มากกว่าแค่เก็บ base URL เซสชันจะเก็บส่วนหัวเริ่มต้น (default headers), การรับรองความถูกต้อง (authentication) และคุกกี้ไว้ ดังนั้นทุกคำขอที่ทำผ่านเซสชันนี้จะสืบทอดสถานะเหล่านั้น สิ่งนี้สำคัญสำหรับ API ใดๆ ที่ต้องการการเข้าสู่ระบบ เพราะคุณจะยืนยันตัวตนเพียงครั้งเดียวแล้วนำเซสชันนั้นกลับมาใช้ใหม่ได้

*** Test Cases ***
Create Order With Authenticated Session
    Create Session    api    ${BASE_URL}
    ${login}=         POST On Session    api    /auth/login
    ...               json={"email": "qa@example.com", "password": "test-pass"}
    ${token}=         Set Variable    ${login.json()}[token]
    ${headers}=       Create Dictionary    Authorization=Bearer ${token}
    ${order}=         POST On Session    api    /orders
    ...               json={"product_id": 7, "quantity": 2}
    ...               headers=${headers}
    Status Should Be  201    ${order}

ไวยากรณ์ ... ใช้ต่อการเรียกคีย์เวิร์ดไปยังบรรทัดถัดไป ซึ่งช่วยให้คำขอที่ยาวอ่านง่ายขึ้น Create Dictionary สร้างแผนที่ส่วนหัว เนื่องจากเซสชันยังคงอยู่ คุณจึงสามารถทำการร้องขอเพิ่มเติมหลายครั้งได้โดยไม่ต้องสร้างใหม่ คีย์เวิร์ด RequestsLibrary สำหรับเซสชันมีอยู่ในเอกสารอ้างอิงของ RequestsLibrary

การยืนยัน (Asserting) เนื้อหาการตอบกลับ

การตรวจสอบรหัสสถานะเป็นขั้นตอนแรก ในการยืนยันเนื้อหา ให้แยกวิเคราะห์ JSON และยืนยันฟิลด์ต่างๆ คีย์เวิร์ดในตัวของ Robot Framework ครอบคลุมการตรวจสอบความเท่าเทียมกันและการมีอยู่ และ JSONLibrary เพิ่มการแยกข้อมูลตามพาธ:

*** Settings ***
Library           RequestsLibrary
Library           JSONLibrary
Library           Collections

*** Variables ***
${BASE_URL}       https://api.example.com/v1

*** Test Cases ***
Order Response Has Correct Shape
    Create Session    api    ${BASE_URL}
    ${response}=      POST On Session    api    /orders
    ...               json={"product_id": 7, "quantity": 2}
    Status Should Be  201    ${response}
    ${body}=          Set Variable    ${response.json()}
    Dictionary Should Contain Key    ${body}    total
    Should Be Equal As Integers      ${body}[quantity]    2
    ${status}=        Get Value From Json    ${body}    $.status
    Should Be Equal    ${status}[0]    pending

Dictionary Should Contain Key ยืนยันว่ามีฟิลด์อยู่ Should Be Equal As Integers เปรียบเทียบค่าตัวเลขโดยไม่เกิดปัญหาประเภทข้อมูลไม่ตรงกัน Get Value From Json ใช้ JSONPath expression เพื่อเข้าถึงข้อมูลที่ซ้อนกัน สำหรับชุดการตรวจสอบที่กว้างขึ้นซึ่งควรใช้กับการตอบกลับ API คู่มือ การยืนยัน API (API assertions) ของเราเป็นคู่มือที่ดี

การสร้างคีย์เวิร์ดที่นำกลับมาใช้ใหม่ได้

การทำซ้ำ Create Session และขั้นตอนการเข้าสู่ระบบในการทดสอบทุกครั้งเปรียบเสมือนการคัดลอกและวาง (copy-paste) ในรูปแบบที่ขับเคลื่อนด้วยคีย์เวิร์ด Robot Framework ช่วยให้คุณสามารถกำหนดคีย์เวิร์ดของคุณเองในส่วน *** Keywords *** ได้ ดังนั้นขั้นตอนทั่วไปจึงกลายเป็นบรรทัดเดียวที่อ่านง่าย:

*** Keywords ***
Authenticate And Open Session
    Create Session    api    ${BASE_URL}
    ${login}=         POST On Session    api    /auth/login
    ...               json={"email": "qa@example.com", "password": "test-pass"}
    ${token}=         Set Variable    ${login.json()}[token]
    Set Suite Variable    ${AUTH_HEADERS}    Bearer ${token}

*** Test Cases ***
Create Order
    Authenticate And Open Session
    ${headers}=       Create Dictionary    Authorization=${AUTH_HEADERS}
    ${order}=         POST On Session    api    /orders
    ...               json={"product_id": 7, "quantity": 2}    headers=${headers}
    Status Should Be  201    ${order}

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

ไฟล์ทรัพยากรคือไฟล์ .robot ที่ไม่มี test cases มีเพียงส่วน *** Keywords *** และ *** Variables *** คุณนำเข้าไฟล์นี้จากไฟล์ทดสอบด้วย Resource common.robot ในส่วนการตั้งค่า สิ่งนี้จะช่วยเก็บขั้นตอนการเข้าสู่ระบบ, base URL และส่วนอื่นๆ ที่ใช้ร่วมกันไว้ในที่เดียว เมื่อโปรเจกต์เติบโตขึ้น รูปแบบทั่วไปคือมีไฟล์ทรัพยากรหนึ่งไฟล์ต่อพื้นที่ API พร้อมกับไฟล์ระดับบนสุดสำหรับการตั้งค่าส่วนกลาง การแยก test cases ออกจากตรรกะสนับสนุนเป็นหัวใจสำคัญของโครงสร้างที่ขับเคลื่อนด้วยคีย์เวิร์ด และคู่มือ เฟรมเวิร์กการทดสอบอัตโนมัติ ที่ครอบคลุมของเราจะอธิบายว่าทำไมมันถึงขยายขนาดได้

การรัน Robot Framework ใน CI

Robot Framework ทำงานแบบ headless และคืนค่า exit code ที่ไม่ใช่ศูนย์เมื่อเกิดความล้มเหลว ซึ่งเป็นสิ่งที่ pipeline ต้องการเพื่อให้ build ล้มเหลว ตัวรันยังเขียนไฟล์ output.xml, log.html และ report.html หลังจากการรันทุกครั้ง ดังนั้น CI artifacts จะพร้อมใช้งานโดยไม่ต้องตั้งค่าเพิ่มเติม

มีบางแฟล็กที่ทำให้การรัน CI สะอาดขึ้น ใช้ --outputdir เพื่อส่งรายงานไปยังโฟลเดอร์ที่กำหนด, --include และ --exclude พร้อมแท็กเพื่อรันชุดย่อย และไฟล์ตัวแปร หรือ --variable เพื่อฉีดค่าเฉพาะสภาพแวดล้อม เช่น base URL และข้อมูลรับรอง โดยไม่ต้องแก้ไขไฟล์ทดสอบ:

robot --outputdir results --variable BASE_URL:https://staging.example.com/v1 tests/

ติดแท็กการทดสอบของคุณด้วย [Tags] เพื่อให้คุณสามารถรัน smoke test ชุดเล็กได้อย่างรวดเร็วในทุก commit และรันชุดทดสอบทั้งหมดทุกคืน การเชื่อมโยงสิ่งนี้เข้ากับ GitHub Actions หรือ pipeline อื่นๆ เป็นไปตามรูปแบบเดียวกับคำแนะนำ การทดสอบ API ใน CI/CD ของเรา: ติดตั้ง dependencies, รันคำสั่ง, เผยแพร่ report artifacts

เมื่อแพลตฟอร์ม API เฉพาะทางมีประโยชน์มากกว่า

Robot Framework เป็นทางเลือกที่แข็งแกร่งเมื่อคุณต้องการการทดสอบที่อ่านง่ายและขับเคลื่อนด้วยคีย์เวิร์ดที่ทีมที่มีทักษะหลากหลายสามารถใช้ร่วมกันได้ มันจะสะดวกน้อยลงเมื่อคุณต้องการการออกแบบ API, การจำลอง (mocking) และการดีบัก (debugging) ในที่เดียว หรือเมื่อคุณต้องการการตรวจสอบ schema กับ OpenAPI spec โดยไม่ต้องประกอบมันจากไลบรารีต่างๆ

Apidog จัดการความต้องการเหล่านั้นได้โดยตรง มันมีตัวสร้างการทดสอบแบบภาพ (visual test builder), การตรวจสอบ OpenAPI schema โดยอัตโนมัติ, การรันแบบขับเคลื่อนด้วยข้อมูลจาก CSV และ JSON, การจัดการสภาพแวดล้อม และรายงาน HTML พร้อมกับ CLI runner สำหรับ CI ทีมงานมักจะใช้ทั้งสองอย่าง: Robot Framework ในที่ที่ความสามารถในการอ่านด้วยคีย์เวิร์ดสำคัญที่สุด และ Apidog สำหรับการออกแบบ, การจำลอง และการทดสอบ API ภายใต้การทดสอบอย่างกว้างขวาง คุณสามารถ ดาวน์โหลด Apidog และสร้างชุดทดสอบ API ที่ใช้งานได้โดยไม่ต้องเขียนไลบรารีคีย์เวิร์ดใดๆ

คำถามที่พบบ่อย

Robot Framework ใช้สำหรับการทดสอบ UI เท่านั้นหรือไม่?

ไม่ Robot Framework เป็นเฟรมเวิร์กอัตโนมัติทั่วไป ด้วย RequestsLibrary มันสามารถจัดการการทดสอบ API ได้เป็นอย่างดี และไลบรารีอื่นๆ ก็ครอบคลุมฐานข้อมูล, SSH และอื่นๆ การออกแบบที่ขับเคลื่อนด้วยคีย์เวิร์ดของมันไม่ขึ้นอยู่กับเลเยอร์ เฟรมเวิร์กนี้ได้รับความนิยมสำหรับการทดสอบ UI ผ่าน SeleniumLibrary แต่การทดสอบ API ก็เป็นการใช้งานที่พบได้บ่อยเช่นกัน

ความแตกต่างระหว่าง Create Session กับ plain request คืออะไร?

Create Session เปิด HTTP session ที่มีชื่อและคงอยู่ ซึ่งจะจัดเก็บ base URL, headers, cookies และ authentication คีย์เวิร์ดที่ตามมา เช่น GET On Session จะนำสถานะนั้นกลับมาใช้ใหม่ ซึ่งจำเป็นสำหรับ API ที่ต้องการการเข้าสู่ระบบ คำขอที่ไม่มีเซสชัน (sessionless request) จะไม่สามารถนำคุกกี้หรือข้อมูลการยืนยันตัวตนไปใช้ระหว่างการเรียกได้ ทำให้คุณต้องส่งทุกอย่างใหม่ทุกครั้ง

ฉันจำเป็นต้องรู้ Python เพื่อใช้ Robot Framework หรือไม่?

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

Robot Framework เปรียบเทียบกับ pytest อย่างไรสำหรับการทดสอบ API?

Pytest เป็นเครื่องมือที่เน้นโค้ดเป็นหลักและเหมาะสำหรับทีม Python ที่ต้องการเขียนการทดสอบควบคู่ไปกับโค้ดแอปพลิเคชัน Robot Framework ขับเคลื่อนด้วยคีย์เวิร์ดและเหมาะสำหรับทีมที่มีทักษะหลากหลายที่ให้ความสำคัญกับการทดสอบที่อ่านง่ายและเป็นรูปแบบตาราง ทั้งสองอย่างทำงานใน CI และสร้างรายงาน การเลือกขึ้นอยู่กับว่าใครเป็นผู้เขียนและบำรุงรักษาชุดทดสอบ มากกว่าความสามารถดิบๆ

Robot Framework สามารถตรวจสอบการตอบกลับเทียบกับ OpenAPI schema ได้หรือไม่?

ไม่สามารถทำได้ทันที คุณสามารถยืนยันฟิลด์แต่ละรายการด้วยคีย์เวิร์ดในตัวและ JSONLibrary และไลบรารีของชุมชนก็เพิ่มการตรวจสอบ schema หากการตรวจสอบอัตโนมัติกับเอกสาร OpenAPI เป็นหัวใจสำคัญของเวิร์กโฟลว์ของคุณ แพลตฟอร์มอย่าง Apidog ที่ทำสิ่งนี้ได้โดยตรงจะช่วยให้คุณประหยัดเวลาในการประกอบไลบรารีและการบำรุงรักษา