17.9-dars: Integratsion testlar
17-QISM — TESTLASH · 9-dars
1. Kirish va motivatsiya
Shu paytgacha asosan unit testlar yozdik: bitta funksiya yoki sinfni izolyatsiyada, bog'liqliklarni mock qilib. Unit testlar tez va aniq, lekin ular bitta muhim narsani tekshirmaydi: qismlar birga to'g'ri ishlaydimi? Kod bilan baza, ikki modul, yoki ilova bilan tashqi xizmat orasidagi bog'lanish mock qilinganda tekshirilmaydi. Integratsion testlar aynan shuni tekshiradi — bir necha qismning haqiqiy bog'lanishda birga ishlashini.
Unit va integratsion testlar bir-birini to'ldiradi: unit testlar mantiqni, integratsion testlar bog'lanishlarni tekshiradi. Ikkalasining muvozanati — "test piramidasi" g'oyasi.
Real vaziyat. Bir jamoada barcha unit testlar o'tardi — 200 ta, hammasi yashil. Lekin ilova ishlab chiqarishda yiqildi. Sabab: repozitoriy INSERT INTO users(login) VALUES(?) yozardi, lekin baza jadvalida ustun username deb nomlangan edi. Unit testlarda baza mock qilingan edi — mock har qanday SQL ni "qabul qilardi", shuning uchun nomuvofiqlik hech qachon ushlanmadi. Ular integratsion test qo'shishdi: repozitoriyni haqiqiy (xotiradagi SQLite) baza bilan sinash. Bu test darhol yiqildi va xatoni ko'rsatdi — mock yashira olmaydigan narsani. Endi unit testlar mantiqni, integratsion testlar esa haqiqiy baza bilan bog'lanishni tekshiradi.
Bu darsda integratsion testlarni — qismlarning birga ishlashini tekshirishni o'rganamiz.
Bu darsda:
- Integratsion test nima va unit'dan farqi
- Test piramidasi — muvozanat
- Haqiqiy baza bilan test (SQLite)
- Qachon mock, qachon haqiqiy
- Integratsion testlarni belgilash va ajratish
- Test ma'lumotini boshqarish
- Sekin testlar bilan ishlash
- Amaliy: repozitoriy va xizmat integratsiyasi
ℹ Misollarda haqiqiy baza sifatida xotiradagi
sqlite316.7-bob ishlatiladi — tez, izolyatsiyalangan, real SQL.
2. Nazariya — chuqur tushuntirish
2.1. Integratsion test nima
Integratsion test — bir necha qismning birga ishlashini tekshiradi (mock siz yoki kam mock bilan):
| Unit test | Integratsion test |
|---|---|
| Bitta funksiya/sinf | Bir necha qism birga |
| Bog'liqliklar mock | Haqiqiy bog'liqliklar |
| Mantiqni tekshiradi | Bog'lanishni tekshiradi |
| Juda tez | Sekinroq |
| Aniq yiqilish | Kengroq qamrov |
Integratsion test mock yashira olmaydigan xatolarni topadi: noto'g'ri SQL, API kontrakt nomuvofiqligi, konfiguratsiya xatolari.
2.2. Test piramidasi
Sog'lom test to'plami — piramida shaklida:
/\ E2E (kam) — butun tizim
/ \
/____\ Integratsion (o'rta) — qismlar birga
/ \
/________\ Unit (ko'p) — tez, aniq| Daraja | Soni | Tezlik | Nimani topadi |
|---|---|---|---|
| Unit | Ko'p | Juda tez | Mantiq xatolari |
| Integratsion | O'rta | O'rtacha | Bog'lanish xatolari |
| E2E | Kam | Sekin | Tizim xatolari |
"Teskari piramida" (ko'p sekin E2E, kam unit) — sekin, mo'rt test to'plamiga olib keladi. Ko'p tez unit + yetarli integratsion afzal.
2.3. Haqiqiy baza bilan test
Integratsion testda baza mock qilinmaydi — haqiqiy (lekin test uchun) baza ishlatiladi:
@pytest.fixture
def baza():
con = sqlite3.connect(":memory:") # haqiqiy SQLite, lekin xotirada
con.executescript(SXEMA) # haqiqiy sxema
yield con
con.close()
def test_repozitoriy(baza):
repo = FoydalanuvchiRepo(baza)
repo.qosh("aziz") # haqiqiy INSERT
assert repo.ol("aziz") is not None # haqiqiy SELECTXotiradagi SQLite — integratsion test uchun ideal: haqiqiy SQL, lekin tez va izolyatsiyalangan. Katta loyihalarda haqiqiy Postgres/MySQL konteynerlari (Docker) ishlatiladi (28-qism).
2.4. Qachon mock, qachon haqiqiy
| Mock | Haqiqiy |
|---|---|
| Tashqi API (tarmoq, pul) | O'z baza sxemangiz |
| Vaqt, tasodif | Modullar orasidagi bog'lanish |
| Nazoratdan tashqari xizmat | Test uchun arzon resurs (SQLite) |
| Xato holatlarini simulyatsiya | Haqiqiy ma'lumot oqimi |
Qoida: o'zingiz nazorat qiladigan va arzon narsani (SQLite, ichki modullar) haqiqiy sinang; nazoratdan tashqari yoki qimmat narsani (tashqi API, to'lov) mock qiling.
2.5. Integratsion testlarni belgilash
Integratsion testlar sekinroq — ularni belgilab, alohida ishga tushirish mumkin:
@pytest.mark.integration
def test_baza_bilan(baza): ...[tool.pytest.ini_options]
markers = ["integration: sekin, haqiqiy bog'liqlikli testlar"]pytest -m "not integration" # faqat tez unit testlar (rivojlanishda)
pytest -m integration # faqat integratsion (CI da)Bu rivojlanishda tez qaytar aloqa (unit) va CI da to'liq tekshiruv (hammasi) beradi.
2.6. Test ma'lumotini boshqarish
Integratsion testda har test toza, ma'lum ma'lumotdan boshlashi kerak:
| Usul | Izoh |
|---|---|
| Har test yangi baza | :memory: fixture (eng toza) |
| Tranzaksiya + rollback | Har test rollback bilan tozalanadi |
| Sinov ma'lumoti (fixtures) | Ma'lum boshlang'ich holat |
Testlar bir-birining ma'lumotiga bog'lanmasligi kerak (17.3 mustaqillik) — aks holda tartib o'zgarsa yiqiladi.
2.7. Sekin testlar bilan ishlash
| Muammo | Yechim |
|---|---|
| Integratsion testlar sekin | Belgilab ajrating, parallel ishga tushiring (pytest-xdist) |
| Har o'zgarishda hammasi | Rivojlanishda faqat unit (-m "not integration") |
| CI da to'liq | CI da barcha testlar |
| Tashqi resurs kerak | Docker konteyner (28-qism) yoki fixture |
2.8. Muvozanat
Yaxshi test to'plami — piramida:
- Ko'p unit — tez, mantiqni to'liq qamraydi
- Yetarli integratsion — muhim bog'lanishlarni tekshiradi
- Kam E2E — kritik foydalanuvchi yo'llari
Faqat unit — bog'lanish xatolarini o'tkazib yuboradi (baza misolidagidek); faqat integratsion — sekin va aniq emas. Ikkalasi kerak.
3. Tez ma'lumotnoma
import pytest, sqlite3
@pytest.fixture
def baza():
con = sqlite3.connect(":memory:") # haqiqiy, izolyatsiyalangan
con.executescript(SXEMA)
yield con
con.close()
@pytest.mark.integration # belgilab ajrating
def test_repo_baza_bilan(baza):
repo = Repo(baza)
repo.qosh(...) # haqiqiy SQL
assert repo.ol(...) == kutilganpytest -m "not integration" # tez unit (rivojlanish)
pytest # hammasi (CI)Qoidalar
unit — mantiq (mock bilan); integratsion — bog'lanish (haqiqiy)
test piramidasi: ko'p unit, o'rta integratsion, kam E2E
o'z baza sxemangiz — haqiqiy sinang (SQLite)
tashqi API, qimmat resurs — mock
integratsion testlarni belgilang (@pytest.mark.integration)
har test toza, ma'lum ma'lumotdan boshlansin4. Batafsil misollar
Misollarda
pytestni deterministik ishga tushiruvchipytest_ishgayordamchisi ishlatiladi.
Misol 1 — Unit vs integratsion: mock yashira olmaydigan xato
"""unit testda mock har SQL ni qabul qiladi — noto'g'ri ustun nomi o'tib ketadi; integratsion test (haqiqiy SQLite) uni darhol topadi."""
import re
import subprocess
import sys
import tempfile
from pathlib import Path
def pytest_ishga(katalog: Path, *args: str) -> tuple[int, list[str]]:
r = subprocess.run([sys.executable, "-m", "pytest", "-p", "no:cacheprovider", "-o", "addopts=", *args],
cwd=katalog, capture_output=True, text=True, encoding="utf-8")
satrlar = []
for l in r.stdout.splitlines():
if re.match(r"(=+ test session|collecting|collected|platform |cachedir|rootdir|plugins|configfile|hypothesis profile)", l):
continue
l = re.sub(r"\s+\[\s*\d+%\]$", "", l)
l = re.sub(r" in [\d.]+s\b", "", l)
l = re.sub(r"^(=+) (.*?) =+$", r"--- \2 ---", l)
satrlar.append(l.rstrip())
while satrlar and satrlar[0] == "":
satrlar.pop(0)
while satrlar and satrlar[-1] == "":
satrlar.pop()
return r.returncode, satrlar
# Repozitoriyda XATO bor: jadval 'username', kod 'login' yozadi
KOD = '''
class FoydalanuvchiRepo:
def __init__(self, con):
self.con = con
def qosh(self, login):
# XATO: jadval ustuni 'username', bu yerda 'login'
self.con.execute("INSERT INTO foydalanuvchi(login) VALUES(?)", (login,))
def soni(self):
return self.con.execute("SELECT COUNT(*) FROM foydalanuvchi").fetchone()[0]
'''
# UNIT test: baza mock — noto'g'ri SQL o'tib ketadi
UNIT_TEST = '''
from unittest.mock import Mock
from repo import FoydalanuvchiRepo
def test_qosh_unit():
con = Mock()
repo = FoydalanuvchiRepo(con)
repo.qosh("aziz")
con.execute.assert_called_once() # SQL bajarildi... lekin to'g'rimi?
'''
# INTEGRATSION test: haqiqiy SQLite — xatoni topadi
INTEG_TEST = '''
import sqlite3
import pytest
from repo import FoydalanuvchiRepo
@pytest.fixture
def baza():
con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE foydalanuvchi(id INTEGER PRIMARY KEY, username TEXT)")
yield con
con.close()
def test_qosh_integ(baza):
repo = FoydalanuvchiRepo(baza)
repo.qosh("aziz") # haqiqiy INSERT — 'login' ustuni yo'q!
assert repo.soni() == 1
'''
def main() -> None:
with tempfile.TemporaryDirectory() as katalog:
r = Path(katalog)
(r / "repo.py").write_text(KOD, encoding="utf-8")
print("=== 1. UNIT test (mock baza) — xato o'tib ketadi ===")
(r / "test_unit.py").write_text(UNIT_TEST, encoding="utf-8")
kod, satrlar = pytest_ishga(r, "-q", "--tb=no")
print(f" {[s for s in satrlar if 'passed' in s or 'failed' in s][0]}")
print(" ⚠️ mock har SQL ni qabul qiladi — noto'g'ri ustun nomi ushlanmadi")
(r / "test_unit.py").unlink()
print("\n=== 2. INTEGRATSION test (haqiqiy SQLite) — xatoni topadi ===")
(r / "test_integ.py").write_text(INTEG_TEST, encoding="utf-8")
kod, satrlar = pytest_ishga(r, "-q", "--tb=line")
print(f" {[s for s in satrlar if 'passed' in s or 'failed' in s][0]}")
print(f" chiqish kodi: {kod}")
print(" ⭐ haqiqiy baza 'no column named login' xatosini darhol ochib berdi")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. UNIT test (mock baza) — xato o'tib ketadi ===
1 passed
⚠️ mock har SQL ni qabul qiladi — noto'g'ri ustun nomi ushlanmadi
=== 2. INTEGRATSION test (haqiqiy SQLite) — xatoni topadi ===
1 failed
chiqish kodi: 1
⭐ haqiqiy baza 'no column named login' xatosini darhol ochib berdiNima ko'rsatdi: 2.1, 2.4-bo'limlar.
Misol 2 — Haqiqiy baza bilan integratsion test
"""haqiqiy SQLite bilan repozitoriyni test qilish: CRUD oqimi, cheklovlar (UNIQUE, foreign key), tranzaksiya; fixture har test toza baza beradi."""
import re
import subprocess
import sys
import tempfile
from pathlib import Path
def pytest_ishga(katalog: Path, *args: str) -> tuple[int, list[str]]:
r = subprocess.run([sys.executable, "-m", "pytest", "-p", "no:cacheprovider", "-o", "addopts=", *args],
cwd=katalog, capture_output=True, text=True, encoding="utf-8")
satrlar = []
for l in r.stdout.splitlines():
if re.match(r"(=+ test session|collecting|collected|platform |cachedir|rootdir|plugins|configfile|hypothesis profile)", l):
continue
l = re.sub(r"\s+\[\s*\d+%\]$", "", l)
l = re.sub(r" in [\d.]+s\b", "", l)
l = re.sub(r"^(=+) (.*?) =+$", r"--- \2 ---", l)
satrlar.append(l.rstrip())
while satrlar and satrlar[0] == "":
satrlar.pop(0)
while satrlar and satrlar[-1] == "":
satrlar.pop()
return r.returncode, satrlar
KOD = '''
import sqlite3
SXEMA = """
CREATE TABLE muallif(id INTEGER PRIMARY KEY, ism TEXT UNIQUE NOT NULL);
CREATE TABLE kitob(
id INTEGER PRIMARY KEY,
nom TEXT NOT NULL,
muallif_id INTEGER NOT NULL REFERENCES muallif(id)
);
"""
class Kutubxona:
def __init__(self, con):
self.con = con
con.execute("PRAGMA foreign_keys = ON")
def muallif_qosh(self, ism):
cur = self.con.execute("INSERT INTO muallif(ism) VALUES(?)", (ism,))
return cur.lastrowid
def kitob_qosh(self, nom, muallif_id):
cur = self.con.execute("INSERT INTO kitob(nom, muallif_id) VALUES(?, ?)", (nom, muallif_id))
return cur.lastrowid
def muallif_kitoblari(self, muallif_id):
qatorlar = self.con.execute("SELECT nom FROM kitob WHERE muallif_id=? ORDER BY nom", (muallif_id,))
return [q[0] for q in qatorlar]
'''
TEST = '''
import sqlite3
import pytest
from kutubxona import Kutubxona, SXEMA
@pytest.fixture
def kutubxona():
con = sqlite3.connect(":memory:")
con.executescript(SXEMA)
yield Kutubxona(con)
con.close()
def test_muallif_va_kitob(kutubxona):
mid = kutubxona.muallif_qosh("Qodiriy")
kutubxona.kitob_qosh("O'tkan kunlar", mid)
kutubxona.kitob_qosh("Mehrobdan chayon", mid)
assert kutubxona.muallif_kitoblari(mid) == ["Mehrobdan chayon", "O'tkan kunlar"]
def test_takroriy_muallif_rad(kutubxona):
kutubxona.muallif_qosh("Qodiriy")
with pytest.raises(sqlite3.IntegrityError):
kutubxona.muallif_qosh("Qodiriy") # UNIQUE buzilishi
def test_mavjud_emas_muallif_rad(kutubxona):
with pytest.raises(sqlite3.IntegrityError):
kutubxona.kitob_qosh("Kitob", 999) # foreign key buzilishi
def test_har_test_toza_baza(kutubxona):
# oldingi testlar muallif qo'shdi, lekin bu test yangi, bo'sh baza oladi
assert kutubxona.muallif_kitoblari(1) == []
'''
def main() -> None:
with tempfile.TemporaryDirectory() as katalog:
r = Path(katalog)
(r / "kutubxona.py").write_text(KOD, encoding="utf-8")
(r / "test_kutubxona.py").write_text(TEST, encoding="utf-8")
print("=== 1. Haqiqiy baza bilan integratsion testlar ===")
kod, satrlar = pytest_ishga(r, "-v", "--tb=short")
for satr in satrlar:
if "::" in satr:
print(f" {satr}")
print(f" chiqish kodi: {kod}")
print(" ⭐ haqiqiy SQL, cheklovlar (UNIQUE, foreign key) va CRUD oqimi tekshirildi")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Haqiqiy baza bilan integratsion testlar ===
test_kutubxona.py::test_muallif_va_kitob PASSED
test_kutubxona.py::test_takroriy_muallif_rad PASSED
test_kutubxona.py::test_mavjud_emas_muallif_rad PASSED
test_kutubxona.py::test_har_test_toza_baza PASSED
chiqish kodi: 0
⭐ haqiqiy SQL, cheklovlar (UNIQUE, foreign key) va CRUD oqimi tekshirildiNima ko'rsatdi: 2.3, 2.6-bo'limlar.
Misol 3 — Belgilash: unit va integratsion ajratish
"""@pytest.mark bilan integratsion testlarni belgilash; -m bilan tanlab ishga tushirish; rivojlanishda tez unit, CI da hammasi."""
import re
import subprocess
import sys
import tempfile
from pathlib import Path
def pytest_ishga(katalog: Path, *args: str) -> tuple[int, list[str]]:
r = subprocess.run([sys.executable, "-m", "pytest", "-p", "no:cacheprovider", *args],
cwd=katalog, capture_output=True, text=True, encoding="utf-8")
satrlar = []
for l in r.stdout.splitlines():
if re.match(r"(=+ test session|collecting|collected|platform |cachedir|rootdir|plugins|configfile|hypothesis profile)", l):
continue
l = re.sub(r"\s+\[\s*\d+%\]$", "", l)
l = re.sub(r" in [\d.]+s\b", "", l)
l = re.sub(r"^(=+) (.*?) =+$", r"--- \2 ---", l)
satrlar.append(l.rstrip())
while satrlar and satrlar[0] == "":
satrlar.pop(0)
while satrlar and satrlar[-1] == "":
satrlar.pop()
return r.returncode, satrlar
PYPROJECT = '''
[tool.pytest.ini_options]
markers = ["integration: sekin, haqiqiy bog'liqlikli testlar"]
'''
TEST = '''
import sqlite3
import pytest
# Unit testlar (tez, mock/sof)
def test_unit_qoshish():
assert 2 + 3 == 5
def test_unit_royxat():
assert sorted([3, 1, 2]) == [1, 2, 3]
# Integratsion testlar (belgilangan)
@pytest.mark.integration
def test_integ_baza():
con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE t(x INTEGER)")
con.execute("INSERT INTO t VALUES(42)")
assert con.execute("SELECT x FROM t").fetchone()[0] == 42
con.close()
@pytest.mark.integration
def test_integ_yana():
con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE t(x)")
con.executemany("INSERT INTO t VALUES(?)", [(i,) for i in range(5)])
assert con.execute("SELECT SUM(x) FROM t").fetchone()[0] == 10
con.close()
'''
def main() -> None:
with tempfile.TemporaryDirectory() as katalog:
r = Path(katalog)
(r / "pyproject.toml").write_text(PYPROJECT, encoding="utf-8")
(r / "test_hammasi.py").write_text(TEST, encoding="utf-8")
print("=== 1. Barcha testlar ===")
kod, satrlar = pytest_ishga(r, "-v", "--tb=short")
for satr in satrlar:
if "::" in satr or satr.startswith("---"):
print(f" {satr}")
print("\n=== 2. Faqat unit (rivojlanishda tez qaytar aloqa) ===")
kod, satrlar = pytest_ishga(r, "-v", "--tb=short", "-m", "not integration")
for satr in satrlar:
if "::" in satr or satr.startswith("---"):
print(f" {satr}")
print("\n=== 3. Faqat integratsion (CI da) ===")
kod, satrlar = pytest_ishga(r, "-v", "--tb=short", "-m", "integration")
for satr in satrlar:
if "::" in satr or satr.startswith("---"):
print(f" {satr}")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Barcha testlar ===
test_hammasi.py::test_unit_qoshish PASSED
test_hammasi.py::test_unit_royxat PASSED
test_hammasi.py::test_integ_baza PASSED
test_hammasi.py::test_integ_yana PASSED
--- 4 passed ---
=== 2. Faqat unit (rivojlanishda tez qaytar aloqa) ===
test_hammasi.py::test_unit_qoshish PASSED
test_hammasi.py::test_unit_royxat PASSED
--- 2 passed, 2 deselected ---
=== 3. Faqat integratsion (CI da) ===
test_hammasi.py::test_integ_baza PASSED
test_hammasi.py::test_integ_yana PASSED
--- 2 passed, 2 deselected ---Nima ko'rsatdi: 2.5, 2.7-bo'limlar.
Misol 4 — Amaliy: xizmat + baza integratsiyasi
Buyurtma xizmatini test qilamiz: u repozitoriy (baza) va tashqi to'lov xizmatiga bog'liq. To'g'ri yondashuv — bazani haqiqiy (SQLite) sinash, to'lov API sini esa mock qilish (17.4 qoidasi). Bu integratsion test xizmat, repozitoriy va baza birga ishlashini tekshiradi, tashqi qimmat bog'liqlikni esa boshqariladigan qiladi.
"""aralash integratsiya: baza HAQIQIY (SQLite), to'lov API MOCK; xizmat+repo+baza birga; buyurtma oqimi, holat, xato yo'llari."""
import re
import subprocess
import sys
import tempfile
from pathlib import Path
KOD = '''
import sqlite3
SXEMA = """
CREATE TABLE buyurtma(
id INTEGER PRIMARY KEY,
mijoz TEXT NOT NULL,
summa INTEGER NOT NULL,
holat TEXT NOT NULL DEFAULT 'yangi'
);
"""
class BuyurtmaRepo:
def __init__(self, con):
self.con = con
def yarat(self, mijoz, summa):
cur = self.con.execute("INSERT INTO buyurtma(mijoz, summa) VALUES(?, ?)", (mijoz, summa))
return cur.lastrowid
def holat_ozgartir(self, id, holat):
self.con.execute("UPDATE buyurtma SET holat=? WHERE id=?", (holat, id))
def ol(self, id):
r = self.con.execute("SELECT mijoz, summa, holat FROM buyurtma WHERE id=?", (id,)).fetchone()
return dict(zip(("mijoz", "summa", "holat"), r)) if r else None
class BuyurtmaXizmati:
def __init__(self, repo, tolov_api):
self.repo = repo
self.tolov = tolov_api # tashqi — mock qilinadi
def buyurtma_ber(self, mijoz, summa):
if summa <= 0:
raise ValueError("summa musbat bo'lishi kerak")
id = self.repo.yarat(mijoz, summa) # HAQIQIY baza
natija = self.tolov.tolov_qil(summa) # MOCK tashqi API
if natija["holat"] == "muvaffaqiyat":
self.repo.holat_ozgartir(id, "tolangan")
else:
self.repo.holat_ozgartir(id, "rad")
return id
'''
TEST = '''
import sqlite3
from unittest.mock import Mock
import pytest
from xizmat import BuyurtmaRepo, BuyurtmaXizmati, SXEMA
@pytest.fixture
def repo():
con = sqlite3.connect(":memory:")
con.executescript(SXEMA)
yield BuyurtmaRepo(con)
con.close()
def test_muvaffaqiyatli_buyurtma(repo):
tolov = Mock()
tolov.tolov_qil.return_value = {"holat": "muvaffaqiyat"}
xizmat = BuyurtmaXizmati(repo, tolov)
id = xizmat.buyurtma_ber("Aziz", 50000)
# HAQIQIY baza: buyurtma saqlandi va holati yangilandi
saqlangan = repo.ol(id)
assert saqlangan == {"mijoz": "Aziz", "summa": 50000, "holat": "tolangan"}
# MOCK: to'lov to'g'ri summa bilan chaqirildi
tolov.tolov_qil.assert_called_once_with(50000)
def test_tolov_rad_etildi(repo):
tolov = Mock()
tolov.tolov_qil.return_value = {"holat": "rad"}
xizmat = BuyurtmaXizmati(repo, tolov)
id = xizmat.buyurtma_ber("Bek", 99999)
assert repo.ol(id)["holat"] == "rad"
def test_notogri_summa_baza_ozgapmaydi(repo):
tolov = Mock()
xizmat = BuyurtmaXizmati(repo, tolov)
with pytest.raises(ValueError):
xizmat.buyurtma_ber("Nodira", -100)
# baza bo'sh qoldi, to'lov chaqirilmadi
assert repo.con.execute("SELECT COUNT(*) FROM buyurtma").fetchone()[0] == 0
tolov.tolov_qil.assert_not_called()
'''
def pytest_ishga(katalog: Path, *args: str) -> tuple[int, list[str]]:
r = subprocess.run([sys.executable, "-m", "pytest", "-p", "no:cacheprovider", "-o", "addopts=", *args],
cwd=katalog, capture_output=True, text=True, encoding="utf-8")
satrlar = []
for l in r.stdout.splitlines():
if re.match(r"(=+ test session|collecting|collected|platform |cachedir|rootdir|plugins|configfile|hypothesis profile)", l):
continue
l = re.sub(r"\s+\[\s*\d+%\]$", "", l)
l = re.sub(r" in [\d.]+s\b", "", l)
l = re.sub(r"^(=+) (.*?) =+$", r"--- \2 ---", l)
satrlar.append(l.rstrip())
while satrlar and satrlar[0] == "":
satrlar.pop(0)
while satrlar and satrlar[-1] == "":
satrlar.pop()
return r.returncode, satrlar
def main() -> None:
with tempfile.TemporaryDirectory() as katalog:
r = Path(katalog)
(r / "xizmat.py").write_text(KOD, encoding="utf-8")
(r / "test_xizmat.py").write_text(TEST, encoding="utf-8")
print("=== 1. Aralash integratsiya (haqiqiy baza + mock API) ===")
kod, satrlar = pytest_ishga(r, "-v", "--tb=short")
for satr in satrlar:
if "::" in satr:
print(f" {satr}")
print(f"\n chiqish kodi: {kod}")
print(" ⭐ baza HAQIQIY sinaldi (SQL, holat), to'lov API MOCK (tashqi, qimmat)")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Aralash integratsiya (haqiqiy baza + mock API) ===
test_xizmat.py::test_muvaffaqiyatli_buyurtma PASSED
test_xizmat.py::test_tolov_rad_etildi PASSED
test_xizmat.py::test_notogri_summa_baza_ozgapmaydi PASSED
chiqish kodi: 0
⭐ baza HAQIQIY sinaldi (SQL, holat), to'lov API MOCK (tashqi, qimmat)Nima ko'rsatdi: 2.3, 2.4, 2.8-bo'limlar.
5. To'g'ri va noto'g'ri tushunishlar
| Noto'g'ri fikr | To'g'risi |
|---|---|
| "Unit testlar yetarli" | Bog'lanish xatolarini o'tkazadi (SQL, kontrakt) |
| "Hamma narsani mock qilish kerak" | O'z baza sxemangizni haqiqiy sinang |
| "Integratsion testlar unit o'rnini bosadi" | Bir-birini to'ldiradi |
| "Ko'p E2E test — yaxshi" | Sekin, mo'rt — piramida teskari |
| "Haqiqiy baza test — sekin" | Xotiradagi SQLite tez |
| "Tashqi API ni haqiqiy sinash kerak" | Mock — tarmoq, pul, beqarorlik |
| "Integratsion testlarni har doim ishga tushirish" | Belgilab, tanlab ishga tushiring |
| "Mock xatoni topadi" | Mock har SQL/chaqiruvni qabul qiladi |
6. Keng tarqalgan xatolar va yechimlari
1. Bazani har doim mock qilish
con = Mock(); repo = Repo(con) # ❌ noto'g'ri SQL o'tadi
con = sqlite3.connect(":memory:") # ✅ haqiqiy sxema bilan2. Tashqi API ni haqiqiy sinash
def test_x(): natija = haqiqiy_api_chaqir() # ❌ sekin, beqaror
def test_x(): with patch(...): ... # ✅ mock3. Integratsion testlarni belgilamaslik
def test_baza(): ... # ❌ har doim ishlaydi (sekin)
@pytest.mark.integration # ✅ tanlab ishga tushiriladi
def test_baza(): ...4. Testlar orasida ma'lumot ulashish
@pytest.fixture(scope="session") # ❌ testlar bir-birini buzadi
def baza(): ...
@pytest.fixture # ✅ har test toza
def baza(): ...5. Teskari piramida
# 100 sekin E2E, 10 unit # ❌ sekin, mo'rt
# ✅ ko'p unit, o'rta integratsion, kam E2E6. Faqat "baxtli yo'l" integratsiyasi
def test_qosh(repo): repo.qosh(...) # ❌ cheklovlar test qilinmagan
def test_takroriy_rad(repo): # ✅ UNIQUE, foreign key ham
with pytest.raises(IntegrityError): ...7. Baza fixture da tozalashni unutish
@pytest.fixture
def baza():
con = sqlite3.connect("test.db"); return con # ❌ fayl qoladi
@pytest.fixture
def baza():
con = sqlite3.connect(":memory:"); yield con; con.close() # ✅7. Integratsiya — bu bilim qayerda kerak bo'ladi
- 16.7-dars (o'tilgan): sqlite3 — integratsion test uchun haqiqiy baza
- 17.3-dars (o'tilgan): fixture — baza fixture
- 17.5–17.6-darslar (o'tilgan): mock — tashqi bog'liqlik uchun
- 20.15-dars: FastAPI —
TestClientbilan integratsion test - 23-qism: ORM — repozitoriy integratsion testlari
- 28-qism: CI/CD va Docker — integratsion test muhiti
8. Eng yaxshi amaliyotlar
Unit (mantiq) va integratsion (bog'lanish) testlar — ikkalasi.
Test piramidasi: ko'p unit, o'rta integratsion, kam E2E.
O'z baza sxemangizni haqiqiy (SQLite) sinang, mock emas.
Tashqi API, qimmat resurslarni mock qiling.
Integratsion testlarni belgilang va tanlab ishga tushiring.
Har test toza, ma'lum ma'lumotdan boshlansin (
:memory:fixture).Cheklovlar (UNIQUE, foreign key) va xato yo'llarini ham sinang.
Rivojlanishda unit, CI da barcha testlar.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
1. # unit vs integratsion — qaysi noto'g'ri SQL ustun nomini topadi?
2. # test piramidasida qaysi daraja eng ko'p bo'lishi kerak?
3. # xotiradagi SQLite integratsion test uchun mosmi?
4. # tashqi to'lov API ni integratsion testda haqiqiy sinash kerakmi?
5. # pytest -m "not integration" nima qiladi?
6. # @pytest.fixture (scope siz) har test uchun necha marta chaqiriladi?
7. # mock baza noto'g'ri ustun nomini ushlaydimi?
8. # haqiqiy SQLite noto'g'ri ustun nomida qanday xato beradi?Javoblar
- Integratsion test (haqiqiy baza)
- Unit (piramida asosi)
- Ha — haqiqiy SQL, tez, izolyatsiyalangan
- Yo'q — mock (tarmoq, pul, beqarorlik)
- Integratsion belgili testlarni o'tkazib, faqat unit ishga tushiradi
- Har test uchun bir marta (yangi nusxa)
- Yo'q — mock har SQL ni qabul qiladi
sqlite3.OperationalError: no column named ...
Vazifa 2: Xatolarni tuzating
1. def test_repo():
con = Mock()
repo = Repo(con)
repo.qosh("aziz") # SQL to'g'riligi tekshirilmaydi
2. def test_api():
natija = tashqi_ob_havo_api("Toshkent") # haqiqiy tarmoq
assert natija["temp"] > -50
3. @pytest.fixture(scope="session")
def baza():
con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE t(x)")
return con # tozalash yo'q, umumiy
4. def test_baza(): # belgilanmagan, har doim sekin ishlaydi
con = sqlite3.connect(":memory:")
# ... 5 soniya davom etadi
5. def test_qosh(repo):
repo.qosh("aziz") # faqat baxtli yo'l
assert repo.soni() == 1Javoblar
1. @pytest.fixture
def baza():
con = sqlite3.connect(":memory:")
con.executescript(SXEMA)
yield con; con.close()
def test_repo(baza):
repo = Repo(baza); repo.qosh("aziz") # haqiqiy SQL
assert repo.soni() == 1
2. def test_api():
with patch("app.tashqi_ob_havo_api", return_value={"temp": 25}):
assert app.xabar("Toshkent") # mock
3. @pytest.fixture # function scope
def baza():
con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE t(x)")
yield con; con.close()
4. @pytest.mark.integration # belgilangan
def test_baza():
con = sqlite3.connect(":memory:")
...
5. def test_qosh(repo):
repo.qosh("aziz")
assert repo.soni() == 1
def test_takroriy_rad(repo): # cheklov ham
repo.qosh("aziz")
with pytest.raises(sqlite3.IntegrityError):
repo.qosh("aziz")Vazifa 3: Blog integratsion testlari
Blog repozitoriysi (post, izoh, foydalanuvchi — SQLite) uchun:
- Haqiqiy baza fixture (sxema bilan)
- CRUD oqimi: post yaratish → izoh qo'shish → o'qish
- Cheklovlar: foreign key (post yo'q izoh), UNIQUE (takroriy login)
@pytest.mark.integrationbilan belgilang
Vazifa 4: Aralash integratsiya
Email yuboruvchi + baza xizmatini:
- Bazani haqiqiy (SQLite), SMTP ni mock qiling
- Foydalanuvchi ro'yxatdan o'tadi → bazaga saqlanadi → email yuboriladi
- Baza saqlandi (haqiqiy) va email chaqirildi (mock) — ikkalasini tekshiring
- Email xatosida baza holati qanday bo'lishini sinang
Vazifa 5: Test piramidasi tahlili
Mavjud loyihada:
- Unit, integratsion, E2E testlar sonini sanang
- Piramida shaklidami yoki teskarimi — aniqlang
- Yetishmayotgan darajani toping
- Muvozanatni yaxshilash rejasini yozing
Vazifa 6: Tranzaksiya bilan izolyatsiya
- Har test bir tranzaksiyada ishlab, oxirida
rollbackqilsin :memory:fixture bilan solishtiring — qaysi biri tez- Katta sinov ma'lumoti bo'lsa qaysi usul afzal
- Tranzaksiya izolyatsiyasi darajasini tekshiring
Vazifa 7: O'ylash
"Test piramidasi" (ko'p unit, kam E2E) ko'p yillik standart edi, lekin so'nggi vaqtlarda ba'zi jamoalar "test troficasi" (test trophy — ko'proq integratsion) yoki "ko'proq integratsion test yozing" yondashuvini targ'ib qilmoqda. Nima uchun bu bahs mavjud, va unit va integratsion testlar orasidagi muvozanat qaysi omillarga bog'liq?
Javob
Qisqa javob: Bahs mavjud, chunki ikkala yondashuv ham haqiqat urug'iga ega. Klassik piramida tezlik va aniqlik ni ustun qo'yadi (ko'p tez unit). "Test troficasi" esa ishonch ni ustun qo'yadi: integratsion testlar foydalanuvchi haqiqatan duch keladigan narsaga yaqinroq, va zamonaviy vositalar ularni tezroq qildi. To'g'ri muvozanat loyihaga bog'liq: tez unit testlar murakkab mantiq uchun, integratsion testlar bog'lanishlar ko'p bo'lgan (masalan CRUD ilova) kod uchun.
1. Klassik piramida mantig'i
| Argument | Izoh |
|---|---|
| Unit tez | Minglab test soniyalarda |
| Aniq yiqilish | Qaysi funksiya buzilgani aniq |
| Arzon yozish | Kam tayyorlash |
| E2E mo'rt | Sekin, beqaror, qimmat |
2. "Test troficasi" mantig'i
| Argument | Izoh |
|---|---|
| Ishonch | Integratsion foydalanuvchiga yaqin |
| Mock yashiradi | Ko'p mock = kam haqiqat |
| Vositalar yaxshilandi | Integratsion test tezlashdi |
| Refaktoringga chidamli | Xatti-harakat, tuzilma emas |
3. Muvozanatga ta'sir qiluvchi omillar
| Omil | Ko'proq unit | Ko'proq integratsion |
|---|---|---|
| Kod turi | Murakkab algoritm/mantiq | CRUD, bog'lanishlar |
| Bog'liqlik | Kam | Ko'p (baza, xizmat) |
| O'zgaruvchanlik | Barqaror | Tez o'zgaradi |
| Resurs narxi | Qimmat mock | Arzon (SQLite) |
| Jamoa | Tez qaytar aloqa kerak | Ishonch muhim |
4. Amaliy sintez
- Murakkab mantiq (algoritm, hisob) → unit
- Bog'lanish (kod + baza, modullar) → integratsion
- Kritik foydalanuvchi yo'llari → kam E2E
- "Mock yashira olmaydigan" narsalarni integratsion sinang
5. Chuqurroq tamoyil
Test turi emas, nimaga ishonch berishi muhim. Har test "bu kod ishlaydi" degan ishonchni qancha oshiradi? Ko'p mock qilingan unit test kam ishonch, haqiqiy bog'lanishli integratsion test ko'p ishonch beradi — lekin sekinroq. Muvozanat — ishonch va tezlik orasida.
6. Xulosa
- Bahs ikkala yondashuvning haqiqatidan kelib chiqadi
- Piramida — tezlik/aniqlik; trofica — ishonch
- Muvozanat kod turi va bog'liqlikka bog'liq
- "Ishonchni maksimallashtir" — turdan muhimroq
Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.
Xulosa
Bu darsda integratsion testlarni — qismlarning birga ishlashini tekshirishni o'rgandik.
Eng muhim uch fikr:
Integratsion testlar mock yashira olmaydigan xatolarni topadi. Unit testlar bitta qismni izolyatsiyada, bog'liqliklarni mock qilib tekshiradi — lekin mock har SQL yoki chaqiruvni qabul qiladi, shuning uchun noto'g'ri ustun nomi yoki API kontrakt nomuvofiqligi o'tib ketadi. Integratsion test qismlarni haqiqiy bog'lanishda (masalan haqiqiy baza) sinab, bunday xatolarni darhol ochib beradi. Unit va integratsion testlar bir-birini to'ldiradi: unit — mantiq, integratsion — bog'lanish.
Test piramidasi — muvozanat. Sog'lom test to'plami: ko'p tez unit test (mantiqni to'liq qamraydi), o'rta miqdorda integratsion (muhim bog'lanishlarni tekshiradi), kam E2E (kritik foydalanuvchi yo'llari). Teskari piramida (ko'p sekin E2E) sekin va mo'rt to'plamga olib keladi. O'z baza sxemangizni haqiqiy (xotiradagi SQLite — tez va izolyatsiyalangan) sinang.
Qachon mock, qachon haqiqiy. Qoida: o'zingiz nazorat qiladigan va arzon narsani (SQLite, ichki modullar) haqiqiy sinang; nazoratdan tashqari yoki qimmat narsani (tashqi API, to'lov) mock qiling. Integratsion testlarni
@pytest.mark.integrationbilan belgilab, rivojlanishda-m "not integration"bilan faqat tez unitlarni, CI da esa barchasini ishga tushiring. Har test toza, ma'lum ma'lumotdan (:memory:fixture) boshlansin va cheklovlar (UNIQUE, foreign key) hamda xato yo'llarini ham sinang.
Keyingi darsda — 17-qismning yakuniy darsi: property-based testing (hypothesis) — misollar emas, xususiyatlar asosida test yozish: kutubxona yuzlab tasodifiy kirishni o'zi yaratib, kodingizni siz o'ylamagan chegara holatlarida sinaydi.
Izohlar · 0
Izoh yozish uchun kiring.