1  use abundantis::source::{EnvSource, MemorySource, Priority, SourceCapabilities, SourceType};
  2  
  3  #[test]
  4  fn test_memory_source_creation() {
  5      let source = MemorySource::new();
  6      assert_eq!(source.id().as_str(), "memory");
  7      assert_eq!(source.source_type(), SourceType::Memory);
  8      assert_eq!(source.priority(), Priority::MEMORY);
  9  }
 10  
 11  #[test]
 12  fn test_memory_source_default() {
 13      let source = MemorySource::default();
 14      assert_eq!(source.id().as_str(), "memory");
 15  }
 16  
 17  #[test]
 18  fn test_memory_source_capabilities() {
 19      let source = MemorySource::new();
 20      let caps = source.capabilities();
 21  
 22      assert!(caps.contains(SourceCapabilities::READ));
 23      assert!(caps.contains(SourceCapabilities::WRITE));
 24      assert!(caps.contains(SourceCapabilities::CACHEABLE));
 25      assert!(!caps.contains(SourceCapabilities::WATCH));
 26      assert!(!caps.contains(SourceCapabilities::ASYNC_ONLY));
 27  }
 28  
 29  #[test]
 30  fn test_memory_source_set() {
 31      let source = MemorySource::new();
 32  
 33      source.set("KEY1", "value1");
 34      source.set("KEY2", "value2");
 35      source.set("KEY3", "value3");
 36  
 37      let snapshot = source.load().unwrap();
 38      assert_eq!(snapshot.variables.len(), 3);
 39  
 40      let keys: Vec<_> = snapshot.variables.iter().map(|v| v.key.as_str()).collect();
 41      assert!(keys.contains(&"KEY1"));
 42      assert!(keys.contains(&"KEY2"));
 43      assert!(keys.contains(&"KEY3"));
 44  }
 45  
 46  #[test]
 47  fn test_memory_source_set_with_description() {
 48      let source = MemorySource::new();
 49  
 50      source.set_with_description("API_KEY", "secret-value", "External API key for production");
 51  
 52      let snapshot = source.load().unwrap();
 53      assert_eq!(snapshot.variables.len(), 1);
 54      assert_eq!(snapshot.variables[0].key.as_str(), "API_KEY");
 55      assert_eq!(snapshot.variables[0].raw_value.as_str(), "secret-value");
 56      assert_eq!(
 57          snapshot.variables[0].description.as_deref(),
 58          Some("External API key for production")
 59      );
 60  }
 61  
 62  #[test]
 63  fn test_memory_source_remove() {
 64      let source = MemorySource::new();
 65  
 66      source.set("KEY1", "value1");
 67      source.set("KEY2", "value2");
 68      assert_eq!(source.len(), 2);
 69  
 70      let removed = source.remove("KEY1");
 71      assert!(removed.is_some());
 72      assert_eq!(removed.unwrap().key.as_str(), "KEY1");
 73      assert_eq!(source.len(), 1);
 74  }
 75  
 76  #[test]
 77  fn test_memory_source_remove_nonexistent() {
 78      let source = MemorySource::new();
 79  
 80      source.set("KEY1", "value1");
 81  
 82      let removed = source.remove("KEY2");
 83      assert!(removed.is_none());
 84      assert_eq!(source.len(), 1);
 85  }
 86  
 87  #[test]
 88  fn test_memory_source_clear() {
 89      let source = MemorySource::new();
 90  
 91      source.set("KEY1", "value1");
 92      source.set("KEY2", "value2");
 93      source.set("KEY3", "value3");
 94      assert_eq!(source.len(), 3);
 95  
 96      source.clear();
 97      assert_eq!(source.len(), 0);
 98      assert!(source.is_empty());
 99  }
