tell-encoding 0.6.0

FlatBuffer encoding for the Tell analytics protocol
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
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

use crate::{API_KEY_LENGTH, BatchParams, SchemaType, encode_batch};

#[test]
fn encode_batch_produces_valid_flatbuffer() {
    let api_key = [0xA1u8; API_KEY_LENGTH];
    let data = b"test payload data";

    let bytes = encode_batch(&BatchParams {
        api_key: &api_key,
        schema_type: SchemaType::Event,
        version: 100,
        batch_id: 42,
        data,
    });

    // Root offset is first 4 bytes
    let root_offset = u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]) as usize;
    assert!(root_offset < bytes.len());

    // Read soffset from table
    let table_start = root_offset;
    let soffset = i32::from_le_bytes([
        bytes[table_start],
        bytes[table_start + 1],
        bytes[table_start + 2],
        bytes[table_start + 3],
    ]);
    let vtable_start = table_start - soffset as usize;

    // Read vtable size
    let vtable_size = u16::from_le_bytes([bytes[vtable_start], bytes[vtable_start + 1]]) as usize;
    assert_eq!(vtable_size, 16); // 4 + 6*2

    // Read schema_type from table (at table_start + 24)
    assert_eq!(bytes[table_start + 24], SchemaType::Event.as_u8());

    // Read version from table (at table_start + 25)
    assert_eq!(bytes[table_start + 25], 100);

    // Read batch_id from table (at table_start + 16)
    let batch_id = u64::from_le_bytes([
        bytes[table_start + 16],
        bytes[table_start + 17],
        bytes[table_start + 18],
        bytes[table_start + 19],
        bytes[table_start + 20],
        bytes[table_start + 21],
        bytes[table_start + 22],
        bytes[table_start + 23],
    ]);
    assert_eq!(batch_id, 42);
}

#[test]
fn encode_batch_contains_api_key() {
    let api_key: [u8; 16] = [
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
        0x10,
    ];
    let data = b"payload";

    let bytes = encode_batch(&BatchParams {
        api_key: &api_key,
        schema_type: SchemaType::Log,
        version: 100,
        batch_id: 0,
        data,
    });

    // The api_key bytes should appear in the output
    let found = bytes.windows(API_KEY_LENGTH).any(|w| w == api_key);
    assert!(found, "api_key not found in encoded batch");
}

#[test]
fn encode_batch_contains_data_payload() {
    let api_key = [0xFFu8; API_KEY_LENGTH];
    let data = b"hello world payload";

    let bytes = encode_batch(&BatchParams {
        api_key: &api_key,
        schema_type: SchemaType::Event,
        version: 100,
        batch_id: 1,
        data,
    });

    let found = bytes.windows(data.len()).any(|w| w == data.as_slice());
    assert!(found, "data payload not found in encoded batch");
}

#[test]
fn encode_batch_zero_batch_id() {
    let api_key = [0x00u8; API_KEY_LENGTH];
    let data = b"x";

    let bytes = encode_batch(&BatchParams {
        api_key: &api_key,
        schema_type: SchemaType::Event,
        version: 100,
        batch_id: 0,
        data,
    });

    // Should still produce valid output
    assert!(bytes.len() > 4);

    let root_offset = u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]) as usize;
    assert!(root_offset < bytes.len());
}