actix/actix-web

Hi all, I wrote these small piece of testing code to get access to the internal web:Data<T>:

#[actix_web::test]
    async fn test_crawl_does_get_root_page_links() {
        let set: HashSet<Url> = HashSet::default();
        let (server, port) = spawn_server(set).unwrap();
        let client = reqwest::Client::default();
        let response = client
            .get(format!("http://localhost:{}/", port))
            .send()
            .await
            .expect("Failed to execute the request");
        assert_eq!(response.text().await.unwrap(), root_body(&port));
        server.stop(false).await;
    }

    fn spawn_server(set: HashSet<Url>) -> Result<(Server, u16), std::io::Error> {
        let (server, port) = run_server(set).unwrap();
        let _ = tokio::spawn(server.clone());
        Ok((server, port))
    }

    fn run_server(set: HashSet<Url>) -> Result<(Server, u16), std::io::Error> {
        let listener = TcpListener::bind("localhost:0").expect("Failed to bind to random port");
        let port = listener.local_addr().unwrap().port();
        let server = HttpServer::new(move || {
            App::new()
                .app_data(web::Data::new(set.clone()))
                .app_data(web::Data::new(port.clone()))
                .wrap_fn(|request, server| {
                    let app_state = request.app_data::<web::Data<HashSet<Url>>>();
                    let s = app_state.unwrap().get_ref();
                    println!("{}", s.len());
                    let fut = server.call(request);
                    async move {
                        let response = fut.await.unwrap();
                        Ok(response)
                    }
                })
                .wrap_fn(|request, server| {
                    let fut = server.call(request);
                    async move {
                        let response = fut.await.unwrap();
                        Ok(response)
                    }
                })
                .route("/", web::get().to(root_page))
        })
        .listen(listener)?
        .run();

        Ok((server, port))
    }

The idea was to have two of these wrapped middleware running, with the first registered running last and thus containing the modifications of the first request, which doesn't do any modifications. However, I do not understand how this is supposed to work. Once the outer layer has run, I have a response. The inner layer doesn't know anything about this response and creates a response on its own. I am sure it is my understanding that is lacking, could someone explain to me how I get these to middlewares chained? Maybe the whole idea is flawed, but it is my first success to actually access web:Data<T> from a unit test. I am open to any suggestions ;-)