easyhttpmock 0.1.3-beta.10

EasyHttpMock is a simple HTTP mock server for testing HTTP clients.
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

use std::{error::Error, sync::Arc};

use caramelo::{
    expect,
    matchers::{ge, lt},
    MatcherExt,
};

use crate::{
    config::EasyHttpMockConfig,
    errors::EasyHttpMockError,
    mock::Mock,
    server::{PortGenerator, ServerAdapter},
    EasyHttpMock,
};

#[derive(Debug, Clone)]
pub struct TestServerConfig {
    port: u32,
    interface: String,
}

impl Default for TestServerConfig {
    fn default() -> Self {
        Self { port: 8080, interface: "127.0.0.1".to_string() }
    }
}

impl TestServerConfig {
    pub fn port(&self) -> u32 {
        self.port
    }

    pub fn interface(&self) -> &str {
        &self.interface
    }
}

pub struct TestServer {
    config: TestServerConfig,
    mock: Option<Arc<Mock>>,
}

impl ServerAdapter for TestServer {
    type Config = TestServerConfig;

    fn new(config: Self::Config) -> Result<Self, EasyHttpMockError> {
        Ok(Self { config, mock: None })
    }

    fn hostname(&self) -> String {
        "localhost".to_string()
    }

    fn base_url(&self) -> String {
        format!("http://{}:{}", self.hostname(), self.config.port)
    }

    fn config(&self) -> &Self::Config {
        &self.config
    }

    fn register_mock(&mut self, mock: Arc<Mock>) {
        self.mock = Some(mock);
    }

    async fn start(&mut self) -> Result<(), EasyHttpMockError> {
        todo!()
    }

    async fn stop(&mut self) -> Result<(), EasyHttpMockError> {
        todo!()
    }
}

impl PortGenerator<TestServer> for TestServerConfig {
    fn with_random_port(self) -> Self {
        let port = rand::random_range(9000..65535);
        Self { port, ..self }
    }
}

#[test]
fn test_server() -> Result<(), Box<dyn Error>> {
    let mock_server = EasyHttpMock::<TestServer>::new(crate::config::EasyHttpMockConfig {
        server_config: TestServerConfig { port: 8080, interface: "127.0.0.1".to_string() },
        base_url: Some("http://127.0.0.1:8080".to_string()),
    })?;

    assert_eq!(
        mock_server
            .config
            .server_config
            .port,
        8080,
        "server port should be 8080"
    );

    Ok(())
}

#[test]
fn test_random_port() -> Result<(), Box<dyn Error>> {
    let mock_server = EasyHttpMock::<TestServer>::new(EasyHttpMockConfig {
        server_config: TestServerConfig { port: 0, interface: "127.0.0.1".to_string() },
        base_url: None,
    })?;

    let config = mock_server
        .config
        .server_config
        .with_random_port();

    expect(config.port).to_be(ge(9000).and(lt(65535)));

    Ok(())
}