การใช้งาน Pytest Advanced Fixtures อย่างเชี่ยวชาญ: การทดสอบแบบ Parametrized และการผสานรวม Mock

Pytest เป็นเฟรมเวิร์กการทดสอบสำหรับ Python ที่ทรงพลังและยืดหยุ่น ความเรียบง่ายและความสามารถในการขยายของมันทำให้เป็นที่ชื่นชอบของนักพัฒนาทั่วโลก หนึ่งในคุณสมบัติที่น่าสนใจที่สุดของ Pytest คือระบบ fixture ซึ่งช่วยให้สามารถตั้งค่าการทดสอบที่สวยงามและนำกลับมาใช้ใหม่ได้ บล็อกโพสต์นี้จะเจาะลึกถึงเทคนิค fixture ขั้นสูง โดยเฉพาะอย่างยิ่งการเน้นไปที่ การทดสอบแบบ parametrized และ การผสานรวม mock เราจะสำรวจว่าเทคนิคเหล่านี้สามารถปรับปรุงกระบวนการทดสอบของคุณได้อย่างไร ซึ่งนำไปสู่โค้ดที่แข็งแกร่งและบำรุงรักษาง่ายขึ้น

ทำความเข้าใจเกี่ยวกับ Pytest Fixtures

ก่อนที่จะลงลึกในหัวข้อขั้นสูง เรามาทบทวนพื้นฐานของ Pytest fixtures กันสั้นๆ fixture คือฟังก์ชันที่ทำงานก่อนแต่ละฟังก์ชันทดสอบที่นำไปใช้ มันถูกใช้เพื่อจัดเตรียมสภาพแวดล้อมพื้นฐานที่คงที่สำหรับการทดสอบ ทำให้มั่นใจในความสม่ำเสมอและลดโค้ดที่ซ้ำซ้อน Fixtures สามารถทำงานต่างๆ เช่น:

• การตั้งค่าการเชื่อมต่อฐานข้อมูล
• การสร้างไฟล์หรือไดเรกทอรีชั่วคราว
• การเริ่มต้นอ็อบเจกต์ด้วยการกำหนดค่าเฉพาะ
• การยืนยันตัวตนกับ API

Fixtures ส่งเสริมการนำโค้ดกลับมาใช้ใหม่และทำให้การทดสอบของคุณอ่านง่ายและบำรุงรักษาได้ง่ายขึ้น สามารถกำหนดได้ในขอบเขตที่แตกต่างกัน (function, module, session) เพื่อควบคุมวงจรชีวิตและการใช้ทรัพยากร

ตัวอย่าง Fixture พื้นฐาน

นี่คือตัวอย่างง่ายๆ ของ Pytest fixture ที่สร้างไดเรกทอรีชั่วคราว:

            
import pytest
import tempfile
import os

@pytest.fixture
def temp_dir():
    with tempfile.TemporaryDirectory() as tmpdir:
        yield tmpdir

            

              
                Copy
              
            
          

ในการใช้ fixture นี้ในการทดสอบ เพียงแค่ใส่เป็นอาร์กิวเมนต์ในฟังก์ชันทดสอบของคุณ:

            
def test_create_file(temp_dir):
    filepath = os.path.join(temp_dir, "test_file.txt")
    with open(filepath, "w") as f:
        f.write("Hello, world!")
    assert os.path.exists(filepath)

            

              
                Copy
              
            
          

การทดสอบแบบ Parametrized ด้วย Pytest

การทดสอบแบบ Parametrized ช่วยให้คุณสามารถรันฟังก์ชันทดสอบเดียวกันหลายครั้งด้วยชุดข้อมูลอินพุตที่แตกต่างกัน ซึ่งมีประโยชน์อย่างยิ่งสำหรับการทดสอบฟังก์ชันที่มีอินพุตและผลลัพธ์ที่คาดหวังหลากหลาย Pytest มี decorator @pytest.mark.parametrize สำหรับการนำการทดสอบแบบ parametrized ไปใช้งาน

ประโยชน์ของการทดสอบแบบ Parametrized

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

ตัวอย่าง Parametrization พื้นฐาน

สมมติว่าคุณมีฟังก์ชันที่บวกเลขสองตัว:

            
def add(x, y):
    return x + y

            

              
                Copy
              
            
          

คุณสามารถใช้การทดสอบแบบ parametrized เพื่อทดสอบฟังก์ชันนี้ด้วยค่าอินพุตที่แตกต่างกัน:

            
import pytest

