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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use std::sync::Arc;

use crate::application::{
    dtos::{
        requests::{SettingsOperation, SettingsRequest},
        responses::SettingsResponse,
    },
    errors::ApplicationError,
    ports::{
        inbound::settings_port::SettingsPort,
        outbound::settings_repository_port::SettingsRepositoryPort,
    },
};

pub struct SettingsService {
    repository: Arc<dyn SettingsRepositoryPort>,
}

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

impl SettingsPort for SettingsService {
    fn execute(&self, req: SettingsRequest) -> Result<SettingsResponse, ApplicationError> {
        match req.op {
            SettingsOperation::Get => {
                let v = self.repository.load()?;
                Ok(SettingsResponse { settings: v })
            }
            SettingsOperation::Update { settings } => {
                self.repository.save(&settings)?;
                Ok(SettingsResponse { settings })
            }
        }
    }
}

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

    struct InMemorySettingsRepo {
        value: std::sync::Mutex<serde_json::Value>,
    }

    impl InMemorySettingsRepo {
        fn new(v: serde_json::Value) -> Self {
            Self {
                value: std::sync::Mutex::new(v),
            }
        }
    }

    impl crate::application::ports::outbound::settings_repository_port::SettingsRepositoryPort
        for InMemorySettingsRepo
    {
        fn load(&self) -> Result<serde_json::Value, crate::application::errors::StorageError> {
            Ok(self.value.lock().unwrap().clone())
        }

        fn save(
            &self,
            settings: &serde_json::Value,
        ) -> Result<(), crate::application::errors::StorageError> {
            *self.value.lock().unwrap() = settings.clone();
            Ok(())
        }
    }

    fn make_service(repo: std::sync::Arc<InMemorySettingsRepo>) -> SettingsService {
        SettingsService::new(repo)
    }

    #[test]
    fn execute_get_returns_saved_settings() {
        let repo = std::sync::Arc::new(InMemorySettingsRepo::new(json!({"k": "v"})));
        let service = make_service(repo);
        let req = SettingsRequest {
            op: SettingsOperation::Get,
        };

        let res = service.execute(req).unwrap();
        assert_eq!(res.settings, json!({"k":"v"}));
    }

    #[test]
    fn execute_update_saves_and_returns_settings() {
        let repo = std::sync::Arc::new(InMemorySettingsRepo::new(json!({})));
        let service = make_service(repo.clone());
        let new_settings = json!({"a":1});
        let req = SettingsRequest {
            op: SettingsOperation::Update {
                settings: new_settings.clone(),
            },
        };

        let res = service.execute(req).unwrap();
        assert_eq!(res.settings, new_settings);
        assert_eq!(*repo.value.lock().unwrap(), new_settings);
    }
}