Page MenuHomePhorge
Files F33006668

D9310.1768363536.diff
No OneTemporary
Actions

Size
8 KB
Referenced Files
None
Subscribers
None

D9310.1768363536.diff
View Options

diff --git a/services/commtest/src/tunnelbroker/mod.rs b/services/commtest/src/tunnelbroker/mod.rs
--- a/services/commtest/src/tunnelbroker/mod.rs
+++ b/services/commtest/src/tunnelbroker/mod.rs
@@ -1 +1 @@
-
+pub mod socket;
diff --git a/services/commtest/src/tunnelbroker/socket.rs b/services/commtest/src/tunnelbroker/socket.rs
new file mode 100644
--- /dev/null
+++ b/services/commtest/src/tunnelbroker/socket.rs
@@ -0,0 +1,34 @@
+use crate::identity::device::DeviceInfo;
+use futures_util::SinkExt;
+use tokio::net::TcpStream;
+use tokio_tungstenite::tungstenite::Message;
+use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
+use tunnelbroker_messages::{ConnectionInitializationMessage, DeviceTypes};
+
+pub async fn create_socket(
+ device_info: &DeviceInfo,
+) -> WebSocketStream<MaybeTlsStream<TcpStream>> {
+ let (mut socket, _) = connect_async("ws://localhost:51001")
+ .await
+ .expect("Can't connect");
+
+ let session_request = ConnectionInitializationMessage {
+ device_id: device_info.device_id.to_string(),
+ access_token: device_info.access_token.to_string(),
+ user_id: device_info.user_id.to_string(),
+ notify_token: None,
+ device_type: DeviceTypes::Keyserver,
+ device_app_version: None,
+ device_os: None,
+ };
+
+ let serialized_request = serde_json::to_string(&session_request)
+ .expect("Failed to serialize connection request");
+
+ socket
+ .send(Message::Text(serialized_request))
+ .await
+ .expect("Failed to send message");
+
+ socket
+}
diff --git a/services/commtest/tests/identity_tunnelbroker_tests.rs b/services/commtest/tests/identity_tunnelbroker_tests.rs
--- a/services/commtest/tests/identity_tunnelbroker_tests.rs
+++ b/services/commtest/tests/identity_tunnelbroker_tests.rs
@@ -8,39 +8,18 @@
use client::identity_client_service_client::IdentityClientServiceClient;
use client::UploadOneTimeKeysRequest;
use commtest::identity::device::create_device;
+use commtest::tunnelbroker::socket::create_socket;
use futures_util::StreamExt;
-use futures_util::{SinkExt, TryStreamExt};
-use tokio_tungstenite::{connect_async, tungstenite::Message};
use tonic::transport::Endpoint;
use tonic::Request;
-use tunnelbroker_messages::{
- ConnectionInitializationMessage, DeviceTypes, RefreshKeyRequest,
-};
+use tunnelbroker_messages::RefreshKeyRequest;
#[tokio::test]
#[should_panic]
async fn test_tunnelbroker_invalid_auth() {
- let (mut socket, _) = connect_async("ws://localhost:51001")
- .await
- .expect("Can't connect");
-
- let session_request = ConnectionInitializationMessage {
- device_id: "".to_string(),
- access_token: "".to_string(),
- user_id: "".to_string(),
- notify_token: None,
- device_type: DeviceTypes::Keyserver,
- device_app_version: None,
- device_os: None,
- };
-
- let serialized_request = serde_json::to_string(&session_request)
- .expect("Failed to serialize connection request");
-
- socket
- .send(Message::Text(serialized_request))
- .await
- .expect("Failed to send message");
+ let mut device_info = create_device().await;
+ device_info.access_token = "".to_string();
+ let mut socket = create_socket(&device_info).await;
socket
.next()
@@ -51,28 +30,8 @@
#[tokio::test]
async fn test_tunnelbroker_valid_auth() {
- let (mut socket, _) = connect_async("ws://localhost:51001")
- .await
- .expect("Can't connect");
-
let device_info = create_device().await;
- let session_request = ConnectionInitializationMessage {
- device_id: device_info.device_id.to_string(),
- access_token: device_info.access_token.to_string(),
- user_id: device_info.user_id.to_string(),
- notify_token: None,
- device_type: DeviceTypes::Keyserver,
- device_app_version: None,
- device_os: None,
- };
-
- let serialized_request = serde_json::to_string(&session_request)
- .expect("Failed to serialize connection request");
-
- socket
- .send(Message::Text(serialized_request))
- .await
- .expect("Failed to send message");
+ let mut socket = create_socket(&device_info).await;
socket
.next()
@@ -136,27 +95,8 @@
// from tunnelbroker to refresh keys
// Create session as a keyserver
- let (mut socket, _) = connect_async("ws://localhost:51001")
- .await
- .expect("Can't connect");
-
- let session_request = ConnectionInitializationMessage {
- device_id: device_info.device_id.to_string(),
- access_token: device_info.access_token.to_string(),
- user_id: device_info.user_id.to_string(),
- notify_token: None,
- device_type: DeviceTypes::Keyserver,
- device_app_version: None,
- device_os: None,
- };
-
- let serialized_request = serde_json::to_string(&session_request)
- .expect("Failed to serialize connection request");
-
- socket
- .send(Message::Text(serialized_request))
- .await
- .expect("Failed to send message");
+ let device_info = create_device().await;
+ let mut socket = create_socket(&device_info).await;
// Have keyserver receive any websocket messages
if let Some(Ok(response)) = socket.next().await {
diff --git a/services/commtest/tests/tunnelbroker_integration_test.rs b/services/commtest/tests/tunnelbroker_integration_test.rs
--- a/services/commtest/tests/tunnelbroker_integration_test.rs
+++ b/services/commtest/tests/tunnelbroker_integration_test.rs
@@ -1,42 +1,19 @@
-use futures_util::SinkExt;
-use tokio_tungstenite::{connect_async, tungstenite::Message};
mod proto {
tonic::include_proto!("tunnelbroker");
}
use commtest::identity::device::create_device;
+use commtest::tunnelbroker::socket::create_socket;
use futures_util::StreamExt;
use proto::tunnelbroker_service_client::TunnelbrokerServiceClient;
use proto::MessageToDevice;
use tunnelbroker_messages as messages;
-use tunnelbroker_messages::{
- ConnectionInitializationMessage, DeviceTypes, RefreshKeyRequest,
-};
+use tunnelbroker_messages::RefreshKeyRequest;
#[tokio::test]
async fn send_refresh_request() {
// Create session as a keyserver
- let (mut socket, _) = connect_async("ws://localhost:51001")
- .await
- .expect("Can't connect");
-
let device_info = create_device().await;
- let session_request = ConnectionInitializationMessage {
- device_id: device_info.device_id.to_string(),
- access_token: device_info.access_token.to_string(),
- user_id: device_info.user_id.to_string(),
- notify_token: None,
- device_type: DeviceTypes::Keyserver,
- device_app_version: None,
- device_os: None,
- };
-
- let serialized_request = serde_json::to_string(&session_request)
- .expect("Failed to serialize connection request");
-
- socket
- .send(Message::Text(serialized_request))
- .await
- .expect("Failed to send message");
+ let mut socket = create_socket(&device_info).await;
// Send request for keyserver to refresh keys (identity service)
let mut tunnelbroker_client =
@@ -75,6 +52,8 @@
/// then recalled once a device connects
#[tokio::test]
async fn presist_messages() {
+ let device_info = create_device().await;
+
// Send request for keyserver to refresh keys (identity service)
let mut tunnelbroker_client =
TunnelbrokerServiceClient::connect("http://localhost:50051")
@@ -82,13 +61,13 @@
.unwrap();
let refresh_request = messages::RefreshKeyRequest {
- device_id: "bar".to_string(),
+ device_id: device_info.device_id.to_string(),
number_of_keys: 5,
};
let payload = serde_json::to_string(&refresh_request).unwrap();
let request = MessageToDevice {
- device_id: "bar".to_string(),
+ device_id: device_info.device_id.to_string(),
payload,
};
let grpc_message = tonic::Request::new(request);
@@ -102,23 +81,7 @@
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")
- .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");
-
+ let mut socket = create_socket(&device_info).await;
// Have keyserver receive any websocket messages
if let Some(Ok(response)) = socket.next().await {
// Check that message received by keyserver matches what identity server

File Metadata

Mime Type
text/plain
Expires
Wed, Jan 14, 4:05 AM (4 h, 6 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
5930240
Default Alt Text
D9310.1768363536.diff (8 KB)

Event Timeline