பைடெஸ்ட் மேம்பட்ட ஃபிக்ஸ்சர்களில் தேர்ச்சி பெறுதல்: அளவுருவாக்கப்பட்ட சோதனை மற்றும் மாக் ஒருங்கிணைப்பு

பைடெஸ்ட் என்பது பைத்தானுக்கான ஒரு சக்திவாய்ந்த மற்றும் நெகிழ்வான சோதனை கட்டமைப்பாகும். அதன் எளிமை மற்றும் விரிவாக்கத்தன்மை காரணமாக, இது உலகெங்கிலும் உள்ள டெவலப்பர்களிடையே ஒரு விருப்பமான தேர்வாக உள்ளது. பைடெஸ்ட்டின் மிக ஈர்க்கக்கூடிய அம்சங்களில் ஒன்று அதன் ஃபிக்ஸ்சர் அமைப்பு, இது நேர்த்தியான மற்றும் மீண்டும் பயன்படுத்தக்கூடிய சோதனை அமைப்புகளை அனுமதிக்கிறது. இந்த வலைப்பதிவு இடுகை மேம்பட்ட ஃபிக்ஸ்சர் நுட்பங்களை ஆராய்கிறது, குறிப்பாக அளவுருவாக்கப்பட்ட சோதனை மற்றும் மாக் ஒருங்கிணைப்பு ஆகியவற்றில் கவனம் செலுத்துகிறது. இந்த நுட்பங்கள் உங்கள் சோதனை செயல்முறையை எவ்வாறு கணிசமாக மேம்படுத்தலாம், மேலும் வலுவான மற்றும் பராமரிக்கக்கூடிய குறியீட்டிற்கு வழிவகுக்கும் என்பதை நாம் ஆராய்வோம்.

பைடெஸ்ட் ஃபிக்ஸ்சர்களைப் புரிந்துகொள்ளுதல்

மேம்பட்ட தலைப்புகளுக்குள் செல்வதற்கு முன், பைடெஸ்ட் ஃபிக்ஸ்சர்களின் அடிப்படைகளை சுருக்கமாக நினைவுபடுத்துவோம். ஒரு ஃபிக்ஸ்சர் என்பது ஒவ்வொரு சோதனைச் செயல்பாட்டிற்கும் முன் இயக்கப்படும் ஒரு செயல்பாடு ஆகும். இது சோதனைகளுக்கு ஒரு நிலையான அடிப்படையை வழங்க பயன்படுகிறது, நிலைத்தன்மையை உறுதிசெய்து, தேவையற்ற குறியீட்டைக் குறைக்கிறது. ஃபிக்ஸ்சர்கள் பின்வரும் பணிகளைச் செய்ய முடியும்:

• ஒரு தரவுத்தள இணைப்பை அமைத்தல்
• தற்காலிக கோப்புகள் அல்லது கோப்பகங்களை உருவாக்குதல்
• குறிப்பிட்ட உள்ளமைவுகளுடன் ஆப்ஜெக்ட்களைத் தொடங்குதல்
• ஒரு API உடன் அங்கீகரித்தல்

ஃபிக்ஸ்சர்கள் குறியீட்டின் மறுபயன்பாட்டை ஊக்குவிக்கின்றன மற்றும் உங்கள் சோதனைகளை மேலும் படிக்கக்கூடியதாகவும், பராமரிக்கக்கூடியதாகவும் ஆக்குகின்றன. அவற்றின் வாழ்நாள் மற்றும் வள நுகர்வைக் கட்டுப்படுத்த, அவை வெவ்வேறு ஸ்கோப்களில் (செயல்பாடு, தொகுதி, அமர்வு) வரையறுக்கப்படலாம்.

அடிப்படை ஃபிக்ஸ்சர் உதாரணம்

