111 lines
3.6 KiB
Rust
111 lines
3.6 KiB
Rust
use iota_identity::{
|
|
AuthorityLocator, LocalNodeIdentity, NodeDescriptor, NodeDirectory, NodeIdentityResolver,
|
|
SignedNodeDescriptor,
|
|
};
|
|
use iota_storage::node_directory::SqliteNodeDirectory;
|
|
use mtp::crypto::Keyring;
|
|
|
|
#[tokio::test]
|
|
async fn node_directory_persists_identity_revision_endpoints_and_pins() {
|
|
let storage = tempfile::tempdir().unwrap();
|
|
iota_util::file_util::configure_storage_directory(storage.path().to_owned());
|
|
iota_storage::util::db::initialize_database().unwrap();
|
|
|
|
let identity = LocalNodeIdentity::from_keyring(Keyring::generate()).unwrap();
|
|
let endpoint = AuthorityLocator::new("iota.example.org:443").unwrap();
|
|
let relay = AuthorityLocator::new("relay.example.org:443").unwrap();
|
|
let now = iota_storage::util::sync::now_millis();
|
|
let signed = SignedNodeDescriptor::sign(
|
|
NodeDescriptor {
|
|
node: identity.node_id().clone(),
|
|
public_keys: identity.public_keys(),
|
|
direct_endpoints: vec![endpoint.clone()],
|
|
relay_hints: vec![relay.clone()],
|
|
revision: 1,
|
|
valid_until: Some(now + 60_000),
|
|
},
|
|
&identity,
|
|
)
|
|
.unwrap();
|
|
let verified = signed.verify(None, now).unwrap();
|
|
SqliteNodeDirectory
|
|
.upsert_node_descriptor(&verified)
|
|
.unwrap();
|
|
SqliteNodeDirectory
|
|
.pin_endpoint(&endpoint, identity.node_id(), now)
|
|
.unwrap();
|
|
let certificate = b"test certificate";
|
|
SqliteNodeDirectory
|
|
.pin_endpoint_certificate(&endpoint, certificate)
|
|
.unwrap();
|
|
SqliteNodeDirectory
|
|
.record_successful_endpoint(identity.node_id(), &endpoint)
|
|
.unwrap();
|
|
|
|
let resolved = SqliteNodeDirectory
|
|
.resolve_node(identity.node_id())
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(resolved.descriptor_revision, 1);
|
|
assert_eq!(resolved.direct_endpoints, vec![endpoint.clone()]);
|
|
assert_eq!(resolved.relay_hints, vec![relay]);
|
|
assert_eq!(resolved.last_successful_endpoint, Some(endpoint.clone()));
|
|
assert_eq!(
|
|
SqliteNodeDirectory.pinned_node(&endpoint).unwrap(),
|
|
Some(identity.node_id().clone())
|
|
);
|
|
assert_eq!(
|
|
SqliteNodeDirectory
|
|
.pinned_endpoint_certificate(&endpoint)
|
|
.unwrap(),
|
|
Some(certificate.to_vec())
|
|
);
|
|
assert!(
|
|
SqliteNodeDirectory
|
|
.pin_endpoint_certificate(&endpoint, b"changed certificate")
|
|
.is_err()
|
|
);
|
|
|
|
let stale = SignedNodeDescriptor::sign(
|
|
NodeDescriptor {
|
|
node: identity.node_id().clone(),
|
|
public_keys: identity.public_keys(),
|
|
direct_endpoints: Vec::new(),
|
|
relay_hints: Vec::new(),
|
|
revision: 0,
|
|
valid_until: Some(now + 60_000),
|
|
},
|
|
&identity,
|
|
)
|
|
.unwrap()
|
|
.verify(None, now)
|
|
.unwrap();
|
|
assert!(SqliteNodeDirectory.upsert_node_descriptor(&stale).is_err());
|
|
|
|
let conflicting = SignedNodeDescriptor::sign(
|
|
NodeDescriptor {
|
|
node: identity.node_id().clone(),
|
|
public_keys: identity.public_keys(),
|
|
direct_endpoints: Vec::new(),
|
|
relay_hints: Vec::new(),
|
|
revision: 1,
|
|
valid_until: Some(now + 60_000),
|
|
},
|
|
&identity,
|
|
)
|
|
.unwrap()
|
|
.verify(None, now)
|
|
.unwrap();
|
|
assert!(
|
|
SqliteNodeDirectory
|
|
.upsert_node_descriptor(&conflicting)
|
|
.is_err()
|
|
);
|
|
|
|
let other = LocalNodeIdentity::from_keyring(Keyring::generate()).unwrap();
|
|
assert!(
|
|
SqliteNodeDirectory
|
|
.pin_endpoint(&endpoint, other.node_id(), now + 1)
|
|
.is_err()
|
|
);
|
|
}
|