అడ్వాన్స్‌డ్ ఫిక్చర్ టెక్నిక్స్‌తో పైటెస్ట్ పూర్తి సామర్థ్యాన్ని అన్‌లాక్ చేయండి. పటిష్టమైన మరియు సమర్థవంతమైన పైథాన్ టెస్టింగ్ కోసం పారామీటరైజ్డ్ టెస్టింగ్ మరియు మాక్ ఇంటిగ్రేషన్‌ను ఎలా ఉపయోగించాలో నేర్చుకోండి.
పైటెస్ట్ అడ్వాన్స్‌డ్ ఫిక్చర్‌లలో నైపుణ్యం: పారామీటరైజ్డ్ టెస్టింగ్ మరియు మాక్ ఇంటిగ్రేషన్
పైటెస్ట్ పైథాన్ కోసం ఒక శక్తివంతమైన మరియు ఫ్లెక్సిబుల్ టెస్టింగ్ ఫ్రేమ్‌వర్క్. దాని సరళత మరియు విస్తరించదగిన స్వభావం ప్రపంచవ్యాప్తంగా డెవలపర్‌లలో దీనిని ఒక అభిమాన సాధనంగా మార్చింది. పైటెస్ట్ యొక్క అత్యంత ఆకర్షణీయమైన ఫీచర్లలో ఒకటి దాని ఫిక్చర్ సిస్టమ్, ఇది సొగసైన మరియు పునర్వినియోగించగల టెస్ట్ సెటప్‌లను అనుమతిస్తుంది. ఈ బ్లాగ్ పోస్ట్ అడ్వాన్స్‌డ్ ఫిక్చర్ టెక్నిక్స్‌లోకి లోతుగా వెళ్తుంది, ముఖ్యంగా పారామీటరైజ్డ్ టెస్టింగ్ మరియు మాక్ ఇంటిగ్రేషన్ పై దృష్టి పెడుతుంది. ఈ టెక్నిక్స్ మీ టెస్టింగ్ వర్క్‌ఫ్లోను ఎలా గణనీయంగా మెరుగుపరుస్తాయో, మరింత పటిష్టమైన మరియు నిర్వహించదగిన కోడ్‌కు దారితీస్తాయో మనం అన్వేషిస్తాము.
పైటెస్ట్ ఫిక్చర్‌లను అర్థం చేసుకోవడం
అడ్వాన్స్‌డ్ టాపిక్స్‌లోకి వెళ్లే ముందు, పైటెస్ట్ ఫిక్చర్‌ల బేసిక్స్‌ను క్లుప్తంగా గుర్తుచేసుకుందాం. ఫిక్చర్ అనేది ప్రతి టెస్ట్ ఫంక్షన్‌కు ముందు రన్ అయ్యే ఒక ఫంక్షన్. ఇది టెస్ట్‌ల కోసం ఒక స్థిరమైన బేస్‌లైన్‌ను అందించడానికి ఉపయోగపడుతుంది, స్థిరత్వాన్ని నిర్ధారిస్తుంది మరియు బాయిలర్‌ప్లేట్ కోడ్‌ను తగ్గిస్తుంది. ఫిక్చర్‌లు ఈ క్రింది పనులను చేయగలవు:
- డేటాబేస్ కనెక్షన్‌ను సెటప్ చేయడం
- తాత్కాలిక ఫైల్స్ లేదా డైరెక్టరీలను సృష్టించడం
- నిర్దిష్ట కాన్ఫిగరేషన్‌లతో ఆబ్జెక్ట్‌లను ఇనిషియలైజ్ చేయడం
- APIతో ప్రామాణీకరించడం
ఫిక్చర్‌లు కోడ్ పునర్వినియోగాన్ని ప్రోత్సహిస్తాయి మరియు మీ టెస్ట్‌లను మరింత చదవగలిగేలా మరియు నిర్వహించగలిగేలా చేస్తాయి. వాటి జీవితకాలాన్ని మరియు వనరుల వినియోగాన్ని నియంత్రించడానికి వాటిని వేర్వేరు స్కోప్‌లలో (ఫంక్షన్, మాడ్యూల్, సెషన్) నిర్వచించవచ్చు.
సాధారణ ఫిక్చర్ ఉదాహరణ
ఇక్కడ ఒక తాత్కాలిక డైరెక్టరీని సృష్టించే ఒక సాధారణ పైటెస్ట్ ఫిక్చర్ ఉదాహరణ ఉంది:
import pytest
import tempfile
import os
@pytest.fixture
def temp_dir():
with tempfile.TemporaryDirectory() as tmpdir:
yield tmpdir
ఈ ఫిక్చర్‌ను ఒక టెస్ట్‌లో ఉపయోగించడానికి, దానిని మీ టెస్ట్ ఫంక్షన్‌కు ఒక ఆర్గ్యుమెంట్‌గా చేర్చండి:
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)
పైటెస్ట్‌తో పారామీటరైజ్డ్ టెస్టింగ్
పారామీటరైజ్డ్ టెస్టింగ్ ఒకే టెస్ట్ ఫంక్షన్‌ను వేర్వేరు ఇన్‌పుట్ డేటా సెట్‌లతో పలుసార్లు అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. వేర్వేరు ఇన్‌పుట్‌లు మరియు ఆశించిన అవుట్‌పుట్‌లతో ఫంక్షన్‌లను పరీక్షించడానికి ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది. పైటెస్ట్ పారామీటరైజ్డ్ టెస్ట్‌లను అమలు చేయడానికి @pytest.mark.parametrize డెకరేటర్‌ను అందిస్తుంది.
పారామీటరైజ్డ్ టెస్టింగ్ ప్రయోజనాలు
- కోడ్ డూప్లికేషన్‌ను తగ్గిస్తుంది: దాదాపు ఒకేలాంటి బహుళ టెస్ట్ ఫంక్షన్‌లను రాయడం నివారించండి.
- టెస్ట్ కవరేజ్‌ను మెరుగుపరుస్తుంది: విస్తృత శ్రేణి ఇన్‌పుట్ విలువలను సులభంగా పరీక్షించండి.
- టెస్ట్ రీడబిలిటీని మెరుగుపరుస్తుంది: ప్రతి టెస్ట్ కేస్ కోసం ఇన్‌పుట్ విలువలు మరియు ఆశించిన అవుట్‌పుట్‌లను స్పష్టంగా నిర్వచించండి.
సాధారణ పారామీటరైజేషన్ ఉదాహరణ
మీ వద్ద రెండు సంఖ్యలను జోడించే ఫంక్షన్ ఉందని అనుకుందాం:
def add(x, y):
return x + y
ఈ ఫంక్షన్‌ను వేర్వేరు ఇన్‌పుట్ విలువలతో పరీక్షించడానికి మీరు పారామీటరైజ్డ్ టెస్టింగ్‌ను ఉపయోగించవచ్చు:
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
ఈ ఉదాహరణలో, @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
ఈ ఉదాహరణలో, 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
ఐడీలు లేకుండా, పైటెస్ట్ 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"]
ఈ ఉదాహరణలో, input_data ఫిక్చర్ "valid" మరియు "invalid" విలువలతో పారామీటరైజ్ చేయబడింది. indirect=True ఆర్గ్యుమెంట్ పైటెస్ట్‌కు ఈ విలువలను input_data ఫిక్చర్ ఫంక్షన్‌కు పంపమని చెబుతుంది. అప్పుడు input_data ఫిక్చర్ పారామీటర్ విలువ ఆధారంగా వేర్వేరు డేటా డిక్షనరీలను తిరిగి ఇస్తుంది. test_validate_data ఫంక్షన్ వేర్వేరు ఇన్‌పుట్ డేటాతో validate_data ఫంక్షన్‌ను పరీక్షించడానికి input_data ఫిక్చర్‌ను ఉపయోగిస్తుంది.
పైటెస్ట్‌తో మాకింగ్
మాకింగ్ అనేది టెస్టింగ్ సమయంలో నిజమైన డిపెండెన్సీలను నియంత్రిత ప్రత్యామ్నాయాలతో (మాక్స్) భర్తీ చేయడానికి ఉపయోగించే ఒక టెక్నిక్. ఇది పరీక్షించబడుతున్న కోడ్‌ను వేరు చేయడానికి మరియు డేటాబేస్‌లు, APIలు లేదా ఫైల్ సిస్టమ్‌లు వంటి బాహ్య సిస్టమ్‌లపై ఆధారపడటాన్ని నివారించడానికి మిమ్మల్ని అనుమతిస్తుంది.
మాకింగ్ ప్రయోజనాలు
- కోడ్‌ను వేరుచేయడం: బాహ్య డిపెండెన్సీలపై ఆధారపడకుండా, కోడ్‌ను వేరుగా పరీక్షించండి.
- ప్రవర్తనను నియంత్రించడం: రిటర్న్ విలువలు మరియు ఎక్సెప్షన్‌లు వంటి డిపెండెన్సీల ప్రవర్తనను నిర్వచించండి.
- టెస్ట్‌లను వేగవంతం చేయడం: నెమ్మదిగా లేదా నమ్మదగని బాహ్య సిస్టమ్‌లను నివారించండి.
- ఎడ్జ్ కేసులను పరీక్షించడం: నిజమైన వాతావరణంలో పునరుత్పత్తి చేయడం కష్టంగా ఉండే ఎర్రర్ కండిషన్‌లు మరియు ఎడ్జ్ కేసులను అనుకరించండి.
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()
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"}
ఈ ఉదాహరణలో, @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"}
ఇక్కడ, mock_api_get ఒక మాక్‌ను సృష్టించి దానిని తిరిగి ఇస్తుంది. patched_get అప్పుడు monkeypatch, ఒక పైటెస్ట్ ఫిక్చర్, ఉపయోగించి నిజమైన `requests.get`ను మాక్‌తో భర్తీ చేస్తుంది. ఇది ఇతర టెస్ట్‌లు అదే మాక్ చేయబడిన API ఎండ్‌పాయింట్‌ను ఉపయోగించడానికి అనుమతిస్తుంది.
అడ్వాన్స్‌డ్ మాకింగ్ టెక్నిక్స్
పైటెస్ట్ మరియు unittest.mock అనేక అడ్వాన్స్‌డ్ మాకింగ్ టెక్నిక్స్‌ను అందిస్తాయి, వాటిలో కొన్ని:
- సైడ్ ఎఫెక్ట్స్: ఇన్‌పుట్ ఆర్గ్యుమెంట్‌ల ఆధారంగా మాక్స్‌కు కస్టమ్ ప్రవర్తనను నిర్వచించండి.
- ప్రాపర్టీ మాకింగ్: ఆబ్జెక్ట్‌ల ప్రాపర్టీలను మాక్ చేయండి.
- కాంటెక్స్ట్ మేనేజర్లు: తాత్కాలిక భర్తీల కోసం కాంటెక్స్ట్ మేనేజర్‌లలో మాక్స్‌ను ఉపయోగించండి.
సైడ్ ఎఫెక్ట్స్
సైడ్ ఎఫెక్ట్స్ మీ మాక్స్‌కు అవి అందుకునే ఇన్‌పుట్ ఆర్గ్యుమెంట్‌ల ఆధారంగా కస్టమ్ ప్రవర్తనను నిర్వచించడానికి మిమ్మల్ని అనుమతిస్తాయి. ఇది వేర్వేరు దృశ్యాలను లేదా ఎర్రర్ కండిషన్‌లను అనుకరించడానికి ఉపయోగపడుతుంది.
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()
ఈ మాక్ వరుస కాల్స్‌లో 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"
ఈ ఉదాహరణ 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")
పారామీటరైజేషన్ మరియు మాకింగ్‌ను కలపడం
ఈ రెండు శక్తివంతమైన టెక్నిక్స్‌ను మరింత అధునాతనమైన మరియు ప్రభావవంతమైన టెస్ట్‌లను సృష్టించడానికి కలపవచ్చు. మీరు వేర్వేరు మాక్ కాన్ఫిగరేషన్‌లతో వేర్వేరు దృశ్యాలను పరీక్షించడానికి పారామీటరైజేషన్‌ను ఉపయోగించవచ్చు.
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}")
ఈ ఉదాహరణలో, test_get_user_data ఫంక్షన్ వేర్వేరు user_id మరియు expected_data విలువలతో పారామీటరైజ్ చేయబడింది. @patch డెకరేటర్ requests.get ఫంక్షన్‌ను మాక్ చేస్తుంది. పైటెస్ట్ టెస్ట్ ఫంక్షన్‌ను రెండుసార్లు రన్ చేస్తుంది, ప్రతి పారామీటర్ల సెట్‌కు ఒకసారి, మాక్ సంబంధిత expected_dataను తిరిగి ఇచ్చేలా కాన్ఫిగర్ చేయబడి ఉంటుంది.
అడ్వాన్స్‌డ్ ఫిక్చర్‌లను ఉపయోగించడానికి ఉత్తమ పద్ధతులు
- ఫిక్చర్‌లను ఫోకస్డ్‌గా ఉంచండి: ప్రతి ఫిక్చర్‌కు స్పష్టమైన మరియు నిర్దిష్ట ప్రయోజనం ఉండాలి.
- తగిన స్కోప్‌లను ఉపయోగించండి: వనరుల వినియోగాన్ని ఆప్టిమైజ్ చేయడానికి తగిన ఫిక్చర్ స్కోప్‌ను (ఫంక్షన్, మాడ్యూల్, సెషన్) ఎంచుకోండి.
- ఫిక్చర్‌లను డాక్యుమెంట్ చేయండి: ప్రతి ఫిక్చర్ యొక్క ప్రయోజనం మరియు వినియోగాన్ని స్పష్టంగా డాక్యుమెంట్ చేయండి.
- అతిగా మాకింగ్ చేయడం నివారించండి: పరీక్షించబడుతున్న కోడ్‌ను వేరు చేయడానికి అవసరమైన డిపెండెన్సీలను మాత్రమే మాక్ చేయండి.
- స్పష్టమైన అసర్షన్‌లను రాయండి: మీ అసర్షన్‌లు స్పష్టంగా మరియు నిర్దిష్టంగా ఉన్నాయని నిర్ధారించుకోండి, పరీక్షించబడుతున్న కోడ్ యొక్క ఆశించిన ప్రవర్తనను ధృవీకరించండి.
- టెస్ట్-డ్రివెన్ డెవలప్‌మెంట్ (TDD)ని పరిగణించండి: కోడ్ రాసే ముందు మీ టెస్ట్‌లను రాయండి, డెవలప్‌మెంట్ ప్రక్రియకు మార్గనిర్దేశం చేయడానికి ఫిక్చర్‌లు మరియు మాక్స్‌ను ఉపయోగించండి.
ముగింపు
పైటెస్ట్ యొక్క అడ్వాన్స్‌డ్ ఫిక్చర్ టెక్నిక్స్, పారామీటరైజ్డ్ టెస్టింగ్ మరియు మాక్ ఇంటిగ్రేషన్‌తో సహా, పటిష్టమైన, సమర్థవంతమైన మరియు నిర్వహించదగిన టెస్ట్‌లను రాయడానికి శక్తివంతమైన సాధనాలను అందిస్తాయి. ఈ టెక్నిక్స్‌లో నైపుణ్యం సాధించడం ద్వారా, మీరు మీ పైథాన్ కోడ్ యొక్క నాణ్యతను గణనీయంగా మెరుగుపరచవచ్చు మరియు మీ టెస్టింగ్ వర్క్‌ఫ్లోను క్రమబద్ధీకరించవచ్చు. స్పష్టమైన, ఫోకస్డ్ ఫిక్చర్‌లను సృష్టించడం, తగిన స్కోప్‌లను ఉపయోగించడం మరియు సమగ్రమైన అసర్షన్‌లను రాయడంపై దృష్టి పెట్టాలని గుర్తుంచుకోండి. ప్రాక్టీస్‌తో, మీరు సమగ్రమైన మరియు ప్రభావవంతమైన టెస్టింగ్ వ్యూహాన్ని సృష్టించడానికి పైటెస్ట్ యొక్క ఫిక్చర్ సిస్టమ్ పూర్తి సామర్థ్యాన్ని ఉపయోగించుకోగలుగుతారు.