ஒரு தற்காலிக கோப்பகத்தை உருவாக்கும் பைடெஸ்ட் ஃபிக்ஸ்சரின் ஒரு எளிய உதாரணம் இங்கே:

            
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.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 மற்றும் எதிர்பார்க்கப்படும் முடிவுக்கு வெவ்வேறு மதிப்புகளைக் கொண்டுள்ளன. பைடெஸ்ட் test_add செயல்பாட்டை நான்கு முறை இயக்கும், ஒவ்வொரு அளவுருக்களின் தொகுப்பிற்கும் ஒரு முறை.

மேம்பட்ட அளவுருவாக்க நுட்பங்கள்

பைடெஸ்ட் அளவுருவாக்கத்திற்கு பல மேம்பட்ட நுட்பங்களை வழங்குகிறது, அவற்றுள்:

• அளவுருவாக்கத்துடன் ஃபிக்ஸ்சர்களைப் பயன்படுத்துதல்: ஒவ்வொரு சோதனை நிகழ்விற்கும் வெவ்வேறு அமைப்புகளை வழங்க, ஃபிக்ஸ்சர்களை அளவுருவாக்கத்துடன் இணைத்தல்.
• சோதனை நிகழ்வுகளுக்கான ஐடிகள் (Ids): சிறந்த அறிக்கையிடல் மற்றும் பிழைத்திருத்தத்திற்காக சோதனை நிகழ்வுகளுக்கு தனிப்பயன் ஐடிகளை ஒதுக்குதல்.
• மறைமுக அளவுருவாக்கம் (Indirect Parametrization): ஃபிக்ஸ்சர்களுக்கு அனுப்பப்படும் ஆர்குமென்ட்களை அளவுருவாக்குதல், இது டைனமிக் ஃபிக்ஸ்சர் உருவாக்கத்தை அனுமதிக்கிறது.

அளவுருவாக்கத்துடன் ஃபிக்ஸ்சர்களைப் பயன்படுத்துதல்

சோதனைக்கு அனுப்பப்பட்ட அளவுருக்களின் அடிப்படையில் ஃபிக்ஸ்சர்களை டைனமிக்காக உள்ளமைக்க இது உங்களை அனுமதிக்கிறது. ஒரு தரவுத்தளத்துடன் தொடர்பு கொள்ளும் ஒரு செயல்பாட்டை நீங்கள் சோதிப்பதாக கற்பனை செய்து பாருங்கள். வெவ்வேறு சோதனை நிகழ்வுகளுக்கு வெவ்வேறு தரவுத்தள உள்ளமைவுகளை (எ.கா., வெவ்வேறு இணைப்பு சரங்கள்) பயன்படுத்த விரும்பலாம்.

            
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 ஆர்குமென்ட், அளவுருக்களை ("prod" மற்றும் "test") db_config ஃபிக்ஸ்சர் செயல்பாட்டிற்கு அனுப்பும்படி பைடெஸ்ட்டிடம் கூறுகிறது. பின்னர் db_config ஃபிக்ஸ்சர் அளவுருவின் மதிப்பைப் பொறுத்து வெவ்வேறு தரவுத்தள உள்ளமைவுகளை வழங்குகிறது. db_connection ஃபிக்ஸ்சர், தரவுத்தள இணைப்பை நிறுவ db_config ஃபிக்ஸ்சரைப் பயன்படுத்துகிறது. இறுதியாக, test_database_interaction செயல்பாடு தரவுத்தளத்துடன் தொடர்பு கொள்ள db_connection ஃபிக்ஸ்சரைப் பயன்படுத்துகிறது.

சோதனை நிகழ்வுகளுக்கான ஐடிகள்

தனிப்பயன் ஐடிகள் உங்கள் சோதனை அறிக்கையில் சோதனை நிகழ்வுகளுக்கு மேலும் விளக்கமான பெயர்களை வழங்குகின்றன, இது தோல்விகளைக் கண்டறிந்து பிழைதிருத்தம் செய்வதை எளிதாக்குகிறது.

            
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
              
            
          

