tests: move cql_value.rs tests into serialization.rs

Author: k0machi

scylla/tests/integration/cql_value.rs

@@ -2,7 +2,6 @@ mod authenticate;
 mod batch;
 mod consistency;
 mod cql_collections;
-mod cql_value;
 mod default_policy;
 mod execution_profiles;
 mod history;

scylla/tests/integration/main.rs

@@ -1,7 +1,8 @@
+use assert_matches::assert_matches;
 use itertools::Itertools;
 use scylla::client::session::Session;
 use scylla::serialize::value::SerializeValue;
-use scylla::value::{Counter, CqlDate, CqlTime, CqlTimestamp, CqlTimeuuid, CqlValue, CqlVarint};
+use scylla::value::{Counter, CqlDate, CqlDuration, CqlTime, CqlTimestamp, CqlTimeuuid, CqlValue, CqlVarint};
 use scylla::{DeserializeValue, SerializeValue};
 use std::cmp::PartialEq;
 use std::fmt::Debug;
@@ -1863,3 +1864,148 @@ async fn test_udt_with_missing_field() {
     )
     .await;
 }
+
+
+#[tokio::test]
+async fn test_cqlvalue_udt() {
+    setup_tracing();
+    let session: Session = create_new_session_builder().build().await.unwrap();
+    let ks = unique_keyspace_name();
+    session
+        .ddl(format!(
+            "CREATE KEYSPACE IF NOT EXISTS {} WITH REPLICATION = \
+            {{'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}}",
+            ks
+        ))
+        .await
+        .unwrap();
+    session.use_keyspace(&ks, false).await.unwrap();
+
+    session
+        .ddl("CREATE TYPE IF NOT EXISTS cqlvalue_udt_type (int_val int, text_val text)")
+        .await
+        .unwrap();
+    session.ddl("CREATE TABLE IF NOT EXISTS cqlvalue_udt_test (k int, my cqlvalue_udt_type, primary key (k))").await.unwrap();
+
+    let udt_cql_value = CqlValue::UserDefinedType {
+        keyspace: ks,
+        name: "cqlvalue_udt_type".to_string(),
+        fields: vec![
+            ("int_val".to_string(), Some(CqlValue::Int(42))),
+            ("text_val".to_string(), Some(CqlValue::Text("hi".into()))),
+        ],
+    };
+
+    session
+        .query_unpaged(
+            "INSERT INTO cqlvalue_udt_test (k, my) VALUES (5, ?)",
+            (&udt_cql_value,),
+        )
+        .await
+        .unwrap();
+
+    let rows_result = session
+        .query_unpaged("SELECT my FROM cqlvalue_udt_test", &[])
+        .await
+        .unwrap()
+        .into_rows_result()
+        .unwrap();
+
+    let (received_udt_cql_value,) = rows_result.single_row::<(CqlValue,)>().unwrap();
+
+    assert_eq!(received_udt_cql_value, udt_cql_value);
+}
+
+#[tokio::test]
+async fn test_cqlvalue_duration() {
+    setup_tracing();
+    let session: Session = create_new_session_builder().build().await.unwrap();
+
+    let ks = unique_keyspace_name();
+    session
+        .ddl(format!(
+            "CREATE KEYSPACE IF NOT EXISTS {} WITH REPLICATION = \
+                {{'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}}",
+            ks
+        ))
+        .await
+        .unwrap();
+    session.use_keyspace(&ks, false).await.unwrap();
+
+    let duration_cql_value = CqlValue::Duration(CqlDuration {
+        months: 6,
+        days: 9,
+        nanoseconds: 21372137,
+    });
+
+    session.ddl("CREATE TABLE IF NOT EXISTS cqlvalue_duration_test (pk int, ck int, v duration, primary key (pk, ck))").await.unwrap();
+    let fixture_queries = vec![
+        (
+            "INSERT INTO cqlvalue_duration_test (pk, ck, v) VALUES (0, 0, ?)",
+            vec![&duration_cql_value],
+        ),
+        (
+            "INSERT INTO cqlvalue_duration_test (pk, ck, v) VALUES (0, 1, 89h4m48s)",
+            vec![],
+        ),
+        (
+            "INSERT INTO cqlvalue_duration_test (pk, ck, v) VALUES (0, 2, PT89H8M53S)",
+            vec![],
+        ),
+        (
+            "INSERT INTO cqlvalue_duration_test (pk, ck, v) VALUES (0, 3, P0000-00-00T89:09:09)",
+            vec![],
+        ),
+    ];
+
+    for query in fixture_queries {
+        session.query_unpaged(query.0, query.1).await.unwrap();
+    }
+
+    let rows_result = session
+        .query_unpaged(
+            "SELECT v FROM cqlvalue_duration_test WHERE pk = ?",
+            (CqlValue::Int(0),),
+        )
+        .await
+        .unwrap()
+        .into_rows_result()
+        .unwrap();
+
+    let mut rows_iter = rows_result.rows::<(CqlValue,)>().unwrap();
+
+    let (first_value,) = rows_iter.next().unwrap().unwrap();
+    assert_eq!(first_value, duration_cql_value);
+
+    let (second_value,) = rows_iter.next().unwrap().unwrap();
+    assert_eq!(
+        second_value,
+        CqlValue::Duration(CqlDuration {
+            months: 0,
+            days: 0,
+            nanoseconds: 320_688_000_000_000,
+        })
+    );
+
+    let (third_value,) = rows_iter.next().unwrap().unwrap();
+    assert_eq!(
+        third_value,
+        CqlValue::Duration(CqlDuration {
+            months: 0,
+            days: 0,
+            nanoseconds: 320_933_000_000_000,
+        })
+    );
+
+    let (fourth_value,) = rows_iter.next().unwrap().unwrap();
+    assert_eq!(
+        fourth_value,
+        CqlValue::Duration(CqlDuration {
+            months: 0,
+            days: 0,
+            nanoseconds: 320_949_000_000_000,
+        })
+    );
+
+    assert_matches!(rows_iter.next(), None);
+}