From e5483ba49a8a7f41b68a6b5abaa1c9b184d0ea04 Mon Sep 17 00:00:00 2001 From: TommyLike Date: Fri, 21 Jul 2023 23:54:14 +0800 Subject: [PATCH] Add more testcases --- src/domain/datakey/entity.rs | 2 +- src/domain/token/entity.rs | 25 ++++++ src/domain/user/entity.rs | 20 +++++ src/infra/database/model/clusterkey/dto.rs | 45 +++++++++++ src/infra/database/model/datakey/dto.rs | 77 +++++++++++++++++++ .../database/model/request_delete/dto.rs | 45 ++++++++++- src/infra/database/model/token/dto.rs | 43 ++++++++++- 7 files changed, 254 insertions(+), 3 deletions(-) diff --git a/src/domain/datakey/entity.rs b/src/domain/datakey/entity.rs index 23cb900..e86cce6 100644 --- a/src/domain/datakey/entity.rs +++ b/src/domain/datakey/entity.rs @@ -175,7 +175,7 @@ impl X509CRL { } } -#[derive(Debug, Clone)] +#[derive(Debug, Clone, PartialEq)] pub enum X509RevokeReason { Unspecified, KeyCompromise, diff --git a/src/domain/token/entity.rs b/src/domain/token/entity.rs index 1c17f56..d6087bc 100644 --- a/src/domain/token/entity.rs +++ b/src/domain/token/entity.rs @@ -54,3 +54,28 @@ impl Token { }) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_new_token() { + let token = Token::new(1, "Test".to_string(), "abc123".to_string()).unwrap(); + assert_eq!(token.id, 0); + assert_eq!(token.user_id, 1); + assert_eq!(token.description, "Test"); + assert_eq!(token.token, "abc123"); + assert!(token.create_at < Utc::now()); + assert_eq!(token.expire_at, token.create_at + Duration::days(TOKEN_EXPIRE_IN_DAYS)); + } + + #[test] + fn test_token_display() { + let token = Token::new(1, "Test".to_string(), "abc123".to_string()).unwrap(); + let expected = format!("id: {}, user_id: {}, expire_at: {}", + token.id, token.user_id, token.expire_at); + assert_eq!(expected, format!("{}", token)); + } +} + diff --git a/src/domain/user/entity.rs b/src/domain/user/entity.rs index aa9653c..0541e37 100644 --- a/src/domain/user/entity.rs +++ b/src/domain/user/entity.rs @@ -44,3 +44,23 @@ impl User { }) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_new_user() { + let user = User::new("test@example.com".to_string()).unwrap(); + assert_eq!(user.id, 0); + assert_eq!(user.email, "test@example.com"); + } + + #[test] + fn test_user_display() { + let user = User::new("test@example.com".to_string()).unwrap(); + let expected = format!("id: {}, email: {}", user.id, user.email); + assert_eq!(expected, format!("{}", user)); + } +} + diff --git a/src/infra/database/model/clusterkey/dto.rs b/src/infra/database/model/clusterkey/dto.rs index e9a8864..659268c 100644 --- a/src/infra/database/model/clusterkey/dto.rs +++ b/src/infra/database/model/clusterkey/dto.rs @@ -52,3 +52,48 @@ impl From for ClusterKeyDTO { } } } + +#[cfg(test)] +mod tests { + use chrono::Utc; + use super::{ClusterKey,ClusterKeyDTO}; + + #[test] + fn test_cluster_key_dto_from_entity() { + let key = ClusterKey { + id: 1, + data: vec![1, 2, 3], + algorithm: "algo".to_string(), + identity: "id".to_string(), + create_at: Utc::now() + }; + let create_at = key.create_at.clone(); + let dto = ClusterKeyDTO::from(key); + assert_eq!(dto.id, 1); + assert_eq!(dto.data, vec![1, 2, 3]); + assert_eq!(dto.algorithm, "algo"); + assert_eq!(dto.identity, "id"); + assert_eq!(dto.create_at, create_at); + } + + #[test] + fn test_cluster_key_entity_from_dto() { + let dto = ClusterKeyDTO { + id: 1, + data: vec![1, 2, 3], + algorithm: "algo".to_string(), + identity: "id".to_string(), + create_at: Utc::now() + }; + + let create_at = dto.create_at.clone(); + let key = ClusterKey::from(dto); + assert_eq!(key.id, 1); + assert_eq!(key.data, vec![1, 2, 3]); + assert_eq!(key.algorithm, "algo"); + assert_eq!(key.identity, "id"); + assert_eq!(key.create_at, create_at); + } + +} + diff --git a/src/infra/database/model/datakey/dto.rs b/src/infra/database/model/datakey/dto.rs index 5dcfad0..289f00d 100644 --- a/src/infra/database/model/datakey/dto.rs +++ b/src/infra/database/model/datakey/dto.rs @@ -153,3 +153,80 @@ impl TryFrom for X509CRLDTO { }) } } + +#[cfg(test)] +mod tests { + use std::collections::HashMap; + use super::*; + use crate::domain::datakey::entity::{Visibility}; + + #[test] + fn test_data_key_dto_from_entity() { + let key = DataKey{ + id: 0, + name: "Test Key".to_string(), + visibility: Visibility::Public, + description: "test key description".to_string(), + user: 0, + attributes: HashMap::new(), + key_type: KeyType::OpenPGP, + parent_id: None, + fingerprint: "".to_string(), + serial_number: None, + private_key: vec![1,2,3], + public_key: vec![4,5,6], + certificate: vec![7,8,9,10], + create_at: Utc::now(), + expire_at: Utc::now(), + key_state: KeyState::Disabled, + user_email: None, + request_delete_users: None, + request_revoke_users: None, + parent_key: None, + }; + let dto = DataKeyDTO::try_from(key).unwrap(); + assert_eq!(dto.id, 0); + assert_eq!(dto.name, "Test Key"); + assert_eq!(dto.visibility, Visibility::Public.to_string()); + assert_eq!(dto.key_state, KeyState::Disabled.to_string()); + assert_eq!(dto.private_key, "010203"); + assert_eq!(dto.public_key, "040506"); + assert_eq!(dto.certificate, "0708090A"); + } + + #[test] + fn test_data_key_entity_from_dto() { + let dto = DataKeyDTO { + id: 1, + name: "Test Key".to_string(), + description: "".to_string(), + visibility: Visibility::Public.to_string(), + user: 0, + attributes: "{}".to_string(), + key_type: "pgp".to_string(), + parent_id: None, + fingerprint: "".to_string(), + serial_number: None, + private_key: "0708090A".to_string(), + public_key: "040506".to_string(), + certificate: "010203".to_string(), + create_at: Utc::now(), + expire_at: Utc::now(), + key_state: "disabled".to_string(), + user_email: None, + request_delete_users: None, + request_revoke_users: None, + x509_crl_update_at: None, + }; + let key = DataKey::try_from(dto).unwrap(); + assert_eq!(key.id, 1); + assert_eq!(key.name, "Test Key"); + assert_eq!(key.visibility, Visibility::Public); + assert_eq!(key.key_type, KeyType::OpenPGP); + assert_eq!(key.private_key, vec![7,8,9,10]); + assert_eq!(key.public_key, vec![4,5,6]); + assert_eq!(key.certificate, vec![1,2,3]); + } + +} + diff --git a/src/infra/database/model/request_delete/dto.rs b/src/infra/database/model/request_delete/dto.rs index 72438a8..3bf334e 100644 --- a/src/infra/database/model/request_delete/dto.rs +++ b/src/infra/database/model/request_delete/dto.rs @@ -121,4 +121,47 @@ impl PendingOperationDTO { request_type: RequestType::Revoke, } } -} \ No newline at end of file +} + +#[cfg(test)] +mod tests { + use super::*; + use chrono::Utc; + + #[test] + fn test_request_type_display() { + let delete = RequestType::Delete; + assert_eq!(format!("{}", delete), "delete"); + + let revoke = RequestType::Revoke; + assert_eq!(format!("{}", revoke), "revoke"); + } + + #[test] + fn test_request_type_from_str() { + let delete = RequestType::from_str("delete").unwrap(); + assert_eq!(delete, RequestType::Delete); + + let revoke = RequestType::from_str("revoke").unwrap(); + assert_eq!(revoke, RequestType::Revoke); + } + + #[test] + fn test_revoked_key_dto_conversion() { + let now = Utc::now(); + let dto = RevokedKeyDTO::new(1, 2, X509RevokeReason::KeyCompromise); + let revoked_key = RevokedKey::try_from(dto).unwrap(); + assert_eq!(revoked_key.key_id, 1); + assert_eq!(revoked_key.ca_id, 2); + assert_eq!(revoked_key.reason, X509RevokeReason::KeyCompromise); + assert!(revoked_key.create_at > now); + } + + #[test] + fn test_pending_operation_dto() { + let delete_dto = PendingOperationDTO::new_for_delete(1, 2, "test@email.com".into()); + assert_eq!(delete_dto.request_type, RequestType::Delete); + let revoke_dto = PendingOperationDTO::new_for_revoke(3, 4, "test2@email.com".into()); + assert_eq!(revoke_dto.request_type, RequestType::Revoke); + } +} diff --git a/src/infra/database/model/token/dto.rs b/src/infra/database/model/token/dto.rs index 88c1389..12084a6 100644 --- a/src/infra/database/model/token/dto.rs +++ b/src/infra/database/model/token/dto.rs @@ -19,7 +19,7 @@ use chrono::{DateTime, Utc}; use crate::domain::token::entity::Token; use crate::util::key::get_token_hash; -#[derive(Debug, FromRow)] +#[derive(Debug, FromRow, Clone)] pub(super) struct TokenDTO { pub id: i32, pub user_id: i32, @@ -54,3 +54,44 @@ impl From for Token { } } } + +#[cfg(test)] +mod tests { + use super::*; + use chrono::Utc; + + #[test] + fn test_token_dto_from_entity() { + let token = Token::new(1, "Test token".to_string(), "abc123".to_string()).unwrap(); + let token_hash = get_token_hash(&token.token); + let dto = TokenDTO::from(token.clone()); + assert_eq!(dto.id, token.id); + assert_eq!(dto.user_id, token.user_id); + assert_eq!(dto.description, token.description); + assert_ne!(dto.token, token.token); + assert_eq!(dto.token, token_hash); + assert_eq!(dto.create_at, token.create_at); + assert_eq!(dto.expire_at, token.expire_at); + } + + #[test] + fn test_token_entity_from_dto() { + let now = Utc::now(); + let dto = TokenDTO { + id: 1, + user_id: 2, + description: "Test token".to_string(), + token: "hashedtoken".to_string(), + create_at: now, + expire_at: now + chrono::Duration::days(1) + }; + let token = Token::from(dto.clone()); + assert_eq!(token.id, dto.id); + assert_eq!(token.user_id, dto.user_id); + assert_eq!(token.description, dto.description); + assert_eq!(token.token, dto.token); + assert_eq!(token.create_at, dto.create_at); + assert_eq!(token.expire_at, dto.expire_at); + } +} + -- Gitee