ஐடிகள் இல்லாமல், பைடெஸ்ட் 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 ஆர்குமென்ட், இந்த மதிப்புகளை input_data ஃபிக்ஸ்சர் செயல்பாட்டிற்கு அனுப்பும்படி பைடெஸ்ட்டிடம் கூறுகிறது. பின்னர் input_data ஃபிக்ஸ்சர், அளவுருவின் மதிப்பைப் பொறுத்து வெவ்வேறு தரவு அகராதிகளை வழங்குகிறது. test_validate_data செயல்பாடு, வெவ்வேறு உள்ளீட்டுத் தரவுகளுடன் validate_data செயல்பாட்டைச் சோதிக்க input_data ஃபிக்ஸ்சரைப் பயன்படுத்துகிறது.

பைடெஸ்ட்டுடன் மாக்கிங்

மாக்கிங் என்பது சோதனையின் போது உண்மையான சார்புகளை (dependencies) கட்டுப்படுத்தப்பட்ட மாற்றுப்பொருட்களுடன் (mocks) மாற்றுவதற்குப் பயன்படுத்தப்படும் ஒரு நுட்பமாகும். இது சோதிக்கப்படும் குறியீட்டைத் தனிமைப்படுத்தவும், தரவுத்தளங்கள், APIகள் அல்லது கோப்பு முறைமைகள் போன்ற வெளிப்புற அமைப்புகளைச் சார்ந்திருப்பதைத் தவிர்க்கவும் உங்களை அனுமதிக்கிறது.

மாக்கிங்கின் நன்மைகள்

• குறியீட்டைத் தனிமைப்படுத்துதல்: வெளிப்புற சார்புகளைச் சார்ந்திராமல், குறியீட்டைத் தனிமையில் சோதித்தல்.
• நடத்தையைக் கட்டுப்படுத்துதல்: ரிட்டர்ன் மதிப்புகள் மற்றும் விதிவிலக்குகள் போன்ற சார்புகளின் நடத்தையை வரையறுத்தல்.
• சோதனைகளை வேகப்படுத்துதல்: மெதுவான அல்லது நம்பமுடியாத வெளிப்புற அமைப்புகளைத் தவிர்த்தல்.
• எட்ஜ் கேஸ்களை (Edge Cases) சோதித்தல்: உண்மையான சூழலில் மீண்டும் உருவாக்குவது கடினமான பிழை நிலைமைகள் மற்றும் எட்ஜ் கேஸ்களை உருவகப்படுத்துதல்.

unittest.mock நூலகத்தைப் பயன்படுத்துதல்

பைத்தான் மாக்குகளை உருவாக்க unittest.mock நூலகத்தை வழங்குகிறது. பைடெஸ்ட் unittest.mock உடன் தடையின்றி ஒருங்கிணைந்து, உங்கள் சோதனைகளில் சார்புகளை மாக் செய்வதை எளிதாக்குகிறது.

அடிப்படை மாக்கிங் உதாரணம்

ஒரு வெளிப்புற 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 க்கு கோரிக்கை விடுக்காமல் இந்தச் செயல்பாட்டைச் சோதிக்க, நீங்கள் 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_get ஆர்குமென்ட் தான் அந்த மாக் ஆப்ஜெக்ட். பின்னர் நாம் அந்த மாக் ஆப்ஜெக்டை ஒரு குறிப்பிட்ட பதிலை வழங்குமாறு உள்ளமைத்து, அது சரியான URL உடன் அழைக்கப்பட்டதா என்பதை உறுதிப்படுத்தலாம்.

ஃபிக்ஸ்சர்களுடன் மாக்கிங்

மாக்குகளை உருவாக்கவும் நிர்வகிக்கவும் நீங்கள் ஃபிக்ஸ்சர்களையும் பயன்படுத்தலாம். இது பல சோதனைகளில் மாக்குகளைப் பகிர அல்லது மிகவும் சிக்கலான மாக் அமைப்புகளை உருவாக்க பயனுள்ளதாக இருக்கும்.

            
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 ஒரு மாக்கை உருவாக்கி அதை வழங்குகிறது. patched_get பின்னர், ஒரு பைடெஸ்ட் ஃபிக்ஸ்சரான monkeypatch ஐப் பயன்படுத்தி, உண்மையான `requests.get` ஐ மாக் மூலம் மாற்றுகிறது. இது மற்ற சோதனைகளையும் அதே மாக் செய்யப்பட்ட API எண்ட்பாயிண்டைப் பயன்படுத்த அனுமதிக்கிறது.

