chore(tests): fix tests

iotaledger · Jun 19, 2024 · 0408eb2 · 0408eb2
1 parent 9930bc0
commit 0408eb2
Show file tree

Hide file tree

Showing 4 changed files with 110 additions and 93 deletions.
diff --git a/bindings/grpc/proto/domain_linkage.proto b/bindings/grpc/proto/domain_linkage.proto
@@ -4,48 +4,51 @@
 syntax = "proto3";
 package domain_linkage;
 
-message ValidDomain {
-    string service_id = 1;
-    string url = 2;
-    string credential = 3;
-}
-
-message InvalidDomain {
-    string service_id = 1;
-    optional string credential = 2;
-    string url = 3;
-    string error = 4;
-}
-
 message ValidateDidResponse {
     string did = 1;
     message Domains {
+        message ValidDomain {
+            string url = 1;
+            string credential = 2;
+            string service_id = 3;
+        }
+
         repeated ValidDomain valid = 1;
+
+        message InvalidDomain {
+            string url = 1;
+            optional string credential = 2;
+            string service_id = 3;
+            string error = 4;
+        }
+
         repeated InvalidDomain invalid = 2;
     }
     Domains domains = 2;
 }
 
-message ValidDid {
-    string service_id = 1;
-    string did = 2;
-    string credential = 3;
-}
-
-message InvalidDid {
-    optional string service_id = 1;
-    optional string credential = 2;
-    optional string did = 3;
-    string error = 4;
-}
-
 message ValidateDomainResponse {
     string domain = 1;
-    message LinkedDid {
+    message LinkedDids {
+
+        message ValidDid {
+            string did = 1;
+            string credential = 2;
+            string service_id = 3;
+        }
+
         repeated ValidDid valid = 1;
+
+        message InvalidDid {
+            optional string did = 1;
+            optional string credential = 2;
+            optional string service_id = 3;
+            string error = 4;
+        }
+
         repeated InvalidDid invalid = 2;
     }
-    LinkedDid linked_dids = 2;
+    LinkedDids linked_dids = 2;
 }
 
 message ValidateDomainRequest {

diff --git a/bindings/grpc/src/services/domain_linkage.rs b/bindings/grpc/src/services/domain_linkage.rs
@@ -7,22 +7,25 @@ use std::error::Error;
 use domain_linkage::domain_linkage_server::DomainLinkage;
 use domain_linkage::domain_linkage_server::DomainLinkageServer;
 use domain_linkage::validate_did_response::Domains;
-use domain_linkage::validate_domain_response::LinkedDid;
+
+use crate::services::domain_linkage::domain_linkage::validate_did_response::domains::{InvalidDomain, ValidDomain};
+use crate::services::domain_linkage::domain_linkage::validate_domain_response::linked_dids::{InvalidDid, ValidDid};
+use domain_linkage::validate_domain_response::LinkedDids;
+use domain_linkage::ValidateDidAgainstDidConfigurationsRequest;
+use domain_linkage::ValidateDidRequest;
+use domain_linkage::ValidateDidResponse;
+use domain_linkage::ValidateDomainAgainstDidConfigurationRequest;
 use domain_linkage::ValidateDomainRequest;
 use domain_linkage::ValidateDomainResponse;
-use domain_linkage::{InvalidDid, ValidateDidAgainstDidConfigurationsRequest};
-use domain_linkage::{InvalidDomain, ValidateDomainAgainstDidConfigurationRequest};
-use domain_linkage::{ValidDid, ValidateDidRequest};
-use domain_linkage::{ValidDomain, ValidateDidResponse};
 
 use identity_eddsa_verifier::EdDSAJwsVerifier;
+use identity_iota::core::FromJson;
 use identity_iota::core::Url;
-use identity_iota::core::{FromJson, ToJson};
 use identity_iota::credential::DomainLinkageConfiguration;
 use identity_iota::credential::JwtCredentialValidationOptions;
 use identity_iota::credential::JwtDomainLinkageValidator;
 use identity_iota::credential::LinkedDomainService;
-use identity_iota::did::{CoreDID, DID};
+use identity_iota::did::CoreDID;
 use identity_iota::iota::IotaDID;
 use identity_iota::iota::IotaDocument;
 use identity_iota::resolver::Resolver;
@@ -89,8 +92,8 @@ impl DomainValidationConfig {
 }
 
 /// Builds a validation status for a failed validation from an `Error`.
-fn get_linked_did_validation_failed_status(message: &str, err: &impl Error) -> LinkedDid {
-  LinkedDid {
+fn get_linked_did_validation_failed_status(message: &str, err: &impl Error) -> LinkedDids {
+  LinkedDids {
     valid: vec![],
     invalid: vec![InvalidDid {
       service_id: None,
@@ -221,7 +224,7 @@ impl DomainLinkageService {
     domain: &Url,
     did: Option<CoreDID>,
     config: Option<DomainLinkageConfiguration>,
-  ) -> Result<LinkedDid, DomainLinkageError> {
+  ) -> Result<LinkedDids, DomainLinkageError> {
     // get domain linkage config
     let domain_linkage_configuration: DomainLinkageConfiguration = if let Some(config_value) = config {
       config_value
@@ -297,7 +300,7 @@ impl DomainLinkageService {
         }
       });
 
-    let status_infos = LinkedDid {
+    let status_infos = LinkedDids {
       valid: valid_dids,
       invalid: invalid_dids,
     };
@@ -356,7 +359,6 @@ impl DomainLinkage for DomainLinkageService {
       DomainLinkageError::DidConfigurationParsing(format!("could not parse given DID configuration; {}", &err))
     })?;
 
-    // get validation status for all issuer dids
     let linked_dids = self
       .validate_domains_with_optional_configuration(&domain, None, Some(config))
       .await?;

diff --git a/bindings/grpc/tests/api/domain_linkage.rs b/bindings/grpc/tests/api/domain_linkage.rs
@@ -1,21 +1,24 @@
 // Copyright 2020-2024 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-use _credentials::validate_domain_response::LinkedDid;
-use _credentials::{ValidDid, ValidDomain};
-use identity_iota::core::Duration;
+use _credentials::validate_did_response::Domains;
+use _credentials::validate_domain_response::LinkedDids;
+
+use crate::domain_linkage::_credentials::validate_did_response::domains::{InvalidDomain, ValidDomain};
+use crate::domain_linkage::_credentials::validate_domain_response::linked_dids::ValidDid;
 use identity_iota::core::Object;
 use identity_iota::core::OrderedSet;
 use identity_iota::core::Timestamp;
 use identity_iota::core::Url;
+use identity_iota::core::{Duration, FromJson};
 use identity_iota::credential::Credential;
 use identity_iota::credential::DomainLinkageConfiguration;
 use identity_iota::credential::DomainLinkageCredentialBuilder;
 use identity_iota::credential::Jwt;
 use identity_iota::credential::LinkedDomainService;
 use identity_iota::did::DIDUrl;
 use identity_iota::did::DID;
-use identity_iota::iota::{IotaDID, IotaDocument};
+use identity_iota::iota::IotaDocument;
 use identity_storage::JwkDocumentExt;
 use identity_storage::JwsSignatureOptions;
 use identity_stronghold::StrongholdStorage;
@@ -35,7 +38,7 @@ mod _credentials {
 }
 
 /// Prepares basically the same test setup as in test `examples/1_advanced/6_domain_linkage.rs`.
-async fn prepare_test() -> anyhow::Result<(TestServer, Url, String, Jwt)> {
+async fn prepare_test() -> anyhow::Result<(TestServer, Url, Url, String, Jwt)> {
   let stronghold = StrongholdStorage::new(make_stronghold());
   let server = TestServer::new_with_stronghold(stronghold.clone()).await;
   let api_client = server.client();
@@ -45,7 +48,6 @@ async fn prepare_test() -> anyhow::Result<(TestServer, Url, String, Jwt)> {
   let did = issuer
     .document()
     .ok_or_else(|| anyhow::anyhow!("no DID document for issuer"))?;
-  let did_string = did.to_string();
 
   let did = did.id().clone();
   // =====================================================
@@ -73,6 +75,8 @@ async fn prepare_test() -> anyhow::Result<(TestServer, Url, String, Jwt)> {
     .document()
     .ok_or_else(|| anyhow::anyhow!("no DID document for issuer"))?;
 
+  let did_string = updated_did_document.to_string();
+
   println!("DID document with linked domain service: {updated_did_document:#}");
 
   // =====================================================
@@ -104,12 +108,12 @@ async fn prepare_test() -> anyhow::Result<(TestServer, Url, String, Jwt)> {
     )
     .await?;
 
-  Ok((server, domain_1, did_string, jwt))
+  Ok((server, domain_1, domain_2, did_string, jwt))
 }
 
 #[tokio::test]
 async fn can_validate_domain() -> anyhow::Result<()> {
-  let (server, linked_domain, did, jwt) = prepare_test().await?;
+  let (server, linked_domain, _, did, jwt) = prepare_test().await?;
   let configuration_resource: DomainLinkageConfiguration = DomainLinkageConfiguration::new(vec![jwt.clone()]);
   let mut grpc_client = DomainLinkageClient::connect(server.endpoint()).await?;
 
@@ -119,12 +123,12 @@ async fn can_validate_domain() -> anyhow::Result<()> {
       did_configuration: configuration_resource.to_string(),
     })
     .await?;
-  let did_id = IotaDID::parse(&did)?.to_url().to_string();
+  let did_id = IotaDocument::from_json(&did)?.id().to_string();
 
   assert_eq!(
     response.into_inner(),
     ValidateDomainResponse {
-      linked_dids: Some(LinkedDid {
+      linked_dids: Some(LinkedDids {
         invalid: vec![],
         valid: vec![ValidDid {
           service_id: did_id,
@@ -139,44 +143,50 @@ async fn can_validate_domain() -> anyhow::Result<()> {
   Ok(())
 }
 
-// #[tokio::test]
-// async fn can_validate_did() -> anyhow::Result<()> {
-//   let (server, linked_domain, issuer_did, jwt) = prepare_test().await?;
-//   let configuration_resource: DomainLinkageConfiguration = DomainLinkageConfiguration::new(vec![jwt.clone()]);
-//   let mut grpc_client = DomainLinkageClient::connect(server.endpoint()).await?;
-
-//   let response = grpc_client
-//     .validate_did_against_did_configurations(ValidateDidAgainstDidConfigurationsRequest {
-//       did: issuer_did.clone(),
-//       did_configurations: vec![ValidateDomainAgainstDidConfigurationRequest {
-//         domain: linked_domain.to_string(),
-//         did_configuration: configuration_resource.to_string(),
-//       }],
-//     })
-//     .await?;
-
-//   assert_eq!(
-//     response.into_inner(),
-//     ValidateDidResponse {
-//       service: vec![
-//         LinkedDidEndpointValidationStatus {
-//           id: issuer_did,
-//           service_endpoint: vec![
-//             LinkedDidValidationStatus {
-//                 valid: true,
-//                 document: Some(jwt.as_str().to_string()),
-//                 error: None,
-//             },
-//             LinkedDidValidationStatus {
-//                 valid: false,
-//                 document: None,
-//                 error: Some("could not get domain linkage config; domain linkage error: error sending request for url (https://bar.example.com/.well-known/did-configuration.json): error trying to connect: dns error: failed to lookup address information: nodename nor servname provided, or not known".to_string()),
-//             }
-//           ],
-//         }
-//       ]
-//     }
-//   );
-
-//   Ok(())
-// }
+#[tokio::test]
+async fn can_validate_did() -> anyhow::Result<()> {
+  let (server, linked_domain, domain2, issuer_did, jwt) = prepare_test().await?;
+  let configuration_resource: DomainLinkageConfiguration = DomainLinkageConfiguration::new(vec![jwt.clone()]);
+  let mut grpc_client = DomainLinkageClient::connect(server.endpoint()).await?;
+  let did_id = IotaDocument::from_json(&issuer_did)?.id().to_string();
+
+  let response = grpc_client
+    .validate_did_against_did_configurations(ValidateDidAgainstDidConfigurationsRequest {
+      did: did_id.clone(),
+      did_configurations: vec![ValidateDomainAgainstDidConfigurationRequest {
+        domain: linked_domain.to_string(),
+        did_configuration: configuration_resource.to_string(),
+      }],
+    })
+    .await?;
+
+  let service_id = format!("{}#domain-linkage", did_id);
+
+  let valid_domain = ValidDomain {
+    service_id: service_id.clone(),
+    url: linked_domain.to_string(),
+    credential: jwt.as_str().to_string(),
+  };
+
+  let error = format!("could not get domain linkage config: domain linkage error: error sending request for url ({}.well-known/did-configuration.json): error trying to connect: dns error: failed to lookup address information: nodename nor servname provided, or not known", domain2.to_string());
+
+  let invalid_domain = InvalidDomain {
+    service_id: service_id.clone(),
+    credential: None,
+    url: domain2.to_string(),
+    error,
+  };
+
+  assert_eq!(
+    response.into_inner(),
+    ValidateDidResponse {
+      did: did_id,
+      domains: Some(Domains {
+        invalid: vec![invalid_domain],
+        valid: vec![valid_domain],
+      }),
+    }
+  );
+
+  Ok(())
+}
diff --git a/bindings/grpc/tests/api/utils.rs b/bindings/grpc/tests/api/utils.rs
@@ -6,7 +6,7 @@ use _utils::DataSigningRequest;
 use identity_iota::verification::jws::JwsAlgorithm;
 use identity_storage::JwkStorage;
 use identity_storage::KeyType;
-use identity_stronghold::StrongholdStorage;
+use identity_stronghold::{StrongholdKeyType, StrongholdStorage};
 
 use crate::helpers::make_stronghold;
 use crate::helpers::TestServer;
@@ -28,7 +28,9 @@ async fn raw_data_signing_works() -> anyhow::Result<()> {
     .key_id;
 
   let expected_signature = {
-    let public_key_jwk = stronghold.get_public_key(&key_id).await?;
+    let public_key_jwk = stronghold
+      .get_public_key_with_type(&key_id, StrongholdKeyType::Ed25519)
+      .await?;
     stronghold.sign(&key_id, SAMPLE_SIGNING_DATA, &public_key_jwk).await?
   };