Ausgaben-Tracker

"""Expense tracker: add, list and summarise expenses kept in a JSON file.

Reads one command per line from standard input:
    add 2026-09-12 food 12.50 lunch
    list 2026-09
    summary 2026-09
Amounts are stored as whole cents (int), so totals are exact.
"""

import json
import sys

DATA_FILE = "expenses.json"

HELP = """Commands:
  add DATE CATEGORY AMOUNT [NOTE]   e.g. add 2026-09-12 food 12.50 lunch
  list [MONTH]                      e.g. list 2026-09
  summary [MONTH]                   totals per category
  help                              this text
  quit                              stop reading commands"""


def parse_amount(text: str) -> int:
    """Turn "12.50" into 1250 cents. Raise ValueError for anything else."""
    # TODO: accept "12", "12.5" and "12.50"; reject "-3", "1.234", "abc", "", 0
    # and full-width digits such as "１２" (isdigit accepts them; check isascii too).
    # Hint: text.partition(".") splits "12.50" into ("12", ".", "50").
    raise NotImplementedError


def format_cents(cents: int) -> str:
    """Turn 1250 into "12.50"."""
    # TODO: use // and % with an f-string; 5 cents is "0.05".
    raise NotImplementedError


DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]


def is_leap_year(year: int) -> bool:
    """Every 4th year is a leap year, except every 100th, except every 400th."""
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)


def check_date(text: str) -> str:
    """Return text if it is a real date written YYYY-MM-DD, else raise ValueError."""
    parts = text.split("-")
    if len(parts) != 3 or [len(p) for p in parts] != [4, 2, 2] or not all(p.isascii() and p.isdigit() for p in parts):
        raise ValueError(f"date must look like 2026-09-12, got {text!r}")
    year, month, day = int(parts[0]), int(parts[1]), int(parts[2])
    if not 1 <= month <= 12:
        raise ValueError(f"no such date: {text!r}")
    last_day = DAYS_IN_MONTH[month - 1]
    if month == 2 and is_leap_year(year):
        last_day = 29
    if not 1 <= day <= last_day:
        raise ValueError(f"no such date: {text!r}")
    return text


def check_month(text: str) -> str:
    """Return text if it is a month written YYYY-MM, else raise ValueError."""
    parts = text.split("-")
    if len(parts) != 2 or [len(p) for p in parts] != [4, 2] or not all(p.isascii() and p.isdigit() for p in parts):
        raise ValueError(f"month must look like 2026-09, got {text!r}")
    if not 1 <= int(parts[1]) <= 12:
        raise ValueError(f"no such month: {text!r}")
    return text


def make_expense(date: str, category: str, cents: int, note: str = "") -> dict:
    """Build one expense record, the shape stored in the JSON file."""
    return {"date": check_date(date), "category": category.lower(), "cents": cents, "note": note}


def in_month(expenses: list[dict], month: str | None) -> list[dict]:
    """The expenses of one month ("2026-09"), or all of them for None, sorted by date."""
    # TODO: filter on e["date"], then sort by date.
    raise NotImplementedError


def totals_by_category(expenses: list[dict]) -> dict[str, int]:
    """Total cents per category, categories in alphabetical order."""
    # TODO: add up e["cents"] per e["category"] in a dict.
    raise NotImplementedError


def load_expenses(path: str) -> list[dict]:
    """Read the expenses from path. A missing file means no expenses yet.

    Raise ValueError with a clear message if the file is not a list of expenses.
    """
    # TODO: open with `with open(...)`, json.load, and handle
    # FileNotFoundError (return []) and json.JSONDecodeError (raise ValueError naming path).
    # Then raise ValueError naming path unless the data is a list and
    # _looks_like_expense(item) is True for every item (all(...) helps).
    raise NotImplementedError


def _looks_like_expense(item: object) -> bool:
    """True if item is a dict with a str date and category, an int cents and a str note."""
    if not isinstance(item, dict):
        return False
    return (
        isinstance(item.get("date"), str)
        and isinstance(item.get("category"), str)
        and isinstance(item.get("cents"), int)
        and isinstance(item.get("note", ""), str)
    )


def save_expenses(path: str, expenses: list[dict]) -> None:
    """Write the expenses to path as indented JSON."""
    # TODO: json.dump with indent=2.
    raise NotImplementedError


def list_lines(expenses: list[dict], month: str | None) -> list[str]:
    """One line per expense, oldest first, or ["No expenses."]."""
    # TODO: f"{date}  {category:<12}{amount:>10}  {note}", without trailing spaces.
    raise NotImplementedError


def summary_lines(expenses: list[dict], month: str | None) -> list[str]:
    """One line per category, then the total, or ["No expenses."]."""
    # TODO: f"{category:<12}{amount:>10}" per category, then a line for "total".
    raise NotImplementedError


