bitpill 0.3.5

A personal medication management TUI application built 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
86

use crate::domain::errors::DomainError;

/// The prescribed amount of a medication in milligrams.
///
/// `Dosage` is a value object — two instances with the same `amount_mg` are
/// considered equal regardless of identity.
///
/// # Invariants
///
/// - `amount_mg` must be greater than zero. A zero dosage is meaningless and
///   rejected by the constructor.
///
/// # Examples
///
/// ```rust
/// use bitpill::domain::{value_objects::dosage::Dosage, errors::DomainError};
///
/// let dosage = Dosage::new(500).unwrap();
/// assert_eq!(dosage.amount_mg(), 500);
/// assert_eq!(dosage.to_string(), "500mg");
///
/// assert!(matches!(Dosage::new(0), Err(DomainError::InvalidDosage)));
/// ```
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct Dosage {
    amount_mg: u32,
}

impl Dosage {
    /// Creates a new `Dosage`.
    ///
    /// # Errors
    ///
    /// Returns [`DomainError::InvalidDosage`] when `amount_mg` is `0`.
    pub fn new(amount_mg: u32) -> Result<Self, DomainError> {
        if amount_mg == 0 {
            return Err(DomainError::InvalidDosage);
        }
        Ok(Self { amount_mg })
    }

    /// Returns the dosage amount in milligrams.
    pub fn amount_mg(&self) -> u32 {
        self.amount_mg
    }
}

impl std::fmt::Display for Dosage {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}mg", self.amount_mg)
    }
}

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

    #[test]
    fn new_with_valid_amount_returns_dosage() {
        let result = Dosage::new(500);

        assert!(result.is_ok());
        assert_eq!(result.unwrap().amount_mg(), 500);
    }

    #[test]
    fn new_with_zero_amount_returns_error() {
        let result = Dosage::new(0);

        assert!(matches!(result, Err(DomainError::InvalidDosage)));
    }

    #[test]
    fn amount_mg_returns_value_passed_to_constructor() {
        let dosage = Dosage::new(250).unwrap();

        assert_eq!(dosage.amount_mg(), 250);
    }

    #[test]
    fn display_formats_with_mg_suffix() {
        let dosage = Dosage::new(100).unwrap();

        assert_eq!(dosage.to_string(), "100mg");
    }
}