sz_orm_storage/
tencent.rs1use crate::error::StorageError;
14use crate::storage::Storage;
15use async_trait::async_trait;
16use std::collections::HashMap;
17use std::sync::Arc;
18use tokio::sync::RwLock;
19
20pub struct TencentCosStorage {
25 pub bucket: String,
26 pub region: String,
27 store: Arc<RwLock<HashMap<String, Vec<u8>>>>,
28}
29
30impl TencentCosStorage {
31 pub fn new(bucket: impl Into<String>, region: impl Into<String>) -> Self {
32 Self {
33 bucket: bucket.into(),
34 region: region.into(),
35 store: Arc::new(RwLock::new(HashMap::new())),
36 }
37 }
38
39 pub fn url_for(&self, key: &str) -> String {
40 format!("cos://{}.{}/{}", self.bucket, self.region, key)
41 }
42}
43
44#[async_trait]
45impl Storage for TencentCosStorage {
46 async fn put(
47 &self,
48 key: &str,
49 data: &[u8],
50 _content_type: &str,
51 ) -> Result<String, StorageError> {
52 let mut store = self.store.write().await;
53 store.insert(key.to_string(), data.to_vec());
54 Ok(self.url_for(key))
55 }
56
57 async fn get(&self, key: &str) -> Result<Vec<u8>, StorageError> {
58 let store = self.store.read().await;
59 store
60 .get(key)
61 .cloned()
62 .ok_or_else(|| StorageError::NotFound(format!("cos://{}/{}", self.bucket, key)))
63 }
64
65 async fn delete(&self, key: &str) -> Result<(), StorageError> {
66 let mut store = self.store.write().await;
67 store.remove(key);
68 Ok(())
69 }
70
71 async fn exists(&self, key: &str) -> Result<bool, StorageError> {
72 let store = self.store.read().await;
73 Ok(store.contains_key(key))
74 }
75}
76
77#[cfg(test)]
78mod tests {
79 use super::*;
80
81 #[tokio::test]
82 async fn test_tencent_put_and_get() {
83 let storage = TencentCosStorage::new("bucket-1250000000", "ap-guangzhou");
84 let url = storage
85 .put("a.txt", b"tencent-data", "text/plain")
86 .await
87 .unwrap();
88 assert!(url.starts_with("cos://bucket-1250000000.ap-guangzhou/"));
89 assert!(url.contains("a.txt"));
90
91 let data = storage.get("a.txt").await.unwrap();
92 assert_eq!(data, b"tencent-data");
93 }
94
95 #[tokio::test]
96 async fn test_tencent_get_not_found() {
97 let storage = TencentCosStorage::new("bucket", "ap-guangzhou");
98 let result = storage.get("missing").await;
99 assert!(result.is_err());
100 assert!(matches!(result.unwrap_err(), StorageError::NotFound(_)));
101 }
102
103 #[tokio::test]
104 async fn test_tencent_delete_and_exists() {
105 let storage = TencentCosStorage::new("bucket", "ap-guangzhou");
106 storage.put("key", b"data", "text/plain").await.unwrap();
107 assert!(storage.exists("key").await.unwrap());
108
109 storage.delete("key").await.unwrap();
110 assert!(!storage.exists("key").await.unwrap());
111 }
112
113 #[tokio::test]
114 async fn test_tencent_overwrite() {
115 let storage = TencentCosStorage::new("bucket", "ap-guangzhou");
116 storage.put("key", b"v1", "text/plain").await.unwrap();
117 storage.put("key", b"v2", "text/plain").await.unwrap();
118 assert_eq!(storage.get("key").await.unwrap(), b"v2");
119 }
120
121 #[tokio::test]
122 async fn test_tencent_multiple_keys() {
123 let storage = TencentCosStorage::new("bucket", "ap-guangzhou");
124 storage.put("a", b"a-data", "text/plain").await.unwrap();
125 storage.put("b", b"b-data", "text/plain").await.unwrap();
126
127 assert_eq!(storage.get("a").await.unwrap(), b"a-data");
128 assert_eq!(storage.get("b").await.unwrap(), b"b-data");
129
130 storage.delete("a").await.unwrap();
131 assert!(!storage.exists("a").await.unwrap());
132 assert!(storage.exists("b").await.unwrap());
133 }
134
135 #[tokio::test]
136 async fn test_tencent_url_format() {
137 let storage = TencentCosStorage::new("my-bucket", "ap-beijing");
138 let url = storage.url_for("path/to/file.txt");
139 assert_eq!(url, "cos://my-bucket.ap-beijing/path/to/file.txt");
140 }
141}