webc 3.0.0-rc.1

WebContainer implementation for wapm.io
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
111
112
113
114
115
116

use super::*;

#[test]
fn webc_invalid_data() {
    let content = WebC::parse(b"Nweb", &ParseOptions::default());
    pretty_assertions::assert_eq!(
        content.unwrap_err().0.as_str(),
        "Invalid WebC file (can\'t get magic header)"
    );

    let content = WebC::parse(b"\0webc0x1", &ParseOptions::default());
    pretty_assertions::assert_eq!(content.unwrap_err().0.as_str(), "Version not supported");

    let content = WebC::parse(b"\0webc001", &ParseOptions::default());
    pretty_assertions::assert_eq!(
        content.unwrap_err().0.as_str(),
        "Failed to get checksum type at offset 8..24"
    );

    pretty_assertions::assert_eq!(
        WebC::compute_checksum(b"\0webc001----------------"),
        Ok(None)
    );

    let content = WebC::parse(b"\0webc001----------------", &ParseOptions::default());
    pretty_assertions::assert_eq!(
        content.unwrap_err().0.as_str(),
        "Failed to get signature length at offset 280..284"
    );
}

#[test]
fn test_encode_decode_file_entry() {
    use crate::FsEntryType::*;
    use std::borrow::Cow;
    let entries = vec![
        FsEntry {
            fs_type: Dir,
            text: Cow::Borrowed("a"),
            offset_start: 58,
            offset_end: 91,
        },
        FsEntry {
            fs_type: Dir,
            text: Cow::Borrowed("b"),
            offset_start: 91,
            offset_end: 91,
        },
    ];

    pretty_assertions::assert_eq!(
        FsEntry::parse(&FsEntry::into_bytes(&entries).unwrap_or_default()),
        entries
    );
}

#[test]
fn test_volume() {
    let mut files = BTreeMap::new();
    files.insert(
        DirOrFile::File(Path::new("/a/c/file.txt").to_path_buf()),
        b"hello".to_vec(),
    );
    files.insert(DirOrFile::Dir(Path::new("/b").to_path_buf()), Vec::new());
    let volume_bytes = Volume::serialize_files(files);
    let volume = Volume::parse(&volume_bytes).unwrap();
    pretty_assertions::assert_eq!(volume.get_file("/a/c/file.txt"), Ok(&b"hello"[..]));
}

#[test]
fn test_encode_decode_webc() {
    let mut files = BTreeMap::new();
    files.insert(
        DirOrFile::File(Path::new("atom.wasm").to_path_buf()),
        b"atom wasm content".to_vec(),
    );
    let atom_volume = Volume::serialize_atoms(files);
    let atom_volume = Volume::parse(&atom_volume).unwrap();

    let mut files = BTreeMap::new();
    files.insert(
        DirOrFile::File(Path::new("dependency.txt").to_path_buf()),
        b"dependency!".to_vec(),
    );
    let file_volume = Volume::serialize_files(files);
    let file_volume = Volume::parse(&file_volume).unwrap();

    let webc = WebC {
        version: 1,
        checksum: None,
        signature: Some(Signature {
            valid_until: 1024,
            valid: false,
            data: Vec::new(),
        }),
        manifest: Manifest {
            origin: None,
            use_map: IndexMap::default(),
            package: IndexMap::default(),
            atoms: IndexMap::default(),
            commands: IndexMap::default(),
            bindings: Vec::new(),
            entrypoint: None,
        },
        atoms: atom_volume,
        volumes: {
            let mut map = IndexMap::default();
            map.insert("files".to_string(), file_volume);
            map
        },
    };

    let bytes = webc.into_bytes(GenerateChecksum::NoChecksum).unwrap();

    pretty_assertions::assert_eq!(WebC::parse(&bytes, &ParseOptions::default()).unwrap(), webc);
}