aboutsummaryrefslogtreecommitdiffstats
path: root/src/federation/vectors.rs
blob: 8f2d57c87a20dd014f00d074d3af2ef1ae99efa7 (plain)
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
114
115
116
117
118
119
120
121
122
123
124
125
//! The federation's fixed bytes (`docs/federation-tests.md`, Fixed bytes). Each was
//! computed apart from this code, by a script of its own: JCS written by hand, Ed25519 by
//! another library, the signature's blob as OpenSSH's `PROTOCOL.sshsig` describes it, as
//! `ssh-keygen -Y sign -n continuum-federation` makes it. A vector that changes is a
//! change of the federation, which takes its next number.

use super::event::{self, Checkpoint, Event};
use super::harness::{self, Party, Spec};
use super::jcs::Json;
use super::store::Id;
use super::version::{self, Version};

/// A write by tv (keys from seeds: tv's of 1s, lass's of 2s), on the ID of
/// `a dependency`.
const WRITE: &str = r#"{"deps":["dce3d8e42443079366ace8c08adf3b2fa874d96c0cd82077784425f72009e4e2"],"key":"ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIqI4910CfGV/VLbLTy6XXLKZwm/HZQSG/N0iAG0D29c","party":"tv","sig":"U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgiojj3XQJ8ZX9UtstPLpdcspnCb8dlBIb83SIAbQPb1wAAAAUY29udGludXVtLWZlZGVyYXRpb24AAAAAAAAABnNoYTUxMgAAAFMAAAALc3NoLWVkMjU1MTkAAABA/vW3yl3aMYoxZUQlMDKWni9/LHTNJazS/C24hA5U2tzcg7i45WzOahfdHSYnn8r+eyxckuhVWGiiZ2/QedwPDg==","write":{"path":"home/tv/laptop","value":"10.243.7.3"}}"#;
const WRITE_ID: &str = "fc0741fd5a5be1d3e58002b717591fde50de425a8450b725aca3cf33f81eda4f";

/// The first version for tv and lass, with tv's node (its key of 128s), a namespace each
/// and `names/r/wiki` lass's; and the root it makes.
const VERSION: &str = r#"{"changes":null,"federation":1,"keys":{"lass":{"keys":["ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIE5dw6ofRdfVqNUZsNMfszLjYqRtO43ol32D1uPybOU"],"since":0},"tv":{"keys":["ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIqI4910CfGV/VLbLTy6XXLKZwm/HZQSG/N0iAG0D29c"],"since":0}},"nodes":{"lass":{"nodes":[],"since":0},"tv":{"nodes":["continuum:e5687b6d11ccfb632abbafe844f8f1693d160aa582156ed66eea38ab5e7d1e12"],"since":0}},"number":0,"rules":[{"path":"home/{party}/**","writer":"{party}"},{"path":"names/r/wiki","writer":"lass"}]}"#;
const VERSION_HASH: &str = "33bba83de429c577d94eef5b6b3ec235a1bc8694fc834a86721ad67770ebd47f";
const ROOT_ID: &str = "f65d862fb679df035b4c7bb5debfb69f5fbb89575fbf7f1ca87e4c5078799cd4";

/// A version event writing that version, on the root.
const VERSION_EVENT: &str = r#"{"deps":["f65d862fb679df035b4c7bb5debfb69f5fbb89575fbf7f1ca87e4c5078799cd4"],"version":"33bba83de429c577d94eef5b6b3ec235a1bc8694fc834a86721ad67770ebd47f"}"#;
const VERSION_EVENT_ID: &str = "b5bb686361a5657c7a549a05c14e588199069a2048c2ae8641cb60c8d76b6ed0";

/// A write by tv whose value holds two names that UTF-16 units sort otherwise than bytes:
/// U+E000 and U+10000.
const NAMES_ID: &str = "f19850573b605b3a640302bc68ef1755ff1954aede11e5e575fdd3d2def9c5a2";

fn tv() -> Party {
    Party::new("tv", 1)
}

fn first() -> Spec {
    Spec::first(
        &[&tv(), &Party::new("lass", 2)],
        &[("names/r/wiki", harness::str("lass"))],
    )
}

fn dep() -> Id {
    Id::of(b"a dependency")
}

#[test]
fn an_event_its_signature_and_its_id() {
    let event = tv().write(&[dep()], "home/tv/laptop", harness::str("10.243.7.3"));
    assert_eq!(String::from_utf8(event.clone()).expect("UTF-8"), WRITE);
    assert_eq!(Id::of(&event).to_string(), WRITE_ID);
    assert!(Event::read(WRITE.as_bytes()).is_some());
}

#[test]
fn a_version_its_hash_and_its_root() {
    let spec = first();
    assert_eq!(
        String::from_utf8(spec.json().bytes()).expect("UTF-8"),
        VERSION
    );
    assert_eq!(spec.hash().to_string(), VERSION_HASH);
    let root = Checkpoint {
        at: Vec::new(),
        keeps: Vec::new(),
        version: Version::read(&spec.json()).expect("a version"),
    };
    assert_eq!(Id::of(&root.bytes()).to_string(), ROOT_ID);
}

#[test]
fn a_version_event_and_its_id() {
    let root = Id::from_hex(ROOT_ID).expect("an ID");
    let hash = Id::from_hex(VERSION_HASH).expect("a hash");
    let event = harness::version_event(&[root], hash);
    assert_eq!(
        String::from_utf8(event.clone()).expect("UTF-8"),
        VERSION_EVENT
    );
    assert_eq!(Id::of(&event).to_string(), VERSION_EVENT_ID);
}

#[test]
fn names_in_the_order_of_their_utf16_units() {
    let value = harness::object(vec![
        ("\u{e000}", Json::Int(1)),
        ("\u{10000}", Json::Int(2)),
    ]);
    let event = tv().write(&[dep()], "home/tv/names", value);
    assert_eq!(Id::of(&event).to_string(), NAMES_ID);
}

#[test]
fn events_at_federation_1s_sizes_and_just_past_them() {
    let tv = tv();
    // 256 KiB.
    let base = tv.write(&[dep()], "home/tv/x", harness::str("")).len();
    let at = tv.write(
        &[dep()],
        "home/tv/x",
        harness::str(&"x".repeat(event::LARGEST - base)),
    );
    assert_eq!(at.len(), event::LARGEST);
    assert!(Event::read(&at).is_some());
    let past = tv.write(
        &[dep()],
        "home/tv/x",
        harness::str(&"x".repeat(event::LARGEST - base + 1)),
    );
    assert!(Event::read(&past).is_none());
    // 32 segments of 255 bytes.
    let segment = "s".repeat(version::SEGMENT_BYTES);
    let path = |segments: usize| vec![segment.as_str(); segments].join("/");
    assert!(Event::read(&tv.write(&[dep()], &path(version::SEGMENTS), Json::Null)).is_some());
    assert!(Event::read(&tv.write(&[dep()], &path(version::SEGMENTS + 1), Json::Null)).is_none());
    let longer = format!("{segment}s");
    assert!(Event::read(&tv.write(&[dep()], &longer, Json::Null)).is_none());
    // 64 nodes.
    let nodes: Vec<String> = (0..=version::NODES as u8).map(harness::node_id).collect();
    assert!(Event::read(&tv.nodes(&[dep()], &nodes[..version::NODES])).is_some());
    assert!(Event::read(&tv.nodes(&[dep()], &nodes)).is_none());
    // Integers to 2⁵³.
    let largest = Json::Int(super::jcs::LARGEST_INTEGER);
    assert!(Event::read(&tv.write(&[dep()], "home/tv/n", largest)).is_some());
}