Skip to content

Commit

Permalink
Batch 15: Split big fn | bump version (#112)
Browse files Browse the repository at this point in the history 
* split large function | swift test JSON for DeviceInfo with different case
---------
Co-authored-by: Alexander Cyon <[email protected]>
  • Loading branch information
@CyonAlexRDX
CyonAlexRDX authored Apr 29, 2024
1 parent 5decc31 commit f64e2a9
Show file tree
Hide file tree
Showing 7 changed files with 199 additions and 108 deletions.
2 changes: 1 addition & 1 deletion Cargo.lock
View file

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

2 changes: 1 addition & 1 deletion Cargo.toml
View file
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
[package]
name = "sargon"
version = "0.6.52"
version = "0.6.55"
edition = "2021"
build = "build.rs"

Expand Down
63 changes: 47 additions & 16 deletions apple/Tests/TestCases/Profile/DeviceInfoTests.swift
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,21 +19,52 @@ final class DeviceInfoTests: Test<DeviceInfo> {
)
}

func test_codable() throws {
let raw = """
{
"id": "66f07ca2-a9d9-49e5-8152-77aca3d1dd74",
"date": "2023-09-11T16:05:56.000Z",
"description": "iPhone"
}
""".data(using: .utf8)!

// test decoding
let sut = try JSONDecoder().decode(SUT.self, from: raw)
XCTAssertEqual(sut, SUT.sample)

// test encoding
let encoded = try JSONEncoder().encode(sut)
try XCTAssertEqual(JSONDecoder().decode(SUT.self, from: encoded), sut)
func test_codable_lowercase_rust_styled_uuid() throws {
func doTest(_ jsonString: String, expected: SUT? = .sample) throws {
let raw = Data(jsonString.utf8)

// test decoding
let sut = try JSONDecoder().decode(SUT.self, from: raw)

if let expected {
XCTAssertEqual(sut, expected)
}

// test encoding
let encoded = try JSONEncoder().encode(sut)
try XCTAssertEqual(JSONDecoder().decode(SUT.self, from: encoded), sut)
}

// Rust style:
// * lower UUID
// * date with milliseconds
try doTest("""
{
"id": "66f07ca2-a9d9-49e5-8152-77aca3d1dd74",
"date": "2023-09-11T16:05:56.000Z",
"description": "iPhone"
}
""")

// Swift style:
// * uppercase UUID
// * date without milliseconds
try doTest("""
{
"id": "66F07CA2-A9D9-49E5-8152-77ACA3D1DD74",
"date": "2023-09-11T16:05:56Z",
"description": "iPhone"
}
""")

// Swift style - new.
try doTest("""
{
"id": "\(UUID().uuidString)",
"date": "\(Date.now.ISO8601Format())",
"description": "iPhone"
}
""", expected: nil)
}

}
216 changes: 138 additions & 78 deletions src/profile/logic/profile_network/profile_network_details.rs
View file
Original file line number Diff line number Diff line change
@@ -1,94 +1,154 @@
use crate::prelude::*;

