שליטה בפיקסטורות מתקדמות של Pytest: בדיקות מונעות פרמטרים ושילוב Mock

Pytest היא סביבת בדיקות (framework) חזקה וגמישה עבור Python. הפשטות וההרחבה שלה הופכות אותה לחביבה על מפתחים ברחבי העולם. אחת התכונות המשכנעות ביותר של Pytest היא מערכת הפיקסטורות (fixtures) שלה, המאפשרת הגדרות בדיקה (setups) אלגנטיות וניתנות לשימוש חוזר. פוסט זה צולל לטכניקות פיקסטורה מתקדמות, תוך התמקדות ספציפית בבדיקות מונעות פרמטרים (parameterized testing) ובשילוב Mock. נבחן כיצד טכניקות אלו יכולות לשפר באופן משמעותי את תהליך הבדיקות שלכם, ולהוביל לקוד חזק יותר וקל לתחזוקה.

הבנת פיקסטורות של Pytest

לפני שנצלול לנושאים מתקדמים, נסכם בקצרה את יסודות הפיקסטורות של Pytest. פיקסטורה היא פונקציה שרצה לפני כל פונקציית בדיקה שאליה היא מוחלת. היא משמשת לספק בסיס קבוע לבדיקות, ובכך מבטיחה עקביות ומפחיתה קוד שחוזר על עצמו (boilerplate). פיקסטורות יכולות לבצע משימות כגון:

• הקמת חיבור למסד נתונים
• יצירת קבצים או ספריות זמניות
• אתחול אובייקטים עם תצורות ספציפיות
• אימות מול API

פיקסטורות מקדמות שימוש חוזר בקוד והופכות את הבדיקות שלכם לקריאות וקלות יותר לתחזוקה. ניתן להגדיר אותן בהיקפים (scopes) שונים (פונקציה, מודול, סשן) כדי לשלוט במחזור החיים ובצריכת המשאבים שלהן.

דוגמה בסיסית לפיקסטורה

הנה דוגמה פשוטה לפיקסטורה של Pytest שיוצרת ספרייה זמנית:

            
import pytest
import tempfile
import os

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

            

              
                Copy
              
            
          

כדי להשתמש בפיקסטורה זו בבדיקה, פשוט כללו אותה כארגומנט לפונקציית הבדיקה שלכם:

            
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
              
            
          

בדיקות מונעות פרמטרים עם Pytest

בדיקות מונעות פרמטרים מאפשרות לכם להריץ את אותה פונקציית בדיקה מספר פעמים עם סטים שונים של נתוני קלט. זה שימושי במיוחד לבדיקת פונקציות עם קלטים ותוצאות צפויות משתנות. Pytest מספקת את הדקורטור @pytest.mark.parametrize ליישום בדיקות מונעות פרמטרים.

יתרונות של בדיקות מונעות פרמטרים

• הפחתת שכפול קוד: הימנעו מכתיבת פונקציות בדיקה מרובות שכמעט זהות.
• שיפור כיסוי הבדיקות: בדקו בקלות טווח רחב יותר של ערכי קלט.
• שיפור קריאות הבדיקות: הגדירו בבירור את ערכי הקלט והפלט הצפויים עבור כל מקרה בדיקה.

דוגמה בסיסית לפרמטריזציה

נניח שיש לכם פונקציה שמחברת שני מספרים:

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

            

              
                Copy
              
            
          

אתם יכולים להשתמש בבדיקות מונעות פרמטרים כדי לבדוק פונקציה זו עם ערכי קלט שונים:

            
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
              
            
          

בדוגמה זו, הדקורטור @pytest.mark.parametrize מגדיר ארבעה מקרי בדיקה, כל אחד עם ערכים שונים עבור x, y והתוצאה הצפויה. Pytest יריץ את הפונקציה test_add ארבע פעמים, פעם אחת עבור כל סט של פרמטרים.

טכניקות פרמטריזציה מתקדמות

Pytest מציעה מספר טכניקות מתקדמות לפרמטריזציה, כולל:

