tap-node 0.6.0

Transaction Authorization Protocol (TAP) node implementation for routing and processing messages
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

//! Test DIDComm message validation in TAP Node
//!
//! This test verifies that DIDComm messages (Trust Ping, Basic Message)
//! pass through the ValidationPlainMessageProcessor correctly.

use std::collections::HashMap;
use tap_msg::didcomm::PlainMessage;
use tap_node::message::processor::{PlainMessageProcessor, ValidationPlainMessageProcessor};

#[tokio::test]
async fn test_trust_ping_passes_validation() {
    let processor = ValidationPlainMessageProcessor;

    // Create a Trust Ping message
    let trust_ping = PlainMessage {
        id: "test-ping-123".to_string(),
        typ: "application/didcomm-plain+json".to_string(),
        type_: "https://didcomm.org/trust-ping/2.0/ping".to_string(),
        body: serde_json::json!({
            "response_requested": true,
            "comment": "Test ping"
        }),
        from: "did:key:test_sender".to_string(),
        to: vec!["did:key:test_recipient".to_string()],
        thid: None,
        pthid: None,
        extra_headers: HashMap::new(),
        attachments: None,
        created_time: Some(chrono::Utc::now().timestamp_millis() as u64),
        expires_time: None,
        from_prior: None,
    };

    // Test incoming validation
    let result = processor
        .process_incoming(trust_ping.clone())
        .await
        .unwrap();
    assert!(
        result.is_some(),
        "Trust Ping should pass incoming validation"
    );

    // Test outgoing validation
    let result = processor.process_outgoing(trust_ping).await.unwrap();
    assert!(
        result.is_some(),
        "Trust Ping should pass outgoing validation"
    );
}

#[tokio::test]
async fn test_basic_message_passes_validation() {
    let processor = ValidationPlainMessageProcessor;

    // Create a Basic Message
    let basic_message = PlainMessage {
        id: "test-basic-123".to_string(),
        typ: "application/didcomm-plain+json".to_string(),
        type_: "https://didcomm.org/basicmessage/2.0/message".to_string(),
        body: serde_json::json!({
            "content": "Hello, this is a test message!",
            "locale": "en"
        }),
        from: "did:key:test_sender".to_string(),
        to: vec!["did:key:test_recipient".to_string()],
        thid: None,
        pthid: None,
        extra_headers: HashMap::new(),
        attachments: None,
        created_time: Some(chrono::Utc::now().timestamp_millis() as u64),
        expires_time: None,
        from_prior: None,
    };

    // Test incoming validation
    let result = processor
        .process_incoming(basic_message.clone())
        .await
        .unwrap();
    assert!(
        result.is_some(),
        "Basic Message should pass incoming validation"
    );

    // Test outgoing validation
    let result = processor.process_outgoing(basic_message).await.unwrap();
    assert!(
        result.is_some(),
        "Basic Message should pass outgoing validation"
    );
}

#[tokio::test]
async fn test_unknown_didcomm_message_passes_validation() {
    let processor = ValidationPlainMessageProcessor;

    // Create an unknown DIDComm message type
    let unknown_message = PlainMessage {
        id: "test-unknown-123".to_string(),
        typ: "application/didcomm-plain+json".to_string(),
        type_: "https://didcomm.org/unknown-protocol/1.0/unknown-message".to_string(),
        body: serde_json::json!({
            "test": "data"
        }),
        from: "did:key:test_sender".to_string(),
        to: vec!["did:key:test_recipient".to_string()],
        thid: None,
        pthid: None,
        extra_headers: HashMap::new(),
        attachments: None,
        created_time: Some(chrono::Utc::now().timestamp_millis() as u64),
        expires_time: None,
        from_prior: None,
    };

    // Test incoming validation - should pass (we allow unknown DIDComm types)
    let result = processor
        .process_incoming(unknown_message.clone())
        .await
        .unwrap();
    assert!(
        result.is_some(),
        "Unknown DIDComm message should pass incoming validation"
    );

    // Test outgoing validation - should pass (we allow unknown DIDComm types)
    let result = processor.process_outgoing(unknown_message).await.unwrap();
    assert!(
        result.is_some(),
        "Unknown DIDComm message should pass outgoing validation"
    );
}

#[tokio::test]
async fn test_unknown_protocol_fails_validation() {
    let processor = ValidationPlainMessageProcessor;

    // Create a message with completely unknown protocol
    let unknown_protocol = PlainMessage {
        id: "test-unknown-protocol-123".to_string(),
        typ: "application/didcomm-plain+json".to_string(),
        type_: "https://unknown.example.com/protocol/1.0/message".to_string(),
        body: serde_json::json!({
            "test": "data"
        }),
        from: "did:key:test_sender".to_string(),
        to: vec!["did:key:test_recipient".to_string()],
        thid: None,
        pthid: None,
        extra_headers: HashMap::new(),
        attachments: None,
        created_time: Some(chrono::Utc::now().timestamp_millis() as u64),
        expires_time: None,
        from_prior: None,
    };

    // Test incoming validation - should fail
    let result = processor
        .process_incoming(unknown_protocol.clone())
        .await
        .unwrap();
    assert!(
        result.is_none(),
        "Unknown protocol should fail incoming validation"
    );

    // Test outgoing validation - should fail
    let result = processor.process_outgoing(unknown_protocol).await.unwrap();
    assert!(
        result.is_none(),
        "Unknown protocol should fail outgoing validation"
    );
}