chore: add tests, fix tests

Author: bitfl0wer

…684391b14eaaf1946237e13c3a939bd8a10.json …f04555db3ebb9ffaf1ad53e5169c2fcf4b1.json.sqlx/query-9c4bfdb692922504b9a008b8504c5684391b14eaaf1946237e13c3a939bd8a10.json renamed to .sqlx/query-00736c782f4b8b83e6c8d0c207fc0f04555db3ebb9ffaf1ad53e5169c2fcf4b1.json .sqlx/query-9c4bfdb692922504b9a008b8504c5684391b14eaaf1946237e13c3a939bd8a10.json renamed to .sqlx/query-00736c782f4b8b83e6c8d0c207fc0f04555db3ebb9ffaf1ad53e5169c2fcf4b1.json

@@ -2,7 +2,7 @@
 -- Contains data for testing HomeServerCert::get_idcert_by method
 
 -- Algorithm identifiers including ED25519
-INSERT INTO algorithm_identifiers (id, algorithm_identifier, common_name, parameters) VALUES
+INSERT INTO algorithm_identifiers (id, algorithm_identifier, common_name, parameters_der_encoded) VALUES
 (1, 'rsaEncryption', 'RSA', NULL),
 (2, 'id-ecPublicKey', 'EC', NULL),
 (3, '1.3.101.112', 'Edwards-curve Digital Signature Algorithm (EdDSA) Ed25519', NULL);

fixtures/idcert_integration_tests.sql

@@ -2,7 +2,7 @@
 -- This builds on the basic actor setup and adds specific test data for LocalActor methods
 
 -- Algorithm identifiers for public keys (needed for actor setup)
-INSERT INTO algorithm_identifiers (id, algorithm_identifier, common_name, parameters) VALUES
+INSERT INTO algorithm_identifiers (id, algorithm_identifier, common_name, parameters_der_encoded) VALUES
 (1, 'rsaEncryption', 'RSA', NULL),
 (2, 'id-ecPublicKey', 'EC', NULL);
 

fixtures/local_actor_tests.sql

@@ -2,7 +2,7 @@
 -- Contains common database setup that can be reused across multiple test scenarios
 
 -- Algorithm identifiers for public keys
-INSERT INTO algorithm_identifiers (id, algorithm_identifier, common_name, parameters) VALUES
+INSERT INTO algorithm_identifiers (id, algorithm_identifier, common_name, parameters_der_encoded) VALUES
 (1, 'rsaEncryption', 'RSA', NULL),
 (2, 'id-ecPublicKey', 'EC', NULL);
 

fixtures/tokens_base_fixture.sql

@@ -56,6 +56,11 @@ impl AlgorithmIdentifier {
         }
         let parameters_der_encoded_reformatted =
             parameters_der_encoded.into_iter().map(|num| *num as i16).collect::<Vec<_>>();