@pytest.mark.parametrize("x, y, expected", [
    (1, 2, 3),
    (5, 5, 10),
    (-1, 1, 0),
    (0, 0, 0),
])
def test_add(x, y, expected):
    assert add(x, y) == expected

            

              
                Copy
              
            
          

ในตัวอย่างนี้ decorator @pytest.mark.parametrize กำหนดกรณีทดสอบสี่กรณี โดยแต่ละกรณีมีค่าสำหรับ x, y และผลลัพธ์ที่คาดหวังแตกต่างกัน Pytest จะรันฟังก์ชัน test_add สี่ครั้ง ครั้งละหนึ่งชุดพารามิเตอร์

เทคนิค Parametrization ขั้นสูง

Pytest มีเทคนิคขั้นสูงหลายอย่างสำหรับ parametrization รวมถึง:

• การใช้ Fixtures กับ Parametrization: รวม fixtures กับ parametrization เพื่อให้การตั้งค่าที่แตกต่างกันสำหรับแต่ละกรณีทดสอบ
• Ids สำหรับกรณีทดสอบ: กำหนด ID ที่กำหนดเองให้กับกรณีทดสอบเพื่อการรายงานและดีบักที่ดีขึ้น
• Indirect Parametrization: กำหนดพารามิเตอร์ให้กับอาร์กิวเมนต์ที่ส่งไปยัง fixtures ทำให้สามารถสร้าง fixture แบบไดนามิกได้

การใช้ Fixtures กับ Parametrization

วิธีนี้ช่วยให้คุณสามารถกำหนดค่า fixtures แบบไดนามิกตามพารามิเตอร์ที่ส่งไปยังการทดสอบ ลองนึกภาพว่าคุณกำลังทดสอบฟังก์ชันที่โต้ตอบกับฐานข้อมูล คุณอาจต้องการใช้การกำหนดค่าฐานข้อมูลที่แตกต่างกัน (เช่น connection strings ที่แตกต่างกัน) สำหรับกรณีทดสอบที่แตกต่างกัน

            
import pytest

@pytest.fixture
def db_config(request):
    if request.param == "prod":
        return {"host": "prod.example.com", "port": 5432}
    elif request.param == "test":
        return {"host": "test.example.com", "port": 5433}
    else:
        raise ValueError("Invalid database environment")


@pytest.fixture
def db_connection(db_config):
    # Simulate establishing a database connection
    print(f"Connecting to database at {db_config['host']}:{db_config['port']}")
    return f"Connection to {db_config['host']}"


@pytest.mark.parametrize("db_config", ["prod", "test"], indirect=True)
def test_database_interaction(db_connection):
    # Your test logic here, using the db_connection fixture
    print(f"Using connection: {db_connection}")
    assert "Connection" in db_connection

            

              
                Copy
              
            
          

ในตัวอย่างนี้ fixture db_config ถูกกำหนดพารามิเตอร์ อาร์กิวเมนต์ indirect=True บอก Pytest ให้ส่งพารามิเตอร์ ("prod" และ "test") ไปยังฟังก์ชัน fixture db_config จากนั้น fixture db_config จะส่งคืนการกำหนดค่าฐานข้อมูลที่แตกต่างกันตามค่าพารามิเตอร์ fixture db_connection ใช้ fixture db_config เพื่อสร้างการเชื่อมต่อฐานข้อมูล สุดท้าย ฟังก์ชัน test_database_interaction ใช้ fixture db_connection เพื่อโต้ตอบกับฐานข้อมูล

Ids สำหรับกรณีทดสอบ

ID ที่กำหนดเองให้ชื่อที่สื่อความหมายมากขึ้นสำหรับกรณีทดสอบของคุณในรายงานผลการทดสอบ ทำให้ง่ายต่อการระบุและดีบักข้อผิดพลาด

            
import pytest

@pytest.mark.parametrize(
    "input_string, expected_output",
    [
        ("hello", "HELLO"),
        ("world", "WORLD"),
        ("", ""),
    ],
    ids=["lowercase_hello", "lowercase_world", "empty_string"],
)
def test_uppercase(input_string, expected_output):
    assert input_string.upper() == expected_output

            

              
                Copy
              
            
          

