17.7-dars: Coverage

coverage run -m pytest         # testlarni coverage kuzatuvida ishga tushiradi
coverage report -m             # hisobot + qaysi qatorlar qamralmagan (-m = missing)
coverage html                  # brauzerda ko'riladigan batafsil hisobot

Name          Stmts   Miss  Cover   Missing
-------------------------------------------
kod.py           10      3    70%   5, 7, 11

coverage run --branch -m pytest

Name       Stmts   Miss Branch BrPart  Cover
kod.py        10      3      6      2    69%

pytest --cov=mening_paket --cov-report=term-missing

[tool.coverage.run]
branch = true
source = ["mening_paket"]

[tool.coverage.report]
show_missing = true
fail_under = 80              # 80% dan past bo'lsa xato (CI uchun)

def himoya():
    if holat_bolmaydi:       # pragma: no cover
        raise RuntimeError("bu hech qachon bo'lmasligi kerak")

coverage run -m pytest              # coverage bilan test
coverage report -m                  # hisobot + missing qatorlar
coverage run --branch -m pytest     # tarmoqlanish qamrovi
coverage html                       # batafsil HTML hisobot

pytest --cov=paket --cov-report=term-missing   # pytest-cov bilan

# pyproject.toml
[tool.coverage.run]
branch = true
source = ["paket"]
[tool.coverage.report]
show_missing = true
fail_under = 80

coverage — ko'r nuqtalarni topish vositasi
missing ustuni — test qilinmagan qatorlar
branch coverage — statement dan ishonchliroq
100% coverage ≠ xatosiz (assert siz oshadi)
xato yo'llarini (except) qamrang — ko'p unutiladi
foizni quvma — muhim yo'llarni ma'noli qamra
pragma: no cover — ehtiyotkorlik bilan

"""coverage run + report; missing qatorlar test qilinmagan kodni ko'rsatadi; xato yo'li (except) qamralmagani aniqlanadi; test qo'shib yopish."""

import json
import subprocess
import sys
import tempfile
from pathlib import Path


def coverage_ol(katalog: Path, *args: str) -> dict:
    """coverage run + json; deterministik ma'lumot qaytaradi."""
    subprocess.run([sys.executable, "-m", "coverage", "run", *args, "-m", "pytest",
                    "-p", "no:cacheprovider", "-o", "addopts=", "-q"],
                   cwd=katalog, capture_output=True, text=True, encoding="utf-8")
    r = subprocess.run([sys.executable, "-m", "coverage", "json", "-o", "-"],
                       cwd=katalog, capture_output=True, text=True, encoding="utf-8")
    return json.loads(r.stdout)


KOD = '''
def toifala(son):
    if son < 0:
        return "manfiy"
    if son == 0:
        return "nol"
    if son > 100:
        return "katta"
    return "oddiy"

def xavfsiz_bol(a, b):
    if b == 0:
        raise ValueError("nolga bo'lib bo'lmaydi")
    return a / b
'''


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

        print("=== 1. Kam test — ko'r nuqtalar ko'p ===")
        (r / "test_kod.py").write_text(
            "from kod import toifala, xavfsiz_bol\n"
            "def test_manfiy(): assert toifala(-1) == 'manfiy'\n"
            "def test_oddiy(): assert toifala(50) == 'oddiy'\n"
            "def test_bol(): assert xavfsiz_bol(6, 2) == 3\n", encoding="utf-8")
        d = coverage_ol(r)
        fayl = d["files"]["kod.py"]
        print(f"  qamrov: {fayl['summary']['percent_covered_display']}%")
        print(f"  test qilinmagan qatorlar: {fayl['missing_lines']}")
        print("  ⚠️ 'nol', 'katta' shohobchalari va nolga bo'lish xatosi qamralmagan")

        print("\n=== 2. Ko'r nuqtalarni yopish ===")
        (r / "test_kod.py").write_text(
            "import pytest\n"
            "from kod import toifala, xavfsiz_bol\n"
            "def test_manfiy(): assert toifala(-1) == 'manfiy'\n"
            "def test_nol(): assert toifala(0) == 'nol'\n"
            "def test_katta(): assert toifala(200) == 'katta'\n"
            "def test_oddiy(): assert toifala(50) == 'oddiy'\n"
            "def test_bol(): assert xavfsiz_bol(6, 2) == 3\n"
            "def test_bol_nol():\n"
            "    with pytest.raises(ValueError):\n"
            "        xavfsiz_bol(1, 0)\n", encoding="utf-8")
        d = coverage_ol(r)
        fayl = d["files"]["kod.py"]
        print(f"  qamrov: {fayl['summary']['percent_covered_display']}%")
        print(f"  test qilinmagan qatorlar: {fayl['missing_lines'] or 'yo`q — hammasi qamraldi'}")
        print("  ⭐ coverage aynan qaysi test yetishmasligini ko'rsatdi")