மேம்பட்ட மாக்கிங் நுட்பங்கள்

பைடெஸ்ட் மற்றும் unittest.mock பல மேம்பட்ட மாக்கிங் நுட்பங்களை வழங்குகின்றன, அவற்றுள்:

• பக்க விளைவுகள் (Side Effects): உள்ளீட்டு ஆர்குமென்ட்களின் அடிப்படையில் மாக்குகளுக்கு தனிப்பயன் நடத்தையை வரையறுத்தல்.
• பிராப்பர்ட்டி மாக்கிங் (Property Mocking): ஆப்ஜெக்ட்களின் பிராப்பர்ட்டிகளை மாக் செய்தல்.
• சூழல் மேலாளர்கள் (Context Managers): தற்காலிக மாற்றுகளுக்கு சூழல் மேலாளர்களுக்குள் மாக்குகளைப் பயன்படுத்துதல்.

பக்க விளைவுகள்

பக்க விளைவுகள் உங்கள் மாக்குகள் பெறும் உள்ளீட்டு ஆர்குமென்ட்களின் அடிப்படையில் அவற்றுக்கு தனிப்பயன் நடத்தையை வரையறுக்க அனுமதிக்கின்றன. இது வெவ்வேறு சூழ்நிலைகள் அல்லது பிழை நிலைகளை உருவகப்படுத்த பயனுள்ளதாக இருக்கும்.

            
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
              
            
          

இந்த மாக் அடுத்தடுத்த அழைப்புகளில் 1, 2, மற்றும் 3 ஐ வழங்குகிறது, பின்னர் பட்டியல் தீர்ந்ததும் ஒரு `StopIteration` விதிவிலக்கை எழுப்புகிறது.

பிராப்பர்ட்டி மாக்கிங்

பிராப்பர்ட்டி மாக்கிங், ஆப்ஜெக்ட்களில் உள்ள பிராப்பர்ட்டிகளின் நடத்தையை மாக் செய்ய உங்களை அனுமதிக்கிறது. இது மெத்தட்களை விட ஆப்ஜெக்ட் பிராப்பர்ட்டிகளைச் சார்ந்திருக்கும் குறியீட்டைச் சோதிக்க பயனுள்ளதாக இருக்கும்.

            
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
              
            
          

இந்த எடுத்துக்காட்டு MyClass ஆப்ஜெக்ட்டின் my_property பிராப்பர்ட்டியை மாக் செய்கிறது, இது சோதனையின் போது அதன் ரிட்டர்ன் மதிப்பைக் கட்டுப்படுத்த உங்களை அனுமதிக்கிறது.

சூழல் மேலாளர்கள்

சூழல் மேலாளர்களுக்குள் மாக்குகளைப் பயன்படுத்துவது, ஒரு குறிப்பிட்ட குறியீட்டுத் தொகுதிக்கு தற்காலிகமாக சார்புகளை மாற்ற அனுமதிக்கிறது. இது வெளிப்புற அமைப்புகள் அல்லது ஒரு குறிப்பிட்ட நேரத்திற்கு மட்டுமே மாக் செய்யப்பட வேண்டிய வளங்களுடன் தொடர்பு கொள்ளும் குறியீட்டைச் சோதிக்க பயனுள்ளதாக இருக்கும்.

            
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
              
            
          

அளவுருவாக்கம் மற்றும் மாக்கிங்கை இணைத்தல்

