test: insert with literal

Author: tobyhede

packages/cipherstash-proxy-integration/src/insert/insert_with_literal.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_literal {
+        ($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, '{encrypted_val}')");
+                insert(&sql, &[&id]).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_literal!(insert_with_literal_int2, i16, int2);
+    test_insert_with_literal!(insert_with_literal_int4, i32, int4);
+    test_insert_with_literal!(insert_with_literal_int8, i64, int8);
+    test_insert_with_literal!(insert_with_literal_float8, f64, float8);
+    test_insert_with_literal!(insert_with_literal_bool, bool, bool);
+    test_insert_with_literal!(insert_with_literal_text, String, text);
+    test_insert_with_literal!(insert_with_literal_date, NaiveDate, date);
+    test_insert_with_literal!(insert_with_literal_jsonb, Value, jsonb);
+
+    // -----------------------------------------------------------------
+
+    /// Sanity check insert of unencrypted literal value
+    #[tokio::test]
+    pub async fn insert_with_literal_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, '{encrypted_val}')");
+        insert(&sql, &[&id]).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/insert_with_null_literal.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_null_literal {
+        ($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, NULL)");
+                insert(&sql, &[&id]).await;
+
+                let expected = vec![encrypted_val];
+
+                let sql = format!("SELECT {encrypted_col} FROM encrypted WHERE id = $1");
+
+                let actual = query_by::<Option<$type>>(&sql, &id).await;
+
+                assert_eq!(expected, actual);
+            }
+        };
+    }
+
+    test_insert_with_null_literal!(insert_with_null_literal_int2, i16, int2);
+    test_insert_with_null_literal!(insert_with_null_literal_int4, i32, int4);
+    test_insert_with_null_literal!(insert_with_null_literal_int8, i64, int8);
+    test_insert_with_null_literal!(insert_with_null_literal_float8, f64, float8);
+    test_insert_with_null_literal!(insert_with_null_literal_bool, bool, bool);
+    test_insert_with_null_literal!(insert_with_null_literal_text, String, text);
+    test_insert_with_null_literal!(insert_with_null_literal_date, NaiveDate, date);
+    test_insert_with_null_literal!(insert_with_null_literal_jsonb, Value, jsonb);
+
+    // -----------------------------------------------------------------
+
+    /// Sanity check insert of unencrypted literal value
+    #[tokio::test]
+    pub async fn insert_with_literal_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, NULL");
+        insert(&sql, &[&id]).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

@@ -1,2 +1,4 @@
+mod insert_with_literal;
+mod insert_with_null_literal;
 mod insert_with_null_param;
 mod insert_with_param;