Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_o3db_sync/tests/ns.rs

21.1 KiB, 1 run

created by r1870400018:75879, 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//! The path namespace over Ozone (`ns`): values under paths, with a per-directory index record.
2//!
3//! A round trip of `put`, `get`, `get_capped`, `stat`, `list` and `delete`; a listing that
4//! survives a close and a reopen; a 4 MiB value, which the store chunks; an index entry whose value
5//! is gone, which reads as absent; and 50 puts from 50 threads into one directory, which must
6//! list 50 (without the mutation lane the directory's index read-modify-writes lose entries).
7//!
8//! D1z1b: a put torn after its first index write leaves no directory its parent does not list;
9//! a mutation called from inside a `put_if` predicate returns instead of waiting on itself;
10//! `delete` counts live entries only; racing `put_if`s have exactly one winner; `delete_tree`
11//! and `rename` of a three-level tree; `orphans` lists a value no index reaches; and a second
12//! `O3db::start` on one store is refused.
13//!
14//! D1z1c: a directory record that reached the disk while its parent's new entry did not (a power
15//! loss reorders the two) is relinked by the next put through it; `rename` makes the copy durable
16//! before it deletes a key of the original; and two spaces cannot share a key.
17//!
18//! Each test opens its own store under `~/.cache/lane-daimond-runner/rnd1z1-db/`.
19//!
20//! [Written with AI entirely](https://need2know.ai/entirely-ai/code)\
21//! Anthropic Claude
22
23use oxedyne_fe2o3_core::prelude::*;
24use oxedyne_fe2o3_hash::{
25 csum::ChecksumScheme,
26 hash::HashScheme,
27};
28use oxedyne_fe2o3_o3db_sync::{
29 O3db,
30 data::core::RestSchemesInput,
31 comm::response::Wait,
32 ns::{
33 self,
34 Capped,
35 Ns,
36 },
37 test::{
38 hooks::{
39 self,
40 NsStep,
41 NsTear,
42 },
43 setup::{
44 self,
45 Uid,
46 UID_LEN,
47 },
48 },
49};
50
51use std::{
52 path::PathBuf,
53 sync::{
54 Arc,
55 Barrier,
56 mpsc,
57 },
58 thread,
59 time::Duration,
60};
61
62
63type Db = O3db<{ UID_LEN }, Uid, (), HashScheme, HashScheme, ChecksumScheme>;
64type TestNs = Ns<{ UID_LEN }, Uid, (), HashScheme, HashScheme, ChecksumScheme>;
65
66fn fresh_dir(name: &str) -> Outcome<PathBuf> {
67 let home = match std::env::var_os("HOME") {
68 Some(h) => PathBuf::from(h),
69 None => return Err(err!("HOME is not set."; Test, Missing)),
70 };
71 let dir = home.join(".cache/lane-daimond-runner/rnd1z1-db").join(name);
72 let _ = std::fs::remove_dir_all(&dir);
73 res!(std::fs::create_dir_all(&dir));
74 Ok(res!(dir.canonicalize()))
75}
76
77fn open(db_root: &PathBuf, wipe: bool) -> Outcome<Arc<Db>> {
78 Ok(Arc::new(res!(start(db_root, wipe))))
79}
80
81fn start(db_root: &PathBuf, wipe: bool) -> Outcome<Db> {
82 let schms_input = RestSchemesInput::new(
83 None::<()>,
84 None::<HashScheme>,
85 None::<HashScheme>,
86 Some(ChecksumScheme::new_crc32()),
87 );
88 let mut cfg = res!(setup::default_cfg());
89 cfg.zone_overrides = Default::default();
90 setup::start_db(db_root.clone(), Some(cfg), schms_input, None, false, wipe)
91}
92
93fn wrap(outcome: Outcome<()>) -> Outcome<()> {
94 log_finish_wait!();
95 outcome
96}
97
98fn names(ns: &TestNs, dir: &str) -> Outcome<Vec<String>> {
99 match res!(ns.list(dir)) {
100 Some(entries) => Ok(entries.into_iter().map(|(n, _)| n).collect()),
101 None => Err(err!("Directory '{}' lists as absent.", dir; Test, Missing)),
102 }
103}
104
105#[test]
106fn ns_round_trip() -> Outcome<()> {
107 log_set_level!("warn");
108 wrap(round_trip())
109}
110
111fn round_trip() -> Outcome<()> {
112 let root = res!(fresh_dir("round_trip"));
113 let db = res!(open(&root, true));
114 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
115
116 res!(ns.put("a/b/c.txt", b"hello"));
117 res!(ns.put_at("a/d.txt", b"there!", 1_234));
118 assert_eq!(res!(ns.get("a/b/c.txt")), Some(b"hello".to_vec()));
119 assert_eq!(res!(ns.get("a/b/none")), None);
120
121 let st = match res!(ns.stat("a/d.txt")) {
122 Some(st) => st,
123 None => return Err(err!("stat of a/d.txt is absent."; Test, Missing)),
124 };
125 assert!(!st.is_dir);
126 assert_eq!(st.size, 6);
127 assert_eq!(st.mtime_ms, 1_234);
128 match res!(ns.stat("a/b")) {
129 Some(st) => assert!(st.is_dir),
130 None => return Err(err!("The parent a/b was not made."; Test, Missing)),
131 }
132 assert!(res!(ns.stat("")).is_some());
133 assert_eq!(res!(names(&ns, "")), vec!["a".to_string()]);
134 assert_eq!(res!(names(&ns, "a")), vec!["b".to_string(), "d.txt".to_string()]);
135 assert_eq!(res!(names(&ns, "a/b")), vec!["c.txt".to_string()]);
136 assert!(res!(ns.list("nowhere")).is_none());
137
138 // Overwrite: the index follows the new size.
139 res!(ns.put("a/b/c.txt", b"hello again"));
140 match res!(ns.stat("a/b/c.txt")) {
141 Some(st) => assert_eq!(st.size, 11),
142 None => return Err(err!("stat after an overwrite is absent."; Test, Missing)),
143 }
144
145 match res!(ns.get_capped("a/b/c.txt", 11)) {
146 Capped::Whole(b) => assert_eq!(b, b"hello again".to_vec()),
147 other => return Err(err!("get_capped at the size gave {:?}.", other; Test, Mismatch)),
148 }
149 match res!(ns.get_capped("a/b/c.txt", 10)) {
150 Capped::Over(n) => assert_eq!(n, 11),
151 other => return Err(err!("get_capped under the size gave {:?}.", other; Test, Mismatch)),
152 }
153 match res!(ns.get_capped("a/zzz", 10)) {
154 Capped::Absent => (),
155 other => return Err(err!("get_capped of nothing gave {:?}.", other; Test, Mismatch)),
156 }
157
158 // A file and a directory may not share a path.
159 assert!(ns.put("a/b", b"x").is_err());
160 assert!(ns.put("a/d.txt/e", b"x").is_err());
161 assert!(ns.put("a//e", b"x").is_err());
162 assert!(ns.put("a/../e", b"x").is_err());
163
164 // A non-empty directory is not deleted; files are, then the emptied directory.
165 assert!(ns.delete("a/b").is_err());
166 assert!(res!(ns.delete("a/b/c.txt")));
167 assert!(!res!(ns.delete("a/b/c.txt")));
168 assert_eq!(res!(ns.get("a/b/c.txt")), None);
169 assert!(res!(ns.stat("a/b/c.txt")).is_none());
170 assert!(res!(names(&ns, "a/b")).is_empty());
171 assert!(res!(ns.delete("a/b")));
172 assert!(res!(ns.list("a/b")).is_none());
173 assert_eq!(res!(names(&ns, "a")), vec!["d.txt".to_string()]);
174
175 res!(db.close());
176 Ok(())
177}
178
179#[test]
180fn ns_make_dirs_makes_folders_only() -> Outcome<()> {
181 log_set_level!("warn");
182 wrap(make_dirs())
183}
184
185fn make_dirs() -> Outcome<()> {
186 let root = res!(fresh_dir("make_dirs"));
187 let db = res!(open(&root, true));
188 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
189
190 // Every folder down to the path is made, each listing as an empty directory.
191 res!(ns.make_dirs("a/b/c"));
192 for p in ["a", "a/b", "a/b/c"] {
193 match res!(ns.stat(p)) {
194 Some(st) => assert!(st.is_dir, "{} is not a directory", p),
195 None => return Err(err!("make_dirs did not make '{}'.", p; Test, Missing)),
196 }
197 }
198 assert!(res!(names(&ns, "a/b/c")).is_empty());
199
200 // Again, over what stands: nothing in it is lost.
201 res!(ns.put("a/b/c/f", b"kept"));
202 res!(ns.make_dirs("a/b/c"));
203 res!(ns.make_dirs("a/b"));
204 assert_eq!(res!(names(&ns, "a/b/c")), vec!["f".to_string()]);
205 assert_eq!(res!(ns.get("a/b/c/f")), Some(b"kept".to_vec()));
206
207 // A value in the way is a conflict, and nothing is made beneath it.
208 res!(ns.put("v", b"x"));
209 match ns.make_dirs("v/w") {
210 Ok(()) => return Err(err!("make_dirs made a folder under a value."; Test, Mismatch)),
211 Err(e) => assert!(e.tags().contains(&ErrTag::Conflict), "{}", e),
212 }
213 assert!(ns.make_dirs("a/b/c/f").is_err());
214 assert_eq!(res!(ns.get("v")), Some(b"x".to_vec()));
215 assert!(ns.make_dirs("").is_err());
216
217 res!(db.close());
218 Ok(())
219}
220
221#[test]
222fn ns_list_after_reopen() -> Outcome<()> {
223 log_set_level!("warn");
224 wrap(list_after_reopen())
225}
226
227fn list_after_reopen() -> Outcome<()> {
228 let root = res!(fresh_dir("reopen"));
229 {
230 let db = res!(open(&root, true));
231 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
232 res!(ns.put("d/one", b"1"));
233 res!(ns.put("d/two", b"22"));
234 res!(ns.put("d/sub/three", b"333"));
235 res!(db.close());
236 }
237 {
238 let db = res!(open(&root, false));
239 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
240 assert_eq!(res!(names(&ns, "d")),
241 vec!["one".to_string(), "sub".to_string(), "two".to_string()]);
242 assert_eq!(res!(ns.get("d/sub/three")), Some(b"333".to_vec()));
243 match res!(ns.stat("d/two")) {
244 Some(st) => assert_eq!(st.size, 2),
245 None => return Err(err!("d/two is absent after a reopen."; Test, Missing)),
246 }
247 res!(db.close());
248 }
249 Ok(())
250}
251
252#[test]
253fn ns_four_mib_value_round_trips() -> Outcome<()> {
254 log_set_level!("warn");
255 wrap(four_mib())
256}
257
258fn four_mib() -> Outcome<()> {
259 let root = res!(fresh_dir("four_mib"));
260 let want: Vec<u8> = (0..4 * 1024 * 1024).map(|i: usize| ((i * 31 + 7) % 251) as u8).collect();
261 {
262 let db = res!(open(&root, true));
263 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
264 res!(ns.put("big/blob", &want));
265 match res!(ns.get("big/blob")) {
266 Some(got) => assert!(got == want, "4 MiB value came back as {} other bytes", got.len()),
267 None => return Err(err!("The 4 MiB value is absent."; Test, Missing)),
268 }
269 res!(db.close());
270 }
271 {
272 let db = res!(open(&root, false));
273 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
274 match res!(ns.get_capped("big/blob", 4 * 1024 * 1024)) {
275 Capped::Whole(got) => assert!(got == want, "4 MiB value differs after a reopen"),
276 other => return Err(err!(
277 "The 4 MiB value after a reopen gave {:?}.", other; Test, Mismatch)),
278 }
279 res!(db.close());
280 }
281 Ok(())
282}
283
284#[test]
285fn ns_index_entry_without_value_reads_absent() -> Outcome<()> {
286 log_set_level!("warn");
287 wrap(entry_without_value())
288}
289
290fn entry_without_value() -> Outcome<()> {
291 let root = res!(fresh_dir("no_value"));
292 let db = res!(open(&root, true));
293 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
294 res!(ns.put("d/kept", b"k"));
295 res!(ns.put("d/lost", b"l"));
296 // The value goes, its index entry stays: a crash between `delete`'s two writes, reversed.
297 let key = ns.value_key("d/lost");
298 let resp = db.api().responder();
299 res!(db.api().delete_using_responder(&key, Uid::default(), None, resp.clone()));
300 res!(resp.recv_delete_ack());
301
302 assert!(res!(ns.stat("d/lost")).is_none());
303 assert_eq!(res!(ns.get("d/lost")), None);
304 assert_eq!(res!(names(&ns, "d")), vec!["kept".to_string()]);
305 res!(db.close());
306 Ok(())
307}
308
309const RACERS: usize = 50;
310
311#[test]
312fn ns_fifty_interleaved_puts_list_fifty() -> Outcome<()> {
313 log_set_level!("warn");
314 wrap(fifty_puts())
315}
316
317fn fifty_puts() -> Outcome<()> {
318 let root = res!(fresh_dir("fifty"));
319 let db = res!(open(&root, true));
320 let mut hands = Vec::with_capacity(RACERS);
321 for i in 0..RACERS {
322 // A second `Ns` over the same handle shares its lane.
323 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
324 hands.push(thread::spawn(move || ns.put(&fmt!("dir/f{:02}", i), &[i as u8; 64])));
325 }
326 for h in hands {
327 match h.join() {
328 Ok(outcome) => res!(outcome),
329 Err(_) => return Err(err!("A putting thread panicked."; Test, Thread, Panic)),
330 }
331 }
332 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
333 let listed = res!(names(&ns, "dir"));
334 if listed.len() != RACERS {
335 return Err(err!(
336 "{} interleaved puts into one directory list {}.", RACERS, listed.len();
337 Test, Mismatch, Size));
338 }
339 res!(db.close());
340 Ok(())
341}
342
343// ── D1z1b ────────────────────────────────────────────────────────────────────────────────────
344
345#[test]
346fn ns_torn_put_leaves_no_unlisted_directory() -> Outcome<()> {
347 log_set_level!("warn");
348 wrap(torn_put())
349}
350
351fn torn_put() -> Outcome<()> {
352 let root = res!(fresh_dir("torn_put"));
353 let db = res!(open(&root, true));
354 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
355 res!(ns.put("a/x", b"x"));
356 // The crash: the value of a/b/c and one of its two index writes are in.
357 hooks::set_ns_tear(NsTear::Top(1));
358 res!(ns.put("a/b/c", b"c"));
359 // No directory exists that its parent does not list.
360 if res!(ns.list("a/b")).is_some() && !res!(names(&ns, "a")).contains(&"b".to_string()) {
361 return Err(err!("A torn put left a/b existing but unlisted in a."; Test, Mismatch));
362 }
363 assert_eq!(res!(names(&ns, "a")), vec!["x".to_string()]);
364 assert!(res!(ns.stat("a/b/c")).is_none());
365 // The next put through it heals the chain.
366 res!(ns.put("a/b/d", b"d"));
367 assert_eq!(res!(names(&ns, "a")), vec!["b".to_string(), "x".to_string()]);
368 assert_eq!(res!(names(&ns, "a/b")), vec!["d".to_string()]);
369 // A dead directory entry does not block a value put at its path.
370 hooks::set_ns_tear(NsTear::Top(1));
371 res!(ns.put("e/f/g", b"g"));
372 res!(ns.put("e/f", b"now a value"));
373 assert_eq!(res!(ns.get("e/f")), Some(b"now a value".to_vec()));
374 res!(db.close());
375 Ok(())
376}
377
378#[test]
379fn ns_mutation_inside_a_predicate_returns() -> Outcome<()> {
380 log_set_level!("warn");
381 wrap(mutation_in_pred())
382}
383
384fn mutation_in_pred() -> Outcome<()> {
385 let root = res!(fresh_dir("reentrant"));
386 let db = res!(open(&root, true));
387 let (tx, rx) = mpsc::channel();
388 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
389 let inner = res!(TestNs::new(db.clone(), Uid::default(), "t"));
390 let _ = thread::spawn(move || {
391 let mut nested: Option<bool> = None;
392 let outer = ns.put_if("p/q", b"1", |_| {
393 nested = Some(inner.put("p/r", b"2").is_err());
394 true
395 });
396 let _ = tx.send((outer.is_ok(), nested));
397 });
398 match rx.recv_timeout(Duration::from_secs(20)) {
399 Ok((true, Some(true))) => (),
400 Ok(other) => return Err(err!(
401 "A mutation inside a put_if predicate gave {:?}, not a refusal.", other; Test, Mismatch)),
402 Err(_) => return Err(err!(
403 "A mutation inside a put_if predicate did not return in 20 s."; Test, Timeout)),
404 }
405 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
406 assert_eq!(res!(names(&ns, "p")), vec!["q".to_string()]);
407 res!(db.close());
408 Ok(())
409}
410
411#[test]
412fn ns_delete_counts_live_entries_only() -> Outcome<()> {
413 log_set_level!("warn");
414 wrap(delete_live_only())
415}
416
417fn delete_live_only() -> Outcome<()> {
418 let root = res!(fresh_dir("delete_live"));
419 let db = res!(open(&root, true));
420 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
421 res!(ns.put("d/gone", b"g"));
422 let resp = db.api().responder();
423 res!(db.api().delete_using_responder(&ns.value_key("d/gone"), Uid::default(), None, resp.clone()));
424 res!(resp.recv_delete_ack());
425 assert!(res!(names(&ns, "d")).is_empty());
426 match ns.delete("d") {
427 Ok(true) => (),
428 other => return Err(err!(
429 "Deleting a directory with only a dead entry gave {:?}.", other; Test, Mismatch)),
430 }
431 assert!(res!(ns.list("d")).is_none());
432 assert!(res!(names(&ns, "")).is_empty());
433 res!(db.close());
434 Ok(())
435}
436
437const CAS_RACERS: usize = 8;
438const CAS_ROUNDS: usize = 5;
439
440#[test]
441fn ns_racing_put_if_has_one_winner() -> Outcome<()> {
442 log_set_level!("warn");
443 wrap(put_if_race())
444}
445
446fn put_if_race() -> Outcome<()> {
447 let root = res!(fresh_dir("put_if_race"));
448 let db = res!(open(&root, true));
449 for round in 0..CAS_ROUNDS {
450 let gate = Arc::new(Barrier::new(CAS_RACERS));
451 let mut hands = Vec::with_capacity(CAS_RACERS);
452 for i in 0..CAS_RACERS {
453 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
454 let gate = gate.clone();
455 hands.push(thread::spawn(move || {
456 gate.wait();
457 ns.put_if(&fmt!("race/r{}", round), &[i as u8; 32], |now| now.is_none())
458 }));
459 }
460 let mut wins = 0;
461 for h in hands {
462 match h.join() {
463 Ok(outcome) => if res!(outcome) { wins += 1; },
464 Err(_) => return Err(err!("A racing thread panicked."; Test, Thread, Panic)),
465 }
466 }
467 if wins != 1 {
468 return Err(err!(
469 "Round {}: {} racing put_if calls on an absent path had {} winners.",
470 round, CAS_RACERS, wins;
471 Test, Mismatch));
472 }
473 }
474 // delete_if passes or fails on the current entry.
475 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
476 assert!(!res!(ns.delete_if("race/r0", |now| now.map(|e| e.size) == Some(1))));
477 assert!(res!(ns.stat("race/r0")).is_some());
478 assert!(res!(ns.delete_if("race/r0", |now| now.map(|e| e.size) == Some(32))));
479 assert!(res!(ns.stat("race/r0")).is_none());
480 res!(db.close());
481 Ok(())
482}
483
484#[test]
485fn ns_tree_ops_on_three_levels() -> Outcome<()> {
486 log_set_level!("warn");
487 wrap(tree_ops())
488}
489
490fn tree_ops() -> Outcome<()> {
491 let root = res!(fresh_dir("tree_ops"));
492 let db = res!(open(&root, true));
493 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
494 for p in ["t/a", "t/u/b", "t/u/v/c", "t/u/v/d", "keep/k"] {
495 res!(ns.put(p, p.as_bytes()));
496 }
497
498 // rename the tree, then a value.
499 assert!(ns.rename("t", "t/inside").is_err());
500 assert!(ns.rename("t", "keep").is_err());
501 res!(ns.rename("t", "m/n"));
502 assert!(res!(ns.list("t")).is_none());
503 assert_eq!(res!(names(&ns, "")), vec!["keep".to_string(), "m".to_string()]);
504 assert_eq!(res!(names(&ns, "m/n")), vec!["a".to_string(), "u".to_string()]);
505 assert_eq!(res!(names(&ns, "m/n/u/v")), vec!["c".to_string(), "d".to_string()]);
506 assert_eq!(res!(ns.get("m/n/u/v/d")), Some(b"t/u/v/d".to_vec()));
507 assert_eq!(res!(ns.get("t/u/v/d")), None);
508 res!(ns.rename("m/n/u/b", "keep/b2"));
509 assert_eq!(res!(names(&ns, "keep")), vec!["b2".to_string(), "k".to_string()]);
510 assert_eq!(res!(names(&ns, "m/n/u")), vec!["v".to_string()]);
511
512 // delete_tree the rest.
513 assert_eq!(res!(ns.delete_tree("m")), 3);
514 assert!(res!(ns.list("m")).is_none());
515 assert!(res!(ns.list("m/n/u/v")).is_none());
516 assert_eq!(res!(ns.get("m/n/u/v/c")), None);
517 assert_eq!(res!(names(&ns, "")), vec!["keep".to_string()]);
518 assert_eq!(res!(ns::orphans(&ns, Wait::default())), ns::Orphans::default());
519 res!(db.close());
520 Ok(())
521}
522
523#[test]
524fn ns_orphans_lists_a_value_with_no_index_entry() -> Outcome<()> {
525 log_set_level!("warn");
526 wrap(orphans())
527}
528
529fn orphans() -> Outcome<()> {
530 let root = res!(fresh_dir("orphans"));
531 let db = res!(open(&root, true));
532 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
533 res!(ns.put("o/kept", b"k"));
534 hooks::set_ns_tear(NsTear::Top(0));
535 res!(ns.put("o/lost", b"l")); // a value, no entry
536 hooks::set_ns_tear(NsTear::Top(1));
537 res!(ns.put("o/p/q", b"q")); // o lists p, p has no record
538 let other = res!(TestNs::new(db.clone(), Uid::default(), "u"));
539 hooks::set_ns_tear(NsTear::Top(0));
540 res!(other.put("elsewhere", b"e")); // another space's orphan
541 let found = res!(ns::orphans(&ns, Wait::default()));
542 let mut values = found.values.clone();
543 values.sort();
544 assert_eq!(values, vec!["o/lost".to_string(), "o/p/q".to_string()]);
545 assert!(found.dirs.is_empty());
546 res!(db.close());
547 Ok(())
548}
549
550#[test]
551fn ns_second_start_on_one_store_is_refused() -> Outcome<()> {
552 log_set_level!("warn");
553 wrap(second_start())
554}
555
556fn second_start() -> Outcome<()> {
557 let root = res!(fresh_dir("second_start"));
558 let db = res!(open(&root, true));
559 match start(&root, false) {
560 Err(_) => (),
561 Ok(second) => {
562 let _ = second.close();
563 return Err(err!("A second O3db::start on one store was not refused."; Test, Mismatch));
564 },
565 }
566 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
567 res!(ns.put("still/here", b"yes"));
568 assert_eq!(res!(ns.get("still/here")), Some(b"yes".to_vec()));
569 res!(db.close());
570 Ok(())
571}
572
573// ── D1z1c ────────────────────────────────────────────────────────────────────────────────────
574
575#[test]
576fn ns_put_heals_a_directory_record_its_parent_does_not_list() -> Outcome<()> {
577 log_set_level!("warn");
578 wrap(heals_unlisted())
579}
580
581fn heals_unlisted() -> Outcome<()> {
582 let root = res!(fresh_dir("heals_unlisted"));
583 let db = res!(open(&root, true));
584 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
585 res!(ns.put("a/x", b"x"));
586 // The power loss: a/b's new record reached the disk, a's new entry for b did not.
587 hooks::set_ns_tear(NsTear::Deep(1));
588 res!(ns.put("a/b/c", b"c"));
589 assert_eq!(res!(names(&ns, "a")), vec!["x".to_string()]);
590 assert_eq!(res!(names(&ns, "a/b")), vec!["c".to_string()]);
591 // The next put through it lists b in a again, whatever order the disk kept.
592 res!(ns.put("a/b/d", b"d"));
593 assert_eq!(res!(names(&ns, "a")), vec!["b".to_string(), "x".to_string()]);
594 assert_eq!(res!(names(&ns, "a/b")), vec!["c".to_string(), "d".to_string()]);
595 res!(db.close());
596 Ok(())
597}
598
599#[test]
600fn ns_rename_is_durable_before_it_deletes() -> Outcome<()> {
601 log_set_level!("warn");
602 wrap(rename_barrier())
603}
604
605fn rename_barrier() -> Outcome<()> {
606 let root = res!(fresh_dir("rename_barrier"));
607 let db = res!(open(&root, true));
608 let ns = res!(TestNs::new(db.clone(), Uid::default(), "t"));
609 res!(ns.put("r/one", b"1"));
610 res!(ns.put("r/s/two", b"2"));
611 res!(ns.put("v", b"value"));
612 for (from, to) in [("r", "q"), ("v", "w")] {
613 hooks::set_ns_trace();
614 res!(ns.rename(from, to));
615 let steps = hooks::ns_steps();
616 let barrier = steps.iter().position(|s| *s == NsStep::Barrier);
617 let delete = steps.iter().position(|s| *s == NsStep::Delete);
618 match (barrier, delete) {
619 (Some(b), Some(d)) if b < d => (),
620 _ => return Err(err!(
621 "rename of '{}' deleted before its copy was durable: {:?}.", from, steps;
622 Test, Mismatch)),
623 }
624 }
625 assert_eq!(res!(names(&ns, "q")), vec!["one".to_string(), "s".to_string()]);
626 assert_eq!(res!(ns.get("w")), Some(b"value".to_vec()));
627 res!(db.close());
628 Ok(())
629}
630
631#[test]
632fn ns_spaces_cannot_share_a_key() -> Outcome<()> {
633 log_set_level!("warn");
634 wrap(space_names())
635}
636
637fn space_names() -> Outcome<()> {
638 let root = res!(fresh_dir("space_names"));
639 let db = res!(open(&root, true));
640 // "x" with "v:p" and "x:v" with "p" would both be ns:x:v:v:p, so a ':' is refused, as is "".
641 let x = res!(TestNs::new(db.clone(), Uid::default(), "x"));
642 assert!(TestNs::new(db.clone(), Uid::default(), "x:v").is_err());
643 assert!(TestNs::new(db.clone(), Uid::default(), "").is_err());
644 res!(x.put("v:p", b"x's"));
645 assert_eq!(res!(x.get("v:p")), Some(b"x's".to_vec()));
646 res!(db.close());
647 Ok(())
648}