stubr 0.6.2

Wiremock implemented in Rust
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

use std::time::{SystemTime, UNIX_EPOCH};

use super::HelperExt;
use chrono::{prelude::*, Duration};
use chrono_tz::Tz;
use handlebars::{Context, Handlebars, Helper, HelperDef, RenderContext, RenderError, ScopedJson};
use humantime::parse_duration;
use serde_json::Value;

pub struct NowHelper;

impl NowHelper {
    pub const NAME: &'static str = "now";
    const FORMAT: &'static str = "format";
    const OFFSET: &'static str = "offset";
    const TIMEZONE: &'static str = "timezone";
    const EPOCH: &'static str = "epoch";
    const UNIX: &'static str = "unix";

    fn now() -> DateTime<Utc> {
        Utc::now()
    }

    fn fmt_with_custom_format(now: DateTime<Utc>, h: &Helper) -> Option<String> {
        if let Some(format) = h.get_str_hash(Self::FORMAT) {
            match format {
                Self::EPOCH => SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .map(|d| d.as_millis().to_string())
                    .ok(),
                Self::UNIX => SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .map(|d| d.as_secs().to_string())
                    .ok(),
                _ => simpledateformat::fmt(format).map(|d| d.format(&now)).ok(),
            }
        } else {
            Some(now.to_rfc3339_opts(SecondsFormat::Secs, true))
        }
    }

    fn apply_offset(now: DateTime<Utc>, h: &Helper) -> DateTime<Utc> {
        h.get_str_hash(Self::OFFSET)
            .map(|it| it.replace(' ', ""))
            .and_then(|offset| Self::compute_offset(now, offset))
            .unwrap_or(now)
    }

    fn compute_offset(now: DateTime<Utc>, offset: String) -> Option<DateTime<Utc>> {
        let is_negative = offset.starts_with('-');
        let offset = if is_negative {
            offset.trim_start_matches('-')
        } else {
            offset.as_str()
        };
        parse_duration(offset)
            .ok()
            .and_then(|it| Duration::from_std(it).ok())
            .map(|rhs| if is_negative { now - rhs } else { now + rhs })
    }

    fn apply_timezone(now: DateTime<Utc>, h: &Helper) -> DateTime<Utc> {
        h.get_str_hash(Self::TIMEZONE)
            .and_then(|timezone| timezone.parse().ok())
            .map(|tz: Tz| tz.offset_from_utc_datetime(&now.naive_utc()).fix().local_minus_utc())
            .map(i64::from)
            .map(Duration::seconds)
            .map(|offset: Duration| now + offset)
            .unwrap_or(now)
    }
}

impl HelperDef for NowHelper {
    fn call_inner<'reg: 'rc, 'rc>(
        &self, h: &Helper<'reg, 'rc>, _: &'reg Handlebars<'reg>, _: &'rc Context, _: &mut RenderContext<'reg, 'rc>,
    ) -> Result<ScopedJson<'reg, 'rc>, RenderError> {
        let now = Self::now();
        let now = Self::apply_timezone(now, h);
        let now = Self::apply_offset(now, h);
        Self::fmt_with_custom_format(now, h)
            .map(Value::from)
            .map(ScopedJson::from)
            .ok_or_else(|| RenderError::new("Failed rendering now with custom format"))
    }
}