Ausnahmen behandeln

import json


def load_todos(path: str) -> list[dict]:
    with open(path, encoding="utf-8") as f:
        return json.load(f)

from main import load_todos


def test_missing_file():
    """Eine fehlende Datei ergibt eine leere Liste"""
    try:
        got = load_todos("no_such_file.json")
    except FileNotFoundError:
        assert False, "load_todos löste FileNotFoundError aus; fangen Sie ihn ab und geben Sie [] zurück"
    assert got == [], f"load_todos gab {got!r} zurück, erwartet war []"


def test_valid_file():
    """Eine gültige Datei ergibt ihre Liste"""
    with open("t1.json", "w", encoding="utf-8") as f:
        f.write('[{"title": "Buy milk", "done": false}]')
    got = load_todos("t1.json")
    assert got == [{"title": "Buy milk", "done": False}], f"load_todos gab {got!r} zurück"


def test_broken_file():
    """Eine kaputte Datei löst ValueError mit dem Dateinamen aus"""
    with open("t2.json", "w", encoding="utf-8") as f:
        f.write("[{not json")
    try:
        load_todos("t2.json")
    except ValueError as err:
        assert str(err) == "t2.json is not valid JSON", f"die Meldung war {str(err)!r}, erwartet war 't2.json is not valid JSON'"
    else:
        assert False, "load_todos kehrte bei einer kaputten Datei normal zurück; lösen Sie ValueError aus"

import json


def load_todos(path: str) -> list[dict]:
    try:
        with open(path, encoding="utf-8") as f:
            return json.load(f)
    except FileNotFoundError:
        return []
    except json.JSONDecodeError:
        raise ValueError(f"{path} is not valid JSON")


def add_todo(path: str, title: str) -> list[dict]:
    todos = load_todos(path)
    todos.append({"title": title, "done": False})
    return todos

import json
import os

from main import add_todo


def fresh(path):
    if os.path.exists(path):
        os.remove(path)


def test_saved():
    """Zwei To-dos landen in der Datei, in Reihenfolge"""
    fresh("t1.json")
    add_todo("t1.json", "Buy milk")
    add_todo("t1.json", "Call Ada")
    with open("t1.json", encoding="utf-8") as f:
        got = json.load(f)
    want = [{"title": "Buy milk", "done": False}, {"title": "Call Ada", "done": False}]
    assert got == want, f"die Datei enthält {got!r}"


def test_stripped():
    """Der Titel wird ohne umgebende Leerzeichen gespeichert"""
    fresh("t2.json")
    got = add_todo("t2.json", "  Water plants  ")
    assert got == [{"title": "Water plants", "done": False}], f"add_todo gab {got!r} zurück"


def test_empty_title():
    """Ein leerer Titel löst ValueError aus und lässt die Datei unverändert"""
    fresh("t3.json")
    add_todo("t3.json", "Buy milk")
    try:
        add_todo("t3.json", "   ")
    except ValueError as err:
        assert str(err) == "title must not be empty", f"die Meldung war {str(err)!r}"
    else:
        assert False, "add_todo nahm einen leeren Titel an; lösen Sie ValueError aus"
    with open("t3.json", encoding="utf-8") as f:
        got = json.load(f)
    assert len(got) == 1, f"nach dem leeren Titel enthält die Datei {got!r}"

import json

PATH = "todos.json"


def load_todos(path: str) -> list[dict]:
    try:
        with open(path, encoding="utf-8") as f:
            return json.load(f)
    except FileNotFoundError:
        return []
    except json.JSONDecodeError:
        raise ValueError(f"{path} is not valid JSON")


def save_todos(path: str, todos: list[dict]) -> None:
    with open(path, "w", encoding="utf-8") as f:
        json.dump(todos, f, indent=2)


def add_todo(path: str, title: str) -> list[dict]:
    title = title.strip()
    if not title:
        raise ValueError("title must not be empty")
    todos = load_todos(path)
    todos.append({"title": title, "done": False})
    save_todos(path, todos)
    return todos


def complete_todo(path: str, number: int) -> dict:
    todos = load_todos(path)
    # Raise ValueError here when number is not between 1 and len(todos).
    todo = todos[number - 1]
    todo["done"] = True
    save_todos(path, todos)
    return todo


def show(path: str) -> None:
    todos = load_todos(path)
    if not todos:
        print("nothing to do")
    for number, todo in enumerate(todos, start=1):
        mark = "x" if todo["done"] else " "
        print(f"{number}. [{mark}] {todo['title']}")


def run(line: str) -> None:
    command, _, argument = line.partition(" ")
    if command == "add":
        todos = add_todo(PATH, argument)
        print("added:", todos[-1]["title"])
    elif command == "done":
        todo = complete_todo(PATH, int(argument))
        print("done:", todo["title"])
    elif command == "list":
        show(PATH)
    else:
        raise ValueError(f"unknown command: {command}")


if __name__ == "__main__":
    # Stop at EOFError; print "error:" and the message for a ValueError.
    while True:
        line = input()
        run(line)

import os

from learnrun import run_main


def fresh(*commands):
    if os.path.exists("todos.json"):
        os.remove("todos.json")
    return run_main("\n".join(commands) + "\n").strip().splitlines()


def test_add_and_list():
    """add und list zeigen die To-dos, nummeriert"""
    got = fresh("add Buy milk", "add Call Ada", "list")
    want = ["added: Buy milk", "added: Call Ada", "1. [ ] Buy milk", "2. [ ] Call Ada"]
    assert got == want, f"das Programm gab {got!r} aus"


def test_done():
    """done 2 hakt das zweite To-do ab"""
    got = fresh("add Buy milk", "add Call Ada", "done 2", "list")
    want = ["done: Call Ada", "1. [ ] Buy milk", "2. [x] Call Ada"]
    assert got[-3:] == want, f"das Programm gab {got!r} aus"


def test_bad_numbers():
    """done mit falscher Nummer gibt einen Fehler aus, und das Programm läuft weiter"""
    got = fresh("add Buy milk", "done 5", "done 0", "done two", "list")
    assert got[1:3] == ["error: no to-do number 5", "error: no to-do number 0"], f"das Programm gab {got!r} aus"
    assert got[3].startswith("error: "), f"für done two gab das Programm {got[3]!r} aus"
    assert got[4:] == ["1. [ ] Buy milk"], f"das Programm gab {got!r} aus"


def test_other_errors():
    """Ein leerer Titel und ein unbekannter Befehl geben ebenfalls Fehler aus"""
    got = fresh("add   ", "fly away", "list")
    want = ["error: title must not be empty", "error: unknown command: fly", "nothing to do"]
    assert got == want, f"das Programm gab {got!r} aus"


def test_saved_between_runs():
    """Die Liste ist beim nächsten Lauf noch da"""
    fresh("add Water plants")
    got = run_main("list\n").strip().splitlines()
    assert got == ["1. [ ] Water plants"], f"der zweite Lauf gab {got!r} aus"