chore: Don't ignore generated app code in UI tests

Author: LukeMathWalker

compiler/.gitignore

@@ -1,4 +1,4 @@
 target
 metadata.json
-**/generated_app/
+**/generated_app/blueprint.ron
 Cargo.lock

compiler/ui_tests/annotations/annotated_constructor_works/generated_app/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "application_9d63a47c"
+version = "0.1.0"
+edition = "2024"
+
+[package.metadata.px.generate]
+generator_type = "cargo_workspace_binary"
+generator_name = "app_9d63a47c"
+
+[dependencies]
+app_9d63a47c = { version = "0.1", path = "..", default-features = false }
+http = { version = "1", default-features = false }
+hyper = { version = "1", default-features = false }
+matchit = { version = "0.9", default-features = false }
+pavex = { version = "0.2", path = "../../../../../runtime/pavex", default-features = false }
+serde = { version = "1", default-features = false }
+thiserror = { version = "2", default-features = false }

compiler/ui_tests/annotations/annotated_constructor_works/generated_app/src/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "application_9d63a47c"
+version = "0.1.0"
+edition = "2021"
+
+[package.metadata.px.generate]
+generator_type = "cargo_workspace_binary"
+generator_name = "app_9d63a47c"

compiler/ui_tests/annotations/annotated_constructor_works/generated_app/src/lib.rs

@@ -0,0 +1,196 @@
+//! Do NOT edit this code.
+//! It was automatically generated by Pavex.
+//! All manual edits will be lost next time the code is generated.
+extern crate alloc;
+struct ServerState {
+    router: Router,
+    application_state: ApplicationState,
+}
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ApplicationConfig {}
+pub struct ApplicationState {
+    pub a: app_9d63a47c::A,
+}
+impl ApplicationState {
+    pub async fn new(
+        _app_config: crate::ApplicationConfig,
+    ) -> Result<crate::ApplicationState, crate::ApplicationStateError> {
+        Ok(Self::_new().await)
+    }
+    async fn _new() -> crate::ApplicationState {
+        let v0 = app_9d63a47c::a();
+        crate::ApplicationState { a: v0 }
+    }
+}
+#[derive(Debug, thiserror::Error)]
+pub enum ApplicationStateError {}
+pub fn run(
+    server_builder: pavex::server::Server,
+    application_state: ApplicationState,
+) -> pavex::server::ServerHandle {
+    async fn handler(
+        request: http::Request<hyper::body::Incoming>,
+        connection_info: Option<pavex::connection::ConnectionInfo>,
+        server_state: std::sync::Arc<ServerState>,
+    ) -> pavex::Response {
+        let (router, state) = (&server_state.router, &server_state.application_state);
+        router.route(request, connection_info, state).await
+    }
+    let router = Router::new();
+    let server_state = std::sync::Arc::new(ServerState {
+        router,
+        application_state,
+    });
+    server_builder.serve(handler, server_state)
+}
+struct Router {
+    router: matchit::Router<u32>,
+}
+impl Router {
+    /// Create a new router instance.
+    ///
+    /// This method is invoked once, when the server starts.
+    pub fn new() -> Self {
+        Self { router: Self::router() }
+    }
+    fn router() -> matchit::Router<u32> {
+        let mut router = matchit::Router::new();
+        router.insert("/handler", 0u32).unwrap();
+        router
+    }
+    pub async fn route(
+        &self,
+        request: http::Request<hyper::body::Incoming>,
+        _connection_info: Option<pavex::connection::ConnectionInfo>,
+        #[allow(unused)]
+        state: &ApplicationState,
+    ) -> pavex::Response {
+        let (request_head, _) = request.into_parts();
+        let request_head: pavex::request::RequestHead = request_head.into();
+        let Ok(matched_route) = self.router.at(&request_head.target.path()) else {
+            let allowed_methods: pavex::router::AllowedMethods = pavex::router::MethodAllowList::from_iter(
+                    vec![],
+                )
+                .into();
+            return route_0::entrypoint(&allowed_methods).await;
+        };
+        match matched_route.value {
+            0u32 => {
+                match &request_head.method {
+                    &pavex::http::Method::GET => {
+                        route_1::entrypoint(state.a.clone()).await
+                    }
+                    _ => {
+                        let allowed_methods: pavex::router::AllowedMethods = pavex::router::MethodAllowList::from_iter([
+                                pavex::http::Method::GET,
+                            ])
+                            .into();
+                        route_0::entrypoint(&allowed_methods).await
+                    }
+                }
+            }
+            i => unreachable!("Unknown route id: {}", i),
+        }
+    }
+}
+pub mod route_0 {
+    pub async fn entrypoint<'a>(
+        s_0: &'a pavex::router::AllowedMethods,
+    ) -> pavex::Response {
+        let response = wrapping_0(s_0).await;
+        response
+    }
+    async fn stage_1<'a>(s_0: &'a pavex::router::AllowedMethods) -> pavex::Response {
+        let response = handler(s_0).await;
+        response
+    }
+    async fn wrapping_0(v0: &pavex::router::AllowedMethods) -> pavex::Response {
+        let v1 = crate::route_0::Next0 {
+            s_0: v0,
+            next: stage_1,
+        };
+        let v2 = pavex::middleware::Next::new(v1);
+        let v3 = pavex::middleware::wrap_noop(v2).await;
+        <pavex::Response as pavex::IntoResponse>::into_response(v3)
+    }
+    async fn handler(v0: &pavex::router::AllowedMethods) -> pavex::Response {
+        let v1 = pavex::router::default_fallback(v0).await;
+        <pavex::Response as pavex::IntoResponse>::into_response(v1)
+    }
+    struct Next0<'a, T>
+    where
+        T: std::future::Future<Output = pavex::Response>,
+    {
+        s_0: &'a pavex::router::AllowedMethods,
+        next: fn(&'a pavex::router::AllowedMethods) -> T,
+    }
+    impl<'a, T> std::future::IntoFuture for Next0<'a, T>
+    where
+        T: std::future::Future<Output = pavex::Response>,
+    {
+        type Output = pavex::Response;
+        type IntoFuture = T;
+        fn into_future(self) -> Self::IntoFuture {
+            (self.next)(self.s_0)
+        }
+    }
+}
+pub mod route_1 {
+    pub async fn entrypoint(s_0: app_9d63a47c::A) -> pavex::Response {
+        let response = wrapping_0(s_0).await;
+        response
+    }
+    async fn stage_1(s_0: app_9d63a47c::A) -> pavex::Response {
+        let response = handler(s_0).await;
+        response
+    }
+    async fn wrapping_0(v0: app_9d63a47c::A) -> pavex::Response {
+        let v1 = crate::route_1::Next0 {
+            s_0: v0,
+            next: stage_1,
+        };
+        let v2 = pavex::middleware::Next::new(v1);
+        let v3 = pavex::middleware::wrap_noop(v2).await;
+        <pavex::Response as pavex::IntoResponse>::into_response(v3)
+    }
+    async fn handler(v0: app_9d63a47c::A) -> pavex::Response {
+        let v1 = <app_9d63a47c::A as core::clone::Clone>::clone(&v0);
+        let v2 = app_9d63a47c::b(v1);
+        let v3 = app_9d63a47c::c(&v2);
+        let v4 = match v3 {
+            Ok(ok) => ok,
+            Err(v4) => {
+                return {
+                    let v5 = app_9d63a47c::default_error_handler(&v4);
+                    <pavex::Response as pavex::IntoResponse>::into_response(v5)
+                };
+            }
+        };
+        let v5 = app_9d63a47c::H::with_e();
+        let v6 = app_9d63a47c::H::with_a();
+        let v7 = <app_9d63a47c::A as core::clone::Clone>::clone(&v0);
+        let v8 = app_9d63a47c::G::new(v7);
+        let v9 = app_9d63a47c::E::new();
+        let v10 = app_9d63a47c::F::new(&v9);
+        let v11 = app_9d63a47c::d(&v4, &v0);
+        let v12 = app_9d63a47c::handler(&v0, &v2, &v11, &v9, &v10, &v8, &v6, &v5);
+        <pavex::Response as pavex::IntoResponse>::into_response(v12)
+    }
+    struct Next0<T>
+    where
+        T: std::future::Future<Output = pavex::Response>,
+    {
+        s_0: app_9d63a47c::A,
+        next: fn(app_9d63a47c::A) -> T,
+    }
+    impl<T> std::future::IntoFuture for Next0<T>
+    where
+        T: std::future::Future<Output = pavex::Response>,
+    {
+        type Output = pavex::Response;
+        type IntoFuture = T;
+        fn into_future(self) -> Self::IntoFuture {
+            (self.next)(self.s_0)
+        }
+    }
+}

