null result fixes

Author: ChristianBeilschmidt

ogcapi-drivers/src/postgres/job.rs

@@ -10,6 +10,8 @@ use crate::{JobHandler, ProcessResult};
 
 use super::Db;
 
+type Results = HashMap<String, ExecuteResult>;
+
 #[async_trait::async_trait]
 impl JobHandler for Db {
     async fn register(&self, job: &StatusInfo, response_mode: Response) -> anyhow::Result<String> {
@@ -72,7 +74,7 @@ impl JobHandler for Db {
         status: &StatusCode,
         message: Option<String>,
         links: Vec<Link>,
-        results: Option<HashMap<String, ExecuteResult>>,
+        results: Option<Results>,
     ) -> anyhow::Result<()> {
         sqlx::query(
             r#"
@@ -88,10 +90,10 @@ impl JobHandler for Db {
             "#,
         )
         .bind(job_id)
-        .bind(sqlx::types::Json(status))
+        .bind(Json(status))
         .bind(message)
-        .bind(sqlx::types::Json(links))
-        .bind(sqlx::types::Json(results))
+        .bind(Json(links))
+        .bind(results.map(Json))
         .execute(&self.pool)
         .await?;
         Ok(())
@@ -169,23 +171,21 @@ impl JobHandler for Db {
     }
 
     async fn results(&self, id: &str) -> anyhow::Result<ProcessResult> {
-        let results: Option<(Json<Option<HashMap<String, ExecuteResult>>>, Json<Response>)> = dbg!(
-            sqlx::query_as(
-                r#"
+        let results: Option<(Option<Json<Results>>, Json<Response>)> = sqlx::query_as(
+            r#"
             SELECT results, to_jsonb(response)
             FROM meta.jobs
             WHERE job_id = $1
             "#,
-            )
-            .bind(id)
-            .fetch_optional(&self.pool)
-            .await
-        )?;
+        )
+        .bind(id)
+        .fetch_optional(&self.pool)
+        .await?;
 
         Ok(match results {
             None => ProcessResult::NoSuchJob,
-            Some((Json(None), _)) => ProcessResult::NotReady,
-            Some((Json(Some(results)), Json(response_mode))) => ProcessResult::Results {
+            Some((None, _)) => ProcessResult::NotReady,
+            Some((Some(Json(results)), Json(response_mode))) => ProcessResult::Results {
                 results,
                 response_mode,
             },

ogcapi-drivers/tests/job.rs

@@ -1,7 +1,12 @@
 #[cfg(feature = "processes")]
 mod postgres {
-    use ogcapi_drivers::{JobHandler, postgres::Db};
-    use ogcapi_types::processes::{Response, StatusCode, StatusInfo};
+    use std::collections::HashMap;
+
+    use ogcapi_drivers::{JobHandler, ProcessResult, postgres::Db};
+    use ogcapi_types::processes::{
+        ExecuteResult, InlineOrRefData, InputValueNoObject, Output, Response, StatusCode,
+        StatusInfo,
+    };
 
     #[sqlx::test]
     async fn job_handling(pool: sqlx::PgPool) -> () {
@@ -25,4 +30,82 @@ mod postgres {
 
         assert_eq!(info.unwrap().status, StatusCode::Dismissed)
     }
+
+    #[sqlx::test]
+    async fn job_result(pool: sqlx::PgPool) -> () {
+        let db = Db { pool };
+
+        let job = StatusInfo {
+            job_id: "test-job".to_string(),
+            ..Default::default()
+        };
+
+        matches!(
+            db.results(&job.job_id).await.unwrap(),
+            ProcessResult::NoSuchJob
+        );
+
+        assert_eq!(
+            db.register(&job, Response::Document).await.unwrap(),
+            job.job_id
+        );
+
+        matches!(
+            db.results(&job.job_id).await.unwrap(),
+            ProcessResult::NotReady
+        );
+
+        db.finish(
+            &job.job_id,
+            &StatusCode::Successful,
+            Some("it is ready".to_string()),
+            vec![],
+            Some(HashMap::from([(
+                "key1".to_string(),
+                ExecuteResult {
+                    output: Output {
+                        format: None,
+                        transmission_mode: Default::default(),
+                    },
+                    data: InlineOrRefData::InputValueNoObject(InputValueNoObject::String(
+                        "foobar".into(),
+                    )),
+                },
+            )])),
+        )
+        .await
+        .unwrap();
+
+        matches!(
+            db.results(&job.job_id).await.unwrap(),
+            ProcessResult::Results {
+                results: _,
+                response_mode: Response::Document,
+            }
+        );
+    }
+
+    #[sqlx::test]
+    async fn job_result_failed(pool: sqlx::PgPool) -> () {
+        let db = Db { pool };
+
+        let job = StatusInfo {
+            job_id: "test-job".to_string(),
+            ..Default::default()
+        };
+
+        let _ = db.register(&job, Response::Document).await.unwrap();
+
+        db.finish(&job.job_id, &StatusCode::Failed, None, vec![], None)
+            .await
+            .unwrap();
+
+        matches!(
+            db.results(&job.job_id).await.unwrap(),
+            ProcessResult::Results {
+                results: _,
+                response_mode: Response::Document,
+            }
+        );
+    }
 }

ogcapi-services/src/routes/common.rs

@@ -90,11 +90,23 @@ pub async fn root(
         )
     )
 )]
-pub(crate) async fn api() -> (HeaderMap, Json<openapiv3::OpenAPI>) {
+pub(crate) async fn api(RemoteUrl(url): RemoteUrl) -> (HeaderMap, Json<openapiv3::OpenAPI>) {
     let mut headers = HeaderMap::new();
     headers.insert(CONTENT_TYPE, OPEN_API_JSON.parse().unwrap());
 
-    (headers, Json(OpenAPI::from_slice(OPENAPI).0))
+    let mut open_api = OpenAPI::from_slice(OPENAPI).0;
+
+    let base_url = url[..url::Position::BeforePath].to_string();
+
+    // replace servers with relative server
+    open_api.servers = vec![openapiv3::Server {
+        url: base_url,
+        description: None,
+        variables: None,
+        extensions: Default::default(),
+    }];
+
+    (headers, Json(open_api))
 }
 
 /// API conformance definition