if __name__ == "__main__":
    main()

=== 1. Kam test — ko'r nuqtalar ko'p ===
  qamrov: 75%
  test qilinmagan qatorlar: [6, 8, 13]
  ⚠️ 'nol', 'katta' shohobchalari va nolga bo'lish xatosi qamralmagan

=== 2. Ko'r nuqtalarni yopish ===
  qamrov: 100%
  test qilinmagan qatorlar: yo`q — hammasi qamraldi
  ⭐ coverage aynan qaysi test yetishmasligini ko'rsatdi

"""statement coverage 100% bo'lsa ham branch qamralmagan bo'lishi mumkin; branch coverage ikkala tomonni talab qiladi; qisman tarmoqlanish (BrPart)."""

import json
import subprocess
import sys
import tempfile
from pathlib import Path


def coverage_ol(katalog: Path, branch: bool) -> dict:
    args = ["--branch"] if branch else []
    subprocess.run([sys.executable, "-m", "coverage", "run", *args, "-m", "pytest",
                    "-p", "no:cacheprovider", "-o", "addopts=", "-q"],
                   cwd=katalog, capture_output=True, text=True, encoding="utf-8")
    r = subprocess.run([sys.executable, "-m", "coverage", "json", "-o", "-"],
                       cwd=katalog, capture_output=True, text=True, encoding="utf-8")
    return json.loads(r.stdout)


KOD = '''
def chegirma(narx, vip):
    natija = narx
    if vip:
        natija = narx * 0.9
    return natija
'''

# Test faqat vip=True ni sinaydi — 'if' ning False tomoni test qilinmaydi
TEST = '''
from kod import chegirma
def test_vip():
    assert chegirma(100, True) == 90
'''


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

        print("=== 1. Statement coverage ===")
        d = coverage_ol(r, branch=False)
        s = d["files"]["kod.py"]["summary"]
        print(f"  qamrov: {s['percent_covered_display']}% — barcha qator bajarildi")
        print("  ⚠️ lekin vip=False holati test qilinmagan!")

        print("\n=== 2. Branch coverage ===")
        d = coverage_ol(r, branch=True)
        s = d["files"]["kod.py"]["summary"]
        print(f"  qamrov: {s['percent_covered_display']}%")
        print(f"  jami tarmoqlanish: {s['num_branches']}, qisman qamralgan: {s['num_partial_branches']}")
        print("  ⭐ branch coverage vip=False qamralmaganini ochib berdi")

        print("\n=== 3. Ikkala tomonni test qilib ===")
        (r / "test_kod.py").write_text(
            "from kod import chegirma\n"
            "def test_vip(): assert chegirma(100, True) == 90\n"
            "def test_oddiy(): assert chegirma(100, False) == 100\n", encoding="utf-8")
        d = coverage_ol(r, branch=True)
        s = d["files"]["kod.py"]["summary"]
        print(f"  qamrov: {s['percent_covered_display']}%, qisman qamralgan: {s['num_partial_branches']}")


if __name__ == "__main__":
    main()

=== 1. Statement coverage ===
  qamrov: 100% — barcha qator bajarildi
  ⚠️ lekin vip=False holati test qilinmagan!

=== 2. Branch coverage ===
  qamrov: 86%
  jami tarmoqlanish: 2, qisman qamralgan: 1
  ⭐ branch coverage vip=False qamralmaganini ochib berdi

=== 3. Ikkala tomonni test qilib ===
  qamrov: 100%, qisman qamralgan: 0

"""assert siz test coverage ni oshiradi, lekin xato ushlamaydi; 100% qamrov bilan ham buzuq kod o'tadi; ma'noli test farqi."""

import json
import subprocess
import sys
import tempfile
from pathlib import Path


def coverage_va_test(katalog: Path) -> tuple[dict, int]:
    natija = subprocess.run([sys.executable, "-m", "coverage", "run", "-m", "pytest",
                             "-p", "no:cacheprovider", "-o", "addopts=", "-q"],
                            cwd=katalog, capture_output=True, text=True, encoding="utf-8")
    r = subprocess.run([sys.executable, "-m", "coverage", "json", "-o", "-"],
                       cwd=katalog, capture_output=True, text=True, encoding="utf-8")
    return json.loads(r.stdout), natija.returncode


# Kodda XATO bor: qo'shish o'rniga ayirish
KOD = '''
def yakuniy_narx(narx, chegirma):
    return narx - chegirma / 100        # XATO: bu narxni deyarli o'zgartirmaydi
'''

# "Yomon" test: chaqiradi, lekin natijani JIDDIY tekshirmaydi
YOMON_TEST = '''
from kod import yakuniy_narx
def test_ishlaydi():
    natija = yakuniy_narx(100, 20)
    assert natija is not None            # ⚠️ faqat "None emas" — xatoni ushlamaydi
'''

# "Yaxshi" test: aniq natijani tekshiradi
YAXSHI_TEST = '''
from kod import yakuniy_narx
def test_chegirma():
    assert yakuniy_narx(100, 20) == 80   # aniq qiymat — xatoni ushlaydi
'''


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

        print("=== 1. 'Yomon' test — 100% coverage, lekin xato o'tadi ===")
        (r / "test_kod.py").write_text(YOMON_TEST, encoding="utf-8")
        d, kod = coverage_va_test(r)
        print(f"  qamrov: {d['files']['kod.py']['summary']['percent_covered_display']}%")
        print(f"  test natijasi: {'o`tdi' if kod == 0 else 'yiqildi'}")
        print("  ⚠️ 100% qamrov, lekin buzuq kod o'tib ketdi (assert is not None yetarli emas)")

        print("\n=== 2. 'Yaxshi' test — xatoni ushlaydi ===")
        (r / "test_kod.py").write_text(YAXSHI_TEST, encoding="utf-8")
        d, kod = coverage_va_test(r)
        print(f"  qamrov: {d['files']['kod.py']['summary']['percent_covered_display']}%")
        print(f"  test natijasi: {'o`tdi' if kod == 0 else 'yiqildi (xato ushlandi!)'}")
        print("  ⭐ bir xil coverage, lekin ma'noli assert xatoni topdi")

        print("\n=== 3. Xulosa ===")
        print("  coverage — qator bajarilganini o'lchaydi, to'g'riligini EMAS")
        print("  yuqori coverage + ma'nosiz assert = yolg'on xotirjamlik")


