Rust屬性測試實戰：用Proptest在上線前發現5類隱藏邊界Bug

编程语言

Rust屬性測試：為什麼單元測試永遠不夠

寫了幾百個單元測試，還是被邊界值Bug打臉？i32::MAX + 1溢位、空字串解析崩潰、併發競爭條件——這些Bug的共同特點是你不會主動測試那些極端輸入。屬性測試（Property-Based Testing）透過自動生成大量隨機輸入，驗證程式碼的「屬性」（不變量）是否始終成立。2026年，Rust的proptest庫已成熟，支援策略定義→自動縮小→狀態機測試→迴歸持久化。

本文將從5個核心模式出發，帶你完成策略設計→屬性驗證→狀態測試→迴歸持久化→模糊測試整合的全鏈路實戰。

核心概念

概念 說明
Property 程式碼應始終滿足的不變量/屬性
Strategy 生成隨機測試輸入的策略
Shrinking 測試失敗時自動縮小到最小失敗用例
Stateful Testing 基於狀態機的屬性測試
Regression 持久化失敗用例，防止迴歸
Arbitraries 預定義的隨機生成器
PropTest Rust屬性測試框架
Fuzz Testing 模糊測試，與屬性測試互補

問題分析：屬性測試解決的5類Bug

  1. 整數溢位：i32::MAX + 1、usize::MAX等邊界值
  2. 字串解析：空串、超長串、非法UTF-8、特殊字元
  3. 併發競爭：多執行緒下的資料競爭和死結
  4. 狀態機違規：狀態轉換不符合預期
  5. API契約違反：函式傳回值不符合文件承諾

分步實操：5個Rust屬性測試核心模式

模式1：Proptest基礎與策略定義

# Cargo.toml
[dependencies]
proptest = "1.5"

// src/parser.rs
pub fn parse_coordinate(input: &str) -> Result<(f64, f64), ParseError> {
    let parts: Vec<&str> = input.split(',').collect();
    if parts.len() != 2 {
        return Err(ParseError::InvalidFormat);
    }
    let lat: f64 = parts[0].trim().parse().map_err(|_| ParseError::InvalidLatitude)?;
    let lng: f64 = parts[1].trim().parse().map_err(|_| ParseError::InvalidLongitude)?;
    if !(-90.0..=90.0).contains(&lat) {
        return Err(ParseError::InvalidLatitude);
    }
    if !(-180.0..=180.0).contains(&lng) {
        return Err(ParseError::InvalidLongitude);
    }
    Ok((lat, lng))
}

#[derive(Debug, PartialEq)]
pub enum ParseError {
    InvalidFormat,
    InvalidLatitude,
    InvalidLongitude,
}

// tests/parser_proptest.rs
use proptest::prelude::*;
use myapp::parser::{parse_coordinate, ParseError};

proptest! {
    #[test]
    fn test_valid_coordinates(lat in -90.0f64..90.0, lng in -180.0f64..180.0) {
        let input = format!("{},{}", lat, lng);
        let result = parse_coordinate(&input);
        prop_assert!(result.is_ok());
        let (parsed_lat, parsed_lng) = result.unwrap();
        prop_assert!((parsed_lat - lat).abs() < 1e-10);
        prop_assert!((parsed_lng - lng).abs() < 1e-10);
    }

    #[test]
    fn test_invalid_latitude(lat in 90.1f64..1000.0) {
        let input = format!("{},0.0", lat);
        let result = parse_coordinate(&input);
        prop_assert!(matches!(result, Err(ParseError::InvalidLatitude)));
    }

    #[test]
    fn test_roundtrip_any_string(input in ".*") {
        let _ = parse_coordinate(&input);
    }
}

模式2：自定義策略與組合器

// tests/custom_strategy.rs
use proptest::prelude::*;

#[derive(Debug, Clone)]
struct User {
    id: u64,
    name: String,
    email: String,
    age: u8,
}