100  
101  #[test]
102  fn test_memory_source_is_empty() {
103      let source = MemorySource::new();
104      assert!(source.is_empty());
105  
106      source.set("KEY1", "value1");
107      assert!(!source.is_empty());
108  }
109  
110  #[test]
111  fn test_memory_source_len() {
112      let source = MemorySource::new();
113      assert_eq!(source.len(), 0);
114  
115      for i in 0..100 {
116          source.set(format!("KEY{}", i), format!("value{}", i));
117      }
118  
119      assert_eq!(source.len(), 100);
120  }
121  
122  #[test]
123  fn test_memory_source_overwrite() {
124      let source = MemorySource::new();
125  
126      source.set("KEY1", "value1");
127      source.set("KEY2", "value2");
128  
129      source.set("KEY1", "value1-updated");
130  
131      let snapshot = source.load().unwrap();
132      assert_eq!(snapshot.variables.len(), 2);
133  
134      let key1 = snapshot
135          .variables
136          .iter()
137          .find(|v| v.key.as_str() == "KEY1")
138          .unwrap();
139      assert_eq!(key1.raw_value.as_str(), "value1-updated");
140  }
141  
142  #[test]
143  fn test_memory_source_version_tracking() {
144      let source = MemorySource::new();
145  
146      let snapshot1 = source.load().unwrap();
147      let v1 = snapshot1.version.unwrap();
148  
149      source.set("KEY1", "value1");
150      let snapshot2 = source.load().unwrap();
151      let v2 = snapshot2.version.unwrap();
152  
153      assert!(v2 > v1);
154  
155      source.set("KEY2", "value2");
156      let snapshot3 = source.load().unwrap();
157      let v3 = snapshot3.version.unwrap();
158  
159      assert!(v3 > v2);
160  }
161  
162  #[test]
163  fn test_memory_source_load() {
164      let source = MemorySource::new();
165  
166      source.set("KEY1", "value1");
167      source.set("KEY2", "value2");
168      source.set("KEY3", "value3");
169  
170      let snapshot = source.load().unwrap();
171      assert_eq!(snapshot.variables.len(), 3);
172      assert_eq!(snapshot.source_id.as_str(), "memory");
173      assert!(snapshot.timestamp.elapsed().as_secs() < 1);
174      assert!(snapshot.version.is_some());
175  }
176  
177  #[test]
178  fn test_memory_source_has_changed() {
179      let source = MemorySource::new();
180  
181      assert!(source.has_changed());
182  }
183  
184  #[test]
185  fn test_memory_source_invalidate() {
186      let source = MemorySource::new();
187  
188      source.set("KEY1", "value1");
189      assert_eq!(source.len(), 1);
190  
191      source.invalidate();
192  
193      assert_eq!(source.len(), 1);
194  }
195  
196  #[test]
197  fn test_memory_source_empty_load() {
198      let source = MemorySource::new();
199  
200      let snapshot = source.load().unwrap();
201      assert_eq!(snapshot.variables.len(), 0);
202      assert_eq!(snapshot.version.unwrap(), 0);
203  }
204  
205  #[test]
206  fn test_memory_source_special_characters() {
207      let source = MemorySource::new();
208  
209      source.set("KEY-WITH-DASHES", "value");
210      source.set("KEY_WITH_UNDERSCORE", "value");
211      source.set("key.with.dots", "value");
212  
213      let snapshot = source.load().unwrap();
214      assert_eq!(snapshot.variables.len(), 3);
215  }
216  
217  #[test]
218  fn test_memory_source_large_values() {
219      let source = MemorySource::new();
220  
221      let large_value = "a".repeat(10000);
222      source.set("LARGE_KEY", large_value.clone());
223  
224      let snapshot = source.load().unwrap();
225      assert_eq!(snapshot.variables.len(), 1);
226      assert_eq!(snapshot.variables[0].raw_value.len(), 10000);
227  }
228  
229  #[test]
230  fn test_memory_source_unicode() {
231      let source = MemorySource::new();
232  
233      source.set("UNICODE_KEY", "日本語");
234      source.set("EMOJI_KEY", "🌽");
235      source.set("ARABIC_KEY", "مرحبا");
236  
237      let snapshot = source.load().unwrap();
238      assert_eq!(snapshot.variables.len(), 3);
239  }
240  
241  #[test]
242  fn test_memory_source_order_preserved() {
243      let source = MemorySource::new();
244  
245      for i in 0..10 {
246          source.set(format!("KEY{}", i), format!("value{}", i));
247      }
248  
249      let snapshot = source.load().unwrap();
250      assert_eq!(snapshot.variables.len(), 10);
251  
252      for (i, var) in snapshot.variables.iter().enumerate() {
253          assert_eq!(var.key.as_str(), format!("KEY{}", i));
254          assert_eq!(var.raw_value.as_str(), format!("value{}", i));
255      }
256  }
257  
258  #[test]
259  fn test_memory_source_many_operations() {
260      let source = MemorySource::new();
261  
262      for i in 0..1000 {
263          source.set(format!("KEY{}", i), format!("value{}", i));
264      }
265  
266      assert_eq!(source.len(), 1000);
267  
268      for i in 0..1000 {
269          if i % 2 == 0 {
270              source.remove(&format!("KEY{}", i));
271          }
272      }
273  
274      assert_eq!(source.len(), 500);
275  }
276  
277  #[test]
278  fn test_memory_source_set_after_load() {
279      let source = MemorySource::new();
280  
281      source.set("KEY1", "value1");
282      let snapshot1 = source.load().unwrap();
283      assert_eq!(snapshot1.variables.len(), 1);
284  
285      source.set("KEY2", "value2");
286      let snapshot2 = source.load().unwrap();
287      assert_eq!(snapshot2.variables.len(), 2);
288  }
289  
290  #[test]
291  fn test_memory_source_remove_and_set() {
292      let source = MemorySource::new();
293  
294      source.set("KEY1", "value1");
295      source.set("KEY2", "value2");
296  
297      source.remove("KEY1");
298      assert_eq!(source.len(), 1);
299  
300      source.set("KEY1", "new-value");
301      assert_eq!(source.len(), 2);
302  }
303  
304  #[test]
305  fn test_memory_source_clone_behavior() {
306      let source1 = MemorySource::new();
307      let source2 = MemorySource::new();
308  
309      source1.set("KEY1", "value1");
310      source2.set("KEY2", "value2");
311  
312      let snapshot1 = source1.load().unwrap();
313      let snapshot2 = source2.load().unwrap();
314  
315      assert_eq!(snapshot1.variables.len(), 1);
316      assert_eq!(snapshot2.variables.len(), 1);
317      assert_ne!(
318          snapshot1.variables[0].key.as_str(),
319          snapshot2.variables[0].key.as_str()
320      );
321  }
322  
323  #[test]
324  fn test_memory_source_metadata() {
325      let source = MemorySource::new();
326      let metadata = source.metadata();
327  
328      assert_eq!(metadata.display_name, None);
329      assert_eq!(metadata.description, None);
330      assert_eq!(metadata.error_count, 0);
331      assert!(metadata.last_refreshed.is_none());
332  }
333  
334  #[test]
335  fn test_memory_source_value_types() {
336      let source = MemorySource::new();
337  
338      source.set("STRING_KEY", "string");
339      source.set("NUMERIC_KEY", "12345");
340      source.set("EMPTY_KEY", "");
341      source.set("WHITESPACE_KEY", "   ");
342  
343      let snapshot = source.load().unwrap();
344      assert_eq!(snapshot.variables.len(), 4);
345  }
346  
347  #[test]
348  fn test_memory_source_key_case_sensitivity() {
349      let source = MemorySource::new();
350  
351      source.set("lowercase_key", "value1");
352      source.set("UPPERCASE_KEY", "value2");
353      source.set("MixedCase_Key", "value3");
354  
355      let snapshot = source.load().unwrap();
356      assert_eq!(snapshot.variables.len(), 3);
357  
358      let keys: Vec<_> = snapshot.variables.iter().map(|v| v.key.as_str()).collect();
359      assert!(keys.contains(&"lowercase_key"));
360      assert!(keys.contains(&"UPPERCASE_KEY"));
361      assert!(keys.contains(&"MixedCase_Key"));
362  }