Differential D7799 Diff 26432 services/commtest/tests/tunnelbroker_integration_test.rs

Changeset View

Standalone View

services/commtest/tests/tunnelbroker_integration_test.rs

Show All 39 Lines	async fn send_refresh_request() {
};		};

let payload = serde_json::to_string(&refresh_request).unwrap();		let payload = serde_json::to_string(&refresh_request).unwrap();
let request = MessageToDevice {		let request = MessageToDevice {
device_id: "foo".to_string(),		device_id: "foo".to_string(),
payload,		payload,
};		};
let grpc_message = tonic::Request::new(request);		let grpc_message = tonic::Request::new(request);

		tunnelbroker_client
		.send_message_to_device(grpc_message)
		.await
		.unwrap();

		// Have keyserver receive any websocket messages
		let response = socket.next().await.unwrap().unwrap();
		bartekUnsubmitted Done Inline Actions For future reviewers: This `unwrap` is refactored in the next diff 😉 bartek: For future reviewers: This `unwrap` is refactored in the next diff 😉
		jonAuthorUnsubmitted Done Inline Actions Yea, meant to comment. Thanks :) jon: Yea, meant to comment. Thanks :)

		// Check that message received by keyserver matches what identity server
		// issued
		let serialized_response: RefreshKeyRequest =
		serde_json::from_str(&response.to_text().unwrap()).unwrap();
		assert_eq!(serialized_response, refresh_request);
		}

		/// Test that a message to an offline device gets pushed to dynamodb
		/// then recalled once a device connects
		#[tokio::test]
		async fn presist_messages() {
		// Send request for keyserver to refresh keys (identity service)
		let mut tunnelbroker_client =
		TunnelbrokerServiceClient::connect("http://localhost:50051")
		.await
		.unwrap();

		let refresh_request = messages::RefreshKeyRequest {
		device_id: "bar".to_string(),
		number_of_keys: 5,
		};

		let payload = serde_json::to_string(&refresh_request).unwrap();
		let request = MessageToDevice {
		device_id: "bar".to_string(),
		payload,
		};
		let grpc_message = tonic::Request::new(request);
tunnelbroker_client		tunnelbroker_client
.send_message_to_device(grpc_message)		.send_message_to_device(grpc_message)
.await		.await
.unwrap();		.unwrap();

		// Wait one second to ensure that message had time to persist
		use std::{thread, time};
		let ten_millis = time::Duration::from_millis(50);
		thread::sleep(ten_millis);

		// Create session as a keyserver
		let (mut socket, _) = connect_async("ws://localhost:51001")
		bartekUnsubmitted Done Inline Actions Just a general note: We eventually might want to store the tested service hostnames and ports in a separate, easily configurable place. If you have some ideas already, maybe we could discuss them in some Linear task, I'll be dealing with the same problem when designing blob service HTTP tests very soon so maybe we can do it the right way 😄 (for blob and backup we use the env variable for port number but this isn't clean and flexible enough) bartek: Just a general note: We eventually might want to store the tested service hostnames and ports…
		jonAuthorUnsubmitted Done Inline Actions Created https://linear.app/comm/issue/ENG-3940. But I agree, it would nice to create a paradigm for configuring this. jon: Created https://linear.app/comm/issue/ENG-3940. But I agree, it would nice to create a…
		.await
		.expect("Can't connect");

		let session_request = r#"{
		"type": "sessionRequest",
		"accessToken": "xkdexfjsld",
		"deviceId": "bar",
		"deviceType": "keyserver"
		}"#;

		socket
		.send(Message::Text(session_request.to_string()))
		.await
		.expect("Failed to send message");

// Have keyserver receive any websocket messages		// Have keyserver receive any websocket messages
let response = socket.next().await.unwrap().unwrap();		let response = socket.next().await.unwrap().unwrap();

// Check that message received by keyserver matches what identity server		// Check that message received by keyserver matches what identity server
// issued		// issued
let serialized_response: RefreshKeyRequest =		let serialized_response: RefreshKeyRequest =
serde_json::from_str(&response.to_text().unwrap()).unwrap();		serde_json::from_str(&response.to_text().unwrap()).unwrap();
assert_eq!(serialized_response, refresh_request);		assert_eq!(serialized_response, refresh_request);
}		}