Skip to main content

libkeri/keri/db/subing/
catcesrioset.rs

1use crate::cesr::Parsable;
2use crate::keri::db::dbing::LMDBer;
3use crate::keri::db::subing::catcesr::CatCesrSuberBase;
4use crate::keri::db::subing::ioset::IoSetSuber;
5use crate::keri::db::subing::SuberError;
6use crate::Matter;
7use std::sync::Arc;
8
9pub struct CatCesrIoSetSuber<M: Matter> {
10    pub base: CatCesrSuberBase<M>,
11    pub io_set_suber: IoSetSuber,
12}
13
14impl<M: Matter + Parsable> CatCesrIoSetSuber<M> {
15    pub fn new(
16        db: Arc<LMDBer>,
17        subkey: &str,
18        formats: Vec<String>,
19        sep: Option<u8>,
20        verify: bool,
21    ) -> Result<Self, SuberError> {
22        let base = CatCesrSuberBase::new(db.clone(), subkey, formats, sep, verify)?;
23        let io_set_suber = IoSetSuber::new(db, subkey, sep, verify)?;
24
25        Ok(Self { base, io_set_suber })
26    }
27
28    // Wrapper methods from CatCesrSuberBase (base)
29    pub fn ser(&self, val: &[&dyn Matter]) -> Result<Vec<u8>, SuberError> {
30        self.base.ser(val)
31    }
32
33    pub fn des(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
34        self.base.des(val)
35    }
36
37    // Wrapper methods from IoSetSuber (io_set_suber)
38    pub fn put<K: AsRef<[u8]>>(
39        &self,
40        keys: &[K],
41        vals: &[&dyn Matter],
42    ) -> Result<bool, SuberError> {
43        let sval = self.ser(vals)?;
44        let sbuf = vec![&sval];
45        self.io_set_suber.put(keys, &sbuf)
46    }
47
48    pub fn add<K: AsRef<[u8]>>(
49        &self,
50        keys: &[K],
51        vals: &[&dyn Matter],
52    ) -> Result<bool, SuberError> {
53        let sval = self.ser(vals)?;
54        self.io_set_suber.add(keys, &sval)
55    }
56
57    pub fn pin<K: AsRef<[u8]>>(
58        &self,
59        keys: &[K],
60        valss: &[&[&dyn Matter]], // Now accepts an array of arrays of Matter
61    ) -> Result<bool, SuberError> {
62        let mut sbuf = Vec::with_capacity(valss.len());
63        for vals in valss {
64            sbuf.push(self.ser(vals)?);
65        }
66        self.io_set_suber
67            .pin(keys, &sbuf.iter().collect::<Vec<_>>())
68    }
69
70    pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Vec<Vec<Box<dyn Matter>>>, SuberError> {
71        let vals = self.io_set_suber.get::<K, Vec<u8>>(keys)?;
72        let mut result = vec![];
73
74        for val in vals {
75            result.push(self.des(&val)?);
76        }
77
78        Ok(result)
79    }
80
81    pub fn get_iter<K: AsRef<[u8]>>(
82        &self,
83        keys: &[K],
84    ) -> Result<Vec<Result<Vec<Box<dyn Matter>>, SuberError>>, SuberError> {
85        // Get the Vec<u8> iterator from io_set_suber
86        let iter = self.io_set_suber.get_iter::<K, Vec<u8>>(keys)?;
87
88        // Collect and transform each result
89        let mut results = Vec::new();
90        for val_result in iter {
91            let matter_result = match val_result {
92                Ok(val) => self.des(&val),
93                Err(e) => Err(e),
94            };
95            results.push(matter_result);
96        }
97
98        Ok(results)
99    }
100
101    pub fn get_last<K: AsRef<[u8]>>(
102        &self,
103        keys: &[K],
104    ) -> Result<Option<Vec<Box<dyn Matter>>>, SuberError> {
105        match self.io_set_suber.get_last::<K, Vec<u8>>(keys)? {
106            Some(val) => {
107                let deserialized = self.des(&val)?;
108                Ok(Some(deserialized))
109            }
110            None => Ok(None),
111        }
112    }
113
114    pub fn rem<K: AsRef<[u8]>>(
115        &self,
116        keys: &[K],
117        vals: Option<&[&dyn Matter]>, // Changed to accept an array of Matter
118    ) -> Result<bool, SuberError> {
119        match vals {
120            Some(vs) => {
121                let sval = self.ser(vs)?; // Now we serialize all the values
122                self.io_set_suber.rem(keys, Some(&sval))
123            }
124            None => self.io_set_suber.rem::<K, Vec<u8>>(keys, None),
125        }
126    }
127
128    pub fn cnt<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<usize, SuberError> {
129        self.io_set_suber.cnt(keys)
130    }
131
132    pub fn get_item_iter<K: AsRef<[u8]>>(
133        &self,
134        keys: &[K],
135        topive: bool,
136    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<Box<dyn Matter>>)>, SuberError> {
137        let items = self
138            .io_set_suber
139            .get_item_iter::<K, Vec<u8>>(keys, topive)?;
140        self.process_items(items)
141    }
142
143    // Helper method for processing items (similar to CatCesrSuber)
144    pub fn process_items(
145        &self,
146        items: Vec<(Vec<Vec<u8>>, Vec<u8>)>,
147    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<Box<dyn Matter>>)>, SuberError> {
148        let mut result = Vec::with_capacity(items.len());
149
150        for (key, val) in items {
151            let deserialized = self.des(&val)?;
152            result.push((key, deserialized));
153        }
154
155        Ok(result)
156    }
157
158    // Wrapper methods from SuberBase (base.base.base)
159    pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
160        self.base.base.base.to_key(keys, topive)
161    }
162
163    pub fn to_keys(&self, key: &[u8]) -> Vec<Vec<u8>> {
164        self.base.base.base.to_keys(key)
165    }
166
167    pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
168        self.base.base.base.trim(keys, topive)
169    }
170
171    pub fn get_full_item_iter<K: AsRef<[u8]>>(
172        &self,
173        keys: &[K],
174        topive: bool,
175    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
176        self.base.base.base.get_full_item_iter(keys, topive)
177    }
178
179    pub fn cnt_all(&self) -> Result<usize, SuberError> {
180        self.base.base.base.cnt_all()
181    }
182}
183#[cfg(test)]
184mod tests {
185    use std::sync::Arc;
186
187    use crate::cesr::diger::Diger;
188    use crate::cesr::indexing::siger::Siger;
189    use crate::cesr::seqner::Seqner;
190    use crate::keri::db::dbing::LMDBer;
191    use crate::keri::db::subing::SuberError;
192    use crate::Matter;
193
194    use super::CatCesrIoSetSuber;
195
196    #[test]
197    fn test_cat_cesr_ioset_suber() -> Result<(), SuberError> {
198        // Create temporary database with LMDBerBuilder
199        let lmdb = LMDBer::builder().temp(true).build()?;
200        let db = Arc::new(lmdb);
201
202        // Test default constructor
203        let formats = vec!["seqner".to_string(), "diger".to_string()];
204        let sdb =
205            CatCesrIoSetSuber::<Diger>::new(db.clone(), "bags.", formats.clone(), None, false)?;
206
207        // Create test data
208        let sqr0 = Seqner::from_sn(20);
209        assert_eq!(sqr0.qb64(), "0AAAAAAAAAAAAAAAAAAAAAAU");
210
211        let dgr0 = Diger::from_ser(b"Hello Me Maties.", None)?;
212        assert_eq!(dgr0.qb64(), "ELq6uSA62FaWKAQf2rclt4D1wRAeVwQ7hBucDG43GrsJ");
213
214        let vals0: [&dyn Matter; 2] = [&sqr0, &dgr0];
215
216        // Test serialization and deserialization
217        let val0b = sdb.ser(&vals0)?;
218        assert_eq!(val0b, [sqr0.qb64b(), dgr0.qb64b()].concat());
219
220        let vals = sdb.des(&val0b)?;
221        assert_eq!(vals.len(), 2);
222        assert_eq!(vals[0].qb64(), sqr0.qb64());
223        assert_eq!(vals[1].qb64(), dgr0.qb64());
224
225        // Create more test data
226        let sqr1 = Seqner::from_sn(32);
227        assert_eq!(sqr1.qb64(), "0AAAAAAAAAAAAAAAAAAAAAAg");
228
229        let dgr1 = Diger::from_ser(b"Hi Guy.", None)?;
230        assert_eq!(dgr1.qb64(), "EAdfsnL-ko8ldxIZ9JL-KBTD4eMCqAAkEw4HmKFsT45C");
231
232        let vals1: [&dyn Matter; 2] = [&sqr1, &dgr1];
233
234        let sqr2 = Seqner::from_sn(1534);
235        assert_eq!(sqr2.qb64(), "0AAAAAAAAAAAAAAAAAAAAAX-");
236
237        let dgr2 = Diger::from_ser(b"Bye Bye Birdie.", None)?;
238        assert_eq!(dgr2.qb64(), "EAO4UVcSfvfoGnSzJycMiihykJyYOshsyvU_l8U5TrO2");
239
240        let vals2: [&dyn Matter; 2] = [&sqr2, &dgr2];
241
242        let keys0 = ["a", "front"];
243        let keys1 = ["ab", "side"];
244        let keys2 = ["ac", "back"];
245
246        // Test put and get
247        assert!(sdb.put(&keys0, &vals0)?);
248        assert_eq!(sdb.cnt(&keys0)?, 1);
249
250        assert!(sdb.put(&keys0, &vals1)?);
251        assert_eq!(sdb.cnt(&keys0)?, 2);
252
253        let actuals = sdb.get(&keys0)?;
254        assert_eq!(actuals.len(), 2);
255
256        // Check first result matches vals0
257        assert_eq!(actuals[0].len(), 2);
258        assert_eq!(actuals[0][0].qb64(), sqr0.qb64());
259        assert_eq!(actuals[0][1].qb64(), dgr0.qb64());
260
261        // Check second result matches vals1
262        assert_eq!(actuals[1].len(), 2);
263        assert_eq!(actuals[1][0].qb64(), sqr1.qb64());
264        assert_eq!(actuals[1][1].qb64(), dgr1.qb64());
265
266        // Test get_last
267        let actual = sdb.get_last(&keys0)?;
268        assert!(actual.is_some());
269        let actual = actual.unwrap();
270        assert_eq!(actual.len(), 2);
271        assert_eq!(actual[0].qb64(), sqr1.qb64());
272        assert_eq!(actual[1].qb64(), dgr1.qb64());
273
274        // Test remove
275        assert!(sdb.rem(&keys0, None)?);
276        let empty_results = sdb.get(&keys0)?;
277        assert_eq!(empty_results.len(), 0);
278        assert_eq!(sdb.cnt(&keys0)?, 0);
279
280        // Test put again with different order
281        assert!(sdb.put(&keys0, &vals1)?);
282        assert!(sdb.put(&keys0, &vals0)?);
283
284        let actuals = sdb.get(&keys0)?;
285        assert_eq!(actuals.len(), 2);
286
287        // Check first result matches vals1
288        assert_eq!(actuals[0].len(), 2);
289        assert_eq!(actuals[0][0].qb64(), sqr1.qb64());
290        assert_eq!(actuals[0][1].qb64(), dgr1.qb64());
291
292        // Check second result matches vals0
293        assert_eq!(actuals[1].len(), 2);
294        assert_eq!(actuals[1][0].qb64(), sqr0.qb64());
295        assert_eq!(actuals[1][1].qb64(), dgr0.qb64());
296
297        // Test get_last again
298        let actual = sdb.get_last(&keys0)?;
299        assert!(actual.is_some());
300        let actual = actual.unwrap();
301        assert_eq!(actual.len(), 2);
302        assert_eq!(actual[0].qb64(), sqr0.qb64());
303        assert_eq!(actual[1].qb64(), dgr0.qb64());
304        // Create the values
305        let sqr2 = Seqner::from_sn(1534);
306        assert_eq!(sqr2.qb64(), "0AAAAAAAAAAAAAAAAAAAAAX-");
307
308        let dgr2 = Diger::from_ser(b"Bye Bye Birdie.", None)?;
309        assert_eq!(dgr2.qb64(), "EAO4UVcSfvfoGnSzJycMiihykJyYOshsyvU_l8U5TrO2");
310
311        let vals2: [&dyn Matter; 2] = [&sqr2, &dgr2];
312
313        // Test add
314        assert!(sdb.add(&keys0, &vals2)?);
315
316        assert_eq!(sdb.cnt(&keys0)?, 3);
317
318        let actuals = sdb.get(&keys0)?;
319        assert_eq!(actuals.len(), 3);
320
321        // Check last result
322        assert_eq!(actuals[2].len(), 2);
323        assert_eq!(actuals[2][0].qb64(), sqr2.qb64());
324        assert_eq!(actuals[2][1].qb64(), dgr2.qb64());
325
326        // Test pin
327        assert!(sdb.pin(&keys0, &[&vals0[..], &vals1[..]])?);
328        assert_eq!(sdb.cnt(&keys0)?, 2);
329
330        let actuals = sdb.get(&keys0)?;
331        assert_eq!(actuals.len(), 2);
332
333        // Check values after pin
334        assert_eq!(actuals[0].len(), 2);
335        assert_eq!(actuals[0][0].qb64(), sqr0.qb64());
336        assert_eq!(actuals[0][1].qb64(), dgr0.qb64());
337
338        assert_eq!(actuals[1].len(), 2);
339        assert_eq!(actuals[1][0].qb64(), sqr1.qb64());
340        assert_eq!(actuals[1][1].qb64(), dgr1.qb64());
341
342        // Test put on another key
343        assert!(sdb.put(&keys1, &vals2)?);
344        assert!(sdb.put(&keys1, &vals1)?);
345        assert_eq!(sdb.cnt(&keys1)?, 2);
346
347        let actuals = sdb.get(&keys1)?;
348        assert_eq!(actuals.len(), 2);
349
350        // Check first result for keys1
351        assert_eq!(actuals[0].len(), 2);
352        assert_eq!(actuals[0][0].qb64(), sqr2.qb64());
353        assert_eq!(actuals[0][1].qb64(), dgr2.qb64());
354
355        // Test get_iter
356        let vals_iter = sdb.get_iter(&keys1)?;
357        let mut iter_results = Vec::new();
358
359        for val_result in vals_iter {
360            iter_results.push(val_result?);
361        }
362
363        assert_eq!(iter_results.len(), 2);
364        assert_eq!(iter_results[0][0].qb64(), sqr2.qb64());
365        assert_eq!(iter_results[0][1].qb64(), dgr2.qb64());
366        assert_eq!(iter_results[1][0].qb64(), sqr1.qb64());
367        assert_eq!(iter_results[1][1].qb64(), dgr1.qb64());
368
369        // Test rem with specific value
370        assert!(sdb.rem(&keys1, Some(&vals1[..]))?);
371        assert_eq!(sdb.cnt(&keys1)?, 1);
372
373        let actuals = sdb.get(&keys1)?;
374        assert_eq!(actuals.len(), 1);
375        assert_eq!(actuals[0][0].qb64(), sqr2.qb64());
376        assert_eq!(actuals[0][1].qb64(), dgr2.qb64());
377
378        // Test put on third key
379        assert!(sdb.put(&keys2, &vals0)?);
380        assert!(sdb.put(&keys2, &vals2)?);
381
382        // Test get_item_iter without keys (all items)
383        let items = sdb.get_item_iter(&[] as &[&str], false)?;
384
385        // Convert to a comparable format
386        let mut formatted_items = Vec::new();
387        for (keys, vals) in items {
388            let key_strs: Vec<String> = keys
389                .iter()
390                .map(|k| String::from_utf8_lossy(k).to_string())
391                .collect();
392
393            let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
394
395            formatted_items.push((key_strs, val_qb64s));
396        }
397
398        // Test should have all items from all keys
399        assert_eq!(formatted_items.len(), 5);
400
401        // Verify that items contain all expected entries
402        let expected_pairs = [
403            (
404                vec!["a".to_string(), "front".to_string()],
405                vec![sqr0.qb64(), dgr0.qb64()],
406            ),
407            (
408                vec!["a".to_string(), "front".to_string()],
409                vec![sqr1.qb64(), dgr1.qb64()],
410            ),
411            (
412                vec!["ab".to_string(), "side".to_string()],
413                vec![sqr2.qb64(), dgr2.qb64()],
414            ),
415            (
416                vec!["ac".to_string(), "back".to_string()],
417                vec![sqr0.qb64(), dgr0.qb64()],
418            ),
419            (
420                vec!["ac".to_string(), "back".to_string()],
421                vec![sqr2.qb64(), dgr2.qb64()],
422            ),
423        ];
424
425        // Verify all expected pairs are in formatted_items
426        for expected in &expected_pairs {
427            assert!(
428                formatted_items
429                    .iter()
430                    .any(|item| { item.0 == expected.0 && item.1 == expected.1 }),
431                "Expected item not found: {:?}",
432                expected
433            );
434        }
435
436        // Test getFullItemIter - accessing internal ordinal values
437        let full_items = sdb.get_full_item_iter(&[] as &[&str], false)?;
438        assert_eq!(full_items.len(), 5);
439
440        // Process full items to extract the ordinal suffix
441        let mut formatted_full_items = Vec::new();
442        for (keys, val) in full_items {
443            // Extract key parts including ordinal suffix
444            let key_strs: Vec<String> = keys
445                .iter()
446                .map(|k| String::from_utf8_lossy(k).to_string())
447                .collect();
448
449            // Deserialize value
450            let vals = sdb.des(&val)?;
451            let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
452
453            formatted_full_items.push((key_strs, val_qb64s));
454        }
455
456        // Verify that key format has three parts (key1, key2, ordinal)
457        for (keys, _) in &formatted_full_items {
458            assert_eq!(keys.len(), 3, "Full item keys should have 3 parts");
459            assert!(
460                keys[2].starts_with("00000000000000000000000000000"),
461                "Third key part should be an ordinal: {}",
462                keys[2]
463            );
464        }
465
466        // Test get_item_iter with specific keys for keys0
467        let items = sdb.get_item_iter(&keys0, false)?;
468
469        let mut formatted_items = Vec::new();
470        for (keys, vals) in items {
471            let key_strs: Vec<String> = keys
472                .iter()
473                .map(|k| String::from_utf8_lossy(k).to_string())
474                .collect();
475
476            let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
477
478            formatted_items.push((key_strs, val_qb64s));
479        }
480
481        assert_eq!(formatted_items.len(), 2);
482        // Verify items for keys0
483        assert!(formatted_items.iter().any(|item| {
484            item.0 == vec!["a".to_string(), "front".to_string()]
485                && item.1 == vec![sqr0.qb64(), dgr0.qb64()]
486        }));
487        assert!(formatted_items.iter().any(|item| {
488            item.0 == vec!["a".to_string(), "front".to_string()]
489                && item.1 == vec![sqr1.qb64(), dgr1.qb64()]
490        }));
491
492        // Test with topkeys for partial tree match
493        let topkeys = ["a", ""];
494        let items = sdb.get_item_iter(&topkeys, false)?;
495
496        let mut formatted_items = Vec::new();
497        for (keys, vals) in items {
498            let key_strs: Vec<String> = keys
499                .iter()
500                .map(|k| String::from_utf8_lossy(k).to_string())
501                .collect();
502
503            let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
504
505            formatted_items.push((key_strs, val_qb64s));
506        }
507
508        // Only keys0 entries should be returned with topkeys=["a", ""]
509        assert_eq!(formatted_items.len(), 2);
510        for item in &formatted_items {
511            assert_eq!(item.0[0], "a");
512            assert_eq!(item.0[1], "front");
513        }
514
515        // Test using get_full_item_iter with topkeys
516        let items = sdb.get_full_item_iter(&topkeys, true)?;
517        let mut vals_count = 0;
518
519        // Process and convert the values to verify
520        for (keys, val) in &items {
521            let key_parts: Vec<String> = keys
522                .iter()
523                .map(|k| String::from_utf8_lossy(k).to_string())
524                .collect();
525
526            // Ensure we're looking at "a" prefix keys
527            assert_eq!(key_parts[0], "a");
528
529            // Count number of entries for verification
530            vals_count += 1;
531        }
532
533        // Should get items with keys starting with "a"
534        assert_eq!(vals_count, 2);
535
536        // Test trim operation with specific prefix
537        assert!(sdb.trim(&["ab", ""], false)?);
538
539        // Verify keys1 entries are removed
540        let items = sdb.get_item_iter(&keys1, false)?;
541        assert_eq!(items.len(), 0);
542
543        // Verify total count after trim
544        let items = sdb.get_item_iter(&[] as &[&str], false)?;
545        let mut formatted_items = Vec::new();
546        for (keys, vals) in items {
547            let key_strs: Vec<String> = keys
548                .iter()
549                .map(|k| String::from_utf8_lossy(k).to_string())
550                .collect();
551
552            let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
553
554            formatted_items.push((key_strs, val_qb64s));
555        }
556
557        // Now should only have keys0 and keys2 entries (4 total)
558        assert_eq!(formatted_items.len(), 4);
559
560        // Check remaining keys
561        let mut has_keys0 = false;
562        let mut has_keys2 = false;
563        for (keys, _) in &formatted_items {
564            if keys[0] == "a" && keys[1] == "front" {
565                has_keys0 = true;
566            } else if keys[0] == "ac" && keys[1] == "back" {
567                has_keys2 = true;
568            }
569        }
570        assert!(has_keys0, "Keys0 entries should still exist after trim");
571        assert!(has_keys2, "Keys2 entries should still exist after trim");
572
573        // Test trim with top parameters (removing keys0 entries)
574        assert!(sdb.trim(&["a"], true)?);
575
576        // Verify keys0 entries are removed but keys2 still exist
577        let items = sdb.get_item_iter(&[] as &[&str], false)?;
578        let mut formatted_items = Vec::new();
579        for (keys, vals) in items {
580            let key_strs: Vec<String> = keys
581                .iter()
582                .map(|k| String::from_utf8_lossy(k).to_string())
583                .collect();
584
585            let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
586
587            formatted_items.push((key_strs, val_qb64s));
588        }
589
590        // Should only have keys2 entries left
591        assert_eq!(formatted_items.len(), 2);
592        for (keys, _) in &formatted_items {
593            assert_eq!(keys[0], "ac");
594            assert_eq!(keys[1], "back");
595        }
596
597        // Add new test entries to verify partial tree trim
598        assert!(sdb.put(&["b", "1"], &vals0)?);
599        assert!(sdb.put(&["b", "2"], &vals1)?);
600        assert!(sdb.put(&["bc", "3"], &vals2)?);
601        assert!(sdb.put(&["ac", "4"], &vals0)?);
602
603        // Verify all entries
604        let items = sdb.get_item_iter(&[] as &[&str], false)?;
605        assert_eq!(items.len(), 6);
606
607        // Test trim with a different prefix
608        assert!(sdb.trim(&["b", ""], false)?);
609
610        // Verify "b" prefix entries are gone but "bc" remains
611        let items = sdb.get_item_iter(&[] as &[&str], false)?;
612        let mut formatted_items = Vec::new();
613        for (keys, vals) in items {
614            let key_strs: Vec<String> = keys
615                .iter()
616                .map(|k| String::from_utf8_lossy(k).to_string())
617                .collect();
618
619            let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
620
621            formatted_items.push((key_strs, val_qb64s));
622        }
623
624        // Should have keys2 (2) + new keys ac/4 (1) + bc/3 (1) = 4 entries
625        assert_eq!(formatted_items.len(), 4);
626
627        // Check that "b" prefix entries are gone
628        for (keys, _) in &formatted_items {
629            assert!(keys[0] != "b", "Entries with 'b' prefix should be removed");
630        }
631
632        // Final verification - clear all entries
633        assert!(sdb.trim(&[] as &[&str], false)?);
634        let items = sdb.get_item_iter(&[] as &[&str], false)?;
635        assert_eq!(items.len(), 0, "All entries should be removed");
636
637        // First, create the test data (similar to Python test)
638        let sqr0 = Seqner::from_sn(20);
639        assert_eq!(sqr0.qb64(), "0AAAAAAAAAAAAAAAAAAAAAAU");
640
641        let dgr0 = Diger::from_ser(b"Hello Me Maties.", None)?;
642        assert_eq!(dgr0.qb64(), "ELq6uSA62FaWKAQf2rclt4D1wRAeVwQ7hBucDG43GrsJ");
643
644        let vals0: [&dyn Matter; 2] = [&sqr0, &dgr0];
645
646        let sqr1 = Seqner::from_sn(32);
647        assert_eq!(sqr1.qb64(), "0AAAAAAAAAAAAAAAAAAAAAAg");
648
649        let dgr1 = Diger::from_ser(b"Hi Guy.", None)?;
650        assert_eq!(dgr1.qb64(), "EAdfsnL-ko8ldxIZ9JL-KBTD4eMCqAAkEw4HmKFsT45C");
651
652        let vals1: [&dyn Matter; 2] = [&sqr1, &dgr1];
653
654        let sqr2 = Seqner::from_sn(1534);
655        assert_eq!(sqr2.qb64(), "0AAAAAAAAAAAAAAAAAAAAAX-");
656
657        let dgr2 = Diger::from_ser(b"Bye Bye Birdie.", None)?;
658        assert_eq!(dgr2.qb64(), "EAO4UVcSfvfoGnSzJycMiihykJyYOshsyvU_l8U5TrO2");
659
660        let vals2: [&dyn Matter; 2] = [&sqr2, &dgr2];
661
662        // Define the keys
663        let keys0 = ["a", "front"];
664        let keys1 = ["ab", "side"];
665        let keys2 = ["ac", "back"];
666
667        // Insert data into the database (as in the Python test)
668        sdb.put(&keys0, &vals0)?;
669        sdb.put(&keys0, &vals1)?;
670        sdb.put(&keys1, &vals2)?;
671        sdb.put(&keys2, &vals0)?;
672        sdb.put(&keys2, &vals2)?;
673
674        // Debug statement to verify data in database
675        println!("DEBUG - Database state after insertion: keys0 count = {}, keys1 count = {}, keys2 count = {}",
676                 sdb.cnt(&keys0)?, sdb.cnt(&keys1)?, sdb.cnt(&keys2)?);
677
678        // Now call get_item_iter()
679        let items = sdb.get_item_iter(&[] as &[&str], false)?;
680        println!("DEBUG - get_item_iter returned {} items", items.len());
681
682        // Convert to a comparable format
683        let mut formatted_items = Vec::new();
684        for (keys, vals) in items {
685            let key_strs: Vec<String> = keys
686                .iter()
687                .map(|k| String::from_utf8_lossy(k).to_string())
688                .collect();
689
690            let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
691
692            println!("DEBUG - Item: keys={:?}, vals={:?}", key_strs, val_qb64s);
693            formatted_items.push((key_strs, val_qb64s));
694        }
695
696        // Now the test should pass with the expected 5 items
697        assert_eq!(formatted_items.len(), 5);
698
699        // Test get_item_iter with specific keys
700        let items = sdb.get_item_iter(&keys1, false)?;
701
702        let mut formatted_items = Vec::new();
703        for (keys, vals) in items {
704            let key_strs: Vec<String> = keys
705                .iter()
706                .map(|k| String::from_utf8_lossy(k).to_string())
707                .collect();
708
709            let val_qb64s: Vec<String> = vals.iter().map(|v| v.qb64()).collect();
710
711            formatted_items.push((key_strs, val_qb64s));
712        }
713
714        assert_eq!(formatted_items.len(), 1);
715        assert_eq!(
716            formatted_items[0].0,
717            vec!["ab".to_string(), "side".to_string()]
718        );
719        assert_eq!(formatted_items[0].1, vec![sqr2.qb64(), dgr2.qb64()]);
720
721        // Test get_full_item_iter
722        let items = sdb.get_full_item_iter(&["a", ""], true)?;
723
724        // Should get items with keys starting with "a"
725        assert!(items.len() >= 2); // At least the items with keys0
726        let formats2 = vec!["siger".to_string()];
727        // Test with Siger
728        let sdb_siger =
729            CatCesrIoSetSuber::<Siger>::new(db.clone(), "pigs.", formats2, None, false)?;
730
731        let sig0_qb64 = "AACdI8OSQkMJ9r-xigjEByEjIua7LHH3AOJ22PQKqljMhuhcgh9nGRcKnsz5KvKd7K_H9-1298F4Id1DxvIoEmCQ";
732        let val0 = Siger::from_qb64(sig0_qb64, None)?;
733
734        let siger_keys = ["zeta", "cat"];
735        assert!(sdb_siger.put(&siger_keys, &[&val0])?);
736
737        let actuals = sdb_siger.get(&siger_keys)?;
738        assert_eq!(actuals.len(), 1);
739        assert_eq!(actuals[0].len(), 1);
740        assert_eq!(actuals[0][0].qb64(), sig0_qb64);
741
742        // Clean up - database will be closed when db goes out of scope
743        Ok(())
744    }
745}