mirror/matrix-rust-sdk
1
0
Fork 0
mirror of https://github.com/matrix-org/matrix-rust-sdk.git synced 2026-05-07 15:33:45 -04:00
Code Issues Packages Projects Releases Wiki Activity

testing: create ruma_response_from_json

Browse Source 
We had *two* copies of `response_from_file`, and all calls to them were always
immediately followed by an operation to parse the response as a Ruma response
object.

We can save a whole lot of boilerplate with a generic function that wraps the
json into an HTTP response *and* parses it into a Ruma object.
This commit is contained in:
Richard van der Hoff
2024-08-09 15:06:27 +01:00
committed by Richard van der Hoff
parent f96e82f833
commit 31dbca6c28
13 changed files with 139 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
benchmarks/benches/crypto_bench.rs
View File

@@ -3,14 +3,11 @@ use std::{ops::Deref, sync::Arc};
use criterion::{criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion, Throughput};
use matrix_sdk_crypto::{EncryptionSettings, OlmMachine};
use matrix_sdk_sqlite::SqliteCryptoStore;
use matrix_sdk_test::response_from_file;
use matrix_sdk_test::ruma_response_from_json;
use ruma::{
api::{
client::{
keys::{claim_keys, get_keys},
to_device::send_event_to_device::v3::Response as ToDeviceResponse,
},
IncomingResponse,
api::client::{
keys::{claim_keys, get_keys},
to_device::send_event_to_device::v3::Response as ToDeviceResponse,
},
device_id, room_id, user_id, DeviceId, OwnedUserId, TransactionId, UserId,
};
@@ -28,25 +25,19 @@ fn alice_device_id() -> &'static DeviceId {
fn keys_query_response() -> get_keys::v3::Response {
let data = include_bytes!("crypto_bench/keys_query.json");
let data: Value = serde_json::from_slice(data).unwrap();
let data = response_from_file(&data);
get_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
fn keys_claim_response() -> claim_keys::v3::Response {
let data = include_bytes!("crypto_bench/keys_claim.json");
let data: Value = serde_json::from_slice(data).unwrap();
let data = response_from_file(&data);
claim_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
fn huge_keys_query_response() -> get_keys::v3::Response {
let data = include_bytes!("crypto_bench/keys_query_2000_members.json");
let data: Value = serde_json::from_slice(data).unwrap();
let data = response_from_file(&data);
get_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the `/keys/query` response")
ruma_response_from_json(&data)
}
pub fn keys_query(c: &mut Criterion) {

70
crates/matrix-sdk-base/src/client.rs
View File

@@ -1617,15 +1617,10 @@ fn handle_room_member_event_for_profiles(
#[cfg(test)]
mod tests {
use matrix_sdk_test::{
async_test, response_from_file, sync_timeline_event, InvitedRoomBuilder, LeftRoomBuilder,
StateTestEvent, StrippedStateTestEvent, SyncResponseBuilder,
};
use ruma::{
api::{client as api, IncomingResponse},
room_id,
serde::Raw,
user_id, UserId,
async_test, ruma_response_from_json, sync_timeline_event, InvitedRoomBuilder,
LeftRoomBuilder, StateTestEvent, StrippedStateTestEvent, SyncResponseBuilder,
};
use ruma::{api::client as api, room_id, serde::Raw, user_id, UserId};
use serde_json::{json, value::to_raw_value};
use super::BaseClient;
@@ -1685,7 +1680,7 @@ mod tests {
let client = logged_in_base_client(Some(user_id)).await;
let response = api::sync::sync_events::v3::Response::try_from_http_response(response_from_file(&json!({
let response = ruma_response_from_json(&json!({
"next_batch": "asdkl;fjasdkl;fj;asdkl;f",
"device_one_time_keys_count": {
"signed_curve25519": 50u64
@@ -1754,7 +1749,7 @@ mod tests {
}
}
}
}))).expect("static json doesn't fail to parse");
}));
client.receive_sync_response(response).await.unwrap();
@@ -1848,39 +1843,36 @@ mod tests {
.await
.unwrap();
let response = api::sync::sync_events::v3::Response::try_from_http_response(
response_from_file(&json!({
"next_batch": "asdkl;fjasdkl;fj;asdkl;f",
"rooms": {
"join": {
"!ithpyNKDtmhneaTQja:example.org": {
"state": {
"events": [
{
"invalid": "invalid",
let response = ruma_response_from_json(&json!({
"next_batch": "asdkl;fjasdkl;fj;asdkl;f",
"rooms": {
"join": {
"!ithpyNKDtmhneaTQja:example.org": {
"state": {
"events": [
{
"invalid": "invalid",
},
{
"content": {
"name": "The room name"
},
{
"content": {
"name": "The room name"
},
"event_id": "$143273582443PhrSn:example.org",
"origin_server_ts": 1432735824653u64,
"room_id": "!jEsUZKDJdhlrceRyVU:example.org",
"sender": "@example:example.org",
"state_key": "",
"type": "m.room.name",
"unsigned": {
"age": 1234
}
},
]
}
"event_id": "$143273582443PhrSn:example.org",
"origin_server_ts": 1432735824653u64,
"room_id": "!jEsUZKDJdhlrceRyVU:example.org",
"sender": "@example:example.org",
"state_key": "",
"type": "m.room.name",
"unsigned": {
"age": 1234
}
},
]
}
}
}
})),
)
.expect("static json doesn't fail to parse");
}
}));
client.receive_sync_response(response).await.unwrap();
client

4
crates/matrix-sdk-crypto/Cargo.toml
View File

@@ -27,7 +27,7 @@ _disable-minimum-rotation-period-ms = []
message-ids = []
# Testing helpers for implementations based upon this
testing = ["dep:http"]
testing = ["matrix-sdk-test"]
[dependencies]
aes = "0.8.1"
@@ -43,11 +43,11 @@ futures-core = { workspace = true }
futures-util = { workspace = true }
hkdf = "0.12.3"
hmac = "0.12.1"
http = { workspace = true, optional = true } # feature = testing only
itertools = { workspace = true }
js_option = "0.1.1"
matrix-sdk-qrcode = { workspace = true, optional = true }
matrix-sdk-common = { workspace = true }
matrix-sdk-test = { workspace = true, optional = true } # feature = testing only
pbkdf2 = { version = "0.12.2", default-features = false }
rand = { workspace = true }
rmp-serde = "1.1.1"

57
crates/matrix-sdk-crypto/src/identities/manager.rs
View File

@@ -1067,16 +1067,16 @@ fn debug_log_keys_query_response(
pub(crate) mod testing {
use std::sync::Arc;
use matrix_sdk_test::ruma_response_from_json;
use ruma::{
api::{client::keys::get_keys::v3::Response as KeyQueryResponse, IncomingResponse},
device_id, user_id, DeviceId, UserId,
api::client::keys::get_keys::v3::Response as KeyQueryResponse, device_id, user_id,
DeviceId, UserId,
};
use serde_json::json;
use tokio::sync::Mutex;
use crate::{
identities::IdentityManager,
machine::testing::response_from_file,
olm::{Account, PrivateCrossSigningIdentity},
store::{CryptoStoreWrapper, MemoryStore, PendingChanges, Store},
types::DeviceKeys,
@@ -1114,7 +1114,7 @@ pub(crate) mod testing {
}
pub fn other_key_query() -> KeyQueryResponse {
let data = response_from_file(&json!({
let data = &json!({
"device_keys": {
"@example2:localhost": {
"SKISMLNIMH": {
@@ -1167,16 +1167,15 @@ pub(crate) mod testing {
}
},
"user_signing_keys": {}
}));
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
});
ruma_response_from_json(data)
}
// An updated version of `other_key_query` featuring an additional signature on
// the master key *Note*: The added signature is actually not valid, but a
// valid signature is not required for our test.
pub fn other_key_query_cross_signed() -> KeyQueryResponse {
let data = response_from_file(&json!({
let data = json!({
"device_keys": {
"@example2:localhost": {
"SKISMLNIMH": {
@@ -1233,14 +1232,13 @@ pub(crate) mod testing {
}
},
"user_signing_keys": {}
}));
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
});
ruma_response_from_json(&data)
}
/// Mocked response to a /keys/query request.
pub fn own_key_query_with_user_id(user_id: &UserId) -> KeyQueryResponse {
let data = response_from_file(&json!({
let data = json!({
"device_keys": {
user_id: {
"WSKKLTJZCL": {
@@ -1335,9 +1333,8 @@ pub(crate) mod testing {
}
}
}
}));
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
});
ruma_response_from_json(&data)
}
pub fn own_key_query() -> KeyQueryResponse {
@@ -1367,8 +1364,7 @@ pub(crate) mod testing {
}
);
KeyQueryResponse::try_from_http_response(response_from_file(&json))
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&json)
}
}
@@ -1377,10 +1373,10 @@ pub(crate) mod tests {
use std::ops::Deref;
use futures_util::pin_mut;
use matrix_sdk_test::{async_test, response_from_file, test_json};
use matrix_sdk_test::{async_test, ruma_response_from_json, test_json};
use ruma::{
api::{client::keys::get_keys::v3::Response as KeysQueryResponse, IncomingResponse},
device_id, user_id, TransactionId,
api::client::keys::get_keys::v3::Response as KeysQueryResponse, device_id, user_id,
TransactionId,
};
use serde_json::json;
use stream_assert::{assert_closed, assert_pending, assert_ready};
@@ -1406,9 +1402,7 @@ pub(crate) mod tests {
}
});
let response = response_from_file(&response);
KeysQueryResponse::try_from_http_response(response).unwrap()
ruma_response_from_json(&response)
}
#[async_test]
@@ -1537,9 +1531,7 @@ pub(crate) mod tests {
}
});
let response = KeysQueryResponse::try_from_http_response(response_from_file(&response))
.expect("Can't parse the `/keys/query` response");
let response = ruma_response_from_json(&response);
manager.receive_keys_query_response(&TransactionId::new(), &response).await.unwrap();
let identity = manager.store.get_user_identity(user_id).await.unwrap().unwrap();
@@ -1587,9 +1579,7 @@ pub(crate) mod tests {
}
});
let response = KeysQueryResponse::try_from_http_response(response_from_file(&response))
.expect("Can't parse the `/keys/query` response");
let response = ruma_response_from_json(&response);
let (_, private_identity) = manager.handle_cross_signing_keys(&response).await.unwrap();
assert!(private_identity.is_some());
@@ -1737,7 +1727,7 @@ pub(crate) mod tests {
// Now provide an invalid update
let (reqid, _) = manager.build_key_query_for_users(vec![my_user_id]);
let response_data = response_from_file(&json!({
let response = ruma_response_from_json(&json!({
"device_keys": {
my_user_id: {
test_device_id.as_str(): {
@@ -1760,9 +1750,6 @@ pub(crate) mod tests {
}
}
}));
let response =
ruma::api::client::keys::get_keys::v3::Response::try_from_http_response(response_data)
.expect("Can't parse the `/keys/upload` response");
let (device_changes, identity_changes) =
manager.receive_keys_query_response(&reqid, &response).await.unwrap();
@@ -1927,9 +1914,7 @@ pub(crate) mod tests {
},
});
let response = KeysQueryResponse::try_from_http_response(response_from_file(&response))
.expect("Can't parse the `/keys/query` response");
let response = ruma_response_from_json(&response);
manager.receive_keys_query_response(&TransactionId::new(), &response).await.unwrap();
let devices = manager.store.get_user_devices(other_user).await.unwrap();

9
crates/matrix-sdk-crypto/src/identities/user.rs
View File

@@ -1068,10 +1068,10 @@ pub(crate) mod tests {
use std::{collections::HashMap, sync::Arc};
use assert_matches::assert_matches;
use matrix_sdk_test::{async_test, response_from_file, test_json};
use matrix_sdk_test::{async_test, ruma_response_from_json, test_json};
use ruma::{
api::{client::keys::get_keys::v3::Response as KeyQueryResponse, IncomingResponse},
device_id, user_id, TransactionId,
api::client::keys::get_keys::v3::Response as KeyQueryResponse, device_id, user_id,
TransactionId,
};
use serde_json::{json, Value};
use tokio::sync::Mutex;
@@ -1419,8 +1419,7 @@ pub(crate) mod tests {
"self_signing_keys": DataSet::ssk_b(),
});
let kq_response = KeyQueryResponse::try_from_http_response(response_from_file(&data))
.expect("Can't parse the `/keys/upload` response");
let kq_response: KeyQueryResponse = ruma_response_from_json(&data);
machine.mark_request_as_sent(&TransactionId::new(), &kq_response).await.unwrap();
// The identity should not need any user approval now

10
crates/matrix-sdk-crypto/src/machine/mod.rs
View File

@@ -2409,16 +2409,6 @@ pub struct EncryptionSyncChanges<'a> {
pub next_batch_token: Option<String>,
}
#[cfg(any(feature = "testing", test))]
#[allow(dead_code)]
pub(crate) mod testing {
use http::Response;
pub fn response_from_file(json: &serde_json::Value) -> Response<Vec<u8>> {
Response::builder().status(200).body(json.to_string().as_bytes().to_vec()).unwrap()
}
}
#[cfg(test)]
pub(crate) mod test_helpers;

24
crates/matrix-sdk-crypto/src/machine/test_helpers.rs
View File

@@ -17,12 +17,9 @@
use std::collections::BTreeMap;
use matrix_sdk_test::test_json;
use matrix_sdk_test::{ruma_response_from_json, test_json};
use ruma::{
api::{
client::keys::{claim_keys, get_keys, upload_keys},
IncomingResponse,
},
api::client::keys::{claim_keys, get_keys, upload_keys},
device_id,
encryption::OneTimeKey,
events::dummy::ToDeviceDummyEventContent,
@@ -30,10 +27,7 @@ use ruma::{
user_id, DeviceId, OwnedDeviceKeyId, TransactionId, UserId,
};
use crate::{
machine::testing::response_from_file, store::Changes, types::events::ToDeviceEvent, DeviceData,
OlmMachine,
};
use crate::{store::Changes, types::events::ToDeviceEvent, DeviceData, OlmMachine};
/// These keys need to be periodically uploaded to the server.
type OneTimeKeys = BTreeMap<OwnedDeviceKeyId, Raw<OneTimeKey>>;
@@ -51,15 +45,13 @@ fn user_id() -> &'static UserId {
}
fn keys_upload_response() -> upload_keys::v3::Response {
let data = response_from_file(&test_json::KEYS_UPLOAD);
upload_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
let json = &test_json::KEYS_UPLOAD;
ruma_response_from_json(json)
}
fn keys_query_response() -> get_keys::v3::Response {
let data = response_from_file(&test_json::KEYS_QUERY);
get_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
pub fn keys_query_response() -> get_keys::v3::Response {
let json = &test_json::KEYS_QUERY;
ruma_response_from_json(json)
}
pub async fn get_prepared_machine_test_helper(

16
crates/matrix-sdk-crypto/src/machine/tests/decryption_verification_state.rs
View File

@@ -18,12 +18,8 @@ use assert_matches2::{assert_let, assert_matches};
use matrix_sdk_common::deserialized_responses::{
DeviceLinkProblem, ShieldState, VerificationLevel, VerificationState,
};
use matrix_sdk_test::{async_test, test_json};
use matrix_sdk_test::{async_test, ruma_response_from_json, test_json};
use ruma::{
api::{
client::keys::{get_keys, get_keys::v3::Response as KeyQueryResponse},
IncomingResponse,
},
events::{room::message::RoomMessageEventContent, AnyMessageLikeEventContent},
room_id,
serde::Raw,
@@ -37,7 +33,6 @@ use crate::{
test_helpers::{
get_machine_pair_with_setup_sessions_test_helper, get_prepared_machine_test_helper,
},
testing::response_from_file,
tests,
},
olm::{InboundGroupSession, OutboundGroupSession, SenderData},
@@ -293,9 +288,7 @@ pub async fn mark_alice_identity_as_verified_test_helper(alice: &OlmMachine, bob
}
);
let kq_response = KeyQueryResponse::try_from_http_response(response_from_file(&json))
.expect("Can't parse the `/keys/upload` response");
let kq_response = ruma_response_from_json(&json);
alice.receive_keys_query_response(&TransactionId::new(), &kq_response).await.unwrap();
bob.receive_keys_query_response(&TransactionId::new(), &kq_response).await.unwrap();
@@ -317,9 +310,8 @@ async fn test_verification_states_multiple_device() {
let other_user_id = user_id!("@web2:localhost:8482");
let data = response_from_file(&test_json::KEYS_QUERY_TWO_DEVICES_ONE_SIGNED);
let response = get_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response");
let json = &test_json::KEYS_QUERY_TWO_DEVICES_ONE_SIGNED;
let response = ruma_response_from_json(json);
let (device_change, identity_change) =
bob.receive_keys_query_response(&TransactionId::new(), &response).await.unwrap();

34
crates/matrix-sdk-crypto/src/machine/tests/mod.rs
View File

@@ -20,17 +20,11 @@ use itertools::Itertools;
use matrix_sdk_common::deserialized_responses::{
UnableToDecryptInfo, UnsignedDecryptionResult, UnsignedEventLocation,
};
use matrix_sdk_test::{async_test, message_like_event_content, test_json};
use matrix_sdk_test::{async_test, message_like_event_content, ruma_response_from_json, test_json};
use ruma::{
api::{
client::{
keys::{
get_keys::{self, v3::Response as KeyQueryResponse},
upload_keys,
},
sync::sync_events::DeviceLists,
},
IncomingResponse,
api::client::{
keys::{get_keys, upload_keys},
sync::sync_events::DeviceLists,
},
device_id,
events::{
@@ -51,7 +45,7 @@ use vodozemac::{
Ed25519PublicKey,
};
use super::{testing::response_from_file, CrossSigningBootstrapRequests};
use super::CrossSigningBootstrapRequests;
use crate::{
error::EventError,
machine::{
@@ -103,15 +97,13 @@ fn user_id() -> &'static UserId {
}
fn keys_upload_response() -> upload_keys::v3::Response {
let data = response_from_file(&test_json::KEYS_UPLOAD);
upload_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
let json = &test_json::KEYS_UPLOAD;
ruma_response_from_json(json)
}
fn keys_query_response() -> get_keys::v3::Response {
let data = response_from_file(&test_json::KEYS_QUERY);
get_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
let json = &test_json::KEYS_QUERY;
ruma_response_from_json(json)
}
pub fn to_device_requests_to_content(
@@ -749,9 +741,7 @@ pub async fn setup_cross_signing_for_machine_test_helper(alice: &OlmMachine, bob
}
);
let kq_response = KeyQueryResponse::try_from_http_response(response_from_file(&json))
.expect("Can't parse the `/keys/upload` response");
let kq_response = ruma_response_from_json(&json);
alice.receive_keys_query_response(&TransactionId::new(), &kq_response).await.unwrap();
bob.receive_keys_query_response(&TransactionId::new(), &kq_response).await.unwrap();
}
@@ -810,9 +800,7 @@ async fn sign_alice_device_for_machine_test_helper(alice: &OlmMachine, bob: &Olm
}
);
let kq_response = KeyQueryResponse::try_from_http_response(response_from_file(&json))
.expect("Can't parse the `/keys/upload` response");
let kq_response = ruma_response_from_json(&json);
alice.receive_keys_query_response(&TransactionId::new(), &kq_response).await.unwrap();
bob.receive_keys_query_response(&TransactionId::new(), &kq_response).await.unwrap();
}

33
crates/matrix-sdk-crypto/src/session_manager/group_sessions/mod.rs
View File

@@ -779,14 +779,11 @@ mod tests {
};
use assert_matches2::assert_let;
use matrix_sdk_test::{async_test, response_from_file};
use matrix_sdk_test::{async_test, ruma_response_from_json};
use ruma::{
api::{
client::{
keys::{claim_keys, get_keys, upload_keys},
to_device::send_event_to_device::v3::Response as ToDeviceResponse,
},
IncomingResponse,
api::client::{
keys::{claim_keys, get_keys, upload_keys},
to_device::send_event_to_device::v3::Response as ToDeviceResponse,
},
device_id,
events::room::history_visibility::HistoryVisibility,
@@ -826,9 +823,7 @@ mod tests {
fn keys_query_response() -> get_keys::v3::Response {
let data = include_bytes!("../../../../../benchmarks/benches/crypto_bench/keys_query.json");
let data: Value = serde_json::from_slice(data).unwrap();
let data = response_from_file(&data);
get_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
fn bob_keys_query_response() -> get_keys::v3::Response {
@@ -856,10 +851,7 @@ mod tests {
}
}
});
let data = response_from_file(&data);
get_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
/// Returns a keys claim response for device `BOBDEVICE` of user
@@ -882,10 +874,7 @@ mod tests {
}
}
});
let data = response_from_file(&data);
claim_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the keys claim response")
ruma_response_from_json(&data)
}
/// Returns a key claim response for device `NMMBNBUSNR` of user
@@ -893,9 +882,7 @@ mod tests {
fn keys_claim_response() -> claim_keys::v3::Response {
let data = include_bytes!("../../../../../benchmarks/benches/crypto_bench/keys_claim.json");
let data: Value = serde_json::from_slice(data).unwrap();
let data = response_from_file(&data);
claim_keys::v3::Response::try_from_http_response(data)
.expect("Can't parse the keys claim response")
ruma_response_from_json(&data)
}
async fn machine_with_user_test_helper(user_id: &UserId, device_id: &DeviceId) -> OlmMachine {
@@ -1370,9 +1357,7 @@ mod tests {
}
}
});
let keys_query =
get_keys::v3::Response::try_from_http_response(response_from_file(&keys_query_data))
.unwrap();
let keys_query: get_keys::v3::Response = ruma_response_from_json(&keys_query_data);
let txn_id = TransactionId::new();
machine.mark_request_as_sent(&txn_id, &keys_query).await.unwrap();

35
crates/matrix-sdk-crypto/src/session_manager/sessions.rs
View File

@@ -602,16 +602,10 @@ mod tests {
time::Duration,
};
use matrix_sdk_test::{async_test, response_from_file};
use matrix_sdk_test::{async_test, ruma_response_from_json};
use ruma::{
api::{
client::keys::{
claim_keys::v3::Response as KeyClaimResponse,
get_keys::v3::Response as KeysQueryResponse,
},
IncomingResponse,
},
device_id, owned_server_name, user_id, DeviceId, OwnedUserId, UserId,
api::client::keys::claim_keys::v3::Response as KeyClaimResponse, device_id,
owned_server_name, user_id, DeviceId, OwnedUserId, UserId,
};
use serde_json::json;
use tokio::sync::Mutex;
@@ -649,9 +643,7 @@ mod tests {
}
}
});
let response = response_from_file(&response);
KeyClaimResponse::try_from_http_response(response).unwrap()
ruma_response_from_json(&response)
}
fn keys_claim_without_failure() -> KeyClaimResponse {
@@ -661,9 +653,7 @@ mod tests {
},
"failures": {},
});
let response = response_from_file(&response);
KeyClaimResponse::try_from_http_response(response).unwrap()
ruma_response_from_json(&response)
}
async fn session_manager_test_helper() -> (SessionManager, IdentityManager) {
@@ -776,8 +766,7 @@ mod tests {
// the initial `/keys/query` completes, and we start another
let response_json =
json!({ "device_keys": { manager.store.static_account().user_id.to_owned(): {}}});
let response =
KeysQueryResponse::try_from_http_response(response_from_file(&response_json)).unwrap();
let response = ruma_response_from_json(&response_json);
identity_manager.receive_keys_query_response(&key_query_txn_id, &response).await.unwrap();
let (key_query_txn_id, key_query_request) =
@@ -788,8 +777,7 @@ mod tests {
let response_json = json!({ "device_keys": { bob.user_id(): {
bob_device.device_id(): bob_device.as_device_keys()
}}});
let response =
KeysQueryResponse::try_from_http_response(response_from_file(&response_json)).unwrap();
let response = ruma_response_from_json(&response_json);
identity_manager.receive_keys_query_response(&key_query_txn_id, &response).await.unwrap();
// the missing_sessions_task should now finally complete, with a claim
@@ -821,9 +809,9 @@ mod tests {
// Do a `/keys/query` request, in which Bob's server is a failure.
let (key_query_txn_id, _key_query_request) =
identity_manager.users_for_key_query().await.unwrap().pop_first().unwrap();
let response = KeysQueryResponse::try_from_http_response(response_from_file(
&json!({ "device_keys": {}, "failures": { other_user_id.server_name(): "unreachable" }})
)).unwrap();
let response = ruma_response_from_json(
&json!({ "device_keys": {}, "failures": { other_user_id.server_name(): "unreachable" }}),
);
identity_manager.receive_keys_query_response(&key_query_txn_id, &response).await.unwrap();
// Now, an attempt to get the missing sessions should now *not* block. We use a
@@ -987,8 +975,7 @@ mod tests {
/// checks that it is handled correctly. (The device should be marked as
/// 'failed'; and once that
async fn test_invalid_claim_response(response_json: serde_json::Value) {
let response = response_from_file(&response_json);
let response = KeyClaimResponse::try_from_http_response(response).unwrap();
let response = ruma_response_from_json(&response_json);
let alice = user_id!("@alice:example.org");
let mut alice_account = Account::with_device_id(alice, "DEVICEID".into());

13
testing/matrix-sdk-test/src/lib.rs
View File

@@ -152,10 +152,15 @@ pub fn sync_response(kind: SyncResponseFile) -> SyncResponse {
SyncResponseFile::Voip => &test_json::VOIP_SYNC,
};
let response = Response::builder().body(data.to_string().as_bytes().to_vec()).unwrap();
SyncResponse::try_from_http_response(response).unwrap()
ruma_response_from_json(data)
}
pub fn response_from_file(json: &JsonValue) -> Response<Vec<u8>> {
Response::builder().status(200).body(json.to_string().as_bytes().to_vec()).unwrap()
/// Build a typed Ruma [`IncomingResponse`] object from a json body.
pub fn ruma_response_from_json<ResponseType: IncomingResponse>(
json: &serde_json::Value,
) -> ResponseType {
let json_bytes = serde_json::to_vec(json).expect("JSON-serialization of response value failed");
let http_response =
Response::builder().status(200).body(json_bytes).expect("Failed to build HTTP response");
ResponseType::try_from_http_response(http_response).expect("Can't parse the response json")
}

77
testing/matrix-sdk-test/src/test_json/keys_query_sets.rs
View File

@@ -1,10 +1,10 @@
use ruma::{
api::{client::keys::get_keys::v3::Response as KeyQueryResponse, IncomingResponse},
device_id, user_id, DeviceId, UserId,
api::client::keys::get_keys::v3::Response as KeyQueryResponse, device_id, user_id, DeviceId,
UserId,
};
use serde_json::{json, Value};
use crate::response_from_file;
use crate::ruma_response_from_json;
/// This set of keys/query response was generated using a local synapse.
/// Each users was created, device added according to needs and the payload
@@ -95,10 +95,7 @@ impl KeyDistributionTestData {
}
});
let data = response_from_file(&data);
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
/// Dan has cross-signing setup, one device is cross signed `JHPUERYQUW`,
@@ -200,10 +197,7 @@ impl KeyDistributionTestData {
}
});
let data = response_from_file(&data);
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
/// Same as `dan_keys_query_response` but `FRGNMZVOKA` was removed.
@@ -286,10 +280,7 @@ impl KeyDistributionTestData {
}
});
let data = response_from_file(&data);
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
/// Dave is a user that has not enabled cross-signing
@@ -318,10 +309,7 @@ impl KeyDistributionTestData {
}
});
let data = response_from_file(&data);
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
/// Good is a user that has all his devices correctly cross-signed
@@ -419,10 +407,7 @@ impl KeyDistributionTestData {
}
});
let data = response_from_file(&data);
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
pub fn me_id() -> &'static UserId {
@@ -541,7 +526,7 @@ impl IdentityChangeDataSet {
/// A key query with an identity (Ia), and a first device `GYKSNAWLVK`
/// signed by Ia.
pub fn key_query_with_identity_a() -> KeyQueryResponse {
let data = response_from_file(&json!({
let data = json!({
"device_keys": {
"@bob:localhost": {
"GYKSNAWLVK": Self::device_keys_payload_1_signed_by_a()
@@ -551,9 +536,8 @@ impl IdentityChangeDataSet {
"master_keys": Self::msk_a(),
"self_signing_keys": Self::ssk_a(),
"user_signing_keys": {}
}));
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
});
ruma_response_from_json(&data)
}
pub fn msk_b() -> Value {
@@ -619,7 +603,7 @@ impl IdentityChangeDataSet {
/// `ATWKQFSFRN` is signed with the new identity but `GYKSNAWLVK` is still
/// signed by the old identity (Ia).
pub fn key_query_with_identity_b() -> KeyQueryResponse {
let data = response_from_file(&json!({
let data = json!({
"device_keys": {
"@bob:localhost": {
"ATWKQFSFRN": Self::device_keys_payload_2_signed_by_b(),
@@ -629,15 +613,14 @@ impl IdentityChangeDataSet {
"failures": {},
"master_keys": Self::msk_b(),
"self_signing_keys": Self::ssk_b(),
}));
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
});
ruma_response_from_json(&data)
}
/// A key query with no identity and a new device `OPABMDDXGX` (not
/// cross-signed).
pub fn key_query_with_identity_no_identity() -> KeyQueryResponse {
let data = response_from_file(&json!({
let data = json!({
"device_keys": {
"@bob:localhost": {
"ATWKQFSFRN": Self::device_keys_payload_2_signed_by_b(),
@@ -662,9 +645,8 @@ impl IdentityChangeDataSet {
}
},
"failures": {},
}));
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
});
ruma_response_from_json(&data)
}
}
@@ -744,10 +726,7 @@ impl PreviouslyVerifiedTestData {
}
});
let data = response_from_file(&data);
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
pub fn device_keys_payload_bob_unsigned_device() -> Value {
@@ -839,10 +818,7 @@ impl PreviouslyVerifiedTestData {
"user_signing_keys": {}
});
let data = response_from_file(&data);
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
pub fn bob_device_1_id() -> &'static DeviceId {
@@ -940,10 +916,7 @@ impl PreviouslyVerifiedTestData {
"user_signing_keys": {}
});
let data = response_from_file(&data);
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
pub fn device_1_keys_payload_carol() -> Value {
@@ -1043,10 +1016,7 @@ impl PreviouslyVerifiedTestData {
"user_signing_keys": {}
});
let data = response_from_file(&data);
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
pub fn carol_keys_query_response_signed() -> KeyQueryResponse {
@@ -1082,9 +1052,6 @@ impl PreviouslyVerifiedTestData {
"user_signing_keys": {}
});
let data = response_from_file(&data);
KeyQueryResponse::try_from_http_response(data)
.expect("Can't parse the `/keys/upload` response")
ruma_response_from_json(&data)
}
}