impl AuthorizedPersonaSimple {
fn accounts_for_display(
&self,
non_hidden_accounts: &Accounts,
) -> Result<Option<AccountsForDisplay>> {
let shared_accounts = self
.shared_accounts
.as_ref().map(|s| s.ids.clone())
.unwrap_or_default()
.iter()
.map(|account_address| {
let Some(account) = non_hidden_accounts
.iter().find(|x| x.address == *account_address)
else {
// This is a sign that Profile is in a bad state somehow...
warn!("Discrepancy! AuthorizedDapp references account which does not exist {}", account_address);
return Err(CommonError::DiscrepancyAuthorizedDappReferencedAccountWhichDoesNotExist {
address: account_address.to_owned()
})
};
Ok(AccountForDisplay::new(
account.address,
account.display_name.clone(),
account.appearance_id
))
}).collect::<Result<AccountsForDisplay>>()?;

if shared_accounts.is_empty() {
Ok(None)
} else {
Ok(Some(shared_accounts))
}
}

fn pick_persona_data_from_full(
&self,
full: &PersonaData,
) -> Result<PersonaData> {
let full_ids = &full.ids_of_entries();
let shared = self.shared_persona_data.clone();
let shared_ids = shared.ids_of_entries();

if !full_ids.is_superset(&shared_ids) {
error!("Profile discrepancy - most likely caused by incorrect implementation of DappInteractionFlow and updating of shared persona data. \n\nDetails [persona.personaData.ids] {:?} != {:?} [simple.sharedPersonaData]\n\npersona.personaData: {full}\n\nsimple.sharedPersonaData: {shared}", full_ids, shared_ids);
return Err(
CommonError::AuthorizedDappReferencesFieldIDThatDoesNotExist,
);
};

let mut name: Option<PersonaDataIdentifiedName> = None;
if let Some(saved_name) = &full.name {
if let Some(shared) = shared.name {
if shared.id() == saved_name.id {
name = Some(saved_name.clone());
}
};
};

let phone_numbers = full
.phone_numbers
.collection
.clone()
.into_iter()
.filter(|x| {
shared
.phone_numbers
.clone()
.map(|s| s.ids.clone())
.unwrap_or_default()
.into_iter()
.contains(&x.id)
})
.collect::<CollectionOfPhoneNumbers>();

let email_addresses = full
.email_addresses
.collection
.clone()
.into_iter()
.filter(|x| {
shared
.email_addresses
.clone()
.map(|s| s.ids.clone())
.unwrap_or_default()
.into_iter()
.contains(&x.id)
})
.collect::<CollectionOfEmailAddresses>();

Ok(PersonaData::new(name, phone_numbers, email_addresses))
}

fn persona_from(&self, non_hidden_personas: &Personas) -> Result<Persona> {
let Some(persona) = non_hidden_personas
.iter()
.find(|x| x.address == self.identity_address)
else {
// This is a sign that Profile is in a bad state somehow...
warn!("Discrepancy! AuthorizedDapp references persona which does not exist {}", self.identity_address);
return Err(CommonError::DiscrepancyAuthorizedDappReferencedPersonaWhichDoesNotExist {
address: self.identity_address
});
};
Ok(persona.clone())
}

fn detailed(
&self,
non_hidden_personas: &Personas,
non_hidden_accounts: &Accounts,
) -> Result<AuthorizedPersonaDetailed> {
let persona = self.persona_from(non_hidden_personas)?;
let persona_data =
self.pick_persona_data_from_full(&persona.persona_data)?;

let shared_accounts = self.accounts_for_display(non_hidden_accounts)?;

let has_auth_signing_key = match &persona.security_state {
EntitySecurityState::Unsecured { value: uec } => {
uec.authentication_signing.is_some()
}
};
Ok(AuthorizedPersonaDetailed::new(
persona.address,
persona.display_name.clone(),
shared_accounts.clone(),
persona_data,
has_auth_signing_key,
))
}
}

