use crate::error::BaseError;
use crate::table::{
FieldConfig, FieldPermissions, FieldType, RelationConfig, RelationType, Validator,
};
use serde_json::json;
use std::collections::HashSet;
#[test]
fn test_field_config_new() {
let field = FieldConfig::new("username", FieldType::String { max_length: 50 });
assert_eq!(field.name, "username");
assert_eq!(field.display_name, "");
assert!(!field.required);
assert!(field.default_value.is_none());
assert!(field.validators.is_empty());
assert!(field.filterable);
assert!(field.sortable);
assert!(field.relation.is_none());
}
#[test]
fn test_field_config_builder() {
let field = FieldConfig::new("email", FieldType::String { max_length: 100 })
.display_name("邮箱")
.required(true)
.default_value(json!("default@example.com"))
.validator(Validator::Email)
.filterable(false)
.sortable(false);
assert_eq!(field.name, "email");
assert_eq!(field.display_name, "邮箱");
assert!(field.required);
assert_eq!(field.default_value, Some(json!("default@example.com")));
assert_eq!(field.validators.len(), 1);
assert!(!field.filterable);
assert!(!field.sortable);
}
#[test]
fn test_field_config_with_permissions() {
let permissions = FieldPermissions {
readable_roles: HashSet::from(["admin".to_string()]),
writable_roles: HashSet::from(["admin".to_string()]),
filterable_roles: HashSet::new(),
sortable_roles: HashSet::new(),
};
let field = FieldConfig::new("salary", FieldType::Double).permissions(permissions);
assert_eq!(field.permissions.readable_roles.len(), 1);
assert_eq!(field.permissions.writable_roles.len(), 1);
}
#[test]
fn test_field_config_with_relation() {
let relation = RelationConfig {
table: "users".to_string(),
field: "id".to_string(),
display_fields: vec!["username".to_string(), "email".to_string()],
relation_type: RelationType::OneToOne,
};
let field = FieldConfig::new("user_id", FieldType::BigInt).relation(relation);
assert!(field.relation.is_some());
let rel = field.relation.unwrap();
assert_eq!(rel.table, "users");
assert_eq!(rel.field, "id");
assert_eq!(rel.display_fields.len(), 2);
assert_eq!(rel.relation_type, RelationType::OneToOne);
}
#[test]
fn test_validate_required_field_success() {
let field = FieldConfig::new("username", FieldType::String { max_length: 50 }).required(true);
assert!(field.validate(&json!("alice")).is_ok());
}
#[test]
fn test_validate_required_field_null() {
let field = FieldConfig::new("username", FieldType::String { max_length: 50 }).required(true);
let result = field.validate(&json!(null));
assert!(result.is_err());
if let Err(BaseError::FieldRequired(field_name)) = result {
assert_eq!(field_name, "username");
} else {
panic!("期望 FieldRequired 错误");
}
}
#[test]
fn test_validate_optional_field_null() {
let field = FieldConfig::new("nickname", FieldType::String { max_length: 50 }).required(false);
assert!(field.validate(&json!(null)).is_ok());
}
#[test]
fn test_validate_field_type() {
let field = FieldConfig::new("age", FieldType::Integer).required(true);
assert!(field.validate(&json!(25)).is_ok());
assert!(field.validate(&json!("not a number")).is_err());
}
#[test]
fn test_validate_with_validators() {
let field = FieldConfig::new("username", FieldType::String { max_length: 50 })
.required(true)
.validator(Validator::MinLength(3))
.validator(Validator::MaxLength(20));
assert!(field.validate(&json!("alice")).is_ok());
assert!(field.validate(&json!("ab")).is_err());
assert!(field
.validate(&json!("this_is_a_very_long_username"))
.is_err());
}
#[test]
fn test_validate_chain() {
let field = FieldConfig::new("email", FieldType::String { max_length: 100 })
.required(true)
.validator(Validator::Email);
assert!(field.validate(&json!("user@example.com")).is_ok());
assert!(field.validate(&json!(null)).is_err());
assert!(field.validate(&json!(123)).is_err());
assert!(field.validate(&json!("invalid")).is_err());
}
#[test]
fn test_validate_enum_field() {
let field = FieldConfig::new(
"status",
FieldType::Enum {
values: vec!["active".to_string(), "inactive".to_string()],
},
)
.required(true);
assert!(field.validate(&json!("active")).is_ok());
assert!(field.validate(&json!("inactive")).is_ok());
assert!(field.validate(&json!("invalid")).is_err());
}
#[test]
fn test_field_permissions_default() {
let permissions = FieldPermissions::default();
let user_roles = HashSet::from(["user".to_string()]);
assert!(permissions.can_read(&user_roles));
assert!(permissions.can_write(&user_roles));
assert!(permissions.can_filter(&user_roles));
assert!(permissions.can_sort(&user_roles));
}
#[test]
fn test_field_permissions_can_read() {
let permissions = FieldPermissions {
readable_roles: HashSet::from(["admin".to_string(), "user".to_string()]),
..Default::default()
};
assert!(permissions.can_read(&HashSet::from(["admin".to_string()])));
assert!(permissions.can_read(&HashSet::from(["user".to_string()])));
assert!(!permissions.can_read(&HashSet::from(["guest".to_string()])));
assert!(permissions.can_read(&HashSet::from(["guest".to_string(), "user".to_string()])));
}
#[test]
fn test_field_permissions_can_write() {
let permissions = FieldPermissions {
writable_roles: HashSet::from(["admin".to_string()]),
..Default::default()
};
assert!(permissions.can_write(&HashSet::from(["admin".to_string()])));
assert!(!permissions.can_write(&HashSet::from(["user".to_string()])));
}
#[test]
fn test_field_permissions_can_filter() {
let permissions = FieldPermissions {
filterable_roles: HashSet::from(["admin".to_string()]),
..Default::default()
};
assert!(permissions.can_filter(&HashSet::from(["admin".to_string()])));
assert!(!permissions.can_filter(&HashSet::from(["user".to_string()])));
}
#[test]
fn test_field_permissions_can_sort() {
let permissions = FieldPermissions {
sortable_roles: HashSet::from(["admin".to_string()]),
..Default::default()
};
assert!(permissions.can_sort(&HashSet::from(["admin".to_string()])));
assert!(!permissions.can_sort(&HashSet::from(["user".to_string()])));
}
#[test]
fn test_field_permissions_empty_roles() {
let permissions = FieldPermissions {
readable_roles: HashSet::new(),
writable_roles: HashSet::new(),
filterable_roles: HashSet::new(),
sortable_roles: HashSet::new(),
};
let any_roles = HashSet::from(["any_role".to_string()]);
assert!(permissions.can_read(&any_roles));
assert!(permissions.can_write(&any_roles));
assert!(permissions.can_filter(&any_roles));
assert!(permissions.can_sort(&any_roles));
}
#[test]
fn test_relation_config_one_to_one() {
let relation = RelationConfig {
table: "users".to_string(),
field: "id".to_string(),
display_fields: vec!["username".to_string()],
relation_type: RelationType::OneToOne,
};
assert_eq!(relation.table, "users");
assert_eq!(relation.field, "id");
assert_eq!(relation.display_fields.len(), 1);
assert_eq!(relation.relation_type, RelationType::OneToOne);
}
#[test]
fn test_relation_config_one_to_many() {
let relation = RelationConfig {
table: "posts".to_string(),
field: "user_id".to_string(),
display_fields: vec!["title".to_string(), "content".to_string()],
relation_type: RelationType::OneToMany,
};
assert_eq!(relation.relation_type, RelationType::OneToMany);
}
#[test]
fn test_relation_config_many_to_many() {
let relation = RelationConfig {
table: "tags".to_string(),
field: "id".to_string(),
display_fields: vec!["name".to_string()],
relation_type: RelationType::ManyToMany,
};
assert_eq!(relation.relation_type, RelationType::ManyToMany);
}