หากไม่มี ID, Pytest จะสร้างชื่อทั่วไปเช่น test_uppercase[0], test_uppercase[1] เป็นต้น แต่เมื่อมี ID, รายงานผลการทดสอบจะแสดงชื่อที่มีความหมายมากขึ้นเช่น test_uppercase[lowercase_hello]

Indirect Parametrization

Indirect parametrization ช่วยให้คุณสามารถกำหนดพารามิเตอร์ให้กับอินพุตของ fixture แทนที่จะเป็นฟังก์ชันทดสอบโดยตรง ซึ่งมีประโยชน์เมื่อคุณต้องการสร้างอินสแตนซ์ของ fixture ที่แตกต่างกันตามค่าพารามิเตอร์

            
import pytest

@pytest.fixture
def input_data(request):
    if request.param == "valid":
        return {"name": "John Doe", "email": "john.doe@example.com"}
    elif request.param == "invalid":
        return {"name": "", "email": "invalid-email"}
    else:
        raise ValueError("Invalid input data type")


def validate_data(data):
    if not data["name"]:
        return False, "Name cannot be empty"
    if "@" not in data["email"]:
        return False, "Invalid email address"
    return True, "Valid data"

@pytest.mark.parametrize("input_data", ["valid", "invalid"], indirect=True)
def test_validate_data(input_data):
    is_valid, message = validate_data(input_data)
    if input_data == {"name": "John Doe", "email": "john.doe@example.com"}:
        assert is_valid is True
        assert message == "Valid data"
    else:
        assert is_valid is False
        assert message in ["Name cannot be empty", "Invalid email address"]

            

              
                Copy
              
            
          

ในตัวอย่างนี้ fixture input_data ถูกกำหนดพารามิเตอร์ด้วยค่า "valid" และ "invalid" อาร์กิวเมนต์ indirect=True บอก Pytest ให้ส่งค่าเหล่านี้ไปยังฟังก์ชัน fixture input_data จากนั้น fixture input_data จะส่งคืน dictionary ของข้อมูลที่แตกต่างกันตามค่าพารามิเตอร์ ฟังก์ชัน test_validate_data จะใช้ fixture input_data เพื่อทดสอบฟังก์ชัน validate_data ด้วยข้อมูลอินพุตที่แตกต่างกัน

การทำ Mocking ด้วย Pytest

Mocking เป็นเทคนิคที่ใช้ในการแทนที่ dependency จริงด้วยสิ่งทดแทนที่ควบคุมได้ (mocks) ในระหว่างการทดสอบ ซึ่งช่วยให้คุณสามารถแยกโค้ดที่กำลังทดสอบออกจากส่วนอื่นและหลีกเลี่ยงการพึ่งพาระบบภายนอก เช่น ฐานข้อมูล, API หรือระบบไฟล์

ประโยชน์ของการทำ Mocking

• แยกโค้ด: ทดสอบโค้ดโดยแยกออกจากกัน โดยไม่ต้องพึ่งพา dependency ภายนอก
• ควบคุมพฤติกรรม: กำหนดพฤติกรรมของ dependency เช่น ค่าที่ส่งคืนและข้อยกเว้น
• เพิ่มความเร็วในการทดสอบ: หลีกเลี่ยงระบบภายนอกที่ช้าหรือไม่น่าเชื่อถือ
• ทดสอบกรณีพิเศษ (Edge Cases): จำลองเงื่อนไขข้อผิดพลาดและกรณีพิเศษที่ยากต่อการสร้างขึ้นใหม่ในสภาพแวดล้อมจริง

การใช้ไลบรารี unittest.mock

Python มีไลบรารี unittest.mock สำหรับการสร้าง mocks ซึ่ง Pytest ผสานรวมกับ unittest.mock ได้อย่างราบรื่น ทำให้ง่ายต่อการ mock dependency ในการทดสอบของคุณ

ตัวอย่าง Mocking พื้นฐาน

สมมติว่าคุณมีฟังก์ชันที่ดึงข้อมูลจาก API ภายนอก:

            
import requests

def get_data_from_api(url):
    response = requests.get(url)
    response.raise_for_status()  # Raise an exception for bad status codes
    return response.json()

            

              
                Copy
              
            
          

เพื่อทดสอบฟังก์ชันนี้โดยไม่ต้องทำการร้องขอไปยัง API จริง คุณสามารถ mock ฟังก์ชัน requests.get ได้:

            
import pytest
import requests
from unittest.mock import patch

