cadmpeg-ir 0.6.5

CAD data model, validation, diffing, and codec API for cadmpeg.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

// SPDX-License-Identifier: Apache-2.0

use crate::draft::CommitSession;
use crate::ids::Identity;
use crate::native::NativeRecord;
use crate::CadIr;
use cadmpeg_core::decode::{DecodeArena, DecodeContext, DecodePolicy};

#[test]
fn committed_native_identity_cache_borrows_text_from_document() {
    let id = format!("test:native:record#{}", "n".repeat(1024));
    let mut ir = CadIr::empty();
    ir.native.namespace_mut("test").arenas_mut().insert(
        "records".into(),
        vec![NativeRecord::new(Identity::new(&id).unwrap(), serde_json::Map::new()).unwrap()],
    );
    let arena = DecodeArena::new();
    let mut policy = DecodePolicy::service();
    policy.limits.max_retained_bytes = 0;
    let (ctx, _) = DecodeContext::from_root_bytes(&[], &arena, &policy).unwrap();
    let mut session = CommitSession::new(&mut ir, &ctx, None).unwrap();
    assert!(session.contains(&id).unwrap());
    assert!(session.contains(&id).unwrap());
    assert!(!session.contains("test:native:record#missing").unwrap());
    drop(session);
    ctx.finish_session().unwrap();
}

#[test]
fn committed_native_identity_positions_cover_namespaces_arenas_and_rows() {
    let mut ir = CadIr::empty();
    for namespace in ["alpha", "beta"] {
        for arena in ["first", "second"] {
            let records = (0..3)
                .map(|row| {
                    let id = format!("test:{namespace}:{arena}#{row}");
                    NativeRecord::new(Identity::new(id).unwrap(), serde_json::Map::new()).unwrap()
                })
                .collect();
            ir.native
                .namespace_mut(namespace)
                .arenas_mut()
                .insert(arena.into(), records);
        }
    }
    let arena = DecodeArena::new();
    let (ctx, _) = DecodeContext::from_root_bytes(&[], &arena, &DecodePolicy::service()).unwrap();
    let mut session = CommitSession::new(&mut ir, &ctx, None).unwrap();
    for namespace in ["alpha", "beta"] {
        for arena in ["first", "second"] {
            for row in 0..3 {
                assert!(session
                    .contains(&format!("test:{namespace}:{arena}#{row}"))
                    .unwrap());
            }
        }
    }
    assert!(!session.contains("test:beta:second#3").unwrap());
}

#[test]
fn committed_native_cache_keeps_paths_when_earlier_map_keys_are_inserted() {
    let target = "test:native:record#existing";
    let record =
        || NativeRecord::new(Identity::new(target).unwrap(), serde_json::Map::new()).unwrap();
    let mut ir = CadIr::empty();
    ir.native
        .namespace_mut("zeta")
        .arenas_mut()
        .insert("last".into(), vec![record()]);
    let ctx = cadmpeg_test_support::service_decode_context();
    let mut session = CommitSession::new(ir, &ctx, None).unwrap();
    assert!(session.contains(target).unwrap());
    // Exercise the cache owner directly: map-key insertion does not reorder rows.
    session.state.base.native.namespace_mut("alpha");
    session
        .state
        .base
        .native
        .namespace_mut("zeta")
        .arenas_mut()
        .insert("first".into(), Vec::new());
    assert!(session.contains(target).unwrap());
    assert!(session.contains(target).unwrap());
    assert!(!session.contains("test:native:record#missing").unwrap());
    drop(session);
    ctx.finish_session().unwrap();
}

#[test]
fn committed_native_cache_checks_identity_after_path_hash_matches() {
    let stored = "test:native:record#stored";
    let missing = "test:native:record#absent";
    let mut ir = CadIr::empty();
    ir.native.namespace_mut("native").arenas_mut().insert(
        "records".into(),
        vec![NativeRecord::new(Identity::new(stored).unwrap(), serde_json::Map::new()).unwrap()],
    );
    let index = std::collections::HashMap::from([(
        crate::draft::identity_hash(missing),
        vec![crate::draft::CommittedIdentity::Native {
            namespace_hash: crate::draft::identity_hash("native"),
            arena_hash: crate::draft::identity_hash("records"),
            record: 0,
        }],
    )]);
    assert!(!crate::draft::committed_identity_contains(
        &ir,
        &[],
        &index,
        missing
    ));
}