bitpill 0.3.3

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

use std::sync::Arc;

use crate::{
    application::{
        dtos::{requests::CreateDoseRecordRequest, responses::CreateDoseRecordResponse},
        errors::ApplicationError,
        ports::{
            create_dose_record_port::CreateDoseRecordPort,
            dose_record_repository_port::DoseRecordRepository,
        },
    },
    domain::{entities::dose_record::DoseRecord, value_objects::medication_id::MedicationId},
};

pub struct CreateDoseRecordService {
    repository: Arc<dyn DoseRecordRepository>,
}

impl CreateDoseRecordService {
    pub fn new(repository: Arc<dyn DoseRecordRepository>) -> Self {
        Self { repository }
    }
}

impl CreateDoseRecordPort for CreateDoseRecordService {
    fn execute(
        &self,
        request: CreateDoseRecordRequest,
    ) -> Result<CreateDoseRecordResponse, ApplicationError> {
        let med_id =
            MedicationId::from(uuid::Uuid::parse_str(&request.medication_id).map_err(|_| {
                ApplicationError::InvalidInput(format!(
                    "invalid medication id: {}",
                    request.medication_id
                ))
            })?);
        let record = DoseRecord::new(med_id, request.scheduled_at);
        self.repository.save(&record)?;
        Ok(CreateDoseRecordResponse {
            id: record.id().to_string(),
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::application::ports::fakes::FakeDoseRecordRepository;
    use chrono::NaiveDate;

    fn make_service(repo: std::sync::Arc<FakeDoseRecordRepository>) -> CreateDoseRecordService {
        CreateDoseRecordService::new(repo)
    }

    fn make_datetime(h: u32, m: u32) -> chrono::NaiveDateTime {
        NaiveDate::from_ymd_opt(2025, 1, 1)
            .unwrap()
            .and_hms_opt(h, m, 0)
            .unwrap()
    }

    #[test]
    fn execute_with_valid_request_saves_record() {
        let repo = std::sync::Arc::new(FakeDoseRecordRepository::new());
        let service = make_service(repo.clone());
        let med_id = crate::domain::value_objects::medication_id::MedicationId::generate();
        let req = CreateDoseRecordRequest::new(med_id.to_string(), make_datetime(8, 0));

        let res = service.execute(req).unwrap();
        assert!(!res.id.is_empty());
        assert_eq!(repo.saved_count(), 1);
    }

    #[test]
    fn execute_with_invalid_medication_id_returns_invalid_input() {
        let repo = std::sync::Arc::new(FakeDoseRecordRepository::new());
        let service = make_service(repo);
        let req = CreateDoseRecordRequest::new("not-a-uuid", make_datetime(8, 0));

        let res = service.execute(req);
        assert!(matches!(res, Err(ApplicationError::InvalidInput(_))));
    }
}