Handling exceptions

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():
    """A file that does not exist gives an empty list"""
    try:
        got = load_todos("no_such_file.json")
    except FileNotFoundError:
        assert False, "load_todos raised FileNotFoundError; catch it and return []"
    assert got == [], f"load_todos returned {got!r}, expected []"


def test_valid_file():
    """A valid file gives its list"""
    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 returned {got!r}"


def test_broken_file():
    """A broken file raises ValueError naming the file"""
    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"the message was {str(err)!r}, expected 't2.json is not valid JSON'"
    else:
        assert False, "load_todos returned normally for a broken file; raise ValueError"

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():
    """Two to-dos end up in the file, in order"""
    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"the file holds {got!r}"


def test_stripped():
    """The title is stored without surrounding spaces"""
    fresh("t2.json")
    got = add_todo("t2.json", "  Water plants  ")
    assert got == [{"title": "Water plants", "done": False}], f"add_todo returned {got!r}"


def test_empty_title():
    """An empty title raises ValueError and leaves the file alone"""
    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"the message was {str(err)!r}"
    else:
        assert False, "add_todo accepted an empty title; raise ValueError"
    with open("t3.json", encoding="utf-8") as f:
        got = json.load(f)
    assert len(got) == 1, f"after the empty title the file holds {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 and list show the to-dos, numbered"""
    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"the program printed {got!r}"


def test_done():
    """done 2 ticks off the second to-do"""
    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"the program printed {got!r}"


def test_bad_numbers():
    """done with a wrong number prints an error and the program goes on"""
    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"the program printed {got!r}"
    assert got[3].startswith("error: "), f"for done two the program printed {got[3]!r}"
    assert got[4:] == ["1. [ ] Buy milk"], f"the program printed {got!r}"


def test_other_errors():
    """An empty title and an unknown command print errors too"""
    got = fresh("add   ", "fly away", "list")
    want = ["error: title must not be empty", "error: unknown command: fly", "nothing to do"]
    assert got == want, f"the program printed {got!r}"


def test_saved_between_runs():
    """The list is still there in the next run"""
    fresh("add Water plants")
    got = run_main("list\n").strip().splitlines()
    assert got == ["1. [ ] Water plants"], f"the second run printed {got!r}"