Testy:
Jde pridat knihu
Jde pridat autora
Jde pridat publishera
Jde zmenit pocet vytisku vlastnenych knihovnou
Jde Vypsat vsechny knihy
Jde provezt vypujcku
Jde pridat ctenare
Jde vratit vypujcku knihy
Jde vyhledat knihu dle autora, jmena, nevypujcenych knih, a ztracenych knih
Odstranit knhu
Upravit autora

Co maji handlovat:
Prazdne inputy od uzivatele
Consecutive r/w
Type checking
Fuzzing inputu

-----------------------------------------

Scénáře (přidání knihy) + očekávané výstupy

- Předpoklady testů:
  - Existuje `AuthorID` a `PublisherID` v DB (jinak přidání knihy selže a funkce vrátí null).
  - Implementace `Team2.AddBook` vkládá přes `INSERT OR IGNORE` a následně dělá `SELECT ... LIMIT 1` podle kombinace `(Name, AuthorID, PublisherID, YearOfRelease)`.
  - Poznámka ke schématu: pokud tabulka `Books` NEOBSAHUJE sloupec `Available`, vkládání selže SQL chybou a funkce vrátí null. Pokud `Available` existuje (v předem připravené DB), testy s `Available` dávají smysl.

- Základní flow – úspěch:
  - Vstup: validní `name`, existující `authorId`, existující `publisherId`, rozumný `year`, `total >= 0`, `available >= 0`.
  - Očekávaný výstup: `BookDto` s nenulovým `Id`, hodnotami dle vstupu; návrat nenull.

- Neexistující autor:
  - Vstup: `authorId` neexistuje v `Authors`.
  - Očekávaný výstup: nenastane insert, funkce vrátí `null`.

- Neexistující publisher:
  - Vstup: `publisherId` neexistuje v `Publisher`.
  - Očekávaný výstup: nenastane insert, funkce vrátí `null`.

- Duplicita knihy (stejný `name` + `authorId` + `publisherId` + `year`):
  - Pokud v DB existuje unikátní omezení na tuto kombinaci: `INSERT OR IGNORE` neprovede insert a `SELECT ... LIMIT 1` vrátí existující řádek ⇒ `BookDto` (nenull), nezdvojené data.
  - Pokud v DB NEexistuje žádné unikátní omezení (výchozí schema v `Database.cs` ho nemá): dojde ke vložení DUPLIKÁTNÍHO řádku, `SELECT ... LIMIT 1` vrátí libovolný první shodný záznam ⇒ `BookDto` (nenull), ale data jsou duplicitní v tabulce.

- `name` prázdný řetězec:
  - `Books.Name` je `NOT NULL`, ale prázdný řetězec NENÍ `NULL` ⇒ vložení projde.
  - Očekávaný výstup: `BookDto` (nenull).

- `name` = null:
  - Při předání `null` jako parametru může dojít k chybě binderu parametrů nebo k pokusu vložit `NULL` do `NOT NULL` sloupce.
  - Očekávaný výstup: SQL nebo parametrická výjimka uvnitř metody ⇒ metoda chytá výjimku a vrátí `null`.

- `year` záporný nebo 0:
  - Není validováno na aplikační úrovni ani ve schématu.
  - Očekávaný výstup: vložení projde ⇒ `BookDto` (nenull).

- `total` záporné číslo:
  - Není validováno; ve schématu žádné omezení.
  - Očekávaný výstup: vložení projde ⇒ `BookDto` (nenull). Pozn.: následné reporty mohou dávat nelogické výsledky.

- `available` > `total`:
  - Není validováno; pokud sloupec `Available` v DB existuje, vloží se bez kontroly.
  - Očekávaný výstup: `BookDto` (nenull).

- `available` záporné:
  - Není validováno; pokud sloupec existuje, vloží se.
  - Očekávaný výstup: `BookDto` (nenull).

- Extrémně dlouhé `name`:
  - Bez omezení délky; SQLite uloží. Může mít dopad na výkon a čitelnost.
  - Očekávaný výstup: `BookDto` (nenull).

- Speciální znaky / SQL injection v `name`:
  - Parametrizované dotazy ⇒ bezpečné vůči SQLi.
  - Očekávaný výstup: `BookDto` (nenull).

- Současné (konkurenční) vkládání stejné knihy:
  - Bez unikátního indexu hrozí race condition ⇒ vícenásobné duplicity.
  - Očekávaný výstup: více identických řádků v `Books`.

- Nesoulad schématu: chybějící `Available` ve `Books`:
  - `INSERT` obsahuje `Available` sloupec; pokud DB nemá `Available`, dojde k SQL chybě.
  - Očekávaný výstup: metoda vrátí `null`.

-----------------------------------------

Scénáře (autor) – “stejný autor včetně DOB”

- Vytvoření autora se stejným `Name` + `Surname` + `DateOfBirth` opakovaně:
  - Pokud existuje unikátní omezení nad (Name, Surname, DateOfBirth): `INSERT OR IGNORE` neprovede insert ⇒ vrácen bude existující autor (nenull).
  - Pokud unikát neexistuje (výchozí schema v `Database.cs` jej nemá): vloží se DUPLIKÁT; následný `SELECT ... LIMIT 1` vrátí některého z nich ⇒ `AuthorDto` (nenull), ale v DB jsou duplicity.

- Přidání knihy k “stejnému autorovi”:
  - Logika knihy pracuje výhradně s `authorId`. Pokud existují 2 různé řádky autora se stejnými údaji (Name/Surname/DOB), ale rozdílným `ID`, přidání knihy proběhne ke kterékoliv instanci podle zvoleného `authorId`.
  - Očekávaný výstup: `BookDto` (nenull), navázáno na konkrétní `AuthorID`, nikoli na shodu jména/DOB.

-----------------------------------------

Edge cases (souhrn)

- Chybějící cizí klíče (`AuthorID`, `PublisherID`) ⇒ návrat `null`.
- Duplicity bez unikátních indexů ⇒ v DB vznikají vícenásobné identické záznamy.
- Schéma vs. kód: `Available` ve `Books` – pokud chybí, přidání knihy vždy selže ⇒ `null`.
- `Name` prázdný vs `NULL`: prázdný projde, `NULL` vyvolá chybu kvůli `NOT NULL`.
- Hodnoty mimo rozsah (záporné `year`/`total`/`available`) nejsou validovány.
- Neprobíhá automatické snižování zásob po výpůjčce (`Borrows` neupravují `Books.Total/Available`).
- Potenciálně nekonzistentní pluralita tabulek v jiných částech (např. `Publishers` vs `Publisher`) – neovlivňuje `Team2.AddBook`, ale je rizikem v integračních testech.
