kcode-k1-web-code-session 0.2.0

Own pure session-bound versionless Web-code handles
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

use kcode_k1_transaction_id::TxId;
use kcode_k1_web_code_document::{CodeDocument, Language};
use kcode_k1_web_code_session::{DocumentPart, OpenedSource, SessionError, SessionScope};
use kcode_k1_web_package::{AuthorityId, WebFamily};
use semver::Version;

fn authority(byte: u8) -> [u8; 12] {
    [byte; 12]
}

fn document(code: &str) -> CodeDocument {
    let family = WebFamily::new(AuthorityId::new(TxId::from_bytes(authority(1))), "alpha").unwrap();
    CodeDocument::new(
        family,
        b"<!-- k1-web/v1\n{\"dependencies\":[]}\n-->\nDocs\r\n".to_vec(),
        Language::JavaScript,
        code.as_bytes().to_vec(),
    )
    .unwrap()
}

fn unpublished(revision: u8) -> OpenedSource {
    OpenedSource::Unpublished {
        id: TxId::from_bytes([4; 12]),
        revision: TxId::from_bytes([revision; 12]),
    }
}

#[test]
fn scope_authority_source_and_document_are_all_validated() {
    let scope = SessionScope::new();
    let value = document("export async function runTests(){}\n");
    let opened = scope
        .open(authority(1), value.clone(), unpublished(5))
        .unwrap();
    assert_eq!(opened.version_text(), TxId::from_bytes([4; 12]).to_string());
    assert!(
        scope
            .validate(authority(1), &opened, &value, &unpublished(5))
            .is_ok()
    );
    assert_eq!(
        scope.validate(authority(2), &opened, &value, &unpublished(5)),
        Err(SessionError::ForeignHandle)
    );
    assert_eq!(
        scope.validate(authority(1), &opened, &value, &unpublished(6)),
        Err(SessionError::StaleSource)
    );
    assert_eq!(
        SessionScope::new().validate(authority(1), &opened, &value, &unpublished(5)),
        Err(SessionError::ForeignHandle)
    );
}

#[test]
fn replacement_preserves_the_other_exact_authored_part() {
    let scope = SessionScope::new();
    let value = document("old\r\n");
    let source = OpenedSource::Published(Version::new(1, 2, 3));
    let opened = scope
        .open(authority(1), value.clone(), source.clone())
        .unwrap();
    let changed = scope
        .replacement(
            authority(1),
            &opened,
            &value,
            &source,
            DocumentPart::Code,
            "new\n".into(),
        )
        .unwrap();
    assert_eq!(changed.documentation(), value.documentation());
    assert_eq!(changed.code(), b"new\n");
    let changed_docs = scope
        .replacement(
            authority(1),
            &opened,
            &value,
            &source,
            DocumentPart::Documentation,
            "<!-- k1-web/v1\n{\"dependencies\":[]}\n-->\nNew".into(),
        )
        .unwrap();
    assert_eq!(changed_docs.code(), value.code());
}