@patch("requests.get")
def test_get_data_from_api(mock_get):
    # Configure the mock to return a specific response
    mock_get.return_value.json.return_value = {"data": "test data"}
    mock_get.return_value.status_code = 200

    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    mock_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

ในตัวอย่างนี้ decorator @patch("requests.get") จะแทนที่ฟังก์ชัน requests.get ด้วยอ็อบเจกต์ mock อาร์กิวเมนต์ mock_get คืออ็อบเจกต์ mock นั้น เราสามารถกำหนดค่าอ็อบเจกต์ mock ให้ส่งคืนการตอบสนองที่เฉพาะเจาะจงและยืนยันว่ามันถูกเรียกด้วย URL ที่ถูกต้อง

การทำ Mocking ด้วย Fixtures

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

            
import pytest
import requests
from unittest.mock import Mock

@pytest.fixture
def mock_api_get():
    mock = Mock()
    mock.return_value.json.return_value = {"data": "test data"}
    mock.return_value.status_code = 200
    return mock


@pytest.fixture
def patched_get(mock_api_get, monkeypatch):
    monkeypatch.setattr(requests, "get", mock_api_get)
    return mock_api_get


def test_get_data_from_api(patched_get):
    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    patched_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

ในที่นี้ mock_api_get สร้าง mock และส่งคืนค่า จากนั้น patched_get ใช้ monkeypatch ซึ่งเป็น fixture ของ pytest เพื่อแทนที่ requests.get จริงด้วย mock ซึ่งช่วยให้การทดสอบอื่นๆ สามารถใช้ API endpoint ที่ถูก mock เดียวกันได้

เทคนิค Mocking ขั้นสูง

Pytest และ unittest.mock มีเทคนิคการทำ mocking ขั้นสูงหลายอย่าง รวมถึง:

• Side Effects: กำหนดพฤติกรรมที่กำหนดเองสำหรับ mocks ตามอาร์กิวเมนต์อินพุต
• Property Mocking: Mock คุณสมบัติ (properties) ของอ็อบเจกต์
• Context Managers: ใช้ mocks ภายใน context managers สำหรับการแทนที่ชั่วคราว

Side Effects

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

            
import pytest
from unittest.mock import Mock

def test_side_effect():
    mock = Mock()
    mock.side_effect = [1, 2, 3]

    assert mock() == 1
    assert mock() == 2
    assert mock() == 3
    with pytest.raises(StopIteration):
        mock()

            

              
                Copy
              
            
          

mock นี้จะคืนค่า 1, 2 และ 3 ในการเรียกติดต่อกัน จากนั้นจะเกิดข้อยกเว้น StopIteration เมื่อรายการหมด

Property Mocking

Property mocking ช่วยให้คุณสามารถ mock พฤติกรรมของคุณสมบัติ (properties) บนอ็อบเจกต์ได้ ซึ่งมีประโยชน์สำหรับการทดสอบโค้ดที่พึ่งพาคุณสมบัติของอ็อบเจกต์แทนที่จะเป็นเมธอด

            
import pytest
from unittest.mock import patch

class MyClass:
    @property
    def my_property(self):
        return "original value"


def test_property_mocking():
    obj = MyClass()
    with patch.object(obj, "my_property", new_callable=pytest.PropertyMock) as mock_property:
        mock_property.return_value = "mocked value"
        assert obj.my_property == "mocked value"

            

              
                Copy
              
            
          

ตัวอย่างนี้ mock คุณสมบัติ my_property ของอ็อบเจกต์ MyClass ทำให้คุณสามารถควบคุมค่าที่ส่งคืนระหว่างการทดสอบได้

Context Managers

การใช้ mocks ภายใน context managers ช่วยให้คุณสามารถแทนที่ dependency ชั่วคราวสำหรับบล็อกของโค้ดที่เฉพาะเจาะจงได้ ซึ่งมีประโยชน์สำหรับการทดสอบโค้ดที่โต้ตอบกับระบบภายนอกหรือทรัพยากรที่ควรถูก mock เพียงชั่วคราวเท่านั้น

            
import pytest
from unittest.mock import patch


def test_context_manager_mocking():
    with patch("os.path.exists") as mock_exists:
        mock_exists.return_value = True
        assert os.path.exists("dummy_path") is True
    # The mock is automatically reverted after the 'with' block
    # Ensure the original function is restored, although we can't really assert
    # the real `os.path.exists` function's behavior without a real path.
    # The important thing is that the patch is gone after the context.
    print("Mock has been removed")

            

              
                Copy
              
            
          

