Python kursi17.8-dars: TDD — test avval
Python kursi · Testlash

17.8-dars: TDD — test avval

22 daqiqa8/10-dars

17-QISM — TESTLASH · 8-dars


1. Kirish va motivatsiya

Shu paytgacha odatiy tartibda ishladik: avval kod yozdik, keyin test. TDD (Test-Driven Development — testga asoslangan dasturlash) buni teskari qiladi: avval test yoziladi (u yiqiladi), keyin uni o'tkazadigan kod yoziladi. Bu shunchaki tartib o'zgarishi emas — bu dizayn usuli: test yozishdan oldin siz "bu kod qanday ishlashi kerak?" degan savolga javob berasiz.

TDD amaliyoti "Qizil-Yashil-Refaktoring" sikliga asoslanadi va u yaxshi dizaynga, to'liq qamrovga va ishonchli refaktoringga olib keladi.

Real vaziyat. Bir dasturchi murakkab funksiya yozdi — ko'p shart, ko'p chegara holati. Keyin uni test qilmoqchi bo'lganda, funksiyaning interfeysi noqulay ekanini tushundi: uni chaqirish uchun ko'p tayyorlash kerak, natijasini tekshirish qiyin. Kodni qayta yozishga to'g'ri keldi. Boshqa loyihada u TDD ni sinab ko'rdi: avval "funksiya shunday chaqirilishi va shu natijani berishi kerak" degan testni yozdi. Test yozayotib, interfeys noqulayligini darhol sezdi va uni tuzatdi — kod yozilgunicha. Natijada kod birinchi urinishdayoq qulay interfeysga ega bo'ldi va to'liq test qamroviga ega bo'ldi. TDD dizaynni test nuqtai nazaridan boshlashga majbur qildi.

Bu darsda TDD ni — testni koddan oldin yozish falsafasini o'rganamiz.

Bu darsda:

  • TDD nima va nega
  • Qizil-Yashil-Refaktoring sikli
  • Kichik qadamlar bilan rivojlanish
  • TDD dizaynga qanday ta'sir qiladi
  • TDD tuzoqlari va cheklovlari
  • Qachon TDD, qachon yo'q
  • Amaliy: TDD bilan funksiya yaratish
  • TDD va oddiy yondashuvni solishtirish

ℹ Bu dars amaliyot va falsafa haqida — misollarda TDD siklining har bosqichi pytest bilan ko'rsatiladi.


2. Nazariya — chuqur tushuntirish

2.1. TDD nima

TDD — kod yozishdan oldin test yozadigan usul. Asosiy g'oya: har bir yangi imkoniyat uchun avval uni tavsiflovchi (va yiqiladigan) test yoziladi, keyin uni o'tkazadigan minimal kod.

An'anaviy TDD
Kod → test Test → kod
"Bu qanday ishlaydi?" "Bu qanday ishlashi kerak?"
Test — tekshiruv Test — dizayn va spetsifikatsiya

2.2. Qizil-Yashil-Refaktoring sikli

TDD uchta takrorlanuvchi bosqichdan iborat:

