sdforge 0.3.0

Multi-protocol SDK framework with unified macro configuration
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// Copyright (c) 2026 Kirky.X
// SPDX-License-Identifier: MIT
//! Tests for `AppAuditLoggerBuilder` and `AppAuditLogger::builder()`.

use super::super::*;
use super::make_test_audit_log;

// ============================================================================
// AppAuditLoggerBuilder Tests
// ============================================================================

#[test]
fn test_builder_new_default_values() {
    let builder = AppAuditLoggerBuilder::new();
    assert_eq!(builder.max_logs_per_user, 1000);
    assert_eq!(builder.max_concurrent_ops, 100);
    assert_eq!(builder.queue_size, 1000);
}

#[test]
fn test_builder_default_trait() {
    let builder = AppAuditLoggerBuilder::default();
    assert_eq!(builder.max_logs_per_user, 1000);
    assert_eq!(builder.max_concurrent_ops, 100);
    assert_eq!(builder.queue_size, 1000);
}

#[test]
fn test_builder_max_logs_per_user() {
    let builder = AppAuditLoggerBuilder::new().max_logs_per_user(500);
    assert_eq!(builder.max_logs_per_user, 500);
}

#[test]
fn test_builder_max_concurrent_ops() {
    let builder = AppAuditLoggerBuilder::new().max_concurrent_ops(50);
    assert_eq!(builder.max_concurrent_ops, 50);
}

#[test]
fn test_builder_queue_size() {
    let builder = AppAuditLoggerBuilder::new().queue_size(2000);
    assert_eq!(builder.queue_size, 2000);
}

#[test]
fn test_builder_chaining() {
    let builder = AppAuditLoggerBuilder::new()
        .max_logs_per_user(500)
        .max_concurrent_ops(50)
        .queue_size(2000);
    assert_eq!(builder.max_logs_per_user, 500);
    assert_eq!(builder.max_concurrent_ops, 50);
    assert_eq!(builder.queue_size, 2000);
}

#[tokio::test]
async fn test_builder_build() {
    let logger = AppAuditLoggerBuilder::new()
        .max_logs_per_user(500)
        .max_concurrent_ops(50)
        .queue_size(2000)
        .build();
    assert_eq!(logger.max_logs_per_user, 500);
    assert_eq!(logger.dropped_log_count(), 0);
}

// ============================================================================
// AppAuditLogger::builder() Tests
// ============================================================================

#[test]
fn test_audit_logger_builder_method() {
    let builder = AppAuditLogger::builder();
    assert_eq!(builder.max_logs_per_user, 1000);
    assert_eq!(builder.max_concurrent_ops, 100);
    assert_eq!(builder.queue_size, 1000);
}

#[tokio::test]
async fn test_default_audit_logger() {
    let logger = AppAuditLogger::default();
    assert_eq!(logger.max_logs_per_user, 1000);
}

// ============================================================================
// Builder build() worker tests
//
// AppAuditLoggerBuilder::build() also spawns a worker with the same
// fallback merge logic. This test exercises the builder's worker path.
// ============================================================================

#[tokio::test]
async fn test_builder_build_worker_merges_fallback() {
    let logger = AppAuditLogger::builder()
        .max_logs_per_user(100)
        .max_concurrent_ops(10)
        .queue_size(100)
        .build();

    // Populate fallback for the builder-created logger
    let fallback_log = AuditLog {
        id: "builder-fb-1".to_string(),
        timestamp: chrono::Utc::now().timestamp() - 100,
        user_id: Some("builder_user".to_string()),
        action: "builder_fb_action".to_string(),
        resource: "res".to_string(),
        result: AuditResult::Success,
        metadata: AuthMetadata::default(),
        signature: None,
    };
    logger
        .fallback_logs
        .set("builder_user", serialize_audit_logs(&[fallback_log]));

    // Send a batch to trigger the worker
    let batch = AuditLogBatch {
        user_id: "builder_user".to_string(),
        log: make_test_audit_log("builder_user", "builder_queued"),
    };
    let _ = logger.queue_sender.send(batch).await;

    tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;

    // Worker should have merged and deleted fallback
    assert!(
        logger.fallback_logs.get("builder_user").is_none(),
        "Builder worker should have deleted fallback after merging"
    );

    let logs = logger.get_logs("builder_user");
    let actions: Vec<&str> = logs.iter().map(|l| l.action()).collect();
    assert!(
        actions.contains(&"builder_fb_action"),
        "Merged logs should contain the fallback action"
    );
}