...
← Curs AI pentru programatori: toate lecțiile
Lecția 8 · Primii pași cu AI în cod

Verifici codul generat cu câteva teste simple

În lecția 5 ai comparat de mână rezultatul cu cel corect. Acum transformi comparația în cod: câteva linii care verifică automat funcția generată, de fiecare dată când o rulezi. Începi cu assert, alegi cazurile potrivite (normal, limită, invalid) și folosești un mic ajutor care îți spune clar ce trece și ce pică.

Primul test: assert

ColetExpres adaugă TVA de 21% la serviciile facturate (ambalare, asigurare). Andrei a cerut asistentului funcția și a primit:

def pret_cu_tva(pret):
    """Prețul cu TVA 21%, rotunjit la 2 zecimale. Aruncă ValueError la preț negativ."""
    if pret < 0:
        raise ValueError("prețul nu poate fi negativ")
    return round(pret * 1.21, 2)

print(pret_cu_tva(100))
121.0

Un test e o bucată de cod care verifică automat un rezultat. Cel mai simplu test din Python e instrucțiunea assert: dacă expresia de după ea e adevărată, nu se întâmplă nimic; dacă e falsă, programul se oprește cu o eroare.

def pret_cu_tva(pret):
    """Prețul cu TVA 21%, rotunjit la 2 zecimale. Aruncă ValueError la preț negativ."""
    if pret < 0:
        raise ValueError("prețul nu poate fi negativ")
    return round(pret * 1.21, 2)

assert pret_cu_tva(100) == 121.0
assert pret_cu_tva(0) == 0
print("Toate verificările au trecut")
Toate verificările au trecut

Dacă o așteptare e greșită (sau funcția e greșită), de exemplu assert pret_cu_tva(9.99) == 12.08, programul se oprește la acea linie cu AssertionError, iar liniile de după nu mai rulează. Știi că ceva nu e bine, dar nu și ce valoare a ieșit.

Important

Valoarea așteptată o calculezi tu, din regulă, nu o copiezi din ce a afișat funcția. Altfel testul verifică doar că funcția dă ce dă: 9.99 × 1.21 = 12.0879, deci rotunjit, 12.09.

Ce cazuri alegi

Nu ai nevoie de zeci de teste ca să prinzi majoritatea greșelilor din codul generat. Ai nevoie de câteva cazuri bine alese:

Tip de cazCe verificăPentru pret_cu_tva
Normalsituația obișnuită100 -> 121.0
Limitămarginile: zero, listă goală, exact pe prag0 -> 0.0
Zecimale / rotunjirecalculele cu bani9.99 -> 12.09
Invalidintrări care nu au sens-5 -> ValueError

Asistenții greșesc cel mai des exact la cazurile limită și la intrările invalide, pentru că în exemplele din antrenare apar mai rar. Un test pe zero și unul pe o intrare greșită prind surprinzător de multe probleme.

Ajutorul verifica: OK sau PICĂ

assert se oprește la primul test picat. În curs folosim un ajutor mic, care rulează toate verificările și îți spune pentru fiecare ce a primit și ce aștepta. Nu trebuie să-l scrii tu: îl găsești gata în exerciții.

def verifica(nume, real, asteptat):
    if real == asteptat:
        print(f"OK   {nume}")
    else:
        print(f"PICĂ {nume}: am primit {real!r}, așteptam {asteptat!r}")

def pret_cu_tva_v2(pret):
    return int(pret * 1.21)

verifica("normal", pret_cu_tva_v2(100), 121)
verifica("zecimale", pret_cu_tva_v2(9.99), 12.09)
OK   normal
PICĂ zecimale: am primit 12, așteptam 12.09

Aici pret_cu_tva_v2 e o altă variantă generată de asistent, cu int(...) în loc de round(..., 2). Pe 100 lei trece, deci la o verificare superficială ar fi părut bună. Cazul cu zecimale arată imediat problema: int taie zecimalele, iar clientul ar fi facturat greșit.

Bine de știut

Primul argument e numele testului, al doilea e valoarea reală (apelul funcției), al treilea e valoarea așteptată, calculată de tine. {real!r} afișează valoarea cu tot cu ghilimele la text, ca să vezi exact ce a venit.

Cazul invalid: te aștepți la o eroare

