From 0408eb2fd2f57be614603cdc0c74772767cc664d Mon Sep 17 00:00:00 2001 From: Yasir Date: Wed, 19 Jun 2024 16:56:38 +0300 Subject: [PATCH] chore(tests): fix tests --- bindings/grpc/proto/domain_linkage.proto | 59 +++++----- bindings/grpc/src/services/domain_linkage.rs | 26 +++-- bindings/grpc/tests/api/domain_linkage.rs | 112 ++++++++++--------- bindings/grpc/tests/api/utils.rs | 6 +- 4 files changed, 110 insertions(+), 93 deletions(-) diff --git a/bindings/grpc/proto/domain_linkage.proto b/bindings/grpc/proto/domain_linkage.proto index 1ff4dcc045..d731af2aa5 100644 --- 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 index 1704236e8a..9e02aed4a1 100644 --- 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, config: Option, - ) -> Result { + ) -> Result { // 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 index aae5c39aac..7eb512e3f4 100644 --- a/bindings/grpc/tests/api/domain_linkage.rs +++ b/bindings/grpc/tests/api/domain_linkage.rs @@ -1,13 +1,16 @@ // 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; @@ -15,7 +18,7 @@ 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 index 9c863bf3de..72e1ebdb72 100644 --- 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? };