if __name__ == "__main__":
    main()

=== 1. 'Yomon' test — 100% coverage, lekin xato o'tadi ===
  qamrov: 100%
  test natijasi: o`tdi
  ⚠️ 100% qamrov, lekin buzuq kod o'tib ketdi (assert is not None yetarli emas)

=== 2. 'Yaxshi' test — xatoni ushlaydi ===
  qamrov: 100%
  test natijasi: yiqildi (xato ushlandi!)
  ⭐ bir xil coverage, lekin ma'noli assert xatoni topdi

=== 3. Xulosa ===
  coverage — qator bajarilganini o'lchaydi, to'g'riligini EMAS
  yuqori coverage + ma'nosiz assert = yolg'on xotirjamlik

"""coverage bilan ko'r nuqtalarni topib, ma'noli test qo'shib yopish: xato yo'llari, chegara holatlari; branch coverage; foizni emas, muhim yo'llarni qamrash."""

import json
import subprocess
import sys
import tempfile
from pathlib import Path

KOD = '''
class BuyurtmaXatosi(Exception):
    pass

VALID_HOLATLAR = {"yangi", "tolangan", "yuborildi", "yetkazildi", "bekor"}
OTISHLAR = {
    "yangi": {"tolangan", "bekor"},
    "tolangan": {"yuborildi", "bekor"},
    "yuborildi": {"yetkazildi"},
    "yetkazildi": set(),
    "bekor": set(),
}

def holatni_ozgartir(joriy, yangi):
    if joriy not in VALID_HOLATLAR:
        raise BuyurtmaXatosi(f"noma'lum joriy holat: {joriy}")
    if yangi not in VALID_HOLATLAR:
        raise BuyurtmaXatosi(f"noma'lum yangi holat: {yangi}")
    if yangi not in OTISHLAR[joriy]:
        raise BuyurtmaXatosi(f"{joriy} dan {yangi} ga o'tib bo'lmaydi")
    return yangi

def bekor_qilsa_boladimi(holat):
    return holat in {"yangi", "tolangan"}
'''


def coverage_ol(katalog: Path) -> dict:
    subprocess.run([sys.executable, "-m", "coverage", "run", "--branch", "-m", "pytest",
                    "-p", "no:cacheprovider", "-o", "addopts=", "-q"],
                   cwd=katalog, capture_output=True, text=True, encoding="utf-8")
    r = subprocess.run([sys.executable, "-m", "coverage", "json", "-o", "-"],
                       cwd=katalog, capture_output=True, text=True, encoding="utf-8")
    return json.loads(r.stdout)


DASTLABKI_TEST = '''
from buyurtma import holatni_ozgartir
def test_tolash():
    assert holatni_ozgartir("yangi", "tolangan") == "tolangan"
def test_yuborish():
    assert holatni_ozgartir("tolangan", "yuborildi") == "yuborildi"
'''

TOLIQ_TEST = '''
import pytest
from buyurtma import holatni_ozgartir, bekor_qilsa_boladimi, BuyurtmaXatosi

def test_tolash():
    assert holatni_ozgartir("yangi", "tolangan") == "tolangan"
def test_yuborish():
    assert holatni_ozgartir("tolangan", "yuborildi") == "yuborildi"
def test_yetkazish():
    assert holatni_ozgartir("yuborildi", "yetkazildi") == "yetkazildi"
def test_bekor():
    assert holatni_ozgartir("yangi", "bekor") == "bekor"

def test_notogri_joriy_holat():
    with pytest.raises(BuyurtmaXatosi, match="joriy holat"):
        holatni_ozgartir("nomalum", "tolangan")
def test_notogri_yangi_holat():
    with pytest.raises(BuyurtmaXatosi, match="yangi holat"):
        holatni_ozgartir("yangi", "nomalum")
def test_ruxsatsiz_otish():
    with pytest.raises(BuyurtmaXatosi, match="o'tib bo'lmaydi"):
        holatni_ozgartir("yetkazildi", "yangi")

def test_bekor_qilsa_boladi():
    assert bekor_qilsa_boladimi("yangi") is True
def test_bekor_qilib_bolmaydi():
    assert bekor_qilsa_boladimi("yetkazildi") is False
'''


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

        print("=== 1. Dastlabki testlar bilan coverage ===")
        (r / "test_buyurtma.py").write_text(DASTLABKI_TEST, encoding="utf-8")
        d = coverage_ol(r)
        s = d["files"]["buyurtma.py"]["summary"]
        print(f"  qamrov: {s['percent_covered_display']}%")
        print(f"  test qilinmagan qatorlar: {d['files']['buyurtma.py']['missing_lines']}")
        print(f"  qisman tarmoqlanish: {s['num_partial_branches']}")
        print("  ⚠️ xato yo'llari va bekor_qilsa_boladimi umuman test qilinmagan")

        print("\n=== 2. Ko'r nuqtalarni ma'noli test bilan yopgach ===")
        (r / "test_buyurtma.py").write_text(TOLIQ_TEST, encoding="utf-8")
        d = coverage_ol(r)
        s = d["files"]["buyurtma.py"]["summary"]
        print(f"  qamrov: {s['percent_covered_display']}%")
        print(f"  test qilinmagan qatorlar: {d['files']['buyurtma.py']['missing_lines'] or 'yo`q'}")
        print(f"  qisman tarmoqlanish: {s['num_partial_branches']}")
        print("  ⭐ har xato yo'li va shohobcha ma'noli assert bilan qamraldi")


