#[derive(Dearbitrary)]

这个库实现了自动派生Dearbitrary trait的支持。

不过不要直接依赖这个crate，而是启用dearbitrary crate的"derive"特性。

安装

在项目目录中运行以下Cargo命令：

cargo add derive_dearbitrary

或者在Cargo.toml中添加以下行：

derive_dearbitrary = "1.2.0"

使用示例

下面是一个完整的示例，展示如何使用derive_dearbitrary进行反序列化和自动化测试：

use dearbitrary::{Dearbitrary, Arbitrary};
use serde::{Serialize, Deserialize};

// 定义一个结构体并派生所需的trait
#[derive(Dearbitrary, Arbitrary, Serialize, Deserialize, Debug)]
struct TestStruct {
    field1: u32,
    field2: String,
    #[dearbitrary(default = "default_value")]
    field3: Option<String>,
}

// 为可选字段提供默认值
fn default_value() -> Option<String> {
    Some("default".to_string())
}

fn main() {
    // 生成随机测试实例
    let test_instance = TestStruct::arbitrary();
    println!("Generated instance: {:?}", test_instance);
    
    // 序列化测试
    let serialized = serde_json::to_string(&test_instance).unwrap();
    println!("Serialized: {}", serialized);
    
    // 反序列化测试
    let deserialized: TestStruct = serde_json::from_str(&serialized).unwrap();
    println!("Deserialized: {:?}", deserialized);
}

#[cfg(test)]
mod tests {
    use super::*;
    use quickcheck::{Arbitrary, Gen};
    
    #[test]
    fn test_serialization_roundtrip() {
        quickcheck::quickcheck(|mut g: Gen| {
            let instance = TestStruct::arbitrary(&mut g);
            let serialized = serde_json::to_string(&instance).unwrap();
            let deserialized: TestStruct = serde_json::from_str(&serialized).unwrap();
            assert_eq!(instance.field1, deserialized.field1);
            assert_eq!(instance.field2, deserialized.field2);
            assert_eq!(instance.field3, deserialized.field3);
        });
    }
}

完整示例

以下是一个更完整的示例，展示了derive_dearbitrary在实际项目中的使用场景：

use dearbitrary::{Dearbitrary, Arbitrary};
use serde::{Serialize, Deserialize};
use rand::Rng;

// 定义一个用户结构体
#[derive(Dearbitrary, Arbitrary, Serialize, Deserialize, Debug, PartialEq)]
struct User {
    id: u64,
    username: String,
    #[dearbitrary(default = "default_email")]
    email: Option<String>,
    #[dearbitrary(bound = "Vec<u8>")]
    permissions: Vec<u8>,
    #[dearbitrary(default = "default_active")]
    is_active: bool,
}

// 提供默认邮箱
fn default_email() -> Option<String> {
    Some("user@example.com".to_string())
}

// 提供默认激活状态
fn default_active() -> bool {
    true
}

fn main() {
    // 生成随机用户实例
    let user = User::arbitrary();
    println!("Generated user: {:?}", user);
    
    // 序列化为JSON
    let json = serde_json::to_string_pretty(&user).unwrap();
    println!("Serialized JSON:\n{}", json);
    
    // 从JSON反序列化
    let parsed_user: User = serde_json::from_str(&json).unwrap();
    println!("Parsed user: {:?}", parsed_user);
    
    // 验证数据一致性
    assert_eq!(user.id, parsed_user.id);
    assert_eq!(user.username, parsed_user.username);
}

#[cfg(test)]
mod tests {
    use super::*;
    use quickcheck::{Arbitrary, Gen, quickcheck};
    
    // 测试默认值是否应用正确
    #[test]
    fn test_default_values() {
        let user = User::arbitrary();
        assert!(user.email.is_some());
        assert!(user.is_active);
    }
    
    // 测试序列化往返
    quickcheck! {
        fn test_serialization_roundtrip(user: User) -> bool {
            let serialized = serde_json::to_string(&user).unwrap();
            let deserialized: User = serde_json::from_str(&serialized).unwrap();
            user == deserialized
        }
    }
    
    // 测试权限字段的边界
    #[test]
    fn test_permissions_bound() {
        let mut gen = Gen::new(100);
        let user = User::arbitrary(&mut gen);
        assert!(user.permissions.len() <= 100);
    }
}

特性说明

1. 通过#[derive(Dearbitrary)]自动实现反序列化逻辑
2. 与quickcheck等测试框架集成，支持属性测试
3. 支持为字段指定默认值
4. 与serde的序列化/反序列化完全兼容
5. 支持为特定字段添加类型边界约束
6. 支持复杂的自定义类型验证

许可证

MIT OR Apache-2.0