+        let parameters_for_query = if parameters_der_encoded_reformatted.is_empty() {
+            None
+        } else {
+            Some(parameters_der_encoded_reformatted.as_slice())
+        };
         let record = query!(
             r#"
             SELECT id, algorithm_identifier, common_name, parameters_der_encoded
@@ -64,12 +69,12 @@ impl AlgorithmIdentifier {
                 ($1::int IS NULL OR id = $1)
                 AND ($2::text IS NULL OR algorithm_identifier = $2)
                 AND ($3::text IS NULL OR common_name = $3)
-                AND ($4::smallint [] IS NULL OR parameters_der_encoded = $4)
+                AND ($4::smallint [] IS NULL OR parameters_der_encoded = $4 OR (parameters_der_encoded IS NULL AND $4::smallint [] = '{}'))
             "#,
             id,
             algorithm_identifier.map(|a| a.to_string()),
             common_name,
-            &parameters_der_encoded_reformatted,
+            parameters_for_query,
         )
         .fetch_all(&db.pool)
         .await?;

src/database/algorithm_identifier.rs

@@ -153,3 +153,232 @@ impl PublicKeyInfo {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use sqlx::{Pool, Postgres};
+
+    use super::*;
+    use crate::crypto::ed25519::{DigitalPublicKey, DigitalSignature, generate_keypair};
+
+    #[sqlx::test(fixtures("../../fixtures/tokens_base_fixture.sql"))]
+    async fn test_get_by_empty_parameters(pool: Pool<Postgres>) {
+        let db = Database { pool };
+
+        let result = PublicKeyInfo::get_by(&db, None, None, None, None).await.unwrap();
+
+        assert!(result.is_empty(), "Expected empty result when all parameters are None");
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/tokens_base_fixture.sql"))]
+    async fn test_get_by_id(pool: Pool<Postgres>) {
+        let db = Database { pool };
+
+        let result = PublicKeyInfo::get_by(&db, None, None, None, Some(1)).await.unwrap();
+
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].id(), 1);
+        assert_eq!(
+            result[0].uaid,
+            Some(Uuid::from_str("00000000-0000-0000-0000-000000000001").unwrap())
+        );
+        assert_eq!(result[0].pubkey, "test_pubkey_1");
+        assert_eq!(result[0].algorithm_identifier, 1);
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/tokens_base_fixture.sql"))]
+    async fn test_get_by_uaid(pool: Pool<Postgres>) {
+        let db = Database { pool };
+        let test_uaid = Uuid::from_str("00000000-0000-0000-0000-000000000002").unwrap();
+
+        let result = PublicKeyInfo::get_by(&db, Some(test_uaid), None, None, None).await.unwrap();
+
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].uaid, Some(test_uaid));
+        assert_eq!(result[0].pubkey, "test_pubkey_2");
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/tokens_base_fixture.sql"))]
+    async fn test_get_by_pubkey(pool: Pool<Postgres>) {
+        let db = Database { pool };
+
+        let result =
+            PublicKeyInfo::get_by(&db, None, Some("test_pubkey_3".to_string()), None, None)
+                .await
+                .unwrap();
+
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].pubkey, "test_pubkey_3");
+        assert_eq!(
+            result[0].uaid,
+            Some(Uuid::from_str("00000000-0000-0000-0000-000000000003").unwrap())
+        );
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/tokens_base_fixture.sql"))]
+    async fn test_get_by_algorithm_identifier(pool: Pool<Postgres>) {
+        let db = Database { pool };
+
+        let result = PublicKeyInfo::get_by(&db, None, None, Some(1), None).await.unwrap();
+
+        // Should find all public keys with algorithm_identifier = 1 (RSA)
+        assert!(result.len() >= 6); // Based on the fixture data
+        for key_info in &result {
+            assert_eq!(key_info.algorithm_identifier, 1);
+        }
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/tokens_base_fixture.sql"))]
+    async fn test_get_by_multiple_parameters(pool: Pool<Postgres>) {
+        let db = Database { pool };
+        let test_uaid = Uuid::from_str("00000000-0000-0000-0000-000000000001").unwrap();
+
+        let result =
+            PublicKeyInfo::get_by(&db, Some(test_uaid), None, Some(1), None).await.unwrap();
+
+        // Should find public keys for user 1 with algorithm_identifier = 1
+        assert_eq!(result.len(), 2); // User 1 has 2 keys in the fixture
+        for key_info in &result {
+            assert_eq!(key_info.uaid, Some(test_uaid));
+            assert_eq!(key_info.algorithm_identifier, 1);
+        }
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/tokens_base_fixture.sql"))]
+    async fn test_get_by_nonexistent_data(pool: Pool<Postgres>) {
+        let db = Database { pool };
+        let nonexistent_uaid = Uuid::from_str("99999999-9999-9999-9999-999999999999").unwrap();
+
+        let result =
+            PublicKeyInfo::get_by(&db, Some(nonexistent_uaid), None, None, None).await.unwrap();
+
+        assert!(result.is_empty(), "Expected empty result for nonexistent UAID");
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/tokens_base_fixture.sql"))]
+    async fn test_insert_new_key_with_uaid(pool: Pool<Postgres>) {
+        let db = Database { pool };
+        let (_private_key, public_key) = generate_keypair();
+        let test_uaid = Uuid::from_str("00000000-0000-0000-0000-000000000001").unwrap();
+
+        let result = PublicKeyInfo::insert::<DigitalSignature, DigitalPublicKey>(
+            &db,
+            &public_key,
+            Some(test_uaid),
+        )
+        .await;
+
+        // This should fail because Ed25519 is not in the base fixture (only RSA and EC)
+        assert!(result.is_err(), "Expected error because Ed25519 algorithm is not in the fixture");
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/tokens_base_fixture.sql"))]
+    async fn test_insert_new_key_without_uaid(pool: Pool<Postgres>) {
+        let db = Database { pool };
+        let (_private_key, public_key) = generate_keypair();
+
+        let result =
+            PublicKeyInfo::insert::<DigitalSignature, DigitalPublicKey>(&db, &public_key, None)
+                .await;
+
+        // This should fail because Ed25519 is not in the base fixture
+        assert!(result.is_err(), "Expected error because Ed25519 algorithm is not in the fixture");
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/idcert_integration_tests.sql"))]
+    async fn test_insert_ed25519_key_success(pool: Pool<Postgres>) {
+        let db = Database { pool };
+        let (_private_key, public_key) = generate_keypair();
+        let test_uaid = Uuid::from_str("00000000-0000-0000-0000-000000000010").unwrap();
+
+        let result = PublicKeyInfo::insert::<DigitalSignature, DigitalPublicKey>(
+            &db,
+            &public_key,
+            Some(test_uaid),
+        )
+        .await;
+
+        match result {
+            Ok(key_info) => {
+                assert_eq!(key_info.uaid, Some(test_uaid));
+                assert_eq!(key_info.algorithm_identifier, 3); // Ed25519 algorithm ID from idcert fixture
+                assert!(key_info.id() > 0, "Expected positive ID for inserted key");
+            }
+            Err(e) => {
+                panic!("Expected successful insertion with Ed25519 key, but got error: {e:?}");
+            }
+        }
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/idcert_integration_tests.sql"))]
+    async fn test_insert_duplicate_key_error(pool: Pool<Postgres>) {
+        let db = Database { pool };
+        let (_private_key, public_key) = generate_keypair();
+        let test_uaid = Uuid::from_str("00000000-0000-0000-0000-000000000010").unwrap();
+
+        // Insert the key once
+        let first_result = PublicKeyInfo::insert::<DigitalSignature, DigitalPublicKey>(
+            &db,
+            &public_key,
+            Some(test_uaid),
+        )
+        .await;
+        assert!(first_result.is_ok(), "First insertion should succeed");
+
+        // Try to insert the same key again
+        let second_result = PublicKeyInfo::insert::<DigitalSignature, DigitalPublicKey>(
+            &db,
+            &public_key,
+            Some(test_uaid),
+        )
+        .await;
+        assert!(second_result.is_err(), "Second insertion should fail due to duplicate");
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/idcert_integration_tests.sql"))]
+    async fn test_insert_with_nonexistent_uaid(pool: Pool<Postgres>) {
+        let db = Database { pool };
+        let (_private_key, public_key) = generate_keypair();
+        let nonexistent_uaid = Uuid::from_str("99999999-9999-9999-9999-999999999999").unwrap();
+
+        let result = PublicKeyInfo::insert::<DigitalSignature, DigitalPublicKey>(
+            &db,
+            &public_key,
+            Some(nonexistent_uaid),
+        )
+        .await;
+
+        assert!(result.is_err(), "Expected error when inserting with nonexistent UAID");
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/idcert_integration_tests.sql"))]
+    async fn test_get_by_after_insert(pool: Pool<Postgres>) {
+        let db = Database { pool };
+        let (_private_key, public_key) = generate_keypair();
+        let test_uaid = Uuid::from_str("00000000-0000-0000-0000-000000000011").unwrap();
+
+        // Insert a new key
+        let inserted_key = PublicKeyInfo::insert::<DigitalSignature, DigitalPublicKey>(
+            &db,
+            &public_key,
+            Some(test_uaid),
+        )
+        .await
+        .unwrap();
+
+        // Retrieve it using get_by
+        let retrieved_keys =
+            PublicKeyInfo::get_by(&db, None, None, None, Some(inserted_key.id() as i32))
+                .await
+                .unwrap();
+
+        assert_eq!(retrieved_keys.len(), 1);
+        let retrieved_key = &retrieved_keys[0];
+        assert_eq!(retrieved_key.id(), inserted_key.id());
+        assert_eq!(retrieved_key.uaid, inserted_key.uaid);
+        assert_eq!(retrieved_key.pubkey, inserted_key.pubkey);
+        assert_eq!(retrieved_key.algorithm_identifier, inserted_key.algorithm_identifier);
+    }
+}