fn user_strategy() -> impl Strategy<Value = User> {
    (
        any::<u64>(),
        "[a-zA-Z]{3,20}",
        "[a-z]{3,10}@[a-z]{3,10}\\.(com|org|io)",
        1u8..120,
    )
        .prop_map(|(id, name, email, age)| User { id, name, email, age })
}

proptest! {
    #[test]
    fn test_user_validation(user in user_strategy()) {
        prop_assert!(user.age > 0 && user.age <= 120);
        prop_assert!(user.name.len() >= 3);
        prop_assert!(user.email.contains('@'));
    }
}

fn vec_strategy() -> impl Strategy<Value = Vec<i32>> {
    prop::collection::vec(any::<i32>(), 0..100)
}

proptest! {
    #[test]
    fn test_sort_preserves_elements(mut input in vec_strategy()) {
        let original = input.clone();
        input.sort();
        prop_assert_eq!(input.len(), original.len());
        for elem in &original {
            prop_assert!(input.contains(elem));
        }
        for window in input.windows(2) {
            prop_assert!(window[0] <= window[1]);
        }
    }
}

模式3：狀態機屬性測試

// tests/state_machine.rs
use proptest::prelude::*;
use std::collections::VecDeque;

#[derive(Debug, Clone)]
enum QueueAction {
    Enqueue(i32),
    Dequeue,
    Peek,
    Len,
}

fn queue_action_strategy() -> impl Strategy<Value = QueueAction> {
    prop_oneof![
        any::<i32>().prop_map(QueueAction::Enqueue),
        Just(QueueAction::Dequeue),
        Just(QueueAction::Peek),
        Just(QueueAction::Len),
    ]
}

proptest! {
    #[test]
    fn test_queue_state_machine(actions in prop::collection::vec(queue_action_strategy(), 1..100)) {
        let mut queue: VecDeque<i32> = VecDeque::new();
        let mut expected_len = 0usize;

        for action in actions {
            match action {
                QueueAction::Enqueue(val) => {
                    queue.push_back(val);
                    expected_len += 1;
                }
                QueueAction::Dequeue => {
                    let result = queue.pop_front();
                    if expected_len > 0 {
                        prop_assert!(result.is_some());
                        expected_len -= 1;
                    } else {
                        prop_assert!(result.is_none());
                    }
                }
                QueueAction::Peek => {
                    let result = queue.front();
                    if expected_len > 0 {
                        prop_assert!(result.is_some());
                    } else {
                        prop_assert!(result.is_none());
                    }
                }
                QueueAction::Len => {
                    prop_assert_eq!(queue.len(), expected_len);
                }
            }
        }
    }
}

模式4：迴歸持久化與失敗用例重現

// tests/regression.rs
use proptest::prelude::*;

proptest! {
    #![proptest_config(ProptestConfig {
        failure_persistence: Some(Box::new(FileFailurePersistence::WithSource("regressions"))),
        .. ProptestConfig::default()
    })]

    #[test]
    fn test_base64_roundtrip(input in prop::collection::vec(any::<u8>(), 0..1000)) {
        let encoded = base64_encode(&input);
        let decoded = base64_decode(&encoded).unwrap();
        prop_assert_eq!(input, decoded);
    }
}

模式5：與cargo-fuzz模糊測試整合

// fuzz/fuzz_targets/parse_coordinate.rs
#![no_main]
use libfuzzer_sys::fuzz_target;

fuzz_target!(|data: &[u8]| {
    if let Ok(s) = std::str::from_utf8(data) {
        let _ = myapp::parser::parse_coordinate(s);
    }
});

# fuzz/Cargo.toml
[package]
name = "myapp-fuzz"
version = "0.0.0"
publish = false

[dependencies]
libfuzzer-sys = "0.4"
myapp = { path = ".." }

[[bin]]
name = "parse_coordinate"
path = "fuzz_targets/parse_coordinate.rs"

避坑指南

坑1：策略範圍過窄

// ❌ 錯誤：只測試正常範圍
let lat in -90.0f64..90.0