Bosqich Nima qilinadi Holat
Qizil Yiqiladigan test yoziladi Test FAILED
Yashil Testni o'tkazadigan minimal kod Test PASSED
Refaktoring Kodni yaxshilash (testlar hali o'tadi) Test PASSED

Sikl kichik va tez: bir test yoz, o'tkazadigan kod yoz, tozala, keyingi testga o't. Har sikl bir necha daqiqa.

2.3. "Qizil" bosqich — avval yiqilsin

python
# 1. Avval test (kod hali yo'q):
def test_qoshish():
    assert qoshish(2, 3) == 5      # 'qoshish' hali yozilmagan → yiqiladi

Test yiqilishi kerak — bu testning to'g'ri ekanini isbotlaydi. Agar test darhol o'tsa, u hech narsani tekshirmayotgan bo'lishi mumkin.

2.4. "Yashil" bosqich — minimal kod

python
# 2. Testni o'tkazadigan ENG SODDA kod:
def qoshish(a, b):
    return a + b

"Minimal" muhim: testni o'tkazadigan eng oddiy kodni yozing, ortiqcha emas. Keyingi imkoniyat keyingi test bilan qo'shiladi ("YAGNI" — kerak bo'lmaganini yozma).

2.5. "Refaktoring" bosqich — tozalash

Test o'tgach, kodni testlarni buzmasdan yaxshilaysiz: takrorni yo'q qilish, nomlarni tozalash, tuzilmani soddalashtirish. Testlar himoya to'rlari — refaktoring xavfsiz.

Refaktoring — TDD ning kam e'tibor beriladigan, lekin muhim qismi. Test bo'lmasa, refaktoring qo'rqinchli; test bilan — ishonchli.

2.6. TDD dizaynga ta'siri

TDD kodni test nuqtai nazaridan boshlaydi, bu dizaynga ta'sir qiladi:

Ta'sir Natija
Interfeys avval Qulay, tushunarli API
Kichik birliklar Test qilinadigan, modulli kod
Bog'liqlik in'eksiyasi Mock qilish oson (13.5)
To'liq qamrov Har kod test bilan yoziladi
Kam ortiqcha kod Faqat kerakli (YAGNI)

"Test qilinadigan kod — yaxshi dizaynlangan kod": TDD bu bog'liqlikni tabiiy qiladi.

2.7. TDD tuzoqlari va cheklovlari

Tuzoq Izoh
Interfeys noaniq bo'lsa qiyin Tajriba/o'rganish bosqichida sekinlashtiradi
Testga haddan bog'lanish Implementatsiya testlari refaktoringni buzadi
"Test uchun test" Ma'nosiz mayda testlar
UI/o'rganish kodi TDD har joyga mos kelmaydi
Boshda sekin tuyuladi Foyda keyin ko'rinadi

TDD — vosita, dogma emas: u ko'p holatda foydali, lekin har joyda majburiy emas.

2.8. Qachon TDD

TDD mos TDD kamroq mos
Aniq talab, murakkab mantiq Tadqiqot/prototip
Biznes qoidalari, algoritmlar UI tajribasi
Xato tuzatish (avval regressiya testi) Interfeys hali noaniq
Kritik kod Bir martalik skript

Xato tuzatishda TDD ayniqsa kuchli: avval xatoni ko'rsatuvchi test (qizil), keyin tuzatish (yashil) — 17.1 dagi regressiya g'oyasi.


3. Tez ma'lumotnoma

python
# TDD sikli:
# 1. 🔴 QIZIL — yiqiladigan test
def test_xususiyat():
    assert yangi_funksiya(kirish) == kutilgan   # funksiya hali yo'q

# 2. 🟢 YASHIL — o'tkazadigan minimal kod
def yangi_funksiya(x):
    return kutilgan_natija

# 3. 🔵 REFAKTORING — tozalash (test hali o'tadi)
# takrorni yo'q qil, nomlarni yaxshila

# keyingi test → keyingi sikl

Qoidalar

avval test (yiqilsin), keyin kod
minimal kod — testni o'tkazadigan eng sodda (YAGNI)
refaktoring — testlar himoyasida
kichik, tez sikllar (daqiqalar)
xato tuzatishda: avval regressiya testi
implementatsiyani emas, xatti-harakatni test qil
TDD — vosita, dogma emas

4. Batafsil misollar

Misollarda pytest ni deterministik ishga tushiruvchi pytest_ishga yordamchisi ishlatiladi.

Misol 1 — Qizil-Yashil-Refaktoring sikli

python
"""TDD sikli: 1) yiqiladigan test (qizil), 2) o'tkazadigan minimal kod (yashil), 3) refaktoring (test hali o'tadi); bosqichma-bosqich rivojlanish."""

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


TEST = '''
from fib import fibonachchi

def test_birinchi_ikki():
    assert fibonachchi(0) == 0
    assert fibonachchi(1) == 1

def test_uchinchi():
    assert fibonachchi(2) == 1

def test_kattaroq():
    assert fibonachchi(10) == 55
'''


def main() -> None:
    with tempfile.TemporaryDirectory() as katalog:
        r = Path(katalog)
        (r / "test_fib.py").write_text(TEST, encoding="utf-8")

        print("=== 1. 🔴 QIZIL — kod hali yo'q, test yiqiladi ===")
        (r / "fib.py").write_text("def fibonachchi(n):\n    pass\n", encoding="utf-8")
        kod, satrlar = pytest_ishga(r, "-q", "--tb=no")
        print(f"  natija: {[s for s in satrlar if 'passed' in s or 'failed' in s][0]}")
        print(f"  chiqish kodi: {kod} (yiqilish — kutilgan)")

        print("\n=== 2. 🟢 YASHIL — testni o'tkazadigan minimal kod ===")
        (r / "fib.py").write_text(
            "def fibonachchi(n):\n"
            "    if n < 2:\n"
            "        return n\n"
            "    a, b = 0, 1\n"
            "    for _ in range(n - 1):\n"
            "        a, b = b, a + b\n"
            "    return b\n", encoding="utf-8")
        kod, satrlar = pytest_ishga(r, "-v", "--tb=no")
        for satr in satrlar:
            if "::" in satr:
                print(f"  {satr}")
        print(f"  chiqish kodi: {kod} (hammasi o'tdi)")

        print("\n=== 3. 🔵 REFAKTORING — soddalashtirish (test hali o'tadi) ===")
        (r / "fib.py").write_text(
            "def fibonachchi(n):\n"
            "    a, b = 0, 1\n"
            "    for _ in range(n):\n"
            "        a, b = b, a + b\n"
            "    return a\n", encoding="utf-8")
        kod, satrlar = pytest_ishga(r, "-q", "--tb=no")
        print(f"  refaktoringdan keyin: {[s for s in satrlar if 'passed' in s or 'failed' in s][0]}")
        print(f"  chiqish kodi: {kod}")
        print("  ⭐ testlar himoyasida kodni ishonch bilan soddalashtidik")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. 🔴 QIZIL — kod hali yo'q, test yiqiladi ===
  natija: 3 failed
  chiqish kodi: 1 (yiqilish — kutilgan)

=== 2. 🟢 YASHIL — testni o'tkazadigan minimal kod ===
  test_fib.py::test_birinchi_ikki PASSED
  test_fib.py::test_uchinchi PASSED
  test_fib.py::test_kattaroq PASSED
  chiqish kodi: 0 (hammasi o'tdi)

=== 3. 🔵 REFAKTORING — soddalashtirish (test hali o'tadi) ===
  refaktoringdan keyin: 3 passed
  chiqish kodi: 0
  ⭐ testlar himoyasida kodni ishonch bilan soddalashtidik

Nima ko'rsatdi: 2.2, 2.3, 2.4, 2.5-bo'limlar.

Misol 2 — Kichik qadamlar bilan rivojlanish

python
"""bir imkoniyat — bir test — bir qadam; har test yangi talab qo'shadi va kod bosqichma-bosqich o'sadi; YAGNI (faqat kerakligini yoz)."""

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


def main() -> None:
    with tempfile.TemporaryDirectory() as katalog:
        r = Path(katalog)

        # FizzBuzz TDD bilan — qadam-baqadam
        print("=== Qadam 1: oddiy son o'zini qaytaradi ===")
        (r / "test_fb.py").write_text(
            "from fb import fizzbuzz\n"
            "def test_oddiy_son(): assert fizzbuzz(1) == '1'\n", encoding="utf-8")
        (r / "fb.py").write_text("def fizzbuzz(n):\n    return str(n)\n", 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("\n=== Qadam 2: 3 ga bo'linsa 'Fizz' ===")
        (r / "test_fb.py").write_text(
            "from fb import fizzbuzz\n"
            "def test_oddiy_son(): assert fizzbuzz(1) == '1'\n"
            "def test_fizz(): assert fizzbuzz(3) == 'Fizz'\n", encoding="utf-8")
        (r / "fb.py").write_text(
            "def fizzbuzz(n):\n"
            "    if n % 3 == 0:\n"
            "        return 'Fizz'\n"
            "    return str(n)\n", 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("\n=== Qadam 3: 5 ga bo'linsa 'Buzz' ===")
        (r / "test_fb.py").write_text(
            "from fb import fizzbuzz\n"
            "def test_oddiy_son(): assert fizzbuzz(1) == '1'\n"
            "def test_fizz(): assert fizzbuzz(3) == 'Fizz'\n"
            "def test_buzz(): assert fizzbuzz(5) == 'Buzz'\n", encoding="utf-8")
        (r / "fb.py").write_text(
            "def fizzbuzz(n):\n"
            "    if n % 3 == 0:\n"
            "        return 'Fizz'\n"
            "    if n % 5 == 0:\n"
            "        return 'Buzz'\n"
            "    return str(n)\n", 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("\n=== Qadam 4: 15 ga bo'linsa 'FizzBuzz' ===")
        (r / "test_fb.py").write_text(
            "from fb import fizzbuzz\n"
            "def test_oddiy_son(): assert fizzbuzz(1) == '1'\n"
            "def test_fizz(): assert fizzbuzz(3) == 'Fizz'\n"
            "def test_buzz(): assert fizzbuzz(5) == 'Buzz'\n"
            "def test_fizzbuzz(): assert fizzbuzz(15) == 'FizzBuzz'\n", encoding="utf-8")
        (r / "fb.py").write_text(
            "def fizzbuzz(n):\n"
            "    natija = ''\n"
            "    if n % 3 == 0:\n"
            "        natija += 'Fizz'\n"
            "    if n % 5 == 0:\n"
            "        natija += 'Buzz'\n"
            "    return natija or str(n)\n", encoding="utf-8")
        kod, satrlar = pytest_ishga(r, "-v", "--tb=no")
        for satr in satrlar:
            if "::" in satr:
                print(f"  {satr}")
        print(f"  chiqish kodi: {kod}")
        print("  ⭐ har test bir talab qo'shdi, kod bosqichma-bosqich o'sdi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== Qadam 1: oddiy son o'zini qaytaradi ===
  1 passed

=== Qadam 2: 3 ga bo'linsa 'Fizz' ===
  2 passed

=== Qadam 3: 5 ga bo'linsa 'Buzz' ===
  3 passed

=== Qadam 4: 15 ga bo'linsa 'FizzBuzz' ===
  test_fb.py::test_oddiy_son PASSED
  test_fb.py::test_fizz PASSED
  test_fb.py::test_buzz PASSED
  test_fb.py::test_fizzbuzz PASSED
  chiqish kodi: 0
  ⭐ har test bir talab qo'shdi, kod bosqichma-bosqich o'sdi

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

Misol 3 — TDD dizaynga ta'siri

python
"""TDD interfeysni avval o'ylashga majbur qiladi; test yozayotib qulay API topiladi; bog'liqlik in'eksiyasi tabiiy bo'ladi; to'liq qamrov."""

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


# Test AVVAL yozildi — interfeys shu yerda "loyihalandi"
TEST = '''
from unittest.mock import Mock
from bildirishnoma import BildirishnomaXizmati

def test_email_yuboriladi():
    # test yozayotib, biz interfeysni tanladik: yuboruvchi in'eksiya qilinadi
    yuboruvchi = Mock()
    xizmat = BildirishnomaXizmati(yuboruvchi)
    xizmat.xabar_yubor("aziz@example.com", "Salom")
    yuboruvchi.assert_called_once_with("aziz@example.com", "Salom")

def test_bosh_manzil_rad_etiladi():
    xizmat = BildirishnomaXizmati(Mock())
    import pytest
    with pytest.raises(ValueError):
        xizmat.xabar_yubor("", "Salom")

def test_bosh_xabar_rad_etiladi():
    xizmat = BildirishnomaXizmati(Mock())
    import pytest
    with pytest.raises(ValueError):
        xizmat.xabar_yubor("aziz@example.com", "")
'''

# Kod testdan KEYIN — interfeys allaqachon aniq
KOD = '''
class BildirishnomaXizmati:
    def __init__(self, yuboruvchi):
        self.yuboruvchi = yuboruvchi          # in'eksiya — test talab qildi

    def xabar_yubor(self, manzil, matn):
        if not manzil:
            raise ValueError("manzil bo'sh bo'la olmaydi")
        if not matn:
            raise ValueError("xabar bo'sh bo'la olmaydi")
        self.yuboruvchi(manzil, matn)
'''


def main() -> None:
    with tempfile.TemporaryDirectory() as katalog:
        r = Path(katalog)
        (r / "test_bildirishnoma.py").write_text(TEST, encoding="utf-8")
        (r / "bildirishnoma.py").write_text(KOD, encoding="utf-8")

        print("=== 1. Test avval yozildi — interfeys loyihalandi ===")
        print("  test 'yuboruvchi in'eksiya qilinadi' deb talab qildi")
        print("  → kod tabiiy ravishda bog'liqlik in'eksiyasi bilan yozildi")

        print("\n=== 2. Testlar (interfeys va mantiq) ===")
        kod, satrlar = pytest_ishga(r, "-v", "--tb=short")
        for satr in satrlar:
            if "::" in satr:
                print(f"  {satr}")
        print(f"  chiqish kodi: {kod}")

        print("\n=== 3. Coverage (TDD → to'liq qamrov) ===")
        subprocess.run([sys.executable, "-m", "coverage", "run", "-m", "pytest",
                        "-p", "no:cacheprovider", "-o", "addopts=", "-q"],
                       cwd=r, capture_output=True, text=True, encoding="utf-8")
        cov = subprocess.run([sys.executable, "-m", "coverage", "json", "-o", "-"],
                             cwd=r, capture_output=True, text=True, encoding="utf-8")
        import json
        d = json.loads(cov.stdout)
        print(f"  bildirishnoma.py qamrovi: {d['files']['bildirishnoma.py']['summary']['percent_covered_display']}%")
        print("  ⭐ TDD da kod test bilan yoziladi — qamrov tabiiy to'liq")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Test avval yozildi — interfeys loyihalandi ===
  test 'yuboruvchi in'eksiya qilinadi' deb talab qildi
  → kod tabiiy ravishda bog'liqlik in'eksiyasi bilan yozildi

=== 2. Testlar (interfeys va mantiq) ===
  test_bildirishnoma.py::test_email_yuboriladi PASSED
  test_bildirishnoma.py::test_bosh_manzil_rad_etiladi PASSED
  test_bildirishnoma.py::test_bosh_xabar_rad_etiladi PASSED
  chiqish kodi: 0

=== 3. Coverage (TDD → to'liq qamrov) ===
  bildirishnoma.py qamrovi: 100%
  ⭐ TDD da kod test bilan yoziladi — qamrov tabiiy to'liq

Nima ko'rsatdi: 2.6-bo'lim.

Misol 4 — Amaliy: TDD bilan Rim raqamlari

Rim raqamlari konvertorini (butun son → Rim raqami) TDD bilan noldan quramiz. Bu — TDD ning klassik mashqi: har test yangi qoida qo'shadi, kod bosqichma-bosqich o'sadi va oxirida to'liq, test qilingan yechim paydo bo'ladi. Har bosqichda qizil-yashil-refaktoring siklini kuzatamiz.

python
"""TDD bilan Rim raqamlari konvertori: qadam-baqadam testlar, har biri yangi qoida; oxirgi kod refaktoring bilan toza; to'liq qamrov."""

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


# Yakuniy testlar (TDD jarayonida bosqichma-bosqich yozilgan)
TEST = '''
import pytest
from rim import rimga

@pytest.mark.parametrize("son, rim", [
    (1, "I"), (2, "II"), (3, "III"),
    (4, "IV"), (5, "V"), (9, "IX"),
    (10, "X"), (40, "XL"), (50, "L"),
    (90, "XC"), (100, "C"), (400, "CD"),
    (500, "D"), (900, "CM"), (1000, "M"),
    (2024, "MMXXIV"), (3888, "MMMDCCCLXXXVIII"),
])
def test_rimga(son, rim):
    assert rimga(son) == rim

def test_notogri_nol():
    with pytest.raises(ValueError):
        rimga(0)

def test_notogri_katta():
    with pytest.raises(ValueError):
        rimga(4000)
'''

# Yakuniy kod (refaktoring qilingan — jadval bilan)
KOD = '''
JADVAL = [
    (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"),
    (100, "C"), (90, "XC"), (50, "L"), (40, "XL"),
    (10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I"),
]

def rimga(son):
    if not 1 <= son <= 3999:
        raise ValueError("son 1-3999 orasida bo'lishi kerak")
    natija = []
    for qiymat, belgi in JADVAL:
        while son >= qiymat:
            natija.append(belgi)
            son -= qiymat
    return "".join(natija)
'''


def main() -> None:
    with tempfile.TemporaryDirectory() as katalog:
        r = Path(katalog)
        (r / "rim.py").write_text(KOD, encoding="utf-8")
        (r / "test_rim.py").write_text(TEST, encoding="utf-8")

        print("=== 1. Yakuniy test to'plami (TDD natijasi) ===")
        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(f"  chiqish kodi: {kod}")

        print("\n=== 2. Ba'zi holatlar ===")
        for son, kutilgan in [(4, "IV"), (2024, "MMXXIV"), (3888, "MMMDCCCLXXXVIII")]:
            import importlib.util
            spec = importlib.util.spec_from_file_location("rim", r / "rim.py")
            modul = importlib.util.module_from_spec(spec)
            spec.loader.exec_module(modul)
            print(f"  {son} → {modul.rimga(son)} ({'✅' if modul.rimga(son) == kutilgan else '❌'})")

        print("\n=== 3. Coverage ===")
        subprocess.run([sys.executable, "-m", "coverage", "run", "--branch", "-m", "pytest",
                        "-p", "no:cacheprovider", "-o", "addopts=", "-q"],
                       cwd=r, capture_output=True, text=True, encoding="utf-8")
        cov = subprocess.run([sys.executable, "-m", "coverage", "json", "-o", "-"],
                             cwd=r, capture_output=True, text=True, encoding="utf-8")
        import json
        d = json.loads(cov.stdout)
        print(f"  rim.py qamrovi: {d['files']['rim.py']['summary']['percent_covered_display']}%")
        print("  ⭐ TDD: har qoida test bilan yozildi → to'liq qamrov, ishonchli kod")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Yakuniy test to'plami (TDD natijasi) ===
  19 passed
  chiqish kodi: 0

=== 2. Ba'zi holatlar ===
  4 → IV (✅)
  2024 → MMXXIV (✅)
  3888 → MMMDCCCLXXXVIII (✅)

=== 3. Coverage ===
  rim.py qamrovi: 100%
  ⭐ TDD: har qoida test bilan yozildi → to'liq qamrov, ishonchli kod

Nima ko'rsatdi: 2.2, 2.5, 2.6-bo'limlar.


5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr To'g'risi
"TDD — shunchaki test yozish" Test avval, dizayn usuli
"Avval kod, keyin test — TDD" Teskari — test avval
"Birinchi test o'tishi kerak" Yiqilishi kerak (qizil)
"Barcha kodni yozib, keyin test" Bir test, bir kod, kichik qadamlar
"TDD refaktoringsiz" Refaktoring — siklning uchdan biri
"TDD har joyda majburiy" Vosita, dogma emas
"Minimal kod — sifatsiz kod" Refaktoring bosqichida tozalanadi
"TDD sekin" Boshda sekin, keyin tez (kam xato)

6. Keng tarqalgan xatolar va yechimlari

1. Testni koddan keyin yozish (TDD emas)

python
def kod(): ...                                      # ❌ avval kod
def test_kod(): ...                                 # keyin test
# ✅ TDD: avval test (yiqilsin), keyin kod

2. Qizil bosqichni o'tkazib yuborish

python
def test_x(): assert f(2) == 4                      # ❌ f allaqachon bor va o'tadi
# ✅ avval test yiqilishini ko'ring — u to'g'ri ekanini isbotlaydi

3. Haddan ziyod kod yozish (YAGNI buzilishi)

python
def qoshish(a, b):                                  # ❌ bitta test uchun
    if a is None: ...                               # keraksiz murakkablik
    return a + b
def qoshish(a, b): return a + b                     # ✅ minimal

4. Refaktoringni o'tkazib yuborish

python
# test o'tdi, keyingi testga o'tish                # ❌ kod iflos qoladi
# ✅ test o'tgach, kodni tozala (test himoyasida)

5. Implementatsiyani test qilish

python
def test_ichki_metod_chaqirildi(): ...              # ❌ refaktoring buzadi
def test_natija_togri(): ...                        # ✅ xatti-harakat

6. Katta qadamlar

python
def test_hamma_narsa(): ...                         # ❌ bir vaqtda ko'p
# ✅ bir test — bir kichik imkoniyat

7. Xato tuzatishda TDD ni ishlatmaslik

python
# xatoni to'g'ridan-to'g'ri tuzatish                # ❌ qaytishi mumkin
# ✅ avval xatoni ko'rsatuvchi test (qizil), keyin tuzatish (yashil)

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 17.1-dars (o'tilgan): regressiya — xato tuzatishda TDD
  • 17.2–17.4-darslar (o'tilgan): pytest, fixture, parametrize — TDD vositalari
  • 17.7-dars (o'tilgan): coverage — TDD tabiiy yuqori qamrov beradi
  • 27-qism: arxitektura — TDD test qilinadigan dizaynga undaydi
  • 31-qism: karyera — TDD professional amaliyot

8. Eng yaxshi amaliyotlar

  1. Avval test yozing (yiqilsin), keyin kod.

  2. Minimal kod — testni o'tkazadigan eng sodda (YAGNI).

  3. Refaktoring bosqichini o'tkazib yubormang — testlar himoyasida tozalang.

  4. Kichik, tez sikllar — bir test, bir kod.

  5. Xato tuzatishda avval regressiya testi yozing.

  6. Implementatsiyani emas, xatti-harakatni test qiling.

  7. TDD ni mos joyda ishlating — dogma emas.

  8. Qizil bosqichni ko'ring — test to'g'ri ekanini isbotlaydi.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

TDD siklining har bosqichida test holati (PASSED/FAILED) qanday bo'ladi?

python
# 1. Test yozildi, kod yo'q:
def test_kvadrat(): assert kvadrat(3) == 9

1.  # kvadrat yo'q — test holati?
2.  # def kvadrat(n): pass  qo'shildi — holat?
3.  # def kvadrat(n): return n*n  qo'shildi — holat?
4.  # refaktoring: def kvadrat(n): return n**2 — holat?

Va tushunchalar:

5.  TDD da birinchi qadam nima?
6.  "Qizil" bosqich nimani anglatadi?
7.  Minimal kod nima uchun muhim?
8.  Refaktoring bosqichida testlar qanday bo'ladi?
Javoblar
  1. FAILED (NameError — kvadrat yo'q)
  2. FAILED (pass None qaytaradi, 9 emas)
  3. PASSED
  4. PASSED (refaktoring xatti-harakatni o'zgartirmaydi)
  5. Yiqiladigan test yozish
  6. Test yiqilgan (kod hali yo'q yoki to'liq emas)
  7. Ortiqcha kod yozmaslik (YAGNI), keyingi imkoniyat keyingi test bilan
  8. O'tishda davom etadi (refaktoring xatti-harakatni buzmaydi)

Vazifa 2: Xatolarni tuzating (TDD jarayonini)

python
1.  # avval to'liq kod yozildi:
    def stack_push(s, x): s.append(x)
    def stack_pop(s): return s.pop()
    # keyin test

2.  def test_bosh():
        assert kvadrat(3) == 9      # kvadrat allaqachon bor va to'g'ri

3.  # bitta test uchun:
    def kvadrat(n):
        if n < 0: raise ValueError()
        if n == 0: return 0
        return n * n

4.  # test o'tdi, darhol keyingi imkoniyatga o'tish
    # (kod takrorlanuvchi va iflos)

5.  def test_ichki_holat():
        s = Stack(); s.push(1)
        assert s._items == [1]      # ichki tuzilmani tekshirish
Javoblar
python
1.  # TDD: avval test (yiqilsin), keyin kod
    def test_push():                        # 1. qizil
        s = []; stack_push(s, 1)
        assert s == [1]
    def stack_push(s, x): s.append(x)       # 2. yashil

2.  # avval test yiqilishini ko'ring:
    # kvadrat hali yozilmagan → FAILED (qizil)
    # keyin kod yozing → PASSED (yashil)

3.  def kvadrat(n):
        return n * n                        # minimal — faqat joriy test uchun
    # manfiy/nol holatlari keyingi testlar bilan

4.  # test o'tgach, REFAKTORING:
    # takrorni yo'q qil, nomlarni yaxshila (testlar himoyasida)
    # keyin keyingi testga o't

5.  def test_pop_qaytaradi():
        s = Stack(); s.push(1)
        assert s.pop() == 1                 # xatti-harakat, ichki tuzilma emas

Vazifa 3: TDD bilan Stack

Stack sinfini (push, pop, peek, is_empty, size) TDD bilan:

  1. Har metod uchun avval test (qizil), keyin kod (yashil)
  2. Bo'sh stack dan pop — IndexError (avval test)
  3. Har bosqichda refaktoring
  4. Yakuniy coverage 100% bo'lsin

Vazifa 4: TDD bilan xato tuzatish

Berilgan xatoli funksiya (ortacha([]) yiqiladi):

  1. Avval xatoni ko'rsatuvchi test yozing (qizil)
  2. Testni ishga tushirib, yiqilishini ko'ring
  3. Xatoni tuzating (yashil)
  4. Regressiya testi to'plamda qolganini tasdiqlang

Vazifa 5: TDD bilan validator

Parol validatorini 17.1-bob TDD bilan qayta yarating:

  1. Har qoida uchun bir test-bir kod sikli
  2. Kod bosqichma-bosqich o'sishini kuzating
  3. Oxirgi refaktoring (qoidalarni jadvalga)
  4. An'anaviy (kod-avval) yondashuv bilan solishtiring

Vazifa 6: Kata (mashq) — Bowling

Bowling o'yini ochkolarini hisoblovchi (klassik TDD mashqi):

  1. Oddiy holatlar (hammasi 0, hammasi 1) dan boshlang
  2. Spare, strike qoidalarini bosqichma-bosqich qo'shing
  3. Har bosqichda qizil-yashil-refaktoring
  4. Jarayonni hujjatlang (har qadamda test va kod)

Vazifa 7: O'ylash

TDD tarafdorlari uni "sifat va dizayn uchun eng yaxshi amaliyot" deyishadi, tanqidchilar esa "sekin va har joyga mos kelmaydi" deyishadi. Haqiqat o'rtada: TDD ba'zi kontekstlarda juda foydali, boshqasida kamroq. Qaysi omillar TDD ni foydali yoki foydasiz qiladi, va "test avval" g'oyasi qanday chuqurroq dasturlash tamoyilini ochib beradi?

Javob

Qisqa javob: TDD talab aniq va mantiq murakkab bo'lganda eng foydali: test avval yozilishi interfeysni o'ylashga majbur qiladi va murakkab mantiqni kichik, tekshiriladigan qadamlarga bo'ladi. U talab noaniq (tadqiqot, prototip, UI tajribasi) bo'lganda kamroq foydali — chunki hali "to'g'ri" nima ekani ma'lum emas. "Test avval" g'oyasi chuqurroq tamoyilni ochadi: muammoni yechimdan oldin tushunish — nima kerakligini aniqlab, keyin qurish.

1. TDD ni foydali qiladigan omillar

Omil Nega foydali
Aniq talab Test yozish mumkin
Murakkab mantiq Kichik qadamlar boshqaradi
Chegara holatlari ko'p Har biri test bilan
Uzoq yashaydigan kod Refaktoring himoyasi
Xato tuzatish Regressiya testi tabiiy

2. TDD ni kamroq foydali qiladigan omillar

Omil Nega qiyin
Noaniq talab "To'g'ri" nima — noma'lum
Tadqiqot/prototip Yo'nalish o'zgaradi
UI/tajriba Vizual, testlash qiyin
Bir martalik skript Foyda narxni oqlamaydi

3. "Test avval" ochadigan tamoyil

Tamoyil Ma'nosi
Muammoni yechimdan oldin tushun Nima kerak — keyin qanday
Interfeys implementatsiyadan oldin Foydalanuvchi nuqtai nazari
Spetsifikatsiya birinchi Test — bajariladigan spetsifikatsiya
Kichik qadamlar Murakkablikni boshqarish
Fikrni tashqariladan ichkariga Kontrakt avval

4. TDD ning haqiqiy qiymati

TDD ning eng katta foydasi testlar emas — bu fikrlash tarzi: kod yozishdan oldin "bu qanday ishlashi kerak?" degan savol. Bu savol ko'pincha yaxshi dizaynga olib keladi, TDD bo'lmasa ham.

5. Muvozanatli qarash

  1. TDD — kuchli vosita, universal yechim emas
  2. Aniq talab + murakkab mantiq → TDD juda foydali
  3. Noaniqlik → avval tajriba, keyin (kerak bo'lsa) test
  4. "Test avval" fikrlashi — kontekstdan qat'i nazar qimmatli

6. Xulosa

  1. TDD talab aniq va mantiq murakkab bo'lganda eng foydali
  2. Noaniq/tadqiqot kontekstida kamroq mos
  3. "Test avval" — muammoni yechimdan oldin tushunish tamoyili
  4. Vosita sifatida moslashuvchan qo'llang, dogma sifatida emas

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.


Xulosa

Bu darsda TDD ni — testni koddan oldin yozish falsafasini o'rgandik.

Eng muhim uch fikr:

  1. TDD — testni koddan oldin yozadigan dizayn usuli. An'anaviy "kod → test" o'rniga "test → kod": har imkoniyat uchun avval uni tavsiflovchi test yoziladi. Bu shunchaki tartib emas — test yozish sizni "bu kod qanday ishlashi kerak?" degan savolga koddan oldin javob berishga majbur qiladi, bu esa dizaynga ta'sir qiladi.

  2. Qizil-Yashil-Refaktoring sikli. Yiqiladigan test yozing (test to'g'ri ekanini isbotlaydi) → uni o'tkazadigan minimal kod (YAGNI — ortiqcha yozmang) → kodni testlar himoyasida tozalang. Sikl kichik va tez: bir test, bir kod, tozalash, keyingi test. Refaktoring bosqichi — kam e'tibor beriladigan, lekin muhim qism.

  3. TDD dizaynga ta'sir qiladi, lekin dogma emas. Test avval yozilishi qulay interfeys, kichik modulli birliklar, tabiiy bog'liqlik in'eksiyasi va to'liq qamrovga olib keladi — "test qilinadigan kod — yaxshi dizaynlangan kod". TDD aniq talab va murakkab mantiqda (ayniqsa xato tuzatishda: avval regressiya testi) eng foydali; tadqiqot, prototip yoki noaniq interfeysda kamroq mos. Uni moslashuvchan vosita sifatida ishlating.

Keyingi darsda integratsion testlar ni o'rganamiz: bir necha qismning birga ishlashini (masalan kod + haqiqiy baza) tekshirish, unit va integratsion testlar orasidagi muvozanat va qachon mock, qachon haqiqiy bog'liqlik ishlatish.

Testlash · 8-dars yakunlandi

17.8-dars: TDD — test avval

22 daqvaqt
0belgi
Keyingi dars: 17.9-dars: Integratsion testlar
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0