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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
//! 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";
/// The root of a fork of `first`, at tv's write and keeping it, by the version after the
/// first.
const FORK_ROOT: &str = r#"{"at":["fc0741fd5a5be1d3e58002b717591fde50de425a8450b725aca3cf33f81eda4f"],"keeps":["fc0741fd5a5be1d3e58002b717591fde50de425a8450b725aca3cf33f81eda4f"],"version":{"changes":"33bba83de429c577d94eef5b6b3ec235a1bc8694fc834a86721ad67770ebd47f","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":1,"rules":[{"path":"home/{party}/**","writer":"{party}"},{"path":"names/r/wiki","writer":"lass"}]}}"#;
const FORK_ROOT_ID: &str = "b486c164b5050c555863d9d85f36fc82f158de2d9d07c9a1785363f0ec944991";
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_forks_root_and_its_id() {
let spec = first();
let fork = spec.after(spec.hash());
let write = Id::from_hex(WRITE_ID).expect("an ID");
let root = Checkpoint {
at: vec![write],
keeps: vec![write],
version: Version::read(&fork.json()).expect("a version"),
};
assert_eq!(String::from_utf8(root.bytes()).expect("UTF-8"), FORK_ROOT);
assert_eq!(Id::of(&root.bytes()).to_string(), FORK_ROOT_ID);
let read = Checkpoint::read(FORK_ROOT.as_bytes()).expect("a checkpoint");
assert_eq!(read.bytes(), root.bytes());
}
#[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());
}
/// The changes founding the swarm of `first`'s root, and those founding the fork whose
/// root is `FORK_ROOT`, keeping tv's write: printed, each by its hash and its bytes, to be
/// fixed as vectors (`cargo test --features federation changes_to_fix -- --ignored
/// --nocapture`). Automerge encodes them, so no script apart computes them.
#[test]
#[ignore]
fn changes_to_fix() {
use super::fold::Federation;
use super::store::Fold;
let root = Checkpoint {
at: Vec::new(),
keeps: Vec::new(),
version: Version::read(&first().json()).expect("a version"),
}
.bytes();
let founding = [
(
"root",
crate::document::events::founding(Federation::NAME, &root, &[]),
),
(
"fork",
crate::document::events::founding(
Federation::NAME,
FORK_ROOT.as_bytes(),
&[WRITE.as_bytes().to_vec()],
),
),
];
for (name, changes) in founding {
for change in changes {
let bytes: String = change
.raw_bytes()
.iter()
.map(|byte| format!("{byte:02x}"))
.collect();
println!("{name} {} {bytes}", change.hash());
}
}
}
|