modelvault-core 0.16.0

Core engine for ModelVault — application-focused embedded storage with model schemas, validation, and migrations.
Documentation 
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

use modelvault_core::file_format::{decode_header, FileHeader, FILE_HEADER_SIZE, FILE_MAGIC};
use modelvault_core::segments::header::{
    decode_segment_header, SegmentHeader, SegmentType, SEGMENT_HEADER_LEN, SEGMENT_MAGIC,
};

#[test]
fn file_header_encode_decode_roundtrip_all_supported_minors() {
    for h in [
        FileHeader::new_v0_3(),
        FileHeader::new_v0_4(),
        FileHeader::new_v0_5(),
        FileHeader::new_v0_8(),
    ] {
        let bytes = h.encode();
        let got = decode_header(&bytes).unwrap();
        assert_eq!(got, h);
    }
    assert_eq!(FILE_HEADER_SIZE, 32);
    assert_eq!(FILE_MAGIC, *b"TDB0");
}

#[test]
fn decode_header_rejects_bad_magic_and_unsupported_minor() {
    let mut bytes = FileHeader::new_v0_8().encode();
    bytes[0] = b'X';
    assert!(decode_header(&bytes).is_err());

    let mut bytes2 = FileHeader::new_v0_8().encode();
    // Set minor to 99.
    bytes2[6..8].copy_from_slice(&99u16.to_le_bytes());
    assert!(decode_header(&bytes2).is_err());
}

#[test]
fn segment_header_roundtrip_all_segment_types() {
    for ty in [
        SegmentType::Schema,
        SegmentType::Record,
        SegmentType::Manifest,
        SegmentType::Checkpoint,
        SegmentType::Index,
        SegmentType::TxnBegin,
        SegmentType::TxnCommit,
        SegmentType::TxnAbort,
        SegmentType::Temp,
    ] {
        let h = SegmentHeader {
            segment_type: ty,
            payload_len: 123,
            payload_crc32c: 456,
        };
        let bytes = h.encode();
        let got = decode_segment_header(&bytes).unwrap();
        assert_eq!(got, h);
    }
    assert_eq!(SEGMENT_HEADER_LEN, 32);
    assert_eq!(SEGMENT_MAGIC, *b"TSG0");
}

#[test]
fn decode_segment_header_rejects_truncated_bad_magic_and_bad_checksum() {
    let short = [0u8; SEGMENT_HEADER_LEN - 1];
    assert!(decode_segment_header(&short).is_err());

    let mut bytes = SegmentHeader {
        segment_type: SegmentType::Schema,
        payload_len: 0,
        payload_crc32c: 0,
    }
    .encode();
    bytes[0] = b'X';
    assert!(decode_segment_header(&bytes).is_err());

    // Corrupt the checksum.
    let mut bytes2 = SegmentHeader {
        segment_type: SegmentType::Schema,
        payload_len: 0,
        payload_crc32c: 0,
    }
    .encode();
    bytes2[31] ^= 0xFF;
    assert!(decode_segment_header(&bytes2).is_err());
}