Add a test

… and make it pass in a stupid way.

tower/src/task_local.rs

@@ -69,6 +69,12 @@ where
     }
 
     fn call(&mut self, req: R) -> Self::Future {
-        self.key.scope(self.value.clone(), self.inner.call(req))
+        // This is not great. I don't want to clone the value twice.
+        // Probably need to introduce a custom Future that delays calling
+        // inner.call until the local-key is set?
+        let fut = self
+            .key
+            .sync_scope(self.value.clone(), || self.inner.call(req));
+        self.key.scope(self.value.clone(), fut)
     }
 }

tower/tests/task_local.rs

@@ -0,0 +1,36 @@
+#![cfg(all(feature = "task-local", feature = "util"))]
+
+use futures::pin_mut;
+use tower::{util::ServiceExt, Service as _};
+use tower_test::{assert_request_eq, mock};
+
+mod support;
+
+tokio::task_local! {
+    static NUM: i32;
+}
+
+#[tokio::test]
+async fn set_task_local() {
+    let _t = support::trace_init();
+
+    let (service, handle) = mock::pair();
+    pin_mut!(handle);
+
+    let mut client = service
+        .map_request(|()| {
+            assert_eq!(NUM.get(), 9000);
+        })
+        .map_response(|()| {
+            assert_eq!(NUM.get(), 9000);
+        })
+        .set_task_local(&NUM, 9000);
+
+    // allow a request through
+    handle.allow(1);
+
+    let ready = client.ready().await.unwrap();
+    let fut = ready.call(());
+    assert_request_eq!(handle, ()).send_response(());
+    fut.await.unwrap();
+}