இந்த இரண்டு சக்திவாய்ந்த நுட்பங்களையும் இணைத்து இன்னும் அதிநவீன மற்றும் பயனுள்ள சோதனைகளை உருவாக்க முடியும். வெவ்வேறு மாக் உள்ளமைவுகளுடன் வெவ்வேறு சூழ்நிலைகளைச் சோதிக்க நீங்கள் அளவுருவாக்கத்தைப் பயன்படுத்தலாம்.

            
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 டெக்கரேட்டர் requests.get செயல்பாட்டை மாக் செய்கிறது. பைடெஸ்ட் சோதனைச் செயல்பாட்டை இரண்டு முறை இயக்கும், ஒவ்வொரு அளவுருக்களின் தொகுப்பிற்கும் ஒரு முறை, அதற்கேற்ற expected_data வை வழங்குமாறு மாக் உள்ளமைக்கப்படும்.

மேம்பட்ட ஃபிக்ஸ்சர்களைப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

• ஃபிக்ஸ்சர்களைக் கவனம் சிதறாமல் வைத்திருங்கள்: ஒவ்வொரு ஃபிக்ஸ்சருக்கும் ஒரு தெளிவான மற்றும் குறிப்பிட்ட நோக்கம் இருக்க வேண்டும்.
• பொருத்தமான ஸ்கோப்களைப் பயன்படுத்துங்கள்: வளப் பயன்பாட்டை மேம்படுத்த, பொருத்தமான ஃபிக்ஸ்சர் ஸ்கோப்பை (செயல்பாடு, தொகுதி, அமர்வு) தேர்வு செய்யவும்.
• ஃபிக்ஸ்சர்களை ஆவணப்படுத்துங்கள்: ஒவ்வொரு ஃபிக்ஸ்சரின் நோக்கத்தையும் பயன்பாட்டையும் தெளிவாக ஆவணப்படுத்துங்கள்.
• அதிகப்படியான மாக்கிங்கைத் தவிர்க்கவும்: சோதிக்கப்படும் குறியீட்டைத் தனிமைப்படுத்தத் தேவையான சார்புகளை மட்டுமே மாக் செய்யவும்.
• தெளிவான உறுதிப்படுத்தல்களை (Assertions) எழுதுங்கள்: உங்கள் உறுதிப்படுத்தல்கள் தெளிவாகவும் குறிப்பிட்டதாகவும் இருப்பதை உறுதிசெய்து, சோதிக்கப்படும் குறியீட்டின் எதிர்பார்க்கப்படும் நடத்தையைச் சரிபார்க்கவும்.
• சோதனை சார்ந்த மேம்பாட்டை (TDD) கருத்தில் கொள்ளுங்கள்: குறியீட்டை எழுதுவதற்கு முன் உங்கள் சோதனைகளை எழுதுங்கள், மேம்பாட்டு செயல்முறைக்கு வழிகாட்ட ஃபிக்ஸ்சர்கள் மற்றும் மாக்குகளைப் பயன்படுத்துங்கள்.

முடிவுரை

பைடெஸ்ட்டின் மேம்பட்ட ஃபிக்ஸ்சர் நுட்பங்களான அளவுருவாக்கப்பட்ட சோதனை மற்றும் மாக் ஒருங்கிணைப்பு, வலுவான, திறமையான மற்றும் பராமரிக்கக்கூடிய சோதனைகளை எழுதுவதற்கான சக்திவாய்ந்த கருவிகளை வழங்குகின்றன. இந்த நுட்பங்களில் தேர்ச்சி பெறுவதன் மூலம், உங்கள் பைத்தான் குறியீட்டின் தரத்தை கணிசமாக மேம்படுத்தலாம் மற்றும் உங்கள் சோதனை செயல்முறையை நெறிப்படுத்தலாம். தெளிவான, கவனம் செலுத்திய ஃபிக்ஸ்சர்களை உருவாக்குவதிலும், பொருத்தமான ஸ்கோப்களைப் பயன்படுத்துவதிலும், விரிவான உறுதிப்படுத்தல்களை எழுதுவதிலும் கவனம் செலுத்த நினைவில் கொள்ளுங்கள். பயிற்சியின் மூலம், ஒரு விரிவான மற்றும் பயனுள்ள சோதனை உத்தியை உருவாக்க, பைடெஸ்ட்டின் ஃபிக்ஸ்சர் அமைப்பின் முழு திறனையும் நீங்கள் பயன்படுத்த முடியும்.