Add serde versions of non-serde tests

Author: strykejern

src/builder.rs

@@ -796,6 +796,19 @@ mod tests {
             HeaderValue::from_static("return=representation,resolution=merge-duplicates")
         );
     }
+    
+    #[test]
+    #[cfg(feature = "serde")]
+    fn upsert_assert_prefer_header_serde() {
+        let client = Client::new();
+        let builder = Builder::new(TABLE_URL, None, HeaderMap::new(), client)
+            .upsert(&())
+            .unwrap();
+        assert_eq!(
+            builder.headers.get("Prefer").unwrap(),
+            HeaderValue::from_static("return=representation,resolution=merge-duplicates")
+        );
+    }
 
     #[test]
     fn not_rpc_should_not_have_flag() {

tests/client.rs

@@ -90,6 +90,33 @@ async fn insert() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+#[tokio::test]
+#[cfg(feature = "serde")]
+async fn insert_serde() -> Result<(), Box<dyn Error>> {
+    #[derive(serde::Serialize)]
+    struct Message {
+        message: String,
+        channel_id: i32,
+        username: String,
+    }
+
+    let client = Postgrest::new(REST_URL);
+    let resp = client
+        .from("messages")
+        .insert(&[Message {
+            message: "Test message 1".to_string(),
+            channel_id: 1,
+            username: "kiwicopple".to_string(),
+        }])?
+        .execute()
+        .await?;
+    let status = resp.status();
+
+    assert_eq!(status.as_u16(), 201);
+
+    Ok(())
+}
+
 #[tokio::test]
 #[cfg(not(feature = "serde"))]
 async fn upsert() -> Result<(), Box<dyn Error>> {
@@ -111,6 +138,39 @@ async fn upsert() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+#[tokio::test]
+#[cfg(feature = "serde")]
+async fn upsert_serde() -> Result<(), Box<dyn Error>> {
+    #[derive(serde::Serialize)]
+    struct User {
+        username: String,
+        status: String,
+    }
+
+    let client = Postgrest::new(REST_URL);
+    let resp = client
+        .from("users")
+        .upsert(&[
+            User {
+                username: "dragarcia".to_string(),
+                status: "OFFLINE".to_string(),
+            },
+            User {
+                username: "supabot2".to_string(),
+                status: "ONLINE".to_string(),
+            },
+        ])?
+        .execute()
+        .await?;
+    let body = resp.text().await?;
+    let body = json::parse(&body)?;
+
+    assert_eq!(body[0]["username"], "dragarcia");
+    assert_eq!(body[1]["username"], "supabot2");
+
+    Ok(())
+}
+
 #[tokio::test]
 #[cfg(not(feature = "serde"))]
 async fn upsert_existing() -> Result<(), Box<dyn Error>> {
@@ -130,6 +190,34 @@ async fn upsert_existing() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+#[tokio::test]
+#[cfg(feature = "serde")]
+async fn upsert_existing_serde() -> Result<(), Box<dyn Error>> {
+    #[derive(serde::Serialize)]
+    struct User {
+        username: String,
+        status: String,
+    }
+
+    let client = Postgrest::new(REST_URL);
+    let resp = client
+        .from("users")
+        .upsert(&User {
+            username: "dragarcia".to_string(),
+            status: "ONLINE".to_string(),
+        })?
+        .on_conflict("username")
+        .execute()
+        .await?;
+    let body = resp.text().await?;
+    let body = json::parse(&body)?;
+
+    assert_eq!(body[0]["username"], "dragarcia");
+    assert_eq!(body[0]["status"], "ONLINE");
+
+    Ok(())
+}
+
 #[tokio::test]
 #[cfg(not(feature = "serde"))]
 async fn upsert_nonexisting() -> Result<(), Box<dyn Error>> {
@@ -148,6 +236,33 @@ async fn upsert_nonexisting() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+#[tokio::test]
+#[cfg(feature = "serde")]
+async fn upsert_nonexisting_serde() -> Result<(), Box<dyn Error>> {
+    #[derive(serde::Serialize)]
+    struct User {
+        username: String,
+        status: String,
+    }
+
+    let client = Postgrest::new(REST_URL);
+    let resp = client
+        .from("users")
+        .upsert(&User {
+            username: "supabot3".to_string(),
+            status: "ONLINE".to_string(),
+        })?
+        .execute()
+        .await?;
+    let body = resp.text().await?;
+    let body = json::parse(&body)?;
+
+    assert_eq!(body[0]["username"], "supabot3");
+    assert_eq!(body[0]["status"], "ONLINE");
+
+    Ok(())
+}
+
 #[tokio::test]
 #[cfg(not(feature = "serde"))]
 async fn update() -> Result<(), Box<dyn Error>> {
@@ -168,6 +283,33 @@ async fn update() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+#[tokio::test]
+#[cfg(feature = "serde")]
+async fn update_serde() -> Result<(), Box<dyn Error>> {
+    #[derive(serde::Serialize)]
+    struct User {
+        status: String,
+    }
+
+    let client = Postgrest::new(REST_URL);
+    let resp = client
+        .from("users")
+        .eq("status", "ONLINE")
+        .update(&User {
+            status: "ONLINE".to_string(),
+        })?
+        .execute()
+        .await?;
+    let status = resp.status();
+    let body = resp.text().await?;
+    let body = json::parse(&body)?;
+
+    assert_eq!(status.as_u16(), 200);
+    assert_eq!(body[0]["status"], "ONLINE");
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn delete() -> Result<(), Box<dyn Error>> {
     let client = Postgrest::new(REST_URL);

tests/multi_schema.rs

@@ -66,6 +66,43 @@ async fn write_other_schema() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+#[tokio::test]
+#[cfg(feature = "serde")]
+async fn write_other_schema_serde() -> Result<(), Box<dyn Error>> {
+    #[derive(serde::Serialize)]
+    struct User {
+        status: String,
+    }
+
+    let client = Postgrest::new(REST_URL);
+    let resp = client
+        .from("users")
+        .select("status")
+        .eq("username", "supabot")
+        .execute()
+        .await?;
+    let body = resp.text().await?;
+    let body = json::parse(&body)?;
+
+    assert_eq!(body[0]["status"], "ONLINE");
+
+    let other_client = Postgrest::new(REST_URL).schema("personal");
+    let other_resp = other_client
+        .from("users")
+        .update(&User {
+            status: "OFFLINE".to_string(),
+        })?
+        .eq("username", "supabot")
+        .execute()
+        .await?;
+    let other_body = other_resp.text().await?;
+    let other_body = json::parse(&other_body)?;
+
+    assert_eq!(other_body[0]["status"], "OFFLINE");
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn read_nonexisting_schema() -> Result<(), Box<dyn Error>> {
     let client = Postgrest::new(REST_URL).schema("private");
@@ -102,6 +139,34 @@ async fn write_nonexisting_schema() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+#[tokio::test]
+#[cfg(feature = "serde")]
+async fn write_nonexisting_schema_serde() -> Result<(), Box<dyn Error>> {
+    #[derive(serde::Serialize)]
+    struct Channel {
+        slug: String,
+    }
+
+    let client = Postgrest::new(REST_URL).schema("private");
+    let resp = client
+        .from("channels")
+        .update(&Channel {
+            slug: "private".to_string(),
+        })?
+        .eq("slug", "random")
+        .execute()
+        .await?;
+    let body = resp.text().await?;
+    let body = json::parse(&body)?;
+
+    assert_eq!(
+        body["message"],
+        "The schema must be one of the following: public, personal"
+    );
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn other_schema_rpc() -> Result<(), Box<dyn Error>> {
     let client = Postgrest::new(REST_URL).schema("personal");