Clean up endpoint semantics

1 files changed, 127 insertions, 111 deletions

diff --git a/src/tests.rs b/src/tests.rs
index b10c1ea..586f35a 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -1,7 +1,10 @@
 use axum::{
     Router,
     body::Body,
-    http::{Method, Request, StatusCode, header::CONTENT_TYPE},
+    http::{
+        HeaderMap, Method, Request, StatusCode,
+        header::{CONTENT_TYPE, LOCATION},
+    },
 };
 use http_body_util::BodyExt;
 use serde_json::{Value, json};
@@ -16,7 +19,7 @@ async fn send(
     method: Method,
     uri: &str,
     body: Option<String>,
-) -> (StatusCode, Value) {
+) -> (StatusCode, HeaderMap, Value) {
     let mut request = Request::builder().method(method).uri(uri);
     let body = match body {
         Some(body) => {
@@ -31,12 +34,18 @@ async fn send(
         .await
         .unwrap();
     let status = response.status();
+    let headers = response.headers().clone();
     let bytes = response.into_body().collect().await.unwrap().to_bytes();
-    (status, serde_json::from_slice(&bytes).unwrap_or(Value::Null))
+    (
+        status,
+        headers,
+        serde_json::from_slice(&bytes).unwrap_or(Value::Null),
+    )
 }
 
 async fn get_json(app: &Router, uri: &str) -> (StatusCode, Value) {
-    send(app, Method::GET, uri, None).await
+    let (status, _, body) = send(app, Method::GET, uri, None).await;
+    (status, body)
 }
 
 fn measurement(measured_at: &str, metric_type: &str, value: f64, unit: &str) -> String {
@@ -51,9 +60,9 @@ fn measurement(measured_at: &str, metric_type: &str, value: f64, unit: &str) ->
 
 async fn add_waist(app: &Router, measured_at: &str, value: f64) -> String {
     let body = measurement(measured_at, "Waist", value, "Centimeter");
-    let (status, id) = send(app, Method::POST, "/add", Some(body)).await;
+    let (status, _, created) = send(app, Method::POST, "/measurements", Some(body)).await;
     assert_eq!(status, StatusCode::CREATED);
-    id.as_str().unwrap().to_owned()
+    created["id"].as_str().unwrap().to_owned()
 }
 
 async fn seed(app: &Router) {
@@ -71,34 +80,23 @@ fn values(rows: &Value) -> Vec<f64> {
         .collect()
 }
 
-fn sorted_values(rows: &Value) -> Vec<f64> {
-    let mut values = values(rows);
-    values.sort_by(|a, b| a.partial_cmp(b).unwrap());
-    values
-}
-
 #[sqlx::test]
-async fn index_says_hello(pool: PgPool) {
+async fn health_is_ok(pool: PgPool) {
     let app = router(pool);
-    let (status, _) = get_json(&app, "/").await;
+    let (status, _) = get_json(&app, "/health").await;
     assert_eq!(status, StatusCode::OK);
 }
 
 #[sqlx::test]
-async fn add_returns_created_with_uuid(pool: PgPool) {
+async fn create_returns_the_measurement_and_location(pool: PgPool) {
     let app = router(pool);
-    let id = add_waist(&app, "2026-10-14T12:00:00Z", 80.5).await;
-    Uuid::parse_str(&id).unwrap();
-}
-
-#[sqlx::test]
-async fn add_then_get_by_id_round_trips(pool: PgPool) {
-    let app = router(pool);
-    let id = add_waist(&app, "2026-10-14T12:00:00Z", 80.5).await;
-    let (status, row) = get_json(&app, &format!("/measurement/{id}")).await;
-    assert_eq!(status, StatusCode::OK);
+    let body = measurement("2026-10-14T12:00:00Z", "Waist", 80.5, "Centimeter");
+    let (status, headers, created) = send(&app, Method::POST, "/measurements", Some(body)).await;
+    assert_eq!(status, StatusCode::CREATED);
+    let id = created["id"].as_str().unwrap();
+    Uuid::parse_str(id).unwrap();
     assert_eq!(
-        row,
+        created,
         json!({
             "id": id,
             "measured_at": "2026-10-14T12:00:00Z",
@@ -107,10 +105,15 @@ async fn add_then_get_by_id_round_trips(pool: PgPool) {
             "unit": "Centimeter",
         })
     );
+    let location = headers[LOCATION].to_str().unwrap();
+    assert_eq!(location, format!("/measurements/{id}"));
+    let (status, fetched) = get_json(&app, location).await;
+    assert_eq!(status, StatusCode::OK);
+    assert_eq!(fetched, created);
 }
 
 #[sqlx::test]
-async fn add_rejects_bad_bodies(pool: PgPool) {
+async fn create_rejects_bad_bodies(pool: PgPool) {
     let app = router(pool);
     let cases = [
         (json!({"metric_type": "Hip"}).to_string(), StatusCode::UNPROCESSABLE_ENTITY),
@@ -119,129 +122,142 @@ async fn add_rejects_bad_bodies(pool: PgPool) {
             StatusCode::UNPROCESSABLE_ENTITY,
         ),
         (
-            measurement("2026-10-14T12:00:00Z", "Waist", 80.0, "Kilogram"),
-            StatusCode::UNPROCESSABLE_ENTITY,
-        ),
-        (
             measurement("2026-10-14T12:00:00Z", "Waist", -1.0, "Centimeter"),
             StatusCode::UNPROCESSABLE_ENTITY,
         ),
         ("not json".to_owned(), StatusCode::BAD_REQUEST),
     ];
     for (body, expected) in cases {
-        let (status, _) = send(&app, Method::POST, "/add", Some(body.clone())).await;
+        let (status, _, _) = send(&app, Method::POST, "/measurements", Some(body.clone())).await;
         assert_eq!(status, expected, "body: {body}");
     }
-    let (_, rows) = get_json(&app, "/all").await;
+    let (_, rows) = get_json(&app, "/measurements").await;
     assert!(values(&rows).is_empty());
 }
 
 #[sqlx::test]
-async fn add_accepts_every_valid_pair(pool: PgPool) {
+async fn metric_types_lists_the_valid_pairs(pool: PgPool) {
     let app = router(pool);
-    let pairs = [
-        ("BodyWeight", "Kilogram"),
-        ("Hip", "Centimeter"),
-        ("Waist", "Centimeter"),
-    ];
-    for (metric_type, unit) in pairs {
-        let body = measurement("2026-10-14T12:00:00Z", metric_type, 70.0, unit);
-        let (status, _) = send(&app, Method::POST, "/add", Some(body)).await;
-        assert_eq!(status, StatusCode::CREATED, "{metric_type} {unit}");
+    let (status, pairs) = get_json(&app, "/metric-types").await;
+    assert_eq!(status, StatusCode::OK);
+    assert_eq!(
+        pairs,
+        json!([
+            {"metric_type": "BodyWeight", "unit": "Kilogram"},
+            {"metric_type": "Hip", "unit": "Centimeter"},
+            {"metric_type": "Waist", "unit": "Centimeter"},
+        ])
+    );
+}
+
+#[sqlx::test]
+async fn create_accepts_exactly_the_advertised_pairs(pool: PgPool) {
+    let app = router(pool);
+    let (_, pairs) = get_json(&app, "/metric-types").await;
+    let pairs = pairs.as_array().unwrap();
+    for metric_type in ["BodyWeight", "Hip", "Waist"] {
+        for unit in ["Kilogram", "Centimeter"] {
+            let advertised = pairs.contains(&json!({"metric_type": metric_type, "unit": unit}));
+            let expected = if advertised {
+                StatusCode::CREATED
+            } else {
+                StatusCode::UNPROCESSABLE_ENTITY
+            };
+            let body = measurement("2026-10-14T12:00:00Z", metric_type, 70.0, unit);
+            let (status, _, _) = send(&app, Method::POST, "/measurements", Some(body)).await;
+            assert_eq!(status, expected, "{metric_type} {unit}");
+        }
     }
 }
 
 #[sqlx::test]
-async fn all_is_empty_array_without_data(pool: PgPool) {
+async fn list_is_empty_array_without_data(pool: PgPool) {
     let app = router(pool);
-    let (status, rows) = get_json(&app, "/all").await;
+    let (status, rows) = get_json(&app, "/measurements").await;
     assert_eq!(status, StatusCode::OK);
     assert_eq!(rows, json!([]));
 }
 
 #[sqlx::test]
-async fn all_orders_by_measured_at(pool: PgPool) {
+async fn list_orders_by_measured_at(pool: PgPool) {
     let app = router(pool);
     add_waist(&app, "2026-10-16T08:00:00Z", 4.0).await;
     add_waist(&app, "2026-10-14T12:00:00Z", 1.0).await;
     add_waist(&app, "2026-10-15T23:59:59.500Z", 3.0).await;
     add_waist(&app, "2026-10-15T00:00:00Z", 2.0).await;
-    let (_, rows) = get_json(&app, "/all").await;
+    let (_, rows) = get_json(&app, "/measurements").await;
     assert_eq!(values(&rows), [1.0, 2.0, 3.0, 4.0]);
+    let (_, rows) = get_json(&app, "/measurements?order=asc").await;
+    assert_eq!(values(&rows), [1.0, 2.0, 3.0, 4.0]);
+    let (_, rows) = get_json(&app, "/measurements?order=desc").await;
+    assert_eq!(values(&rows), [4.0, 3.0, 2.0, 1.0]);
 }
 
 #[sqlx::test]
-async fn all_limit_keeps_oldest(pool: PgPool) {
+async fn list_limit_applies_after_ordering(pool: PgPool) {
     let app = router(pool);
     seed(&app).await;
-    let (_, rows) = get_json(&app, "/all?limit=2").await;
+    let (_, rows) = get_json(&app, "/measurements?limit=2").await;
     assert_eq!(values(&rows), [1.0, 2.0]);
+    let (_, rows) = get_json(&app, "/measurements?limit=2&order=desc").await;
+    assert_eq!(values(&rows), [4.0, 3.0]);
 }
 
 #[sqlx::test]
-async fn all_reverse_is_newest_first(pool: PgPool) {
+async fn list_single_date_includes_the_whole_day(pool: PgPool) {
     let app = router(pool);
     seed(&app).await;
-    let (_, rows) = get_json(&app, "/all?reverse=true").await;
-    assert_eq!(values(&rows), [4.0, 3.0, 2.0, 1.0]);
+    let (status, rows) = get_json(&app, "/measurements?date=2026-10-15").await;
+    assert_eq!(status, StatusCode::OK);
+    assert_eq!(values(&rows), [2.0, 3.0]);
 }
 
 #[sqlx::test]
-async fn all_reverse_with_limit_keeps_newest(pool: PgPool) {
+async fn list_ranges_are_inclusive_of_both_days(pool: PgPool) {
     let app = router(pool);
     seed(&app).await;
-    let (_, rows) = get_json(&app, "/all?limit=2&reverse=true").await;
-    assert_eq!(values(&rows), [4.0, 3.0]);
-    let (_, rows) = get_json(&app, "/all?limit=2&reverse=false").await;
-    assert_eq!(values(&rows), [1.0, 2.0]);
-}
-
-#[sqlx::test]
-async fn all_rejects_non_positive_limit(pool: PgPool) {
-    let app = router(pool);
-    for uri in ["/all?limit=0", "/all?limit=-1"] {
-        let (status, _) = get_json(&app, uri).await;
-        assert_eq!(status, StatusCode::BAD_REQUEST, "{uri}");
+    let cases = [
+        ("/measurements?from=2026-10-15", vec![2.0, 3.0, 4.0]),
+        ("/measurements?to=2026-10-14", vec![1.0]),
+        ("/measurements?from=2026-10-14&to=2026-10-15", vec![1.0, 2.0, 3.0]),
+        ("/measurements?from=2026-10-15&to=2026-10-15", vec![2.0, 3.0]),
+        ("/measurements?from=2030-01-01", vec![]),
+    ];
+    for (uri, expected) in cases {
+        let (status, rows) = get_json(&app, uri).await;
+        assert_eq!(status, StatusCode::OK, "{uri}");
+        assert_eq!(values(&rows), expected, "{uri}");
     }
 }
 
 #[sqlx::test]
-async fn search_by_single_date_includes_the_whole_day(pool: PgPool) {
-    let app = router(pool);
-    seed(&app).await;
-    let (status, rows) = get_json(&app, "/search?date=2026-10-15").await;
-    assert_eq!(status, StatusCode::OK);
-    assert_eq!(sorted_values(&rows), [2.0, 3.0]);
-}
-
-#[sqlx::test]
-async fn search_ranges_are_inclusive_of_both_days(pool: PgPool) {
+async fn list_combines_filters_with_order_and_limit(pool: PgPool) {
     let app = router(pool);
     seed(&app).await;
     let cases = [
-        ("/search?from=2026-10-15", vec![2.0, 3.0, 4.0]),
-        ("/search?to=2026-10-14", vec![1.0]),
-        ("/search?from=2026-10-14&to=2026-10-15", vec![1.0, 2.0, 3.0]),
-        ("/search?from=2026-10-15&to=2026-10-15", vec![2.0, 3.0]),
-        ("/search?from=2030-01-01", vec![]),
+        ("/measurements?from=2026-10-15&limit=1", vec![2.0]),
+        ("/measurements?from=2026-10-15&order=desc&limit=2", vec![4.0, 3.0]),
+        ("/measurements?date=2026-10-15&order=desc", vec![3.0, 2.0]),
     ];
     for (uri, expected) in cases {
         let (status, rows) = get_json(&app, uri).await;
         assert_eq!(status, StatusCode::OK, "{uri}");
-        assert_eq!(sorted_values(&rows), expected, "{uri}");
+        assert_eq!(values(&rows), expected, "{uri}");
     }
 }
 
 #[sqlx::test]
-async fn search_rejects_bad_queries(pool: PgPool) {
+async fn list_rejects_bad_queries(pool: PgPool) {
     let app = router(pool);
     let uris = [
-        "/search",
-        "/search?date=bad",
-        "/search?from=bad",
-        "/search?date=2026-10-15&from=2026-10-14",
-        "/search?date=2026-10-15&to=2026-10-16",
-        "/search?from=2026-10-16&to=2026-10-14",
+        "/measurements?limit=0",
+        "/measurements?limit=-1",
+        "/measurements?order=sideways",
+        "/measurements?date=bad",
+        "/measurements?from=bad",
+        "/measurements?date=2026-10-15&from=2026-10-14",
+        "/measurements?date=2026-10-15&to=2026-10-16",
+        "/measurements?from=2026-10-16&to=2026-10-14",
     ];
     for uri in uris {
         let (status, _) = get_json(&app, uri).await;
@@ -250,11 +266,11 @@ async fn search_rejects_bad_queries(pool: PgPool) {
 }
 
 #[sqlx::test]
-async fn get_by_id_not_found_and_bad_id(pool: PgPool) {
+async fn get_not_found_and_bad_id(pool: PgPool) {
     let app = router(pool);
-    let (status, _) = get_json(&app, &format!("/measurement/{}", Uuid::now_v7())).await;
+    let (status, _) = get_json(&app, &format!("/measurements/{}", Uuid::now_v7())).await;
     assert_eq!(status, StatusCode::NOT_FOUND);
-    let (status, _) = get_json(&app, "/measurement/not-a-uuid").await;
+    let (status, _) = get_json(&app, "/measurements/not-a-uuid").await;
     assert_eq!(status, StatusCode::BAD_REQUEST);
 }
 
@@ -262,10 +278,11 @@ async fn get_by_id_not_found_and_bad_id(pool: PgPool) {
 async fn update_replaces_the_row(pool: PgPool) {
     let app = router(pool);
     let id = add_waist(&app, "2026-10-14T12:00:00Z", 80.0).await;
+    let uri = format!("/measurements/{id}");
     let body = measurement("2026-10-20T09:30:00Z", "Hip", 95.0, "Centimeter");
-    let (status, _) = send(&app, Method::PUT, &format!("/update/{id}"), Some(body)).await;
+    let (status, _, _) = send(&app, Method::PUT, &uri, Some(body)).await;
     assert_eq!(status, StatusCode::NO_CONTENT);
-    let (_, row) = get_json(&app, &format!("/measurement/{id}")).await;
+    let (_, row) = get_json(&app, &uri).await;
     assert_eq!(
         row,
         json!({
@@ -282,8 +299,8 @@ async fn update_replaces_the_row(pool: PgPool) {
 async fn update_missing_id_is_not_found(pool: PgPool) {
     let app = router(pool);
     let body = measurement("2026-10-20T09:30:00Z", "Hip", 95.0, "Centimeter");
-    let uri = format!("/update/{}", Uuid::now_v7());
-    let (status, _) = send(&app, Method::PUT, &uri, Some(body)).await;
+    let uri = format!("/measurements/{}", Uuid::now_v7());
+    let (status, _, _) = send(&app, Method::PUT, &uri, Some(body)).await;
     assert_eq!(status, StatusCode::NOT_FOUND);
 }
 
@@ -291,17 +308,17 @@ async fn update_missing_id_is_not_found(pool: PgPool) {
 async fn update_rejects_invalid_body_and_leaves_row_alone(pool: PgPool) {
     let app = router(pool);
     let id = add_waist(&app, "2026-10-14T12:00:00Z", 80.0).await;
-    let uri = format!("/update/{id}");
+    let uri = format!("/measurements/{id}");
     let bodies = [
         json!({"x": 1}).to_string(),
         measurement("2026-10-20T09:30:00Z", "Waist", 82.0, "Kilogram"),
         measurement("2026-10-20T09:30:00Z", "Waist", -1.0, "Centimeter"),
     ];
     for body in bodies {
-        let (status, _) = send(&app, Method::PUT, &uri, Some(body.clone())).await;
+        let (status, _, _) = send(&app, Method::PUT, &uri, Some(body.clone())).await;
         assert_eq!(status, StatusCode::UNPROCESSABLE_ENTITY, "body: {body}");
     }
-    let (_, row) = get_json(&app, &format!("/measurement/{id}")).await;
+    let (_, row) = get_json(&app, &uri).await;
     assert_eq!(row["value"], json!(80.0));
 }
 
@@ -309,9 +326,10 @@ async fn update_rejects_invalid_body_and_leaves_row_alone(pool: PgPool) {
 async fn delete_removes_the_row(pool: PgPool) {
     let app = router(pool);
     let id = add_waist(&app, "2026-10-14T12:00:00Z", 80.0).await;
-    let (status, _) = send(&app, Method::DELETE, &format!("/delete/{id}"), None).await;
+    let uri = format!("/measurements/{id}");
+    let (status, _, _) = send(&app, Method::DELETE, &uri, None).await;
     assert_eq!(status, StatusCode::NO_CONTENT);
-    let (status, _) = get_json(&app, &format!("/measurement/{id}")).await;
+    let (status, _) = get_json(&app, &uri).await;
     assert_eq!(status, StatusCode::NOT_FOUND);
 }
 
@@ -319,23 +337,21 @@ async fn delete_removes_the_row(pool: PgPool) {
 async fn delete_is_idempotent(pool: PgPool) {
     let app = router(pool);
     let id = add_waist(&app, "2026-10-14T12:00:00Z", 80.0).await;
-    let uri = format!("/delete/{id}");
+    let uri = format!("/measurements/{id}");
     for _ in 0..2 {
-        let (status, _) = send(&app, Method::DELETE, &uri, None).await;
+        let (status, _, _) = send(&app, Method::DELETE, &uri, None).await;
         assert_eq!(status, StatusCode::NO_CONTENT);
     }
-    let missing = format!("/delete/{}", Uuid::now_v7());
-    let (status, _) = send(&app, Method::DELETE, &missing, None).await;
+    let missing = format!("/measurements/{}", Uuid::now_v7());
+    let (status, _, _) = send(&app, Method::DELETE, &missing, None).await;
     assert_eq!(status, StatusCode::NO_CONTENT);
 }
 
 #[sqlx::test]
-async fn units_and_metric_types_list_the_enums(pool: PgPool) {
+async fn old_paths_are_gone(pool: PgPool) {
     let app = router(pool);
-    let (status, units) = get_json(&app, "/units").await;
-    assert_eq!(status, StatusCode::OK);
-    assert_eq!(units, json!(["Kilogram", "Centimeter"]));
-    let (status, metric_types) = get_json(&app, "/metric_types").await;
-    assert_eq!(status, StatusCode::OK);
-    assert_eq!(metric_types, json!(["BodyWeight", "Hip", "Waist"]));
+    for uri in ["/", "/all", "/search?from=2026-10-14", "/units", "/metric_types"] {
+        let (status, _) = get_json(&app, uri).await;
+        assert_eq!(status, StatusCode::NOT_FOUND, "{uri}");
+    }
 }