TypedDict, Literal und Final

import json
from typing import TypedDict


class Book(TypedDict):
    title: str
    author: str
    year: int
    isbn: str


def load_books(text: str) -> list[Book]:
    books: list[Book] = json.loads(text)
    return books


def label(book: Book) -> str:
    return f"{book['title']} ({book['author']}, {book['year']}) ISBN {book['isbn']}"

from typing import is_typeddict

from main import Book, label, load_books

DATA = '[{"title": "Dune", "author": "Frank Herbert", "year": 1965, "isbn": "9780441013593"}, {"title": "Emma", "author": "Jane Austen", "year": 1815}]'


def test_keys():
    """title, author und year sind Pflicht; isbn ist optional"""
    assert is_typeddict(Book), "Book sollte ein TypedDict sein"
    got = sorted(Book.__required_keys__), sorted(Book.__optional_keys__)
    assert got == (['author', 'title', 'year'], ['isbn']), f"Pflicht- und optionale Schlüssel sind {got!r}"


def test_label_with_isbn():
    """Ein Buch mit isbn zeigt sie am Ende"""
    got = label(load_books(DATA)[0])
    assert got == "Dune (Frank Herbert, 1965) ISBN 9780441013593", f"label lieferte {got!r}"


def test_label_without_isbn():
    """Ein Buch ohne isbn hat keinen ISBN-Teil"""
    got = label(load_books(DATA)[1])
    assert got == "Emma (Jane Austen, 1815)", f"label lieferte {got!r}"

from typing import Final, Literal

# Define the alias Light, and annotate the constants as Final.
LIGHTS = ("red", "green", "yellow")
NEXT = {"red": "green", "green": "yellow", "yellow": "red"}


def next_light(light: str) -> str:
    return NEXT[light]


def parse_light(text: str) -> str:
    return text

from typing import Final, get_args, get_origin

import main


def test_light_alias():
    """Light ist ein Alias für Literal["red", "green", "yellow"]"""
    light = getattr(main, "Light", None)
    assert light is not None, "main.py definiert kein Light"
    got = get_args(light.__value__)
    assert got == ("red", "green", "yellow"), f"Light erlaubt {got!r}"


def test_constants_are_final():
    """LIGHTS und NEXT sind mit Final[...] annotiert"""
    hints = getattr(main, "__annotations__", {})
    for name in ("LIGHTS", "NEXT"):
        assert get_origin(hints.get(name)) is Final, f"{name} ist als {hints.get(name)!r} annotiert, erwartet Final[...]"


def test_next_light():
    """red, green und yellow folgen im Kreis aufeinander"""
    got = [main.next_light(light) for light in ("red", "green", "yellow")]
    assert got == ["green", "yellow", "red"], f"next_light lieferte {got!r}"


def test_parse_light():
    """parse_light bereinigt den Text: " Green " wird zu "green\""""
    got = main.parse_light(" Green ")
    assert got == "green", f"parse_light(' Green ') lieferte {got!r}"


def test_parse_rejects_unknown():
    """parse_light("blue") löst ValueError aus"""
    try:
        main.parse_light("blue")
    except ValueError:
        return
    assert False, "parse_light('blue') hat keinen ValueError ausgelöst"