test: a beginning to dst

crates/keystore/src/api/server.rs

@@ -24,7 +24,7 @@ impl MasterKeyManagementService for API {
     ) -> Result<tonic::Response<CreateMasterKeyResponse>, tonic::Status> {
         let key = self
             .keystore
-            .create_key(request.get_ref().keyring_name.clone(), request.get_ref().master_key_id.clone())
+            .create_key(request.get_ref().keyring_name.as_str(), request.get_ref().master_key_id.as_str())
             .await;
 
         let reply = CreateMasterKeyResponse {
@@ -86,9 +86,9 @@ impl MasterKeyManagementService for API {
         request: tonic::Request<EncryptRequest>,
     ) -> Result<tonic::Response<EncryptResponse>, tonic::Status> {
         let encrypted_value = self.keystore.encrypt(
-            request.get_ref().keyring_name.clone(),
-            request.get_ref().master_key_id.clone(),
-            request.get_ref().plaintext.clone().to_vec(),
+            request.get_ref().keyring_name.as_str(),
+            request.get_ref().master_key_id.as_str(),
+            request.get_ref().plaintext.to_vec(),
         ).await;
 
         let reply = crate::valv::keystore::v1::EncryptResponse {
@@ -104,9 +104,9 @@ impl MasterKeyManagementService for API {
         request: tonic::Request<DecryptRequest>,
     ) -> Result<tonic::Response<DecryptResponse>, tonic::Status> {
         let decrypted_result = self.keystore.decrypt(
-            request.get_ref().keyring_name.clone(),
-            request.get_ref().master_key_id.clone(),
-            request.get_ref().ciphertext.clone().to_vec(),
+            request.get_ref().keyring_name.as_str(),
+            request.get_ref().master_key_id.as_str(),
+            request.get_ref().ciphertext.to_vec(),
         ).await;
         match decrypted_result {
             Ok(decrypted_value) => {

crates/keystore/src/clock.rs

@@ -0,0 +1,93 @@
+use std::time::{Duration, SystemTime};
+use std::sync::Mutex;
+
+pub struct MockClock {
+    current_time: Mutex<SystemTime>,
+}
+
+impl MockClock {
+    pub fn new(initial_time: SystemTime) -> Self {
+        MockClock {
+            current_time: Mutex::new(initial_time),
+        }
+    }
+
+    fn now(&self) -> SystemTime {
+        *self.current_time.lock().unwrap()
+    }
+
+    fn advance(&self, duration: Duration) {
+        let mut current_time = self.current_time.lock().unwrap();
+        *current_time += duration;
+    }
+}
+
+pub trait Clock: Send + Sync {
+    fn now(&self) -> SystemTime;
+}
+
+impl Clock for MockClock {
+    fn now(&self) -> SystemTime {
+        self.now()
+    }
+}
+
+impl Clock for SystemTime {
+    fn now(&self) -> SystemTime {
+        SystemTime::now()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::{Duration, SystemTime};
+
+    #[test]
+    fn test_mock_clock_new() {
+        let initial_time = SystemTime::UNIX_EPOCH + Duration::from_secs(1000);
+        let clock = MockClock::new(initial_time);
+        assert_eq!(clock.now(), initial_time);
+    }
+
+    #[test]
+    fn test_mock_clock_advance() {
+        let initial_time = SystemTime::UNIX_EPOCH;
+        let clock = MockClock::new(initial_time);
+
+        clock.advance(Duration::from_secs(60));
+        assert_eq!(clock.now(), initial_time + Duration::from_secs(60));
+
+        clock.advance(Duration::from_secs(30));
+        assert_eq!(clock.now(), initial_time + Duration::from_secs(90));
+    }
+
+    #[test]
+    fn test_mock_clock_multiple_advances() {
+        let initial_time = SystemTime::UNIX_EPOCH;
+        let clock = MockClock::new(initial_time);
+
+        for i in 1..=5 {
+            clock.advance(Duration::from_secs(10));
+            assert_eq!(clock.now(), initial_time + Duration::from_secs(i * 10));
+        }
+    }
+
+    #[test]
+    fn test_mock_clock_trait_implementation() {
+        let initial_time = SystemTime::UNIX_EPOCH + Duration::from_secs(500);
+        let clock: Box<dyn Clock> = Box::new(MockClock::new(initial_time));
+
+        assert_eq!(clock.now(), initial_time);
+    }
+
+    #[test]
+    fn test_system_time_clock_trait_implementation() {
+        let clock: Box<dyn Clock> = Box::new(SystemTime::UNIX_EPOCH);
+
+        // This test is non-deterministic, but we can check if the time is recent
+        let now = clock.now();
+        let elapsed = now.duration_since(SystemTime::UNIX_EPOCH).unwrap();
+        assert!(elapsed.as_secs() > 0);
+    }
+}

crates/keystore/src/cmd/main.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{sync::Arc, time::SystemTime};
 
 use clap::Parser;
 use keystore::{
@@ -21,7 +21,7 @@ struct Cli {
 async fn main() {
     let args = Cli::parse();
 
-    let mut keystore = Keystore::new().await;
+    let mut keystore = Keystore::new(Arc::new(SystemTime::now())).await;
 
     let master_key = args.master_key.clone().expose_secret().clone().into_bytes()[..32]
         .try_into()