checkpoint

axum/src/routing/mod.rs

@@ -664,11 +664,11 @@ where
 
         let path = req.uri().path().to_owned();
 
-        // the `unwrap` is safe because `self.state` is always some if `R = WithState`, which it is
+        if req.extensions().get::<State<S>>().is_none() {
-        let prev = req
+            // the `unwrap` is safe because `self.state` is always some if `R = WithState`, which it is
-            .extensions_mut()
+            req.extensions_mut()
-            .insert(State(self.state.as_ref().unwrap().clone()));
+                .insert(State(self.state.as_ref().unwrap().clone()));
-        debug_assert!(prev.is_none());
+        }
 
         match self.node.at(&path) {
             Ok(match_) => self.call_route(match_, req),

axum/src/routing/tests/merge.rs

@@ -417,5 +417,34 @@ async fn middleware_that_return_early() {
 
 #[tokio::test]
 async fn merging_with_different_state() {
-    todo!()
+    #[derive(Clone)]
+    struct AppState {
+        inner: InnerState,
+    }
+
+    #[derive(Clone)]
+    struct InnerState {
+        value: &'static str,
+    }
+
+    impl From<AppState> for InnerState {
+        fn from(state: AppState) -> Self {
+            state.inner
+        }
+    }
+
+    let inner_router = Router::new().route(
+        "/a",
+        get(|State(state): State<InnerState>| async move { state.value }),
+    );
+
+    let app = Router::with_state(AppState {
+        inner: InnerState { value: "inner" },
+    })
+    .merge(inner_router.map_state(Into::into));
+
+    let client = TestClient::new(app);
+
+    let res = client.get("/a").send().await;
+    assert_eq!(res.text().await, "inner");
 }

axum/src/routing/tests/nest.rs

@@ -404,7 +404,7 @@ async fn nesting_with_different_state() {
         }
     }
 
-    let inner_router = Router::<InnerState, Body, _>::new().route(
+    let inner_router = Router::new().route(
         "/b",
         get(|State(state): State<InnerState>| async move { state.value }),
     );
@@ -433,15 +433,15 @@ macro_rules! nested_route_test {
         #[tokio::test]
         async fn $name() {
             let inner = Router::new().route($route_path, get(|| async {}));
-            let app = Router::new().nest($nested_path, inner);
+            let app = Router::without_state().nest($nested_path, inner);
-            let client = TestClient::new(app.state(()));
+            let client = TestClient::new(app);
             let res = client.get($expected_path).send().await;
             let status = res.status();
             assert_eq!(status, StatusCode::OK, "Router");
 
             let inner = Router::new().route($route_path, get(|| async {})).state(());
-            let app = Router::new().nest_service($nested_path, inner);
+            let app = Router::without_state().nest_service($nested_path, inner);
-            let client = TestClient::new(app.state(()));
+            let client = TestClient::new(app);
             let res = client.get(dbg!($expected_path)).send().await;
             assert_eq!(res.status(), StatusCode::OK, "opaque");
         }