lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

source_original_queue_tests.rs (3419B)


      1 use super::*;
      2 
      3 #[test]
      4 fn pending_count_refuses_next_entry_without_evicting_originals() {
      5     let mut queue = OriginalQueue::default();
      6     let baseline = queue.retained_bytes();
      7     for i in 0..MAX_PENDING_EVENTS {
      8         assert!(queue.insert(1, i as u64, [0; 32], "synthetic original"));
      9     }
     10     let exact = queue.retained_bytes();
     11     assert_eq!(
     12         exact,
     13         baseline + MAX_PENDING_EVENTS * "synthetic original".len()
     14     );
     15     assert!(!queue.insert(2, 999, [0; 32], "next"));
     16     assert_eq!(queue.retained_bytes(), exact);
     17     assert_eq!(
     18         queue.take(0, [0; 32]).as_deref(),
     19         Some("synthetic original")
     20     );
     21     assert!(queue.insert(2, 999, [0; 32], "next"));
     22 }
     23 
     24 #[test]
     25 fn complete_byte_bound_includes_reserved_entries_and_releases_only_taken_or_owned_data() {
     26     let mut queue = OriginalQueue::default();
     27     let baseline = queue.retained_bytes();
     28     let mut index = 0;
     29     while MAX_PENDING_BYTES - queue.retained_bytes() > MAX_ORIGINAL_EVENT_BYTES {
     30         assert!(queue.insert(1, index, [0; 32], &"a".repeat(MAX_ORIGINAL_EVENT_BYTES)));
     31         index += 1;
     32     }
     33     let remaining = MAX_PENDING_BYTES - queue.retained_bytes();
     34     assert!(queue.insert(2, index, [0; 32], &"b".repeat(remaining)));
     35     assert_eq!(queue.retained_bytes(), MAX_PENDING_BYTES);
     36     assert!(!queue.insert(3, index + 1, [0; 32], "x"));
     37     assert_eq!(queue.retained_bytes(), MAX_PENDING_BYTES);
     38     assert_eq!(queue.take(index, [0; 32]).unwrap().len(), remaining);
     39     assert_eq!(queue.retained_bytes(), MAX_PENDING_BYTES - remaining);
     40     queue.remove_owner(1);
     41     assert_eq!(queue.retained_bytes(), baseline);
     42     assert!(queue.entries.is_empty());
     43     assert!(!queue.insert(1, 1, [0; 32], &"a".repeat(MAX_ORIGINAL_EVENT_BYTES + 1)));
     44     assert_eq!(queue.retained_bytes(), baseline);
     45 }
     46 
     47 #[test]
     48 fn correlation_is_scoped_fifo_and_never_reconstructs_original_spelling() {
     49     let mut queue = OriginalQueue::default();
     50     assert!(queue.insert(1, 10, [1; 32], "{ \"a\": 1 }"));
     51     assert!(queue.insert(1, 10, [1; 32], "{\"a\":1}"));
     52     assert!(queue.insert(2, 20, [1; 32], "another scope"));
     53     assert!(queue.take(10, [2; 32]).is_none());
     54     assert!(queue.take(99, [1; 32]).is_none());
     55     assert_eq!(queue.take(10, [1; 32]).as_deref(), Some("{ \"a\": 1 }"));
     56     queue.remove_scope(10);
     57     assert!(queue.take(10, [1; 32]).is_none());
     58     assert_eq!(queue.take(20, [1; 32]).as_deref(), Some("another scope"));
     59     assert!(!format!("{queue:?}").contains("another scope"));
     60 }
     61 
     62 #[test]
     63 fn raw_frame_projection_preserves_object_bytes_and_bounds_header_decoding() {
     64     let raw = "[\"EV\\u0045NT\",\"a\\u0062\", { \"unknown\": [1, 2] }]";
     65     let (subscription, value) = frame(raw).unwrap();
     66     assert_eq!(subscription, "ab");
     67     assert_eq!(value.get(), "{ \"unknown\": [1, 2] }");
     68     for raw in [
     69         "[]".into(),
     70         "{}".into(),
     71         "[\"EVENT\",\"a\"]".into(),
     72         "[\"EVENT\",\"\",{}]".into(),
     73         "[\"EOSE\",\"a\",{}]".into(),
     74         format!("[\"{}\",\"a\",{{}}]", "E".repeat(33)),
     75         format!("[\"EVENT\",\"{}\",{{}}]", "a".repeat(6 * 256 + 1)),
     76         format!("[\"EVENT\",\"{}\",{{}}]", "a".repeat(257)),
     77         format!(
     78             "[\"EVENT\",\"a\",{{\"large\":\"{}\"}}]",
     79             "a".repeat(MAX_ORIGINAL_EVENT_BYTES)
     80         ),
     81         "x".repeat(crate::session_socket::MAX_WIRE_MESSAGE_BYTES + 1),
     82     ] {
     83         assert!(frame(&raw).is_none());
     84     }
     85 }