17.8-dars: TDD — test avval
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
pytestbilan 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
# 1. Avval test (kod hali yo'q):
def test_qoshish():
assert qoshish(2, 3) == 5 # 'qoshish' hali yozilmagan → yiqiladiTest 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
# 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
# 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 siklQoidalar
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 emas4. Batafsil misollar
Misollarda
pytestni deterministik ishga tushiruvchipytest_ishgayordamchisi ishlatiladi.
Misol 1 — Qizil-Yashil-Refaktoring sikli
"""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:
=== 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 soddalashtidikNima ko'rsatdi: 2.2, 2.3, 2.4, 2.5-bo'limlar.
Misol 2 — Kichik qadamlar bilan rivojlanish
"""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:
=== 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'sdiNima ko'rsatdi: 2.2, 2.4-bo'limlar.
Misol 3 — TDD dizaynga ta'siri
"""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:
=== 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'liqNima 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.
"""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:
=== 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 kodNima 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)
def kod(): ... # ❌ avval kod
def test_kod(): ... # keyin test
# ✅ TDD: avval test (yiqilsin), keyin kod2. Qizil bosqichni o'tkazib yuborish
def test_x(): assert f(2) == 4 # ❌ f allaqachon bor va o'tadi
# ✅ avval test yiqilishini ko'ring — u to'g'ri ekanini isbotlaydi3. Haddan ziyod kod yozish (YAGNI buzilishi)
def qoshish(a, b): # ❌ bitta test uchun
if a is None: ... # keraksiz murakkablik
return a + b
def qoshish(a, b): return a + b # ✅ minimal4. Refaktoringni o'tkazib yuborish
# test o'tdi, keyingi testga o'tish # ❌ kod iflos qoladi
# ✅ test o'tgach, kodni tozala (test himoyasida)5. Implementatsiyani test qilish
def test_ichki_metod_chaqirildi(): ... # ❌ refaktoring buzadi
def test_natija_togri(): ... # ✅ xatti-harakat6. Katta qadamlar
def test_hamma_narsa(): ... # ❌ bir vaqtda ko'p
# ✅ bir test — bir kichik imkoniyat7. Xato tuzatishda TDD ni ishlatmaslik
# 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
Avval test yozing (yiqilsin), keyin kod.
Minimal kod — testni o'tkazadigan eng sodda (YAGNI).
Refaktoring bosqichini o'tkazib yubormang — testlar himoyasida tozalang.
Kichik, tez sikllar — bir test, bir kod.
Xato tuzatishda avval regressiya testi yozing.
Implementatsiyani emas, xatti-harakatni test qiling.
TDD ni mos joyda ishlating — dogma emas.
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?
# 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
FAILED(NameError —kvadratyo'q)FAILED(passNoneqaytaradi,9emas)PASSEDPASSED(refaktoring xatti-harakatni o'zgartirmaydi)- Yiqiladigan test yozish
- Test yiqilgan (kod hali yo'q yoki to'liq emas)
- Ortiqcha kod yozmaslik (YAGNI), keyingi imkoniyat keyingi test bilan
- O'tishda davom etadi (refaktoring xatti-harakatni buzmaydi)
Vazifa 2: Xatolarni tuzating (TDD jarayonini)
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 tekshirishJavoblar
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 emasVazifa 3: TDD bilan Stack
Stack sinfini (push, pop, peek, is_empty, size) TDD bilan:
- Har metod uchun avval test (qizil), keyin kod (yashil)
- Bo'sh stack dan
pop—IndexError(avval test) - Har bosqichda refaktoring
- Yakuniy coverage 100% bo'lsin
Vazifa 4: TDD bilan xato tuzatish
Berilgan xatoli funksiya (ortacha([]) yiqiladi):
- Avval xatoni ko'rsatuvchi test yozing (qizil)
- Testni ishga tushirib, yiqilishini ko'ring
- Xatoni tuzating (yashil)
- Regressiya testi to'plamda qolganini tasdiqlang
Vazifa 5: TDD bilan validator
Parol validatorini 17.1-bob TDD bilan qayta yarating:
- Har qoida uchun bir test-bir kod sikli
- Kod bosqichma-bosqich o'sishini kuzating
- Oxirgi refaktoring (qoidalarni jadvalga)
- An'anaviy (kod-avval) yondashuv bilan solishtiring
Vazifa 6: Kata (mashq) — Bowling
Bowling o'yini ochkolarini hisoblovchi (klassik TDD mashqi):
- Oddiy holatlar (hammasi 0, hammasi 1) dan boshlang
- Spare, strike qoidalarini bosqichma-bosqich qo'shing
- Har bosqichda qizil-yashil-refaktoring
- 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
- TDD — kuchli vosita, universal yechim emas
- Aniq talab + murakkab mantiq → TDD juda foydali
- Noaniqlik → avval tajriba, keyin (kerak bo'lsa) test
- "Test avval" fikrlashi — kontekstdan qat'i nazar qimmatli
6. Xulosa
- TDD talab aniq va mantiq murakkab bo'lganda eng foydali
- Noaniq/tadqiqot kontekstida kamroq mos
- "Test avval" — muammoni yechimdan oldin tushunish tamoyili
- 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:
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.
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.
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.
Izohlar · 0
Izoh yozish uchun kiring.