Add HTTP integration tests

.github/workflows/pull-request.yml

@@ -35,6 +35,15 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@1d96c772d19495a3b5c517cd2bc0cb401ea0529f # v4
 
+      - name: Setup go
+        uses: actions/setup-go@cdcb36043654635271a94b9a6d1392de5bb323a7 # v5
+        with:
+          go-version: '1.22'
+          cache: false
+
+      - name: Install fake-oidc
+        run: go install github.com/bradenrayhorn/fake-oidc@v0
+
       - name: test
         run: cargo test
 

server/Cargo.toml

@@ -13,7 +13,7 @@ anyhow = "1.0"
 axum = { version = "0.7.5" }
 serde = { version = "1.0.199", features = ["derive"] }
 openidconnect = { version = "4.0.0-alpha.1" }
-reqwest = { version = "0.12.4" }
+reqwest = { version = "0.12.4", features = ["cookies", "json"] }
 axum-extra = { version = "0.9.3", features = ["cookie-private"] }
 serde_json = "1.0.117"
 cookie = "0.18.1"

server/src/bin/server.rs

@@ -1,4 +1,4 @@
-use mise::{config, datastore, http::Server, session_store::SessionStore, sqlite};
+use mise::{config, datastore, http::Server, oidc, session_store::SessionStore, sqlite};
 
 #[tokio::main]
 async fn main() {
@@ -29,7 +29,11 @@ async fn main() {
     let pool = datastore::Pool::new(senders);
     let cache = SessionStore::new(session_store_sender);
 
-    let s = Server::new(config, pool, cache);
+    let oidc_provider = oidc::Provider::new((&config).try_into().unwrap())
+        .await
+        .unwrap();
+
+    let s = Server::new(config, pool, cache, oidc_provider);
 
     if let Err(err) = s.start().await {
         println!("Failed to start http server: {:?}", err)

server/src/domain.rs

@@ -322,7 +322,7 @@ pub mod recipe {
     impl InstructionBlock {
         #[must_use]
         pub fn title(&self) -> Option<&str> {
-            self.title.as_ref().map(|x| &**x)
+            self.title.as_deref()
         }
 
         #[must_use]
@@ -366,7 +366,9 @@ pub mod recipe {
             gather_text(node, &mut heading);
             Ok(heading)
         } else {
-            Err(ValidationError::Format("Expected heading, found ?.".into()))
+            Err(ValidationError::Format(
+                "Expected heading, found not a heading.".into(),
+            ))
         }
     }
 
@@ -376,7 +378,9 @@ pub mod recipe {
         if let comrak::nodes::NodeValue::List(_) = node.data.borrow().value {
             Ok(gather_list(node))
         } else {
-            Err(ValidationError::Format(format!("Expected list, found ?.")))
+            Err(ValidationError::Format(
+                "Expected list, found not a list.".into(),
+            ))
         }
     }
 

server/src/http/server.rs

@@ -24,6 +24,7 @@ pub struct Server {
     config: Config,
     datasource: Pool,
     session_store: SessionStore,
+    oidc_provider: Arc<oidc::Provider>,
 }
 
 #[derive(Clone)]
@@ -42,24 +43,28 @@ impl FromRef<AppState> for Key {
 
 impl Server {
     #[must_use]
-    pub fn new(config: Config, datasource: Pool, session_store: SessionStore) -> Self {
+    pub fn new(
+        config: Config,
+        datasource: Pool,
+        session_store: SessionStore,
+        oidc_provider: oidc::Provider,
+    ) -> Self {
         Server {
             config,
             datasource,
             session_store,
+            oidc_provider: Arc::new(oidc_provider),
         }
     }
 
     pub async fn start(&self) -> anyhow::Result<()> {
         println!("Starting http server on port {:?}", self.config.http_port);
 
-        let oidc_provider = oidc::Provider::new((&self.config).try_into()?).await?;
-
         let state = AppState {
             key: Key::generate(),
             session_store: self.session_store.clone(),
             datasource: self.datasource.clone(),
-            oidc_provider: Arc::new(oidc_provider),
+            oidc_provider: self.oidc_provider.clone(),
         };
 
         let router: Router = Router::new()

server/src/oidc.rs

@@ -77,6 +77,7 @@ impl TryFrom<&config::Config> for Config {
     }
 }
 
+#[derive(Clone)]
 pub struct Provider {
     http_client: reqwest::Client,
     openid_client: CoreClient<

server/tests/http/auth.rs

@@ -0,0 +1,16 @@
+use super::setup;
+use anyhow::Result;
+use reqwest::StatusCode;
+
+#[tokio::test]
+async fn can_get_me() -> Result<()> {
+    let mut harness = setup::harness().await?;
+
+    harness.authenticate("thomas").await?;
+
+    let response = harness.get("/api/v1/auth/me").send().await?;
+
+    assert_eq!(StatusCode::OK, response.status());
+
+    Ok(())
+}

server/tests/http/recipe.rs

@@ -0,0 +1,71 @@
+use super::{requests, responses, setup};
+use anyhow::Result;
+use reqwest::StatusCode;
+
+#[tokio::test]
+async fn cannot_get_unknown_recipe() -> Result<()> {
+    let harness = setup::with_auth().await?;
+
+    let random_id = uuid::Uuid::new_v4();
+
+    let response = harness
+        .get(&format!("/api/v1/recipes/{random_id}"))
+        .send()
+        .await?;
+
+    assert_eq!(StatusCode::NOT_FOUND, response.status());
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn can_create_and_get_recipe() -> Result<()> {
+    let harness = setup::with_auth().await?;
+
+    let response = harness
+        .post("/api/v1/recipes")
+        .json(&requests::CreateRecipe {
+            title: "Chicken Parm".into(),
+            ingredients: "\
+                - One chicken\n\
+                - Parmesan cheese\
+                "
+            .into(),
+            instructions: "\
+                - Broil the chicken\n\
+                - Add the parmesan\
+                "
+            .into(),
+            notes: Some("Best served hot!".into()),
+        })
+        .send()
+        .await?;
+
+    assert_eq!(StatusCode::OK, response.status());
+    let id = response.json::<responses::Id>().await?.data;
+
+    // try to get recipe
+    let response = harness.get(&format!("/api/v1/recipes/{id}")).send().await?;
+    assert_eq!(StatusCode::OK, response.status());
+
+    let result = response.json::<responses::GetRecipe>().await?.data;
+
+    assert_eq!("Chicken Parm", result.title);
+    assert_eq!(
+        vec![responses::Ingredients {
+            title: None,
+            ingredients: vec!["One chicken".into(), "Parmesan cheese".into()]
+        }],
+        result.ingredient_blocks
+    );
+    assert_eq!(
+        vec![responses::Instructions {
+            title: None,
+            instructions: vec!["Broil the chicken".into(), "Add the parmesan".into()]
+        }],
+        result.instruction_blocks
+    );
+    assert_eq!(Some("Best served hot!".into()), result.notes);
+
+    Ok(())
+}

server/tests/http/requests.rs

@@ -0,0 +1,9 @@
+use serde::Serialize;
+
+#[derive(Serialize)]
+pub struct CreateRecipe {
+    pub title: String,
+    pub ingredients: String,
+    pub instructions: String,
+    pub notes: Option<String>,
+}

server/tests/http/responses.rs

@@ -0,0 +1,32 @@
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub struct Data<T> {
+    pub data: T,
+}
+
+pub type Id = Data<uuid::Uuid>;
+
+pub type GetRecipe = Data<Recipe>;
+
+#[derive(Debug, Deserialize, PartialEq, Eq)]
+pub struct Recipe {
+    pub id: String,
+    pub hash: String,
+    pub title: String,
+    pub ingredient_blocks: Vec<Ingredients>,
+    pub instruction_blocks: Vec<Instructions>,
+    pub notes: Option<String>,
+}
+
+#[derive(Debug, Deserialize, PartialEq, Eq)]
+pub struct Instructions {
+    pub title: Option<String>,
+    pub instructions: Vec<String>,
+}
+
+#[derive(Debug, Deserialize, PartialEq, Eq)]
+pub struct Ingredients {
+    pub title: Option<String>,
+    pub ingredients: Vec<String>,
+}