dolang-ext-http-mock 0.1.0

HTTP mock server extension for the Do language.
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

use dolang::runtime::{
    Sym, Type,
    vm::{Builder, Stateful},
};

use crate::mock::{MockObject, RequestObject, Server};

pub(crate) struct Types<'v> {
    pub(crate) server: Type<'v, Server>,
    pub(crate) mock: Type<'v, MockObject>,
    pub(crate) request: Type<'v, RequestObject>,
}

pub(crate) struct Syms<'v> {
    pub(crate) method: Sym<'v, 'v>,
    pub(crate) path: Sym<'v, 'v>,
    pub(crate) path_regex: Sym<'v, 'v>,
    pub(crate) headers: Sym<'v, 'v>,
    pub(crate) query: Sym<'v, 'v>,
    pub(crate) body_json: Sym<'v, 'v>,
    pub(crate) match_kw: Sym<'v, 'v>,
    pub(crate) respond: Sym<'v, 'v>,
    pub(crate) status: Sym<'v, 'v>,
    pub(crate) body: Sym<'v, 'v>,
    #[cfg(feature = "json")]
    pub(crate) json: Sym<'v, 'v>,
    #[cfg(feature = "json")]
    pub(crate) encode: Sym<'v, 'v>,
    pub(crate) expect: Sym<'v, 'v>,
    pub(crate) name: Sym<'v, 'v>,
    pub(crate) close: Sym<'v, 'v>,
    pub(crate) cancel: Sym<'v, 'v>,
}

pub(crate) struct Global<'v> {
    pub(crate) types: Types<'v>,
    pub(crate) syms: Syms<'v>,
}

pub struct Tag;

impl<'v> Stateful<'v> for Global<'v> {
    type Tag = Tag;
}

impl<'v> Global<'v> {
    pub(crate) fn new(builder: &mut Builder<'v>) -> Self {
        Self {
            types: Types {
                server: builder.register_type(),
                mock: builder.register_type(),
                request: builder.register_type(),
            },
            syms: Syms {
                method: builder.sym("method"),
                path: builder.sym("path"),
                path_regex: builder.sym("path_regex"),
                headers: builder.sym("headers"),
                query: builder.sym("query"),
                body_json: builder.sym("body_json"),
                match_kw: builder.sym("match"),
                respond: builder.sym("respond"),
                status: builder.sym("status"),
                body: builder.sym("body"),
                #[cfg(feature = "json")]
                json: builder.sym("json"),
                #[cfg(feature = "json")]
                encode: builder.sym("encode"),
                expect: builder.sym("expect"),
                name: builder.sym("name"),
                close: builder.sym("close"),
                cancel: builder.sym("cancel"),
            },
        }
    }
}