error-forge 0.9.7

A comprehensive Rust error management framework with async support, error recovery patterns, and resilience features for building robust, fault-tolerant applications with rich error handling, formatting, and tracing capabilities.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use error_forge::{
    context::{ContextError, ResultExt},
    AppError, ForgeError,
};

#[test]
fn test_basic_context() {
    let error = AppError::config("Missing config file");
    let with_context = error.context("Failed to load application settings");

    assert_eq!(
        with_context.to_string(),
        "Failed to load application settings: ⚙️ Configuration Error: Missing config file"
    );
}

#[test]
fn test_context_preserves_error_properties() {
    let error = AppError::config("Database connection failed")
        .with_status(503)
        .with_retryable(true)
        .with_fatal(false);

    let with_context = error.context("Config error");

    // Context wrapper should preserve properties of the original error
    assert_eq!(with_context.status_code(), 503);
    assert!(with_context.is_retryable());
    assert!(!with_context.is_fatal());
    assert_eq!(with_context.kind(), "Config");
}

#[test]
fn test_result_context_methods() {
    // Test the context() method on Result
    let result: Result<(), AppError> = Err(AppError::config("Invalid config"));
    let with_context = result.context("Failed to load config");

    assert!(with_context.is_err());
    assert_eq!(
        with_context.unwrap_err().to_string(),
        "Failed to load config: ⚙️ Configuration Error: Invalid config"
    );

    // Test the with_context() method on Result
    let result: Result<(), AppError> = Err(AppError::network("Connection failed", None));
    let with_context = result.with_context(|| format!("Failed to connect at {}", "2025-08-17"));

    assert!(with_context.is_err());
    let err = with_context.unwrap_err();
    assert!(err.to_string().contains("Failed to connect at 2025-08-17"));
    assert!(err.to_string().contains("Connection failed"));
}

#[test]
fn test_nested_context() {
    // Create error with context - first level
    let error_with_first_context =
        AppError::config("Missing key").context("Failed to parse config");

    // Add another layer of context - direct implementation
    let error = ContextError::new(error_with_first_context, "Failed to initialize application");

    // The context messages should be chained in the display representation
    assert_eq!(
        error.to_string(),
        "Failed to initialize application: Failed to parse config: ⚙️ Configuration Error: Missing key"
    );

    // But the original error properties should still be accessible
    assert_eq!(error.kind(), "Config");
}

#[test]
fn test_map_context() {
    let error = AppError::filesystem("File not found", None).context("Could not read file");

    // We can transform the context to a new type
    let new_context = error.map_context(|ctx| format!("{} (at 2025-08-17)", ctx));

    assert_eq!(
        new_context.to_string(),
        "Could not read file (at 2025-08-17): 💾 Filesystem Error at \"File not found\": File operation failed"
    );
}