// ✅ 正確：同時測試邊界和異常
proptest! {
    #[test]
    fn test_normal(lat in -90.0f64..90.0) { /* ... */ }

    #[test]
    fn test_boundary(lat in 89.9f64..90.1) { /* ... */ }

    #[test]
    fn test_extreme(lat in -1e10f64..1e10) { /* ... */ }
}

坑2：忽略Shrinking

// ❌ 錯誤：手動生成輸入，無法Shrink
let input = rand::random::<i32>();

// ✅ 正確：使用proptest策略，自動Shrink
let input in any::<i32>()

坑3：屬性過於寬鬆

// ❌ 錯誤：屬性太弱，幾乎任何實作都通過
prop_assert!(result.is_ok() || result.is_err());

// ✅ 正確：屬性足夠強，只有正確實作才通過
prop_assert_eq!(result.unwrap(), expected);

坑4：狀態測試缺少不變量

// ❌ 錯誤：只執行操作，不驗證不變量
for action in actions {
    queue.execute(action);
}

// ✅ 正確：每步都驗證不變量
for action in actions {
    queue.execute(action);
    prop_assert!(queue.len() <= max_capacity);
    prop_assert!(queue.is_consistent());
}

坑5：未持久化迴歸用例

// ❌ 錯誤：使用預設配置，失敗用例不持久化
proptest! {
    #[test]
    fn test_something(input in any::<i32>()) { /* ... */ }
}

// ✅ 正確：配置failure_persistence
proptest! {
    #![proptest_config(ProptestConfig {
        failure_persistence: Some(Box::new(FileFailurePersistence::WithSource("regressions"))),
        .. ProptestConfig::default()
    })]
    #[test]
    fn test_something(input in any::<i32>()) { /* ... */ }
}

報錯排查

序號 報錯資訊 原因 解決方法
1 test failed: minimal failing input 屬性不成立 檢查Shrunk輸入和屬性邏輯
2 too many retries 策略過濾條件太嚴 放寬過濾或使用prop_filter
3 stack overflow 遞迴策略無限展開 使用prop_recursive限制深度
4 timeout 測試用例執行太慢 減少cases數或最佳化測試程式碼
5 cannot find regression file 迴歸檔案路徑錯誤 檢查failure_persistence配置
6 strategy exhausted 策略空間耗盡 擴大策略範圍或減少cases
7 assertion failed after shrink Shrinking後仍失敗 修復Bug，不只是調整策略
8 unwinding panic 程式碼panic 在測試中catch_unwind
9 duplicate test name 測試名重複 每個proptest!區塊使用唯一名
10 type mismatch in strategy 策略型別不匹配 檢查prop_map型別轉換

進階最佳化

  1. 自定義Shrinking：實作Arbitrary trait自定義縮小邏輯
  2. 平行測試：使用proptest::test_runner::Config的max_shrink_iters控制平行度
  3. CI整合：在CI中執行cargo test並提交迴歸檔案
  4. 覆蓋率引導：結合cargo-tarpaulin分析屬性測試覆蓋率
  5. 與QuickCheck對比：同時執行proptest和QuickCheck，互補發現Bug

對比分析

維度 proptest QuickCheck cargo-fuzz afl
自動Shrinking ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐
狀態測試 ⭐⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐ ⭐⭐
迴歸持久化 ⭐⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐
策略組合 ⭐⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐ ⭐⭐
效能 ⭐⭐⭐⭐ ⭐⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐
覆蓋率引導 ⭐⭐ ⭐ ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐⭐

總結：屬性測試讓你從「手動構造測試用例」進化為「自動發現邊界Bug」。策略設計→屬性驗證→狀態機測試→迴歸持久化→模糊測試五位一體，proptest是2026年Rust屬性測試的首選。核心原則：屬性即不變量、策略即輸入空間、Shrinking即Bug定位。

線上工具推薦

本站提供瀏覽器本地工具，免註冊即可試用 →

#Rust测试#属性测试#proptest#Rust模糊测试#2026#编程语言