synaptic-macros 0.4.0

Procedural macros for the Synaptic framework (#[tool], #[chain], #[entrypoint], etc.)
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
138
139
140
141
142
143
144
145
146
147
148
149

//! Integration tests for the `#[traceable]` macro.

use synaptic_macros::traceable;

// ---------------------------------------------------------------------------
// Basic async function with tracing
// ---------------------------------------------------------------------------

#[traceable]
async fn process_data(input: String, count: usize) -> String {
    format!("{}: {}", input, count)
}

#[tokio::test]
async fn test_traceable_async_basic() {
    let result = process_data("hello".into(), 42).await;
    assert_eq!(result, "hello: 42");
}

// ---------------------------------------------------------------------------
// Sync function with tracing
// ---------------------------------------------------------------------------

#[traceable]
fn add_numbers(a: i64, b: i64) -> i64 {
    a + b
}

#[test]
fn test_traceable_sync_basic() {
    let result = add_numbers(3, 4);
    assert_eq!(result, 7);
}

// ---------------------------------------------------------------------------
// Custom span name
// ---------------------------------------------------------------------------

#[traceable(name = "custom_span")]
async fn custom_named(value: String) -> String {
    value.to_uppercase()
}

#[tokio::test]
async fn test_traceable_custom_name() {
    let result = custom_named("hello".into()).await;
    assert_eq!(result, "HELLO");
}

// ---------------------------------------------------------------------------
// Skip parameters
// ---------------------------------------------------------------------------

#[traceable(skip = "secret")]
async fn with_secret(query: String, secret: String) -> String {
    format!("query={}, has_secret={}", query, !secret.is_empty())
}

#[tokio::test]
async fn test_traceable_skip_param() {
    let result = with_secret("test".into(), "my_secret".into()).await;
    assert_eq!(result, "query=test, has_secret=true");
}

// ---------------------------------------------------------------------------
// Both name and skip
// ---------------------------------------------------------------------------

#[traceable(name = "auth_check", skip = "token")]
async fn authenticate(user: String, token: String) -> bool {
    !user.is_empty() && !token.is_empty()
}

#[tokio::test]
async fn test_traceable_name_and_skip() {
    let result = authenticate("alice".into(), "abc123".into()).await;
    assert!(result);
}

// ---------------------------------------------------------------------------
// Skip multiple parameters
// ---------------------------------------------------------------------------

#[traceable(skip = "password,token")]
async fn login(username: String, _password: String, _token: String) -> String {
    format!("user={}", username)
}

#[tokio::test]
async fn test_traceable_skip_multiple() {
    let result = login("bob".into(), "pass".into(), "tok".into()).await;
    assert_eq!(result, "user=bob");
}

// ---------------------------------------------------------------------------
// Function with Result return type
// ---------------------------------------------------------------------------

#[traceable]
async fn fallible_op(input: String) -> Result<String, String> {
    if input.is_empty() {
        Err("empty input".into())
    } else {
        Ok(input.to_uppercase())
    }
}

#[tokio::test]
async fn test_traceable_result_ok() {
    let result = fallible_op("hello".into()).await;
    assert_eq!(result.unwrap(), "HELLO");
}

#[tokio::test]
async fn test_traceable_result_err() {
    let result = fallible_op("".into()).await;
    assert!(result.is_err());
}

// ---------------------------------------------------------------------------
// No-param function
// ---------------------------------------------------------------------------

#[traceable]
async fn no_params() -> String {
    "done".into()
}

#[tokio::test]
async fn test_traceable_no_params() {
    let result = no_params().await;
    assert_eq!(result, "done");
}

// ---------------------------------------------------------------------------
// Verify tracing actually emits spans (integration with subscriber)
// ---------------------------------------------------------------------------

#[tokio::test]
async fn test_traceable_with_subscriber() {
    // Just verify the function works when tracing subscriber is active
    let _guard = tracing_subscriber::fmt()
        .with_test_writer()
        .with_max_level(tracing::Level::TRACE)
        .try_init();

    let result = process_data("traced".into(), 99).await;
    assert_eq!(result, "traced: 99");
}