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
118

use std::{ops::Add, time::Duration};

use chrono::SubsecRound as _;

use crate::Error as LimitationError;

/// A report for a given key containing the limit status.
#[derive(Debug, Clone)]
pub struct Status {
    pub(crate) limit: usize,
    pub(crate) remaining: usize,
    pub(crate) reset_epoch_utc: usize,
}

impl Status {
    /// Constructs status limit status from parts.
    #[must_use]
    pub(crate) fn new(count: usize, limit: usize, reset_epoch_utc: usize) -> Self {
        let remaining = if count >= limit { 0 } else { limit - count };

        Status {
            limit,
            remaining,
            reset_epoch_utc,
        }
    }

    /// Returns the maximum number of requests allowed in the current period.
    #[must_use]
    pub fn limit(&self) -> usize {
        self.limit
    }

    /// Returns how many requests are left in the current period.
    #[must_use]
    pub fn remaining(&self) -> usize {
        self.remaining
    }

    /// Returns a UNIX timestamp in UTC approximately when the next period will begin.
    #[must_use]
    pub fn reset_epoch_utc(&self) -> usize {
        self.reset_epoch_utc
    }

    pub(crate) fn epoch_utc_plus(duration: Duration) -> Result<usize, LimitationError> {
        match chrono::Duration::from_std(duration) {
            Ok(value) => Ok(chrono::Utc::now()
                .add(value)
                .round_subsecs(0)
                .timestamp()
                .try_into()
                .unwrap_or(0)),

            Err(_) => Err(LimitationError::Other(
                "Source duration value is out of range for the target type".to_string(),
            )),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_create_status() {
        let status = Status {
            limit: 100,
            remaining: 0,
            reset_epoch_utc: 1000,
        };

        assert_eq!(status.limit(), 100);
        assert_eq!(status.remaining(), 0);
        assert_eq!(status.reset_epoch_utc(), 1000);
    }

    #[test]
    fn test_build_status() {
        let count = 200;
        let limit = 100;
        let status = Status::new(count, limit, 2000);
        assert_eq!(status.limit(), limit);
        assert_eq!(status.remaining(), 0);
        assert_eq!(status.reset_epoch_utc(), 2000);
    }

    #[test]
    fn test_build_status_limit() {
        let limit = 100;
        let status = Status::new(0, limit, 2000);
        assert_eq!(status.limit(), limit);
        assert_eq!(status.remaining(), limit);
        assert_eq!(status.reset_epoch_utc(), 2000);
    }

    #[test]
    fn test_epoch_utc_plus_zero() {
        let duration = Duration::from_secs(0);
        let seconds = Status::epoch_utc_plus(duration).unwrap();
        assert!(seconds as u64 >= duration.as_secs());
    }

    #[test]
    fn test_epoch_utc_plus() {
        let duration = Duration::from_secs(10);
        let seconds = Status::epoch_utc_plus(duration).unwrap();
        assert!(seconds as u64 >= duration.as_secs() + 10);
    }

    #[test]
    #[should_panic = "Source duration value is out of range for the target type"]
    fn test_epoch_utc_plus_overflow() {
        let duration = Duration::from_secs(10000000000000000000);
        Status::epoch_utc_plus(duration).unwrap();
    }
}