Python kursi17.9-dars: Integratsion testlar
Python kursi · Testlash

17.9-dars: Integratsion testlar

21 daqiqa9/10-dars

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 sqlite3 16.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:

python
@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 SELECT

Xotiradagi 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:

python
@pytest.mark.integration
def test_baza_bilan(baza): ...
toml
[tool.pytest.ini_options]
markers = ["integration: sekin, haqiqiy bog'liqlikli testlar"]
bash
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

python
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(...) == kutilgan
bash
pytest -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 boshlansin

4. Batafsil misollar

Misollarda pytest ni deterministik ishga tushiruvchi pytest_ishga yordamchisi ishlatiladi.

Misol 1 — Unit vs integratsion: mock yashira olmaydigan xato

python
"""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:

text
=== 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 berdi

Nima ko'rsatdi: 2.1, 2.4-bo'limlar.

Misol 2 — Haqiqiy baza bilan integratsion test

python
"""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:

text
=== 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 tekshirildi

Nima ko'rsatdi: 2.3, 2.6-bo'limlar.

Misol 3 — Belgilash: unit va integratsion ajratish

python
"""@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:

text
=== 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.

python
"""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:

text
=== 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

python
con = Mock(); repo = Repo(con)                      # ❌ noto'g'ri SQL o'tadi
con = sqlite3.connect(":memory:")                   # ✅ haqiqiy sxema bilan

2. Tashqi API ni haqiqiy sinash

python
def test_x(): natija = haqiqiy_api_chaqir()         # ❌ sekin, beqaror
def test_x(): with patch(...): ...                  # ✅ mock

3. Integratsion testlarni belgilamaslik

python
def test_baza(): ...                                # ❌ har doim ishlaydi (sekin)
@pytest.mark.integration                            # ✅ tanlab ishga tushiriladi
def test_baza(): ...

4. Testlar orasida ma'lumot ulashish

python
@pytest.fixture(scope="session")                    # ❌ testlar bir-birini buzadi
def baza(): ...
@pytest.fixture                                     # ✅ har test toza
def baza(): ...

5. Teskari piramida

python
# 100 sekin E2E, 10 unit                            # ❌ sekin, mo'rt
# ✅ ko'p unit, o'rta integratsion, kam E2E

6. Faqat "baxtli yo'l" integratsiyasi

python
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

python
@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 — TestClient bilan integratsion test
  • 23-qism: ORM — repozitoriy integratsion testlari
  • 28-qism: CI/CD va Docker — integratsion test muhiti

8. Eng yaxshi amaliyotlar

  1. Unit (mantiq) va integratsion (bog'lanish) testlar — ikkalasi.

  2. Test piramidasi: ko'p unit, o'rta integratsion, kam E2E.

  3. O'z baza sxemangizni haqiqiy (SQLite) sinang, mock emas.

  4. Tashqi API, qimmat resurslarni mock qiling.

  5. Integratsion testlarni belgilang va tanlab ishga tushiring.

  6. Har test toza, ma'lum ma'lumotdan boshlansin (:memory: fixture).

  7. Cheklovlar (UNIQUE, foreign key) va xato yo'llarini ham sinang.

  8. Rivojlanishda unit, CI da barcha testlar.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
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
  1. Integratsion test (haqiqiy baza)
  2. Unit (piramida asosi)
  3. Ha — haqiqiy SQL, tez, izolyatsiyalangan
  4. Yo'q — mock (tarmoq, pul, beqarorlik)
  5. Integratsion belgili testlarni o'tkazib, faqat unit ishga tushiradi
  6. Har test uchun bir marta (yangi nusxa)
  7. Yo'q — mock har SQL ni qabul qiladi
  8. sqlite3.OperationalError: no column named ...

Vazifa 2: Xatolarni tuzating

python
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() == 1
Javoblar
python
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:

  1. Haqiqiy baza fixture (sxema bilan)
  2. CRUD oqimi: post yaratish → izoh qo'shish → o'qish
  3. Cheklovlar: foreign key (post yo'q izoh), UNIQUE (takroriy login)
  4. @pytest.mark.integration bilan belgilang

Vazifa 4: Aralash integratsiya

Email yuboruvchi + baza xizmatini:

  1. Bazani haqiqiy (SQLite), SMTP ni mock qiling
  2. Foydalanuvchi ro'yxatdan o'tadi → bazaga saqlanadi → email yuboriladi
  3. Baza saqlandi (haqiqiy) va email chaqirildi (mock) — ikkalasini tekshiring
  4. Email xatosida baza holati qanday bo'lishini sinang

Vazifa 5: Test piramidasi tahlili

Mavjud loyihada:

  1. Unit, integratsion, E2E testlar sonini sanang
  2. Piramida shaklidami yoki teskarimi — aniqlang
  3. Yetishmayotgan darajani toping
  4. Muvozanatni yaxshilash rejasini yozing

Vazifa 6: Tranzaksiya bilan izolyatsiya

  1. Har test bir tranzaksiyada ishlab, oxirida rollback qilsin
  2. :memory: fixture bilan solishtiring — qaysi biri tez
  3. Katta sinov ma'lumoti bo'lsa qaysi usul afzal
  4. 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

  1. Murakkab mantiq (algoritm, hisob) → unit
  2. Bog'lanish (kod + baza, modullar) → integratsion
  3. Kritik foydalanuvchi yo'llari → kam E2E
  4. "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

  1. Bahs ikkala yondashuvning haqiqatidan kelib chiqadi
  2. Piramida — tezlik/aniqlik; trofica — ishonch
  3. Muvozanat kod turi va bog'liqlikka bog'liq
  4. "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:

  1. 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.

  2. 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.

  3. 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.integration bilan 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.

Testlash · 9-dars yakunlandi

17.9-dars: Integratsion testlar

21 daqvaqt
0belgi
Keyingi dars: 17.10-dars: Property-based test (hypothesis)
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0