Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_o3db_sync/tests/presence_agree.rs

5.8 KiB, 1 run

created by r1870400018:74307, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1//! A presence query gives `get`'s answer, whatever the key's history.
2//!
3//! Over a seeded mix of keys -- small values of every length up to and past a tombstone's, values
4//! large enough to be chunked, deleted keys, keys deleted and written again, and keys never
5//! written -- `contains` must agree with `get(..).is_some()` for every key: with the values
6//! cached, with them cleared from the cache so a tombstone-length record is read, and after a
7//! reopen. The store is unencrypted, so a small value can have a tombstone's length exactly.
8//!
9//! [Written with AI entirely](https://need2know.ai/entirely-ai/code)\
10//! Anthropic Claude
11
12use oxedyne_fe2o3_core::prelude::*;
13use oxedyne_fe2o3_hash::{
14 csum::ChecksumScheme,
15 hash::HashScheme,
16};
17use oxedyne_fe2o3_iop_db::api::Database;
18use oxedyne_fe2o3_jdat::prelude::*;
19use oxedyne_fe2o3_o3db_sync::{
20 O3db,
21 base::{
22 constant,
23 id::usr_kind_id_deleted,
24 },
25 comm::response::Wait,
26 data::core::RestSchemesInput,
27 test::setup,
28};
29
30use std::{
31 path::PathBuf,
32 time::Duration,
33};
34
35
36type Db = O3db<{ setup::UID_LEN }, setup::Uid, (), HashScheme, HashScheme, ChecksumScheme>;
37
38const SEED: u64 = 0x5eed_0f_0a_be5e;
39const KEYS: usize = 600;
40const OPS: usize = 1_500;
41
42// A xorshift, so the mix is the same on every run and a failure names its seed.
43struct Rng(u64);
44
45impl Rng {
46 fn next(&mut self) -> u64 {
47 self.0 ^= self.0 << 13;
48 self.0 ^= self.0 >> 7;
49 self.0 ^= self.0 << 17;
50 self.0
51 }
52 fn below(&mut self, n: usize) -> usize {
53 (self.next() % n as u64) as usize
54 }
55}
56
57fn key(i: usize) -> Dat {
58 dat!(fmt!("k{:04}", i))
59}
60
61fn wait() -> Wait {
62 Wait {
63 max_wait: Duration::from_secs(30),
64 check_interval: constant::CHECK_INTERVAL,
65 }
66}
67
68fn open(root: &PathBuf, wipe: bool) -> Outcome<Db> {
69 let schms_input = RestSchemesInput::new(
70 None::<()>,
71 None::<HashScheme>,
72 None::<HashScheme>,
73 Some(ChecksumScheme::new_crc32()),
74 );
75 let mut cfg = res!(setup::default_cfg());
76 cfg.zone_overrides = DaticleMap::new();
77 // The test geometry: a value past 1,500 bytes is chunked.
78 setup::start_db(root.clone(), Some(cfg), schms_input, None, false, wipe)
79}
80
81// A string whose encoding is `len` bytes, or the nearest under it.
82fn value(rng: &mut Rng, len: usize) -> Outcome<Dat> {
83 let mut n = len;
84 loop {
85 let v = Dat::Str((0..n).map(|_| (b'a' + (rng.next() % 26) as u8) as char).collect());
86 if n == 0 || res!(v.as_bytes()).len() <= len {
87 return Ok(v);
88 }
89 n -= 1;
90 }
91}
92
93fn agree(db: &Db, when: &str) -> Outcome<usize> {
94 let all: Vec<Dat> = (0..KEYS).map(key).collect();
95 let held = res!(db.contains_many(&all, None));
96 let mut n = 0;
97 for (i, k) in all.iter().enumerate() {
98 let got = res!(db.get(k, None)).is_some();
99 if held[i] != got {
100 return Err(err!(
101 "{}, seed {:#x}: for {:?}, contains says {} and get says {}.",
102 when, SEED, k, held[i], got;
103 Test, Mismatch));
104 }
105 if res!(db.contains(k, None)) != got {
106 return Err(err!(
107 "{}, seed {:#x}: for {:?}, contains of one key says {} and get says {}.",
108 when, SEED, k, !got, got;
109 Test, Mismatch));
110 }
111 if got {
112 n += 1;
113 }
114 }
115 println!("{}: {} of {} keys held, contains agreeing with get on all", when, n, KEYS);
116 Ok(n)
117}
118
119#[test]
120fn presence_agrees_with_get() -> Outcome<()> {
121 log_set_level!("warn");
122 let outcome = run();
123 log_finish_wait!();
124 outcome
125}
126
127fn run() -> Outcome<()> {
128 let root = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("test_db_presence_agree");
129 let _ = std::fs::remove_dir_all(&root);
130 res!(std::fs::create_dir_all(&root));
131 let root = res!(root.canonicalize());
132
133 let tomb = res!(Dat::Usr(usr_kind_id_deleted(), Some(Box::new(Dat::Empty))).as_bytes());
134 let user = setup::Uid::default();
135 let mut rng = Rng(SEED);
136 {
137 let db = res!(open(&root, true));
138 let (mut puts, mut dels, mut at_tomb) = (0, 0, 0);
139 for _ in 0..OPS {
140 // Keys past 5/6 of the range are never written.
141 let i = rng.below(KEYS * 5 / 6);
142 match rng.below(10) {
143 0..=2 => {
144 res!(db.delete(&key(i), user, None));
145 dels += 1;
146 },
147 _ => {
148 let len = match rng.below(5) {
149 0 => tomb.len(), // a tombstone's length exactly
150 1 => 1_600 + rng.below(4_000), // chunked
151 _ => 2 + rng.below(40),
152 };
153 let v = res!(value(&mut rng, len));
154 if res!(v.as_bytes()).len() == tomb.len() {
155 at_tomb += 1;
156 }
157 res!(db.insert(key(i), v, user, None));
158 puts += 1;
159 },
160 }
161 }
162 println!("seed {:#x}: {} puts ({} of a tombstone's length), {} deletes over {} keys",
163 SEED, puts, at_tomb, dels, KEYS);
164 if at_tomb == 0 {
165 return Err(err!("No value of a tombstone's length was written."; Test, Missing));
166 }
167 let cached = res!(agree(&db, "values cached"));
168 res!(db.api().clear_cache_values(wait()));
169 let cleared = res!(agree(&db, "values cleared"));
170 if cached != cleared {
171 return Err(err!("Clearing the cache changed the keys held, {} to {}.", cached, cleared;
172 Test, Mismatch));
173 }
174 res!(db.close());
175 }
176 {
177 let db = res!(open(&root, false));
178 res!(agree(&db, "reopened"));
179 res!(db.close());
180 }
181 let _ = std::fs::remove_dir_all(&root);
182 Ok(())
183}