• שימוש בפיקסטורות עם פרמטריזציה: שלבו פיקסטורות עם פרמטריזציה כדי לספק הגדרות שונות לכל מקרה בדיקה.
• מזהים (IDs) למקרי בדיקה: הקצו מזהים מותאמים אישית למקרי בדיקה לדיווח וניפוי שגיאות טובים יותר.
• פרמטריזציה עקיפה (Indirect): העבירו פרמטרים לארגומנטים של פיקסטורות, מה שמאפשר יצירת פיקסטורות דינמית.

שימוש בפיקסטורות עם פרמטריזציה

זה מאפשר לכם להגדיר פיקסטורות באופן דינמי בהתבסס על הפרמטרים המועברים לבדיקה. דמיינו שאתם בודקים פונקציה שמתקשרת עם מסד נתונים. ייתכן שתרצו להשתמש בתצורות מסד נתונים שונות (למשל, מחרוזות חיבור שונות) עבור מקרי בדיקה שונים.

            
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
              
            
          

בדוגמה זו, הפיקסטורה db_config מקבלת פרמטרים. הארגומנט indirect=True אומר ל-Pytest להעביר את הפרמטרים ("prod" ו-"test") לפונקציית הפיקסטורה db_config. לאחר מכן, הפיקסטורה db_config מחזירה תצורות מסד נתונים שונות בהתבסס על ערך הפרמטר. הפיקסטורה db_connection משתמשת בפיקסטורה db_config כדי ליצור חיבור למסד הנתונים. לבסוף, הפונקציה test_database_interaction משתמשת בפיקסטורה db_connection כדי לתקשר עם מסד הנתונים.

מזהים (IDs) למקרי בדיקה

מזהים מותאמים אישית מספקים שמות תיאוריים יותר למקרי הבדיקה שלכם בדוח הבדיקות, מה שמקל על זיהוי וניפוי שגיאות.

            
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
              
            
          

ללא מזהים, Pytest היה יוצר שמות גנריים כמו test_uppercase[0], test_uppercase[1], וכו'. עם מזהים, דוח הבדיקות יציג שמות משמעותיים יותר כמו test_uppercase[lowercase_hello].

פרמטריזציה עקיפה

פרמטריזציה עקיפה מאפשרת לכם להעביר פרמטרים לקלט של פיקסטורה, במקום ישירות לפונקציית הבדיקה. זה שימושי כאשר אתם רוצים ליצור מופעים שונים של פיקסטורה בהתבסס על ערך הפרמטר.

            
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
              
            
          

בדוגמה זו, הפיקסטורה input_data מקבלת את הערכים "valid" ו-"invalid" כפרמטרים. הארגומנט indirect=True אומר ל-Pytest להעביר את הערכים הללו לפונקציית הפיקסטורה input_data. הפיקסטורה input_data מחזירה אז מילוני נתונים שונים בהתבסס על ערך הפרמטר. לאחר מכן, הפונקציה test_validate_data משתמשת בפיקסטורה input_data כדי לבדוק את הפונקציה validate_data עם נתוני קלט שונים.

שימוש ב-Mocking עם Pytest

Mocking היא טכניקה המשמשת להחלפת תלויות אמיתיות בתחליפים מבוקרים (mocks) במהלך בדיקות. זה מאפשר לכם לבודד את הקוד הנבדק ולהימנע מהסתמכות על מערכות חיצוניות, כגון מסדי נתונים, ממשקי API או מערכות קבצים.

יתרונות של Mocking

• בידוד קוד: בדקו קוד באופן מבודד, מבלי להסתמך על תלויות חיצוניות.
• שליטה בהתנהגות: הגדירו את התנהגות התלויות, כגון ערכי החזרה וחריגות.
• האצת הבדיקות: הימנעו ממערכות חיצוניות איטיות או לא אמינות.
• בדיקת מקרי קצה: הדמו תנאי שגיאה ומקרי קצה שקשה לשחזר בסביבה אמיתית.

שימוש בספריית unittest.mock

פייתון מספקת את ספריית unittest.mock ליצירת mocks. Pytest משתלב איתה בצורה חלקה, מה שמקל על יצירת mocks לתלויות בבדיקות שלכם.

דוגמה בסיסית ל-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
              
            
          