La un preț negativ, funcția trebuie să arunce ValueError. Ca să verifici asta fără să se oprească programul, prinzi eroarea cu try/except:

def pret_cu_tva(pret):
    """Prețul cu TVA 21%, rotunjit la 2 zecimale. Aruncă ValueError la preț negativ."""
    if pret < 0:
        raise ValueError("prețul nu poate fi negativ")
    return round(pret * 1.21, 2)

try:
    pret_cu_tva(-5)
    print("PICĂ negativ: nu a aruncat eroare")
except ValueError as e:
    print("OK   negativ:", e)
OK   negativ: prețul nu poate fi negativ

Dacă funcția ar fi întors pur și simplu -6.05, ar fi apărut linia cu PICĂ. Mulți asistenți nu adaugă singuri astfel de validări; le primești dacă le ceri în prompt (lecția 4) și știi că sunt acolo doar dacă le testezi.

Cum arată în proiectul tău: pytest

În proiectele reale testele stau în fișiere separate și le rulează un instrument de testare. Cel mai folosit în Python e pytest: funcțiile care încep cu test_ sunt găsite și rulate automat, iar assert e suficient. Așa ar arăta testele de mai sus, într-un fișier test_tva.py din proiectul ColetExpres:

import pytest
from tva import pret_cu_tva

def test_normal():
    assert pret_cu_tva(100) == 121.0

def test_zero():
    assert pret_cu_tva(0) == 0

def test_zecimale():
    assert pret_cu_tva(9.99) == 12.09

def test_negativ():
    with pytest.raises(ValueError):
        pret_cu_tva(-5)

Le rulezi în terminal cu comanda pytest. În browser nu avem pytest, de aceea în exerciții folosim ajutorul verifica: ideea e aceeași. Despre teste generate cu AI vorbim pe larg în modulul 3.

Greșeli frecvente

  • Copiezi rezultatul funcției ca valoare așteptată: testul trece mereu, chiar dacă funcția e greșită.
  • Testezi doar cazul normal: exact cel la care asistentul greșește cel mai rar.
  • Compari zecimale fără rotunjire: 0.1 + 0.2 == 0.3 e fals în Python; pentru bani, rotunjești sau folosești Decimal.
  • Ștergi testele după ce trec: le păstrezi, ca să prindă greșelile introduse de modificările viitoare.
Exercițiul tău

Funcția pret_cu_tva generată de asistent e corectă, dar Andrei vrea să o știe sigur. Ajutorul verifica e deja în editor. Scrie sub el trei verificări, cu exact aceste nume: "normal" (100 lei -> 121.0), "zero" (0 lei -> 0) și "zecimale" (9.99 lei -> 12.09). Al doilea argument trebuie să fie apelul funcției, nu un număr scris de mână.

  • Scrie verifica("normal", pret_cu_tva(100), 121.0).
  • Scrie verificarea "zero" pentru prețul 0.
  • Scrie verificarea "zecimale" pentru 9.99 lei (calculează de mână: 9.99 × 1.21, rotunjit la 2 zecimale).
  • Rulează: trebuie să vezi trei linii OK.
verifica("zero", pret_cu_tva(0), 0) și verifica("zecimale", pret_cu_tva(9.99), 12.09)

Soluția exercițiului

# Cod generat de asistent pentru ColetExpres: prețul cu TVA al unui serviciu
def pret_cu_tva(pret):
    """Prețul cu TVA 21%, rotunjit la 2 zecimale. Aruncă ValueError la preț negativ."""
    if pret < 0:
        raise ValueError("prețul nu poate fi negativ")
    return round(pret * 1.21, 2)


# Ajutorul de testare al cursului
def verifica(nume, real, asteptat):
    if real == asteptat:
        print(f"OK   {nume}")
    else:
        print(f"PICĂ {nume}: am primit {real!r}, așteptam {asteptat!r}")


# Scrie aici cele 3 verificări: normal, zero, zecimale
verifica("normal", pret_cu_tva(100), 121.0)
verifica("zero", pret_cu_tva(0), 0)
verifica("zecimale", pret_cu_tva(9.99), 12.09)
Excelent! Continuă cu lecția următoare →
main.pyPython
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Primii pași cu AI în cod Lecția 8 · Verifici codul generat cu câteva teste simple
Progres 0% 0 din 12
Lecția curentă 8 / 10 Primii pași cu ai în cod