impl ProfileNetwork {
pub fn details_for_authorized_dapp(
&self,
dapp: &AuthorizedDapp,
) -> Result<AuthorizedDappDetailed> {
self.is_on_same_network_as(dapp)?;

let non_hidden_personas = &self.personas_non_hidden();
let non_hidden_accounts = &self.accounts_non_hidden();

let detailed_authorized_personas = dapp
.references_to_authorized_personas
.clone()
.clone()
.into_iter()
.map(|simple| {
let Some(persona) = self
.personas_non_hidden()
.into_iter().find(|x| x.address == simple.identity_address)
else {
// This is a sign that Profile is in a bad state somehow...
warn!("Discrepancy! AuthorizedDapp references persona which does not exist {}", simple.identity_address);
return Err(CommonError::DiscrepancyAuthorizedDappReferencedPersonaWhichDoesNotExist {
address: simple.identity_address
})
};

let display_name = persona.display_name.clone();
let shared_accounts = simple
.shared_accounts
.map(|s| s.ids.clone())
.unwrap_or_default()
.into_iter()
.map(|account_address| {
let Some(account) = self
.accounts_non_hidden()
.into_iter().find(|x| x.address == account_address)
else {
// This is a sign that Profile is in a bad state somehow...
warn!("Discrepancy! AuthorizedDapp references account which does not exist {}", account_address);
return Err(CommonError::DiscrepancyAuthorizedDappReferencedAccountWhichDoesNotExist {
address: account_address
})
};
Ok(AccountForDisplay::new(
account.address,
account.display_name,
account.appearance_id
))
}).collect::<Result<AccountsForDisplay>>()?;
let shared_accounts = if shared_accounts.is_empty() { None } else { Some(shared_accounts) };

let full = persona.persona_data.clone();
let full_ids = full.ids_of_entries();
let shared = simple.shared_persona_data.clone();
let shared_ids = shared.ids_of_entries();

if !full_ids.is_superset(&shared_ids) {
error!("Profile discrepancy - most likely caused by incorrect implementation of DappInteractionFlow and updating of shared persona data. \n\nDetails [persona.personaData.ids] {:?} != {:?} [simple.sharedPersonaData]\n\npersona.personaData: {full}\n\nsimple.sharedPersonaData: {shared}", full_ids, shared_ids);
return Err(CommonError::AuthorizedDappReferencesFieldIDThatDoesNotExist)
};

let mut name: Option<PersonaDataIdentifiedName> = None;
if let Some(saved_name) = full.name {
if let Some(shared) = shared.name {
if shared.id() == saved_name.id {
name = Some(saved_name.clone());
}
};
};

let phone_numbers = full.phone_numbers.collection.clone().into_iter().filter(|x| {
shared.phone_numbers.clone().map(|s| s.ids.clone()).unwrap_or_default().into_iter().contains(&x.id)
}).collect::<CollectionOfPhoneNumbers>();

let email_addresses = full.email_addresses.collection.clone().into_iter().filter(|x| {
shared.email_addresses.clone().map(|s| s.ids.clone()).unwrap_or_default().into_iter().contains(&x.id)
}).collect::<CollectionOfEmailAddresses>();

let persona_data = PersonaData::new(name, phone_numbers, email_addresses);

let has_auth_signing_key = match &persona.security_state {
EntitySecurityState::Unsecured { value: uec } => uec.authentication_signing.is_some()
};
Ok(
AuthorizedPersonaDetailed::new(
persona.address,
display_name,
shared_accounts,
persona_data,
has_auth_signing_key
)
)
simple.detailed(non_hidden_personas, non_hidden_accounts)
})
.collect::<Result<DetailedAuthorizedPersonas>>()?;

Expand Down
18 changes: 9 additions & 9 deletions src/radix_connect/mobile/relay_service/models/request/request.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -161,7 +161,7 @@ mod tests {
let public_key = PublicKey::sample();
let request = SUT::new_send_handshake_response_with_public_key(
session_id.clone(),
public_key.clone(),
public_key,
);

assert_eq!(request.method, Method::SendHandshakeResponse);
Expand All @@ -185,7 +185,7 @@ mod tests {
"data": "deaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddead"
}
"#;
assert_eq_after_json_roundtrip(&request, &expected_json);
assert_eq_after_json_roundtrip(&request, expected_json);
}

#[test]
Expand All @@ -199,7 +199,7 @@ mod tests {
"sessionId": "ffffffff-ffff-ffff-ffff-ffffffffffff"
}
"#;
assert_eq_after_json_roundtrip(&request, &expected_json);
assert_eq_after_json_roundtrip(&request, expected_json);
}

#[test]
Expand All @@ -215,7 +215,7 @@ mod tests {
"data": "deaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddead"
}
"#;
assert_eq_after_json_roundtrip(&request, &expected_json);
assert_eq_after_json_roundtrip(&request, expected_json);
}

#[test]
Expand All @@ -229,7 +229,7 @@ mod tests {
"sessionId": "ffffffff-ffff-ffff-ffff-ffffffffffff"
}
"#;
assert_eq_after_json_roundtrip(&request, &expected_json);
assert_eq_after_json_roundtrip(&request, expected_json);
}

#[test]
Expand All @@ -243,7 +243,7 @@ mod tests {
"sessionId": "ffffffff-ffff-ffff-ffff-ffffffffffff"
}
"#;
assert_eq_after_json_roundtrip(&request, &expected_json);
assert_eq_after_json_roundtrip(&request, expected_json);
}

#[test]
Expand All @@ -260,7 +260,7 @@ mod tests {
"data": "deaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddead"
}
"#;
assert_eq_after_json_roundtrip(&request, &expected_json);
assert_eq_after_json_roundtrip(&request, expected_json);
}

#[test]
Expand All @@ -269,7 +269,7 @@ mod tests {
let public_key = PublicKey::sample();
let request = SUT::new_send_handshake_response_with_public_key(
session_id.clone(),
public_key.clone(),
public_key,
);

let expected_json = r#"
Expand All @@ -279,6 +279,6 @@ mod tests {
"data": "ec172b93ad5e563bf4932c70e1245034c35467ef2efd4d64ebf819683467e2bf"
}
"#;
assert_eq_after_json_roundtrip(&request, &expected_json);
assert_eq_after_json_roundtrip(&request, expected_json);
}
}
Loading

0 comments on commit f64e2a9

Please sign in to comment.