def handle(line: str, expenses: list[dict]) -> list[str]:
    """Run one command line against expenses (add changes the list). Return what to print."""
    words = line.split()
    command, args = words[0].lower(), words[1:]
    # TODO: add, list, summary and help. Turn a ValueError into ["Error: ..."].
    return [f"Unknown command {command!r}. Type help for the commands."]


def main(path: str = DATA_FILE) -> None:
    """Read commands from standard input until the input ends or quit."""
    # TODO: if load_expenses raises ValueError, print "Error: ..." and stop
    # without touching the file.
    expenses = load_expenses(path)
    for line in sys.stdin:
        if not line.strip():
            continue
        if line.strip().lower() == "quit":
            break
        before = len(expenses)
        for out in handle(line, expenses):
            print(out)
        if len(expenses) != before:
            save_expenses(path, expenses)


if __name__ == "__main__":
    main()

import json
import os
import tempfile

from learnrun import run_main
from main import format_cents, load_expenses, parse_amount, totals_by_category, in_month

DATA = "expenses.json"

SAMPLE = [
    {"date": "2026-09-12", "category": "food", "cents": 1250, "note": "lunch"},
    {"date": "2026-08-30", "category": "rent", "cents": 80000, "note": ""},
    {"date": "2026-09-03", "category": "transport", "cents": 490, "note": "bus"},
    {"date": "2026-09-20", "category": "food", "cents": 3105, "note": "groceries"},
]


def fresh(content=None):
    """Start a run_main test from no data file, or from one holding content."""
    if os.path.exists(DATA):
        os.remove(DATA)
    if content is not None:
        with open(DATA, "w", encoding="utf-8") as f:
            f.write(content)


def test_parse_amount():
    """parse_amount macht aus "12.50", "12.5" und "7" ganze Cent"""
    got = parse_amount("12.50"), parse_amount("12.5"), parse_amount("7")
    assert got == (1250, 1250, 700), f"parse_amount ergab {got!r}, erwartet: (1250, 1250, 700)"


def test_parse_amount_rejects():
    """parse_amount löst bei abc, -3, 1.234, 0 und leerem Text ValueError aus"""
    for text in ["abc", "-3", "1.234", "0", ""]:
        try:
            got = parse_amount(text)
        except ValueError:
            continue
        raise AssertionError(f"parse_amount({text!r}) gab {got!r} zurück, erwartet: ein ValueError")


def test_parse_amount_rejects_wide_digits():
    """parse_amount löst bei Ziffern voller Breite wie ０.５０ und １２ ValueError aus"""
    for text in ["０.５０", "１２"]:
        try:
            got = parse_amount(text)
        except ValueError:
            continue
        raise AssertionError(f"parse_amount({text!r}) gab {got!r} zurück, erwartet war ein ValueError (nur die ASCII-Ziffern 0-9 bilden Beträge)")


def test_format_cents():
    """format_cents zeigt 1250 als 12.50 und 5 als 0.05"""
    got = format_cents(1250), format_cents(5), format_cents(80000)
    assert got == ("12.50", "0.05", "800.00"), f"format_cents ergab {got!r}, erwartet: ('12.50', '0.05', '800.00')"


def test_missing_file_is_empty():
    """load_expenses gibt [] zurück, wenn die Datei fehlt"""
    with tempfile.TemporaryDirectory() as folder:
        got = load_expenses(os.path.join(folder, "nothing-here.json"))
    assert got == [], f"bei fehlender Datei gab load_expenses {got!r} zurück, erwartet: []"


def test_corrupt_file_raises():
    """load_expenses löst bei ungültigem JSON einen ValueError aus, der die Datei nennt"""
    with tempfile.TemporaryDirectory() as folder:
        path = os.path.join(folder, "broken.json")
        with open(path, "w", encoding="utf-8") as f:
            f.write('[{"date": "2026-09-12", ')
        try:
            got = load_expenses(path)
        except ValueError as err:
            assert "broken.json" in str(err), f"die Fehlermeldung {str(err)!r} sollte die Datei broken.json nennen"
            return
    raise AssertionError(f"bei beschädigter Datei gab load_expenses {got!r} zurück, erwartet: ein ValueError")


def test_wrong_shape_raises():
    """load_expenses löst einen ValueError aus, wenn das JSON keine Liste von Ausgaben ist"""
    with tempfile.TemporaryDirectory() as folder:
        path = os.path.join(folder, "other.json")
        with open(path, "w", encoding="utf-8") as f:
            f.write('{"food": 12.5}')
        try:
            got = load_expenses(path)
        except ValueError:
            return
    raise AssertionError(f"bei {{'food': 12.5}} gab load_expenses {got!r} zurück, erwartet: ein ValueError")


def test_totals_by_category():
    """totals_by_category summiert Cent je Kategorie, alphabetisch geordnet"""
    got = totals_by_category(SAMPLE)
    want = {"food": 4355, "rent": 80000, "transport": 490}
    assert got == want, f"totals_by_category ergab {got!r}, erwartet: {want!r}"
    assert list(got) == ["food", "rent", "transport"], f"die Kategorien kamen in der Reihenfolge {list(got)!r}, erwartet: alphabetisch"


