Spaces:
Sleeping
Sleeping
| """Black-box contract tests for docs/contract.md. | |
| HTTP only, through the `client` fixture (fresh app and empty store per test). | |
| No imports from app.store and no access to app.state. | |
| """ | |
| BOOKS = "/api/books" | |
| STATS = "/api/stats" | |
| STATUSES = ("to-read", "reading", "done") | |
| def add_book(client, **body): | |
| """POST a book and return the created Book JSON, asserting 201.""" | |
| response = client.post(BOOKS, json=body) | |
| assert response.status_code == 201, response.text | |
| return response.json() | |
| def patch_status(client, book_id, status): | |
| return client.patch(f"{BOOKS}/{book_id}", json={"status": status}) | |
| def assert_validation_error(response): | |
| """422 with FastAPI's default shape: detail is a list of items with loc and msg.""" | |
| assert response.status_code == 422, response.text | |
| detail = response.json()["detail"] | |
| assert isinstance(detail, list) | |
| assert len(detail) >= 1 | |
| for item in detail: | |
| assert "loc" in item | |
| assert "msg" in item | |
| # --- POST /api/books: success --------------------------------------------------- | |
| def test_create_returns_201_with_exact_book_shape(client): | |
| response = client.post( | |
| BOOKS, json={"title": "Dune", "author": "Frank Herbert", "status": "reading"} | |
| ) | |
| assert response.status_code == 201 | |
| assert response.json() == { | |
| "id": 1, | |
| "title": "Dune", | |
| "author": "Frank Herbert", | |
| "status": "reading", | |
| } | |
| def test_create_minimal_body_applies_defaults(client): | |
| response = client.post(BOOKS, json={"title": "Dune"}) | |
| assert response.status_code == 201 | |
| assert response.json() == { | |
| "id": 1, | |
| "title": "Dune", | |
| "author": None, | |
| "status": "to-read", | |
| } | |
| def test_create_assigns_incrementing_ids(client): | |
| ids = [add_book(client, title=f"Book {n}")["id"] for n in range(3)] | |
| assert ids == [1, 2, 3] | |
| def test_create_trims_title(client): | |
| assert add_book(client, title=" Dune ")["title"] == "Dune" | |
| def test_create_trims_author(client): | |
| assert add_book(client, title="Dune", author=" Frank Herbert ")["author"] == "Frank Herbert" | |
| def test_create_blank_author_becomes_null(client): | |
| assert add_book(client, title="Dune", author=" ")["author"] is None | |
| def test_create_empty_author_becomes_null(client): | |
| assert add_book(client, title="Dune", author="")["author"] is None | |
| def test_create_explicit_null_author_is_allowed(client): | |
| assert add_book(client, title="Dune", author=None)["author"] is None | |
| def test_create_accepts_each_status(client): | |
| for status in STATUSES: | |
| assert add_book(client, title="Dune", status=status)["status"] == status | |
| def test_create_accepts_200_character_title(client): | |
| title = "a" * 200 | |
| assert add_book(client, title=title)["title"] == title | |
| def test_create_title_length_is_checked_after_trimming(client): | |
| title = "a" * 200 | |
| assert add_book(client, title=f" {title} ")["title"] == title | |
| def test_create_accepts_200_character_author(client): | |
| author = "b" * 200 | |
| assert add_book(client, title="Dune", author=author)["author"] == author | |
| def test_create_allows_duplicate_titles(client): | |
| first = add_book(client, title="Dune") | |
| second = add_book(client, title="Dune") | |
| assert first["id"] != second["id"] | |
| def test_create_ignores_unknown_fields(client): | |
| response = client.post(BOOKS, json={"title": "Dune", "rating": 5}) | |
| assert response.status_code == 201 | |
| assert response.json() == {"id": 1, "title": "Dune", "author": None, "status": "to-read"} | |
| # --- POST /api/books: validation ------------------------------------------------ | |
| def test_create_rejects_missing_title(client): | |
| assert_validation_error(client.post(BOOKS, json={"author": "Frank Herbert"})) | |
| def test_create_rejects_empty_title(client): | |
| assert_validation_error(client.post(BOOKS, json={"title": ""})) | |
| def test_create_rejects_whitespace_only_title(client): | |
| assert_validation_error(client.post(BOOKS, json={"title": " "})) | |
| def test_create_rejects_201_character_title(client): | |
| assert_validation_error(client.post(BOOKS, json={"title": "a" * 201})) | |
| def test_create_rejects_non_string_title(client): | |
| assert_validation_error(client.post(BOOKS, json={"title": 123})) | |
| def test_create_rejects_null_title(client): | |
| assert_validation_error(client.post(BOOKS, json={"title": None})) | |
| def test_create_rejects_201_character_author(client): | |
| assert_validation_error(client.post(BOOKS, json={"title": "Dune", "author": "b" * 201})) | |
| def test_create_rejects_invalid_status(client): | |
| assert_validation_error(client.post(BOOKS, json={"title": "Dune", "status": "finished"})) | |
| def test_create_rejects_malformed_json(client): | |
| response = client.post( | |
| BOOKS, content=b'{"title": "Dune"', headers={"Content-Type": "application/json"} | |
| ) | |
| assert_validation_error(response) | |
| def test_rejected_create_does_not_store_a_book(client): | |
| client.post(BOOKS, json={"title": ""}) | |
| response = client.get(BOOKS) | |
| assert response.status_code == 200 | |
| assert response.json() == [] | |
| # --- GET /api/books ------------------------------------------------------------- | |
| def test_list_is_empty_array_when_store_is_empty(client): | |
| response = client.get(BOOKS) | |
| assert response.status_code == 200 | |
| assert response.json() == [] | |
| def test_list_returns_books_in_insertion_order(client): | |
| created = [ | |
| add_book(client, title="Dune", author="Frank Herbert", status="reading"), | |
| add_book(client, title="Emma", status="done"), | |
| add_book(client, title="Ulysses"), | |
| ] | |
| response = client.get(BOOKS) | |
| assert response.status_code == 200 | |
| assert response.json() == created | |
| def test_list_filters_by_each_status(client): | |
| by_status = { | |
| status: add_book(client, title=f"Book {status}", status=status) for status in STATUSES | |
| } | |
| for status, book in by_status.items(): | |
| response = client.get(BOOKS, params={"status": status}) | |
| assert response.status_code == 200 | |
| assert response.json() == [book] | |
| def test_list_filter_keeps_insertion_order(client): | |
| first = add_book(client, title="A", status="done") | |
| add_book(client, title="B", status="reading") | |
| third = add_book(client, title="C", status="done") | |
| response = client.get(BOOKS, params={"status": "done"}) | |
| assert response.json() == [first, third] | |
| def test_list_filter_with_no_matches_is_empty_array(client): | |
| add_book(client, title="Dune", status="to-read") | |
| response = client.get(BOOKS, params={"status": "done"}) | |
| assert response.status_code == 200 | |
| assert response.json() == [] | |
| def test_list_rejects_invalid_status_filter(client): | |
| assert_validation_error(client.get(BOOKS, params={"status": "finished"})) | |
| # --- PATCH /api/books/{id} ------------------------------------------------------ | |
| def test_patch_returns_updated_book(client): | |
| add_book(client, title="Dune", author="Frank Herbert", status="reading") | |
| response = patch_status(client, 1, "done") | |
| assert response.status_code == 200 | |
| assert response.json() == { | |
| "id": 1, | |
| "title": "Dune", | |
| "author": "Frank Herbert", | |
| "status": "done", | |
| } | |
| def test_patch_change_persists_in_list(client): | |
| add_book(client, title="Dune") | |
| patch_status(client, 1, "reading") | |
| assert client.get(BOOKS).json()[0]["status"] == "reading" | |
| def test_patch_only_changes_the_target_book(client): | |
| add_book(client, title="Dune") | |
| other = add_book(client, title="Emma") | |
| patch_status(client, 1, "done") | |
| assert client.get(BOOKS).json()[1] == other | |
| def test_patch_unknown_id_returns_404_book_not_found(client): | |
| response = patch_status(client, 999, "done") | |
| assert response.status_code == 404 | |
| assert response.json() == {"detail": "Book not found"} | |
| def test_patch_unknown_id_returns_404_when_other_books_exist(client): | |
| add_book(client, title="Dune") | |
| response = patch_status(client, 2, "done") | |
| assert response.status_code == 404 | |
| assert response.json() == {"detail": "Book not found"} | |
| def test_patch_rejects_invalid_status(client): | |
| add_book(client, title="Dune") | |
| assert_validation_error(patch_status(client, 1, "finished")) | |
| def test_patch_rejects_missing_status(client): | |
| add_book(client, title="Dune") | |
| assert_validation_error(client.patch(f"{BOOKS}/1", json={})) | |
| def test_patch_rejects_non_integer_id(client): | |
| assert_validation_error(patch_status(client, "abc", "done")) | |
| def test_rejected_patch_leaves_book_unchanged(client): | |
| book = add_book(client, title="Dune", status="reading") | |
| patch_status(client, 1, "finished") | |
| assert client.get(BOOKS).json() == [book] | |
| # --- GET /api/stats ------------------------------------------------------------- | |
| def test_stats_all_zero_when_empty(client): | |
| response = client.get(STATS) | |
| assert response.status_code == 200 | |
| assert response.json() == { | |
| "total": 0, | |
| "by_status": {"to-read": 0, "reading": 0, "done": 0}, | |
| } | |
| def test_stats_counts_after_adds(client): | |
| add_book(client, title="A", status="done") | |
| add_book(client, title="B", status="done") | |
| add_book(client, title="C") | |
| response = client.get(STATS) | |
| assert response.status_code == 200 | |
| assert response.json() == { | |
| "total": 3, | |
| "by_status": {"to-read": 1, "reading": 0, "done": 2}, | |
| } | |
| def test_stats_counts_after_patch(client): | |
| add_book(client, title="A") | |
| add_book(client, title="B") | |
| patch_status(client, 2, "reading") | |
| assert client.get(STATS).json() == { | |
| "total": 2, | |
| "by_status": {"to-read": 1, "reading": 1, "done": 0}, | |
| } | |
| def test_stats_total_equals_sum_of_by_status(client): | |
| for n, status in enumerate(STATUSES * 2): | |
| add_book(client, title=f"Book {n}", status=status) | |
| stats = client.get(STATS).json() | |
| assert set(stats["by_status"]) == set(STATUSES) | |
| assert stats["total"] == sum(stats["by_status"].values()) == 6 | |
| # --- GET / ---------------------------------------------------------------------- | |
| def test_index_serves_html(client): | |
| response = client.get("/") | |
| assert response.status_code == 200 | |
| assert response.headers["content-type"].startswith("text/html") | |