การผสมผสานระหว่าง Parametrization และ Mocking

เทคนิคที่ทรงพลังทั้งสองนี้สามารถนำมารวมกันเพื่อสร้างการทดสอบที่ซับซ้อนและมีประสิทธิภาพยิ่งขึ้น คุณสามารถใช้ parametrization เพื่อทดสอบสถานการณ์ที่แตกต่างกันด้วยการกำหนดค่า mock ที่แตกต่างกันได้

            
import pytest
import requests
from unittest.mock import patch


def get_user_data(user_id):
    url = f"https://api.example.com/users/{user_id}"
    response = requests.get(url)
    response.raise_for_status()
    return response.json()


@pytest.mark.parametrize(
    "user_id, expected_data",
    [
        (1, {"id": 1, "name": "John Doe"}),
        (2, {"id": 2, "name": "Jane Smith"}),
    ],
)
@patch("requests.get")
def test_get_user_data(mock_get, user_id, expected_data):
    mock_get.return_value.json.return_value = expected_data
    mock_get.return_value.status_code = 200

    data = get_user_data(user_id)

    assert data == expected_data
    mock_get.assert_called_once_with(f"https://api.example.com/users/{user_id}")

            

              
                Copy
              
            
          

ในตัวอย่างนี้ ฟังก์ชัน test_get_user_data ถูกกำหนดพารามิเตอร์ด้วยค่า user_id และ expected_data ที่แตกต่างกัน decorator @patch จะ mock ฟังก์ชัน requests.get Pytest จะรันฟังก์ชันทดสอบสองครั้ง ครั้งละหนึ่งชุดพารามิเตอร์ โดยที่ mock จะถูกกำหนดค่าให้ส่งคืน expected_data ที่สอดคล้องกัน

แนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้ Fixtures ขั้นสูง

• ให้ Fixtures มีจุดประสงค์ที่ชัดเจน: แต่ละ fixture ควรมีจุดประสงค์ที่ชัดเจนและเฉพาะเจาะจง
• ใช้ขอบเขตที่เหมาะสม: เลือกขอบเขตของ fixture ที่เหมาะสม (function, module, session) เพื่อเพิ่มประสิทธิภาพการใช้ทรัพยากร
• จัดทำเอกสารสำหรับ Fixtures: อธิบายจุดประสงค์และการใช้งานของแต่ละ fixture อย่างชัดเจน
• หลีกเลี่ยงการ Mock มากเกินไป: Mock เฉพาะ dependency ที่จำเป็นสำหรับการแยกโค้ดที่กำลังทดสอบเท่านั้น
• เขียน Assertions ที่ชัดเจน: ตรวจสอบให้แน่ใจว่า assertions ของคุณชัดเจนและเฉพาะเจาะจง เพื่อตรวจสอบพฤติกรรมที่คาดหวังของโค้ดที่กำลังทดสอบ
• พิจารณาการพัฒนาโดยใช้การทดสอบเป็นตัวนำ (TDD): เขียนการทดสอบของคุณก่อนที่จะเขียนโค้ด โดยใช้ fixtures และ mocks เพื่อชี้นำกระบวนการพัฒนา

สรุป

เทคนิค fixture ขั้นสูงของ Pytest รวมถึงการทดสอบแบบ parametrized และการผสานรวม mock เป็นเครื่องมือที่ทรงพลังสำหรับการเขียนการทดสอบที่แข็งแกร่ง มีประสิทธิภาพ และบำรุงรักษาง่าย ด้วยการเรียนรู้เทคนิคเหล่านี้อย่างเชี่ยวชาญ คุณจะสามารถปรับปรุงคุณภาพของโค้ด Python ของคุณและทำให้กระบวนการทดสอบของคุณมีประสิทธิภาพมากขึ้น อย่าลืมมุ่งเน้นไปที่การสร้าง fixtures ที่ชัดเจนและมีจุดประสงค์เฉพาะ การใช้ขอบเขตที่เหมาะสม และการเขียน assertions ที่ครอบคลุม ด้วยการฝึกฝน คุณจะสามารถใช้ศักยภาพสูงสุดของระบบ fixture ของ Pytest เพื่อสร้างกลยุทธ์การทดสอบที่ครอบคลุมและมีประสิทธิภาพได้