Update sqlx dependencies to version 0.6.49-beta.4 and refactor database interaction in tests for improved clarity and consistency.

Author: lovasoa

Cargo.lock

@@ -18,7 +18,7 @@ panic = "abort"
 codegen-units = 2
 
 [dependencies]
-sqlx = { package = "sqlx-oldapi", version = "0.6.49-beta.3", default-features = false, features = [
+sqlx = { package = "sqlx-oldapi", version = "0.6.49-beta.4", default-features = false, features = [
     "any",
     "runtime-tokio-rustls",
     "migrate",

Cargo.toml

@@ -342,13 +342,12 @@ async fn test_sql_file_read_utf8() -> anyhow::Result<()> {
     let config = app_config::tests::test_config();
     let state = AppState::init(&config).await?;
     let create_table_sql = DbFsQueries::get_create_table_sql(state.db.info.database_type);
-    state
-        .db
-        .connection
-        .execute(format!("DROP TABLE IF EXISTS sqlpage_files; {create_table_sql}").as_str())
-        .await?;
+    let db = &state.db;
+    let conn = &db.connection;
+    conn.execute("DROP TABLE IF EXISTS sqlpage_files").await?;
+    conn.execute(create_table_sql).await?;
 
-    let dbms = state.db.info.kind;
+    let dbms = db.info.kind;
     let insert_sql = format!(
         "INSERT INTO sqlpage_files(path, contents) VALUES ({}, {})",
         make_placeholder(dbms, 1),
@@ -357,10 +356,10 @@ async fn test_sql_file_read_utf8() -> anyhow::Result<()> {
     sqlx::query(&insert_sql)
         .bind("unit test file.txt")
         .bind("Héllö world! 😀".as_bytes())
-        .execute(&state.db.connection)
+        .execute(conn)
         .await?;
 
-    let fs = FileSystem::init("/", &state.db).await;
+    let fs = FileSystem::init("/", &db).await;
     let actual = fs
         .read_to_string(&state, "unit test file.txt".as_ref(), false)
         .await?;

src/filesystem.rs

@@ -149,24 +149,24 @@ mod tests {
         let db_url = test_database_url();
         let mut c = sqlx::AnyConnection::connect(&db_url).await?;
         let row = sqlx::query(
-            "SELECT \
-            123.456 as one_value, \
-            1 as two_values, \
-            2 as two_values, \
-            'x' as three_values, \
-            'y' as three_values, \
-            'z' as three_values \
-        ",
+            r#"SELECT
+                123.456 as "ONE_VALUE",
+                1 as "TWO_VALUES",
+                2 as "TWO_VALUES",
+                'x' as "THREE_VALUES",
+                'y' as "THREE_VALUES",
+                'z' as "THREE_VALUES"
+        "#,
         )
         .fetch_one(&mut c)
         .await?;
-        assert_eq!(
-            row_to_json(&row),
-            serde_json::json!({
-                "one_value": 123.456,
-                "two_values": [1,2],
-                "three_values": ["x","y","z"],
-            })
+        expect_json_object_equal(
+            &row_to_json(&row),
+            &serde_json::json!({
+                "ONE_VALUE": 123.456,
+                "TWO_VALUES": [1,2],
+                "THREE_VALUES": ["x","y","z"],
+            }),
         );
         Ok(())
     }
@@ -466,7 +466,7 @@ mod tests {
     fn expect_json_object_equal(actual: &Value, expected: &Value) {
         use std::fmt::Write;
 
-        if actual == expected {
+        if json_values_equal(actual, expected) {
             return;
         }
         let actual = actual.as_object().unwrap();
@@ -480,7 +480,7 @@ mod tests {
         for key in all_keys {
             let actual_value = actual.get(key).unwrap_or(&Value::Null);
             let expected_value = expected.get(key).unwrap_or(&Value::Null);
-            if actual_value == expected_value {
+            if json_values_equal(actual_value, expected_value) {
                 continue;
             }
             writeln!(
@@ -494,4 +494,33 @@ mod tests {
             "JSON objects are not equal:\n\n{comparison_string}"
         );
     }
+
+    /// Compare JSON values, treating integers and floats that are numerically equal as equal
+    fn json_values_equal(a: &Value, b: &Value) -> bool {
+        use Value::*;
+
+        match (a, b) {
+            (Null, Null) => true,
+            (Bool(a), Bool(b)) => a == b,
+            (Number(a), Number(b)) => {
+                // Treat integers and floats as equal if they represent the same numerical value
+                a.as_f64() == b.as_f64()
+            }
+            (String(a), String(b)) => a == b,
+            (Array(a), Array(b)) => {
+                a.len() == b.len() && a.iter().zip(b.iter()).all(|(a, b)| json_values_equal(a, b))
+            }
+            (Object(a), Object(b)) => {
+                if a.len() != b.len() {
+                    return false;
+                }
+                a.iter().all(|(key, value)| {
+                    b.get(key).map_or(false, |expected_value| {
+                        json_values_equal(value, expected_value)
+                    })
+                })
+            }
+            _ => false,
+        }
+    }
 }