volli-server 0.1.10

Server for volli
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

#![allow(unused_crate_dependencies)]
use ed25519_dalek::{Signer, Verifier};
use ed25519_dalek::{SigningKey, VerifyingKey};
use serial_test::serial;
use std::convert::TryFrom;
use std::fs;
use volli_server::{bootstrap_keypair, default_secret_dir};

#[test]
#[serial]
fn default_secret_dir_env_overrides() {
    let tmp = tempfile::TempDir::new().unwrap();
    unsafe {
        std::env::set_var("VOLLI_CONFIG_DIR", tmp.path());
    }
    let mut expected = std::path::PathBuf::from(tmp.path());
    expected.push("profiles");
    expected.push("coordinator");
    let dir = default_secret_dir();
    assert_eq!(dir, expected);
    unsafe {
        std::env::remove_var("VOLLI_CONFIG_DIR");
    }
}

#[test]
#[serial]
fn default_secret_dir_fallback() {
    unsafe {
        std::env::remove_var("VOLLI_CONFIG_DIR");
    }
    let mut expected = volli_core::config_dir();
    expected.push("profiles");
    expected.push("coordinator");
    assert_eq!(default_secret_dir(), expected);
}

#[test]
#[serial]
fn bootstrap_keypair_creates_keys() {
    let dir = tempfile::TempDir::new().unwrap();
    bootstrap_keypair(Some(dir.path())).unwrap();
    let sk_data = fs::read(dir.path().join("coord_sk")).unwrap();
    let pk_data = fs::read(dir.path().join("coord_pk")).unwrap();
    let sk_bytes = hex::decode(sk_data).unwrap();
    let pk_bytes = hex::decode(pk_data).unwrap();
    let signing = SigningKey::try_from(&sk_bytes[..]).unwrap();
    let verifying = VerifyingKey::from(&signing);
    assert_eq!(verifying.to_bytes().as_slice(), pk_bytes.as_slice());
}

#[test]
#[serial]
fn bootstrap_keypair_fails_if_exists() {
    let dir = tempfile::TempDir::new().unwrap();
    bootstrap_keypair(Some(dir.path())).unwrap();
    let err = bootstrap_keypair(Some(dir.path())).unwrap_err();
    assert!(err.to_string().contains("exists"));
}

#[test]
#[serial]
fn bootstrap_keypair_uses_default_dir() {
    let dir = tempfile::TempDir::new().unwrap();
    unsafe {
        std::env::set_var("VOLLI_CONFIG_DIR", dir.path());
    }
    let expected = default_secret_dir();
    bootstrap_keypair(None).unwrap();
    assert!(expected.join("coord_sk").exists());
    assert!(expected.join("coord_pk").exists());
    unsafe {
        std::env::remove_var("VOLLI_CONFIG_DIR");
    }
}

#[test]
#[serial]
fn load_keypair_roundtrip() {
    let dir = tempfile::TempDir::new().unwrap();
    volli_server::bootstrap_keypair(Some(dir.path())).unwrap();
    let sk = volli_server::load_signing_key(Some(dir.path())).unwrap();
    let pk = volli_server::load_verifying_key(Some(dir.path())).unwrap();
    let msg = b"test";
    let sig = sk.sign(msg);
    pk.verify(msg, &sig).unwrap();
}

#[test]
#[serial]
fn load_or_generate_cert_persists() {
    let dir = tempfile::TempDir::new().unwrap();
    let (c1, _, f1) = volli_server::load_or_generate_cert(None, None, Some(dir.path())).unwrap();
    let (c2, _, f2) = volli_server::load_or_generate_cert(None, None, Some(dir.path())).unwrap();
    assert_eq!(c1[0].0, c2[0].0);
    assert_eq!(f1, f2);
}