[Fix] Connection Management

iota-storage/tests/descriptor_lifecycle.rs

@@ -0,0 +1,132 @@
+use iota_identity::{
+    AuthorityKind, LocalNodeIdentity, LocalUserDescriptor, LocalUserId, PrincipalHome, PrincipalId,
+    PrincipalStore, VerifiedPrincipalDescriptor,
+};
+use iota_storage::identity::SqlitePrincipalStore;
+use mtp::crypto::Keyring;
+
+#[test]
+fn local_descriptor_revision_persists_changes_and_retirement() {
+    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 user_key = Keyring::generate();
+    let mut user = LocalUserDescriptor {
+        id: LocalUserId(9),
+        username: "alice".into(),
+        display_name: None,
+        public_key: user_key.public_key_bundle().try_to_base64().unwrap(),
+    };
+    iota_storage::util::db::with_db(|connection| {
+        connection.execute(
+            "INSERT INTO users (user_id, username, public_key, created_at) VALUES (?1, ?2, ?3, ?4)",
+            rusqlite::params![user.id.0, user.username, user.public_key, 1_i64],
+        )?;
+        Ok(())
+    })
+    .unwrap();
+
+    let store = SqlitePrincipalStore;
+    let home = PrincipalHome::Iota(identity.node_id().clone());
+    store
+        .ensure_local_principal(
+            identity.authority_id(),
+            AuthorityKind::Iota,
+            &user,
+            home.clone(),
+            1_000,
+        )
+        .unwrap();
+    let first = store.local_principal_descriptor(user.id).unwrap();
+    assert_eq!(first.revision, 0);
+
+    store
+        .ensure_local_principal(
+            identity.authority_id(),
+            AuthorityKind::Iota,
+            &user,
+            home.clone(),
+            1_001,
+        )
+        .unwrap();
+    assert_eq!(
+        store.local_principal_descriptor(user.id).unwrap().revision,
+        0
+    );
+
+    user.display_name = Some("Alice".into());
+    store
+        .ensure_local_principal(
+            identity.authority_id(),
+            AuthorityKind::Iota,
+            &user,
+            home.clone(),
+            1_002,
+        )
+        .unwrap();
+    assert_eq!(
+        store.local_principal_descriptor(user.id).unwrap().revision,
+        1
+    );
+
+    let replacement_key = Keyring::generate().public_key_bundle();
+    user.public_key = replacement_key.try_to_base64().unwrap();
+    store
+        .ensure_local_principal(
+            identity.authority_id(),
+            AuthorityKind::Iota,
+            &user,
+            home.clone(),
+            1_003,
+        )
+        .unwrap();
+    let rotated = store.local_principal_descriptor(user.id).unwrap();
+    assert_eq!(rotated.revision, 2);
+    assert_eq!(rotated.public_keys.len(), 1);
+    assert_eq!(
+        rotated.public_keys[0].try_to_base64().unwrap(),
+        replacement_key.try_to_base64().unwrap()
+    );
+
+    let renewal_at = rotated.valid_until.unwrap() - 1;
+    store
+        .ensure_local_principal(
+            identity.authority_id(),
+            AuthorityKind::Iota,
+            &user,
+            home,
+            renewal_at,
+        )
+        .unwrap();
+    let renewed = store.local_principal_descriptor(user.id).unwrap();
+    assert_eq!(renewed.revision, 3);
+    let mut conflicting = renewed.clone();
+    conflicting.display_name = Some("Changed without revision".into());
+    assert!(
+        store
+            .upsert_remote_descriptor(
+                &VerifiedPrincipalDescriptor::from_trusted_authority(conflicting).unwrap()
+            )
+            .is_err()
+    );
+
+    store
+        .retire_local_principal(user.id, renewal_at + 1)
+        .unwrap();
+    assert!(store.local_principal_descriptor(user.id).is_err());
+    let principal = PrincipalId {
+        authority: identity.authority_id().clone(),
+        user_id: 9,
+    };
+    let retired = store.get_by_canonical_id(&principal).unwrap().unwrap();
+    assert_eq!(retired.descriptor_revision, 4);
+    assert!(
+        store
+            .upsert_remote_descriptor(
+                &VerifiedPrincipalDescriptor::from_trusted_authority(first).unwrap()
+            )
+            .is_err()
+    );
+}