בדוגמה זו, הדקורטור @patch("requests.get") מחליף את הפונקציה requests.get באובייקט mock. הארגומנט mock_get הוא אובייקט ה-mock. לאחר מכן, אנו יכולים להגדיר את אובייקט ה-mock כך שיחזיר תגובה ספציפית ולוודא שהוא נקרא עם ה-URL הנכון.

Mocking עם פיקסטורות

אתם יכולים גם להשתמש בפיקסטורות כדי ליצור ולנהל 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, פיקסטורה של pytest, כדי להחליף את requests.get האמיתי ב-mock. זה מאפשר לבדיקות אחרות להשתמש באותו endpoint של API מדומיין.

טכניקות Mocking מתקדמות

Pytest ו-unittest.mock מציעים מספר טכניקות mocking מתקדמות, כולל:

• תופעות לוואי (Side Effects): הגדירו התנהגות מותאמת אישית ל-mocks בהתבסס על הארגומנטים שהם מקבלים.
• Mocking למאפיינים (Properties): הדמיית מאפיינים של אובייקטים.
• מנהלי הקשר (Context Managers): השתמשו ב-mocks בתוך מנהלי הקשר להחלפות זמניות.

תופעות לוואי (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` כאשר הרשימה נגמרת.

Mocking למאפיינים (Properties)

Mocking למאפיינים מאפשר לכם לדמות את ההתנהגות של מאפיינים (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 בתוך מנהלי הקשר מאפשר לכם להחליף זמנית תלויות עבור בלוק קוד ספציפי. זה שימושי לבדיקת קוד שמתקשר עם מערכות חיצוניות או משאבים שצריך לדמות רק לזמן מוגבל.

            
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
              
            
          

שילוב פרמטריזציה ו-Mocking

שתי הטכניקות החזקות הללו ניתנות לשילוב כדי ליצור בדיקות מתוחכמות ויעילות עוד יותר. אתם יכולים להשתמש בפרמטריזציה כדי לבדוק תרחישים שונים עם תצורות 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 שונים. הדקורטור @patch עושה mock לפונקציה requests.get. Pytest יריץ את פונקציית הבדיקה פעמיים, פעם אחת עבור כל סט של פרמטרים, כאשר ה-mock מוגדר להחזיר את ה-expected_data המתאים.

שיטות עבודה מומלצות לשימוש בפיקסטורות מתקדמות

• שמרו על פיקסטורות ממוקדות: לכל פיקסטורה צריכה להיות מטרה ברורה וספציפית.
• השתמשו בהיקפים (scopes) מתאימים: בחרו את היקף הפיקסטורה המתאים (פונקציה, מודול, סשן) כדי לייעל את השימוש במשאבים.
• תעדו פיקסטורות: תעדו בבירור את המטרה והשימוש של כל פיקסטורה.
• הימנעו מ-Mocking יתר: עשו mock רק לתלויות שהכרחיות לבידוד הקוד הנבדק.
• כתבו Assertions ברורים: ודאו שה-assertions שלכם ברורים וספציפיים, ומאמתים את ההתנהגות הצפויה של הקוד הנבדק.
• שקלו פיתוח מונחה בדיקות (TDD): כתבו את הבדיקות שלכם לפני כתיבת הקוד, והשתמשו בפיקסטורות וב-mocks כדי להנחות את תהליך הפיתוח.

סיכום

הטכניקות המתקדמות של פיקסטורות ב-Pytest, כולל בדיקות מונעות פרמטרים ושילוב mock, מספקות כלים רבי עוצמה לכתיבת בדיקות חזקות, יעילות וקלות לתחזוקה. על ידי שליטה בטכניקות אלו, תוכלו לשפר באופן משמעותי את איכות קוד הפייתון שלכם ולייעל את תהליך הבדיקות. זכרו להתמקד ביצירת פיקסטורות ברורות וממוקדות, להשתמש בהיקפים מתאימים ולכתוב assertions מקיפים. עם תרגול, תוכלו למנף את מלוא הפוטנציאל של מערכת הפיקסטורות של Pytest כדי ליצור אסטרטגיית בדיקות מקיפה ויעילה.