if __name__ == "__main__":
    main()

=== 1. Dastlabki testlar bilan coverage ===
  qamrov: 65%
  test qilinmagan qatorlar: [16, 18, 20, 24]
  qisman tarmoqlanish: 3
  ⚠️ xato yo'llari va bekor_qilsa_boladimi umuman test qilinmagan

=== 2. Ko'r nuqtalarni ma'noli test bilan yopgach ===
  qamrov: 100%
  test qilinmagan qatorlar: yo`q
  qisman tarmoqlanish: 0
  ⭐ har xato yo'li va shohobcha ma'noli assert bilan qamraldi

# 100% coverage, lekin assert yo'q                 # ❌
def test_x(): funksiya(5)
def test_x(): assert funksiya(5) == 10             # ✅ natijani tekshiring

def test_bol(): assert bol(6, 2) == 3              # ❌ nolga bo'lish qamralmagan
def test_bol_nol():                                # ✅ xato yo'lini ham
    with pytest.raises(ValueError): bol(1, 0)

coverage run -m pytest                             # ❌ tarmoqlanish ko'rinmaydi
coverage run --branch -m pytest                    # ✅ ikkala tomon

def muhim(x):
    if x < 0:  # pragma: no cover                  # ❌ muhim shartni yashirish
        return xato()
# ✅ faqat haqiqatan test qilib bo'lmaydigan kod

# oxirgi 5% uchun ma'nosiz testlar yozish          # ❌
# ✅ muhim yo'llarni to'liq qamrash, arzimasni qoldirish

coverage run -m pytest                             # ❌ hisobotsiz — foydasiz
coverage report -m                                 # ✅ missing qatorlarni ko'ring

[tool.coverage.run]
# source aniqlanmagan → testlar ham hisoblanadi    # ❌
source = ["mening_paket"]                          # ✅ faqat manba kod

# kod.py (qatorlar raqami bilan)
1  def bel(son):
2      if son < 0:
3          return "manfiy"
4      if son == 0:
5          return "nol"
6      return "musbat"

# test.py
def test_manfiy(): assert bel(-1) == "manfiy"
def test_musbat(): assert bel(5) == "musbat"

1.  def test_narx():
        yakuniy_narx(100, 20)               # coverage 100%, lekin...

2.  # faqat statement coverage
    # coverage run -m pytest

3.  def test_bol():
        assert bol(6, 2) == 3               # nolga bo'lish qamralmagan

4.  def muhim_hisob(x):
        if x < 0:  # pragma: no cover       # muhim shart yashirilgan
            raise ValueError()
        return x * 2

5.  [tool.coverage.run]
    # source yo'q                           # testlar ham hisoblanadi