-
Notifications
You must be signed in to change notification settings - Fork 82
/
wasm.rs
108 lines (80 loc) · 3.04 KB
/
wasm.rs
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
// Copyright 2020-2021 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0
use wasm_bindgen_test::*;
use identity_wasm::crypto::Digest;
use identity_wasm::crypto::KeyCollection;
use identity_wasm::crypto::KeyPair;
use identity_wasm::crypto::KeyType;
use identity_wasm::did::WasmDID;
use identity_wasm::did::WasmDocument;
use identity_wasm::error::WasmError;
use std::borrow::Cow;
#[wasm_bindgen_test]
fn test_keypair() {
let key1 = KeyPair::new(KeyType::Ed25519).unwrap();
let public_key = key1.public();
let private_key = key1.private();
let key2 = KeyPair::from_base58(KeyType::Ed25519, &public_key, &private_key).unwrap();
let json1 = key1.to_json().unwrap();
let json2 = key2.to_json().unwrap();
let from1 = KeyPair::from_json(&json1).unwrap();
let from2 = KeyPair::from_json(&json2).unwrap();
assert_eq!(from1.public(), key1.public());
assert_eq!(from1.private(), key1.private());
assert_eq!(from2.public(), key2.public());
assert_eq!(from2.private(), key2.private());
}
#[wasm_bindgen_test]
fn test_key_collection() {
let size = 1 << 5;
let keys = KeyCollection::new(KeyType::Ed25519, size).unwrap();
assert_eq!(keys.length(), size);
assert!(!keys.is_empty());
for index in 0..keys.length() {
let key = keys.keypair(index).unwrap();
assert_eq!(key.public(), keys.public(index).unwrap());
assert_eq!(key.private(), keys.private(index).unwrap());
assert!(keys.merkle_proof(Digest::Sha256, index).is_some());
}
assert!(keys.keypair(keys.length()).is_none());
assert!(keys.merkle_proof(Digest::Sha256, keys.length()).is_none());
let json = keys.to_json().unwrap();
let from = KeyCollection::from_json(&json).unwrap();
for index in 0..keys.length() {
assert_eq!(keys.public(index).unwrap(), from.public(index).unwrap());
assert_eq!(keys.private(index).unwrap(), from.private(index).unwrap());
}
}
#[wasm_bindgen_test]
fn test_js_error_from_wasm_error() {
let error = WasmError::new(Cow::Borrowed("Some name"), Cow::Owned("Error message".to_owned()));
let js_error = js_sys::Error::from(error);
assert_eq!(js_error.name(), "Some name");
assert_eq!(js_error.message(), "Error message");
}
#[test]
fn test_did() {
let key = KeyPair::new(KeyType::Ed25519).unwrap();
let did = WasmDID::new(&key, None).unwrap();
assert_eq!(did.network_name(), "main");
let parsed = WasmDID::parse(&did.to_string()).unwrap();
assert_eq!(did.to_string(), parsed.to_string());
let public = key.public();
let base58 = WasmDID::from_base58(&public, Some("dev".to_string())).unwrap();
assert_eq!(base58.tag(), did.tag());
assert_eq!(base58.network_name(), "dev");
}
#[test]
fn test_document() {
let output = WasmDocument::new(KeyType::Ed25519, None, None).unwrap();
let mut document = output.doc();
let keypair = output.key();
document.sign(&keypair).unwrap();
assert!(document.verify());
}
#[test]
fn test_document_network() {
let output = WasmDocument::new(KeyType::Ed25519, Some("dev".into()), None).unwrap();
let document = output.doc();
assert_eq!(document.id().network_name(), "dev");
}