api-bones-test 4.5.1

Test helpers for api-bones: builders and response-assertion utilities
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

use api_bones::links::Links;
use api_bones::response::{ApiResponse, ResponseMeta};
use chrono::Utc;
use uuid::Uuid;

/// Builder for a fake [`ApiResponse<T>`].
///
/// # Quick start
///
/// ```rust
/// use api_bones_test::builders::FakeApiResponse;
///
/// let resp = FakeApiResponse::new("hello").build();
/// assert_eq!(resp.data, "hello");
/// assert!(resp.meta.request_id.is_some());
/// assert!(resp.meta.timestamp.is_some());
/// ```
pub struct FakeApiResponse<T> {
    data: T,
    meta: Option<ResponseMeta>,
    links: Option<Links>,
    request_id: Option<String>,
}

impl<T> FakeApiResponse<T> {
    #[must_use]
    pub fn new(data: T) -> Self {
        Self {
            data,
            meta: None,
            links: None,
            request_id: None,
        }
    }

    #[must_use]
    pub fn with_meta(mut self, meta: ResponseMeta) -> Self {
        self.meta = Some(meta);
        self
    }

    #[must_use]
    pub fn with_links(mut self, links: Links) -> Self {
        self.links = Some(links);
        self
    }

    #[must_use]
    pub fn with_request_id(mut self, id: impl Into<String>) -> Self {
        self.request_id = Some(id.into());
        self
    }

    #[must_use]
    pub fn build(self) -> ApiResponse<T> {
        let request_id = self
            .request_id
            .unwrap_or_else(|| Uuid::new_v4().to_string());
        let meta = self.meta.unwrap_or_else(|| {
            ResponseMeta::new()
                .request_id(request_id)
                .timestamp(Utc::now())
        });
        let mut builder = ApiResponse::builder(self.data).meta(meta);
        if let Some(links) = self.links {
            builder = builder.links(links);
        }
        builder.build()
    }
}