test: insert with param

Author: tobyhede

packages/cipherstash-proxy-integration/src/common.rs

@@ -23,6 +23,13 @@ pub fn random_id() -> i64 {
     rng.random_range(1..=i64::MAX)
 }
 
+// Limited by valid data range
+pub fn random() -> i32 {
+    use rand::Rng;
+    let mut rng = rand::rng();
+    rng.random_range(1..=31)
+}
+
 pub fn random_string() -> String {
     rand::rng()
         .sample_iter(&Alphanumeric)
@@ -126,6 +133,15 @@ pub async fn query<T: for<'a> tokio_postgres::types::FromSql<'a> + Send + Sync>(
     rows.iter().map(|row| row.get(0)).collect::<Vec<T>>()
 }
 
+pub async fn query_by<T>(sql: &str, param: &(dyn ToSql + Sync)) -> Vec<T>
+where
+    T: for<'a> tokio_postgres::types::FromSql<'a> + Send + Sync,
+{
+    let client = connect_with_tls(PROXY).await;
+    let rows = client.query(sql, &[param]).await.unwrap();
+    rows.iter().map(|row| row.get(0)).collect::<Vec<T>>()
+}
+
 pub async fn simple_query<T: std::str::FromStr>(sql: &str) -> Vec<T>
 where
     <T as std::str::FromStr>::Err: std::fmt::Debug,

packages/cipherstash-proxy-integration/src/insert/insert_with_null_param.rs

@@ -0,0 +1,42 @@
+#[cfg(test)]
+mod tests {
+    use crate::common::{clear, insert, query, query_by, random_id, trace};
+    use chrono::NaiveDate;
+    use serde_json::Value;
+    use tracing::info;
+
+    macro_rules! test_insert_with_null_param {
+        ($name: ident, $type: ident, $pg_type: ident) => {
+            #[tokio::test]
+            pub async fn $name() {
+                trace();
+
+                clear().await;
+
+                let id = random_id();
+
+                let encrypted_col = format!("encrypted_{}", stringify!($pg_type));
+                let encrypted_val: Option<$type> = None;
+
+                let sql = format!("INSERT INTO encrypted (id, {encrypted_col}) VALUES ($1, $2)");
+                insert(&sql, &[&id, &encrypted_val]).await;
+
+                let expected = vec![encrypted_val];
+
+                let sql = format!("SELECT {encrypted_col} FROM encrypted WHERE id = $1");
+                let result = query_by::<Option<$type>>(&sql, &id).await;
+
+                assert_eq!(expected, result);
+            }
+        };
+    }
+
+    test_insert_with_null_param!(insert_with_null_param_int2, i16, int2);
+    test_insert_with_null_param!(insert_with_null_param_int4, i32, int4);
+    test_insert_with_null_param!(insert_with_null_param_int8, i64, int8);
+    test_insert_with_null_param!(insert_with_null_param_float8, f64, float8);
+    test_insert_with_null_param!(insert_with_null_param_bool, bool, bool);
+    test_insert_with_null_param!(insert_with_null_param_text_only, String, text);
+    test_insert_with_null_param!(insert_with_null_param_date, NaiveDate, date);
+    test_insert_with_null_param!(insert_with_null_param_jsonb, Value, jsonb);
+}

packages/cipherstash-proxy-integration/src/insert/insert_with_param.rs

@@ -0,0 +1,68 @@
+#[cfg(test)]
+mod tests {
+    use crate::common::{clear, insert, query, query_by, random, random_id, trace};
+    use chrono::NaiveDate;
+    use serde_json::Value;
+    use tracing::info;
+
+    macro_rules! test_insert_with_param {
+        ($name: ident, $type: ident, $pg_type: ident) => {
+            #[tokio::test]
+            pub async fn $name() {
+                trace();
+
+                clear().await;
+
+                let id = random_id();
+
+                let encrypted_col = format!("encrypted_{}", stringify!($pg_type));
+                let encrypted_val = crate::value_for_type!($type, random());
+
+                let sql = format!("INSERT INTO encrypted (id, {encrypted_col}) VALUES ($1, $2)");
+                insert(&sql, &[&id, &encrypted_val]).await;
+
+                let expected = vec![encrypted_val];
+
+                let sql = format!("SELECT {encrypted_col} FROM encrypted WHERE id = $1");
+
+                let actual = query_by::<$type>(&sql, &id).await;
+
+                assert_eq!(expected, actual);
+            }
+        };
+    }
+
+    test_insert_with_param!(insert_with_param_int2, i16, int2);
+    test_insert_with_param!(insert_with_param_int4, i32, int4);
+    test_insert_with_param!(insert_with_param_int8, i64, int8);
+    test_insert_with_param!(insert_with_param_float8, f64, float8);
+    test_insert_with_param!(insert_with_param_bool, bool, bool);
+    test_insert_with_param!(insert_with_param_text, String, text);
+    test_insert_with_param!(insert_with_param_date, NaiveDate, date);
+    test_insert_with_param!(insert_with_param_jsonb, Value, jsonb);
+
+    // -----------------------------------------------------------------
+
+    /// Sanity check insert of unencrypted plaintext value
+    #[tokio::test]
+    pub async fn insert_with_param_plaintext() {
+        trace();
+
+        clear().await;
+
+        let id = random_id();
+
+        let encrypted_val = crate::value_for_type!(String, random());
+
+        let sql = format!("INSERT INTO encrypted (id, plaintext) VALUES ($1, $2)");
+        insert(&sql, &[&id, &encrypted_val]).await;
+
+        let expected = vec![encrypted_val];
+
+        let sql = format!("SELECT plaintext FROM encrypted WHERE id = $1");
+
+        let actual = query_by::<String>(&sql, &id).await;
+
+        assert_eq!(expected, actual);
+    }
+}

packages/cipherstash-proxy-integration/src/insert/mod.rs

@@ -0,0 +1,2 @@
+mod insert_with_null_param;
+mod insert_with_param;

packages/cipherstash-proxy-integration/src/lib.rs

@@ -2,6 +2,7 @@ mod common;
 mod decrypt;
 mod empty_result;
 mod extended_protocol_error_messages;
+mod insert;
 mod map_concat;
 mod map_literals;
 mod map_match_index;
@@ -16,3 +17,26 @@ mod pipeline;
 mod schema_change;
 mod select;
 mod simple_protocol;
+
+#[macro_export]
+macro_rules! value_for_type {
+    (String, $i:expr) => {
+        ((b'A' + ($i - 1) as u8) as char).to_string()
+    };
+
+    (NaiveDate, $i:expr) => {
+        NaiveDate::parse_from_str(&format!("2023-01-{}", $i), "%Y-%m-%d").unwrap()
+    };
+
+    (Value, $i:expr) => {
+        serde_json::json!({"n": $i, "s": format!("{}", $i) })
+    };
+
+    (bool, $i:expr) => {
+        $i % 2 == 0
+    };
+
+    ($type:ident, $i:expr) => {
+        $i as $type
+    };
+}