solana-recover 1.1.3

A comprehensive Solana wallet recovery and account management tool
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

#[cfg(test)]
mod tests {
    use crate::api::server::{ScanRequest, ApiResponse};
    use crate::core::BatchScanRequest;
    use uuid::Uuid;

    #[tokio::test]
    async fn test_scan_request_serialization() {
        let request = ScanRequest {
            wallet_address: "11111111111111111111111111111112".to_string(),
        };

        // Test JSON serialization
        let json = serde_json::to_string(&request);
        assert!(json.is_ok());

        // Test JSON deserialization
        let deserialized: ScanRequest = serde_json::from_str(&json.unwrap()).unwrap();
        assert_eq!(deserialized.wallet_address, "11111111111111111111111111111112");
    }

    #[tokio::test]
    async fn test_api_response_success() {
        let data = "test data".to_string();
        let response = ApiResponse::success(data);

        assert!(response.success);
        assert!(response.data.is_some());
        assert!(response.error.is_none());
    }

    #[tokio::test]
    async fn test_api_response_error() {
        let error = "test error".to_string();
        let response = ApiResponse::<String>::error(error);

        assert!(!response.success);
        assert!(response.data.is_none());
        assert!(response.error.is_some());
    }

    #[tokio::test]
    async fn test_api_response_serialization() {
        let response = ApiResponse::success("test data".to_string());

        // Test JSON serialization
        let json = serde_json::to_string(&response);
        assert!(json.is_ok());

        // Test JSON deserialization
        let deserialized: ApiResponse<String> = serde_json::from_str(&json.unwrap()).unwrap();
        assert!(deserialized.success);
        assert_eq!(deserialized.data.unwrap(), "test data");
    }

    #[tokio::test]
    async fn test_batch_scan_request_serialization() {
        let request = BatchScanRequest {
            id: Uuid::new_v4(),
            wallet_addresses: vec![
                "11111111111111111111111111111112".to_string(),
                "11111111111111111111111111111113".to_string(),
            ],
            user_id: None,
            fee_percentage: None,
            created_at: chrono::Utc::now(),
        };

        // Test JSON serialization
        let json = serde_json::to_string(&request);
        assert!(json.is_ok());

        // Test JSON deserialization
        let deserialized: BatchScanRequest = serde_json::from_str(&json.unwrap()).unwrap();
        assert_eq!(deserialized.wallet_addresses.len(), 2);
    }

    #[tokio::test]
    async fn test_extract_json_from_request() {
        let request = "POST /api/v1/scan HTTP/1.1\r\nContent-Type: application/json\r\n\r\n{\"wallet_address\":\"11111111111111111111111111111112\"}";
        
        let json = crate::api::server::extract_json_from_request(request);
        
        assert!(json.contains("wallet_address"));
        assert!(json.contains("11111111111111111111111111111112"));
    }

    #[tokio::test]
    async fn test_create_json_response() {
        let data = ApiResponse::success("test data".to_string());
        
        let response = crate::api::server::create_json_response(&data);
        
        assert!(response.contains("HTTP/1.1 200 OK"));
        assert!(response.contains("Content-Type: application/json"));
        assert!(response.contains("\"success\":true"));
    }

    #[tokio::test]
    async fn test_health_check_handler() {
        let response = crate::api::handlers::health_check().await;
        
        assert!(response.success);
        assert!(response.data.is_some());
        assert_eq!(response.data.unwrap(), "OK");
    }

    #[tokio::test]
    async fn test_get_scan_status_handler() {
        let scan_id = Uuid::new_v4().to_string();
        let response = crate::api::handlers::get_scan_status(scan_id).await;
        
        assert!(!response.success);
        assert!(response.data.is_none());
        assert!(response.error.is_some());
        assert!(response.error.unwrap().contains("not implemented yet"));
    }
}