artisan 0.10.0

Api RequesT Framework U Like - 你喜欢的 Rust API 请求框架
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

use artisan::Rocket;
use artisan::direction::{Destination, Direction, DirectionKind};
use async_trait::async_trait;
use serde_json::json;
use std::sync::Arc;

#[test]
fn test_direction_kind_default() {
    let kind = DirectionKind::Json;
    assert!(matches!(kind, DirectionKind::Json));
}

#[test]
fn test_destination_default() {
    let dest = Destination::default();
    assert!(matches!(dest, Destination::None));
}

#[test]
fn test_destination_from_json() {
    let value = json!({"key": "value"});
    let dest: Destination = value.into();
    assert!(matches!(dest, Destination::Json(_)));
}

#[test]
fn test_destination_debug() {
    let dest = Destination::Json(json!({"test": 1}));
    let debug_str = format!("{:?}", dest);
    assert!(debug_str.contains("Json"));

    let dest_none = Destination::None;
    assert_eq!(format!("{:?}", dest_none), "None");
}

#[test]
fn test_destination_display() {
    let dest = Destination::Json(json!({"key": "value"}));
    let display_str = format!("{}", dest);
    assert!(display_str.contains("key"));

    let dest_none = Destination::None;
    assert_eq!(format!("{}", dest_none), "None");
}

#[derive(Debug)]
struct CustomJsonDirection {
    prefix: String,
}

#[async_trait]
impl Direction for CustomJsonDirection {
    async fn parse(&self, rocket: &mut Rocket) -> artisan::Result<Destination> {
        match rocket.destination_origin.take() {
            Some(response) => {
                let text = response
                    .text()
                    .await
                    .map_err(artisan::ArtfulError::RequestFailed)?;
                let mut json: serde_json::Value = serde_json::from_str(&text).map_err(|e| {
                    artisan::ArtfulError::JsonDeserializeError {
                        message: e.to_string(),
                        source: Some(e),
                    }
                })?;
                if let Some(obj) = json.as_object_mut() {
                    obj.insert("_custom_prefix".to_string(), json!(self.prefix.clone()));
                }
                Ok(Destination::Json(json))
            }
            None => Err(artisan::ArtfulError::MissingResponse),
        }
    }
}

#[test]
fn test_custom_direction_kind_creation() {
    let custom = Arc::new(CustomJsonDirection {
        prefix: "test_prefix".to_string(),
    });
    let kind = DirectionKind::Custom(custom);
    assert!(matches!(kind, DirectionKind::Custom(_)));
}

#[derive(Debug)]
struct TextDirection;

#[async_trait]
impl Direction for TextDirection {
    async fn parse(&self, rocket: &mut Rocket) -> artisan::Result<Destination> {
        match rocket.destination_origin.take() {
            Some(response) => {
                let text = response
                    .text()
                    .await
                    .map_err(artisan::ArtfulError::RequestFailed)?;
                Ok(Destination::Json(json!({ "text": text })))
            }
            None => Err(artisan::ArtfulError::MissingResponse),
        }
    }
}

#[test]
fn test_multiple_custom_directions() {
    let custom1 = Arc::new(CustomJsonDirection {
        prefix: "prefix1".to_string(),
    });
    let custom2 = Arc::new(TextDirection);

    let kind1 = DirectionKind::Custom(custom1);
    let kind2 = DirectionKind::Custom(custom2);

    assert!(matches!(kind1, DirectionKind::Custom(_)));
    assert!(matches!(kind2, DirectionKind::Custom(_)));
}

#[derive(Debug)]
struct FailingDirection;

#[async_trait]
impl Direction for FailingDirection {
    async fn parse(&self, _rocket: &mut Rocket) -> artisan::Result<Destination> {
        Err(artisan::ArtfulError::DirectionParseError(
            "Custom parse failed".to_string(),
        ))
    }
}

#[test]
fn test_custom_direction_can_fail() {
    let failing = Arc::new(FailingDirection);
    let kind = DirectionKind::Custom(failing);
    assert!(matches!(kind, DirectionKind::Custom(_)));
}