compiler/ui_tests/annotations/non_existing_dependency/generated_app/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "application_3da24ac8"
+version = "0.1.0"
+edition = "2021"
+
+[package.metadata.px.generate]
+generator_type = "cargo_workspace_binary"
+generator_name = "app_3da24ac8"
+
+[dependencies]
+workspace_hack = { version = "0.1", path = "../../../workspace_hack" }

compiler/ui_tests/annotations/non_existing_dependency/generated_app/src/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "application_3da24ac8"
+version = "0.1.0"
+edition = "2021"
+
+[package.metadata.px.generate]
+generator_type = "cargo_workspace_binary"
+generator_name = "app_3da24ac8"

compiler/ui_tests/annotations/non_existing_dependency/generated_app/src/lib.rs

@@ -0,0 +1,11 @@
+[package]
+name = "application_8055d222"
+version = "0.1.0"
+edition = "2021"
+
+[package.metadata.px.generate]
+generator_type = "cargo_workspace_binary"
+generator_name = "app_8055d222"
+
+[dependencies]
+workspace_hack = { version = "0.1", path = "../../../workspace_hack" }

compiler/ui_tests/annotations/non_existing_module/generated_app/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "application_8055d222"
+version = "0.1.0"
+edition = "2021"
+
+[package.metadata.px.generate]
+generator_type = "cargo_workspace_binary"
+generator_name = "app_8055d222"