apimock 4.6.6

HTTP(S) mock server. Drop JSON files into a folder and your API immediately exists.
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

use std::{borrow::Cow, sync::OnceLock};

use console::strip_ansi_codes;
use log::{Level, Metadata, Record, SetLoggerError};
use tokio::sync::mpsc::Sender;

/// logger
static LOGGER: OnceLock<AppLogger> = OnceLock::new();

/// log output
#[derive(Clone)]
enum LogOutput {
    Stdout,
    Sender(Sender<String>),
}

/// app logger
#[derive(Clone)]
struct AppLogger {
    output: LogOutput,
    includes_ansi_codes: bool,
}

impl log::Log for AppLogger {
    /// check if it is enabled
    fn enabled(&self, metadata: &Metadata) -> bool {
        metadata.level() <= Level::Info
    }

    /// log print out
    fn log(&self, record: &Record) {
        if !self.enabled(record.metadata()) {
            return;
        }

        match &self.output {
            // default feature
            LogOutput::Stdout => {
                println!("{}", record.args());
            }
            // spawn feature
            LogOutput::Sender(tx) => {
                let args = record.args().to_string();
                let msg = if !self.includes_ansi_codes {
                    // omit ansi escape codes for console text color
                    strip_ansi_codes(args.as_ref())
                } else {
                    Cow::from(args)
                };
                // message with log level
                let msg_with_log_level = format!(
                    "[{}] {}",
                    record.level().to_string().chars().next().unwrap(),
                    msg
                );

                let tx = tx.clone();
                tokio::spawn(async move {
                    let _ = tx.send(msg_with_log_level).await;
                });
            }
        }
    }

    /// flush
    fn flush(&self) {}
}

/// init logger
pub fn init_logger(
    tx: Option<Sender<String>>,
    includes_ansi_codes: bool,
) -> Result<(), SetLoggerError> {
    let output = if let Some(tx) = tx {
        LogOutput::Sender(tx)
    } else {
        LogOutput::Stdout
    };

    LOGGER
        .set(AppLogger {
            output,
            includes_ansi_codes,
        })
        .ok();
    log::set_logger(LOGGER.get().unwrap())?;
    log::set_max_level(log::LevelFilter::Info);

    Ok(())
}