def test_in_month():
    """in_month behält die Ausgaben eines Monats, die älteste zuerst"""
    got = [e["date"] for e in in_month(SAMPLE, "2026-09")]
    assert got == ["2026-09-03", "2026-09-12", "2026-09-20"], f"in_month(SAMPLE, '2026-09') ergab die Daten {got!r}"
    got_all = len(in_month(SAMPLE, None))
    assert got_all == 4, f"in_month(SAMPLE, None) behielt {got_all} Ausgaben, erwartet: alle 4"


def test_add_saves_cents():
    """add bestätigt die Eingabe und speichert den Betrag als Cent in expenses.json"""
    fresh()
    out = run_main("add 2026-09-12 food 12.50 lunch with Sam\n")
    assert out.strip() == "Added 12.50 food on 2026-09-12.", f"add gab {out.strip()!r} aus, erwartet: 'Added 12.50 food on 2026-09-12.'"
    with open(DATA, encoding="utf-8") as f:
        saved = json.load(f)
    want = [{"date": "2026-09-12", "category": "food", "cents": 1250, "note": "lunch with Sam"}]
    assert saved == want, f"expenses.json enthält {saved!r}, erwartet: {want!r}"


def test_bad_input_is_reported():
    """Ein falscher Betrag, ein falsches Datum oder ein unbekannter Befehl ergibt eine Meldung, gespeichert wird nichts"""
    fresh()
    out = run_main("add 2026-09-12 food twelve\nadd 2026-13-01 food 3\nspend 5\n").splitlines()
    assert len(out) == 3, f"erwartet: eine Zeile je fehlerhaftem Befehl, erhalten: {out!r}"
    assert out[0].startswith("Error:") and out[1].startswith("Error:"), f"die fehlerhaften add-Befehle gaben {out[:2]!r} aus, erwartet: Zeilen, die mit 'Error:' beginnen"
    assert "help" in out[2], f"der unbekannte Befehl gab {out[2]!r} aus, erwartet: ein Hinweis auf help"
    assert not os.path.exists(DATA), "expenses.json wurde geschrieben, obwohl nichts hinzukam"


def test_impossible_dates():
    """add lehnt 2026-02-31 und 2026-02-29 ab, nimmt aber den Schalttag 2024-02-29 an"""
    fresh()
    out = run_main("add 2026-02-31 food 1 x\nadd 2026-02-29 food 1 y\nadd 2024-02-29 food 1 z\n").splitlines()
    assert len(out) == 3 and out[0].startswith("Error:") and out[1].startswith("Error:"), f"die unmöglichen Daten ergaben {out[:2]!r}, erwartet waren Zeilen, die mit 'Error:' beginnen"
    assert out[2] == "Added 1.00 food on 2024-02-29.", f"der Schalttag ergab {out[2]!r}, erwartet war 'Added 1.00 food on 2024-02-29.'"
    with open(DATA, encoding="utf-8") as f:
        saved = [e["date"] for e in json.load(f)]
    assert saved == ["2024-02-29"], f"expenses.json enthält die Daten {saved!r}, erwartet war nur ['2024-02-29']"


def test_list_month():
    """list 2026-09 zeigt die Ausgaben des Monats, die älteste zuerst, und die Daten bleiben zwischen Läufen erhalten"""
    fresh()
    run_main("add 2026-09-12 food 12.50 lunch\nadd 2026-08-30 rent 800\n")
    run_main("add 2026-09-03 transport 4.90 bus\n")
    out = run_main("list 2026-09\n").splitlines()
    want = ["2026-09-03  transport         4.90  bus", "2026-09-12  food             12.50  lunch"]
    assert out == want, f"list 2026-09 gab {out!r} aus, erwartet: {want!r}"


def test_summary():
    """summary 2026-09 zeigt eine Summe je Kategorie und eine Gesamtzeile"""
    fresh(json.dumps(SAMPLE))
    out = run_main("summary 2026-09\n").splitlines()
    want = ["food             43.55", "transport         4.90", "total            48.45"]
    assert out == want, f"summary 2026-09 gab {out!r} aus, erwartet: {want!r}"
    out = run_main("summary 2025-01\n").splitlines()
    assert out == ["No expenses."], f"summary für einen leeren Monat gab {out!r} aus, erwartet: ['No expenses.']"


def test_corrupt_file_kept():
    """Bei beschädigter expenses.json meldet das Programm einen Fehler und lässt die Datei unverändert"""
    broken = '[{"date": "2026-09-12", '
    fresh(broken)
    out = run_main("add 2026-09-13 food 5\n")
    assert out.startswith("Error:") and DATA in out, f"das Programm gab {out.strip()!r} aus, erwartet: ein Fehler, der {DATA} nennt"
    with open(DATA, encoding="utf-8") as f:
        kept = f.read()
    fresh()
    assert kept == broken, f"expenses.json enthält jetzt {kept!r}, erwartet: unverändert"