diff --git a/services/commtest/src/identity/device.rs b/services/commtest/src/identity/device.rs
--- a/services/commtest/src/identity/device.rs
+++ b/services/commtest/src/identity/device.rs
@@ -22,7 +22,14 @@
   pub access_token: String,
 }
 
-pub async fn create_device(keys: Option<&ClientPublicKeys>) -> DeviceInfo {
+/// Register a new user with a device.
+/// - Gives random username (returned by function).
+/// - Device type defaults to keyserver.
+/// - Device ID taken from `keys` (ed25519), see [`DEFAULT_CLIENT_KEYS`]
+pub async fn register_user_device(
+  keys: Option<&ClientPublicKeys>,
+  device_type: Option<DeviceType>,
+) -> DeviceInfo {
   let password = "pass";
   let username: String = rand::thread_rng()
     .sample_iter(&Alphanumeric)
@@ -36,6 +43,7 @@
     serde_json::to_string(&keys).expect("Failed to serialize example payload");
   // The ed25519 value from the olm payload
   let device_id = &keys.primary_identity_public_keys.ed25519;
+  let device_type = device_type.unwrap_or(DeviceType::Keyserver);
 
   let mut client_registration = Registration::new();
   let opaque_registration_request =
@@ -59,7 +67,7 @@
       }),
       one_time_content_prekeys: Vec::new(),
       one_time_notif_prekeys: Vec::new(),
-      device_type: DeviceType::Keyserver.into(),
+      device_type: device_type.into(),
     }),
   };
 
diff --git a/services/commtest/tests/grpc_client_test.rs b/services/commtest/tests/grpc_client_test.rs
--- a/services/commtest/tests/grpc_client_test.rs
+++ b/services/commtest/tests/grpc_client_test.rs
@@ -1,9 +1,9 @@
-use commtest::{identity::device::create_device, service_addr};
+use commtest::{identity::device::register_user_device, service_addr};
 
 #[tokio::test]
 async fn verify_access_token() {
   use grpc_clients::identity::unauthenticated::client::verify_user_access_token;
-  let device_info = create_device(None).await;
+  let device_info = register_user_device(None, None).await;
   let code_version = 1000;
   let device_type = "android";
 
diff --git a/services/commtest/tests/identity_access_tokens_tests.rs b/services/commtest/tests/identity_access_tokens_tests.rs
--- a/services/commtest/tests/identity_access_tokens_tests.rs
+++ b/services/commtest/tests/identity_access_tokens_tests.rs
@@ -1,5 +1,5 @@
 use commtest::identity::device::{
-  create_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
+  register_user_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
 };
 use commtest::service_addr;
 use grpc_clients::identity::{
@@ -9,7 +9,7 @@
 #[tokio::test]
 async fn verify_access_token() {
   let identity_grpc_endpoint = service_addr::IDENTITY_GRPC.to_string();
-  let device_info = create_device(None).await;
+  let device_info = register_user_device(None, None).await;
 
   let mut identity_client = get_unauthenticated_client(
     &identity_grpc_endpoint,
diff --git a/services/commtest/tests/identity_integration_tests.rs b/services/commtest/tests/identity_integration_tests.rs
--- a/services/commtest/tests/identity_integration_tests.rs
+++ b/services/commtest/tests/identity_integration_tests.rs
@@ -1,5 +1,5 @@
 use commtest::identity::device::{
-  create_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
+  register_user_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
 };
 use commtest::service_addr;
 use grpc_clients::identity::protos::authenticated::find_user_id_request::Identifier;
@@ -9,7 +9,7 @@
 
 #[tokio::test]
 async fn find_user_id_by_username() {
-  let device_info = create_device(None).await;
+  let device_info = register_user_device(None, None).await;
 
   let mut client = get_auth_client(
     &service_addr::IDENTITY_GRPC.to_string(),
diff --git a/services/commtest/tests/identity_keyserver_tests.rs b/services/commtest/tests/identity_keyserver_tests.rs
--- a/services/commtest/tests/identity_keyserver_tests.rs
+++ b/services/commtest/tests/identity_keyserver_tests.rs
@@ -1,5 +1,5 @@
 use commtest::identity::device::{
-  create_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
+  register_user_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
 };
 use commtest::service_addr;
 use grpc_clients::identity::{
@@ -12,7 +12,7 @@
 #[tokio::test]
 async fn set_prekey() {
   let identity_grpc_endpoint = service_addr::IDENTITY_GRPC.to_string();
-  let device_info = create_device(None).await;
+  let device_info = register_user_device(None, None).await;
 
   let mut client = get_auth_client(
     &identity_grpc_endpoint,
diff --git a/services/commtest/tests/identity_one_time_key_tests.rs b/services/commtest/tests/identity_one_time_key_tests.rs
--- a/services/commtest/tests/identity_one_time_key_tests.rs
+++ b/services/commtest/tests/identity_one_time_key_tests.rs
@@ -1,5 +1,5 @@
 use commtest::identity::device::{
-  create_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
+  register_user_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
 };
 use commtest::service_addr;
 use grpc_clients::identity::{
@@ -8,7 +8,7 @@
 
 #[tokio::test]
 async fn upload_one_time_keys() {
-  let device_info = create_device(None).await;
+  let device_info = register_user_device(None, None).await;
 
   let mut identity_client = get_auth_client(
     &service_addr::IDENTITY_GRPC.to_string(),
diff --git a/services/commtest/tests/identity_prekey_tests.rs b/services/commtest/tests/identity_prekey_tests.rs
--- a/services/commtest/tests/identity_prekey_tests.rs
+++ b/services/commtest/tests/identity_prekey_tests.rs
@@ -1,5 +1,5 @@
 use commtest::identity::device::{
-  create_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
+  register_user_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
 };
 use commtest::service_addr;
 use grpc_clients::identity::{
@@ -9,7 +9,7 @@
 
 #[tokio::test]
 async fn set_prekey() {
-  let device_info = create_device(None).await;
+  let device_info = register_user_device(None, None).await;
 
   let mut client = get_auth_client(
     &service_addr::IDENTITY_GRPC.to_string(),
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
@@ -1,5 +1,5 @@
 use commtest::identity::device::{
-  create_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
+  register_user_device, DEVICE_TYPE, PLACEHOLDER_CODE_VERSION,
 };
 use commtest::service_addr;
 use commtest::tunnelbroker::socket::{create_socket, receive_message};
@@ -12,7 +12,7 @@
 
 #[tokio::test]
 async fn test_tunnelbroker_invalid_auth() {
-  let mut device_info = create_device(None).await;
+  let mut device_info = register_user_device(None, None).await;
   device_info.access_token = "".to_string();
   let socket = create_socket(&device_info).await;
   assert!(matches!(socket, Result::Err(_)))
@@ -20,7 +20,7 @@
 
 #[tokio::test]
 async fn test_tunnelbroker_valid_auth() {
-  let device_info = create_device(None).await;
+  let device_info = register_user_device(None, None).await;
   let mut socket = create_socket(&device_info).await.unwrap();
 
   socket
@@ -33,7 +33,7 @@
 #[tokio::test]
 async fn test_refresh_keys_request_upon_depletion() {
   let identity_grpc_endpoint = service_addr::IDENTITY_GRPC.to_string();
-  let device_info = create_device(None).await;
+  let device_info = register_user_device(None, None).await;
 
   // Request outbound keys, which should trigger identity service to ask for more keys
   let mut client = get_auth_client(
@@ -71,7 +71,7 @@
   // from Tunnelbroker to refresh keys
   // Create session as a keyserver
 
-  let device_info = create_device(None).await;
+  let device_info = register_user_device(None, None).await;
   let mut socket = create_socket(&device_info).await.unwrap();
   for _ in 0..2 {
     let response = receive_message(&mut socket).await.unwrap();
diff --git a/services/commtest/tests/tunnelbroker_heartbeat_tests.rs b/services/commtest/tests/tunnelbroker_heartbeat_tests.rs
--- a/services/commtest/tests/tunnelbroker_heartbeat_tests.rs
+++ b/services/commtest/tests/tunnelbroker_heartbeat_tests.rs
@@ -1,4 +1,4 @@
-use commtest::identity::device::create_device;
+use commtest::identity::device::register_user_device;
 use commtest::tunnelbroker::socket::create_socket;
 use futures_util::sink::SinkExt;
 use futures_util::stream::StreamExt;
@@ -24,7 +24,7 @@
 
 #[tokio::test]
 async fn test_receiving() {
-  let client = create_device(None).await;
+  let client = register_user_device(None, None).await;
   let mut socket = create_socket(&client).await.unwrap();
 
   let message_to_device = receive_and_parse_message(&mut socket).await;
@@ -39,7 +39,7 @@
 
 #[tokio::test]
 async fn test_responding() {
-  let client = create_device(None).await;
+  let client = register_user_device(None, None).await;
   let mut socket = create_socket(&client).await.unwrap();
 
   let message_to_device = receive_and_parse_message(&mut socket).await;
@@ -66,7 +66,7 @@
 
 #[tokio::test]
 async fn test_closing() {
-  let client = create_device(None).await;
+  let client = register_user_device(None, None).await;
   let mut socket = create_socket(&client).await.unwrap();
 
   let message_to_device = receive_and_parse_message(&mut socket).await;
diff --git a/services/commtest/tests/tunnelbroker_integration_tests.rs b/services/commtest/tests/tunnelbroker_integration_tests.rs
--- a/services/commtest/tests/tunnelbroker_integration_tests.rs
+++ b/services/commtest/tests/tunnelbroker_integration_tests.rs
@@ -2,7 +2,7 @@
   tonic::include_proto!("tunnelbroker");
 }
 
-use commtest::identity::device::create_device;
+use commtest::identity::device::register_user_device;
 use commtest::identity::olm_account_infos::{
   MOCK_CLIENT_KEYS_1, MOCK_CLIENT_KEYS_2,
 };
@@ -21,7 +21,7 @@
 #[tokio::test]
 async fn send_refresh_request() {
   // Create session as a keyserver
-  let device_info = create_device(None).await;
+  let device_info = register_user_device(None, None).await;
   let mut socket = create_socket(&device_info).await.unwrap();
 
   // Send request for keyserver to refresh keys (identity service)
@@ -59,8 +59,8 @@
 
 #[tokio::test]
 async fn test_messages_order() {
-  let sender = create_device(Some(&MOCK_CLIENT_KEYS_1)).await;
-  let receiver = create_device(Some(&MOCK_CLIENT_KEYS_2)).await;
+  let sender = register_user_device(Some(&MOCK_CLIENT_KEYS_1), None).await;
+  let receiver = register_user_device(Some(&MOCK_CLIENT_KEYS_2), None).await;
 
   let messages = vec![
     WebSocketMessageToDevice {
diff --git a/services/commtest/tests/tunnelbroker_persist_tests.rs b/services/commtest/tests/tunnelbroker_persist_tests.rs
--- a/services/commtest/tests/tunnelbroker_persist_tests.rs
+++ b/services/commtest/tests/tunnelbroker_persist_tests.rs
@@ -1,7 +1,7 @@
 mod proto {
   tonic::include_proto!("tunnelbroker");
 }
-use commtest::identity::device::create_device;
+use commtest::identity::device::register_user_device;
 use commtest::identity::olm_account_infos::{
   MOCK_CLIENT_KEYS_1, MOCK_CLIENT_KEYS_2,
 };
@@ -20,7 +20,7 @@
 
 #[tokio::test]
 async fn persist_grpc_messages() {
-  let device_info = create_device(None).await;
+  let device_info = register_user_device(None, None).await;
 
   // Send request for keyserver to refresh keys (identity service)
   let mut tunnelbroker_client =
@@ -60,8 +60,8 @@
 
 #[tokio::test]
 async fn persist_websocket_messages() {
-  let sender = create_device(Some(&MOCK_CLIENT_KEYS_1)).await;
-  let receiver = create_device(Some(&MOCK_CLIENT_KEYS_2)).await;
+  let sender = register_user_device(Some(&MOCK_CLIENT_KEYS_1), None).await;
+  let receiver = register_user_device(Some(&MOCK_CLIENT_KEYS_2), None).await;
 
   // Send message to not connected client
   let mut sender_socket = create_socket(&sender).await.unwrap();
diff --git a/services/commtest/tests/tunnelbroker_recipient_confirmation_tests.rs b/services/commtest/tests/tunnelbroker_recipient_confirmation_tests.rs
--- a/services/commtest/tests/tunnelbroker_recipient_confirmation_tests.rs
+++ b/services/commtest/tests/tunnelbroker_recipient_confirmation_tests.rs
@@ -1,4 +1,4 @@
-use commtest::identity::device::create_device;
+use commtest::identity::device::register_user_device;
 use commtest::identity::olm_account_infos::{
   MOCK_CLIENT_KEYS_1, MOCK_CLIENT_KEYS_2,
 };
@@ -15,8 +15,8 @@
 
 #[tokio::test]
 async fn deliver_until_confirmation_not_connected() {
-  let sender = create_device(Some(&MOCK_CLIENT_KEYS_1)).await;
-  let receiver = create_device(Some(&MOCK_CLIENT_KEYS_2)).await;
+  let sender = register_user_device(Some(&MOCK_CLIENT_KEYS_1), None).await;
+  let receiver = register_user_device(Some(&MOCK_CLIENT_KEYS_2), None).await;
 
   // send message to not connected client
   let mut sender_socket = create_socket(&sender).await.unwrap();
@@ -59,8 +59,8 @@
 
 #[tokio::test]
 async fn deliver_until_confirmation_connected() {
-  let sender = create_device(Some(&MOCK_CLIENT_KEYS_1)).await;
-  let receiver = create_device(Some(&MOCK_CLIENT_KEYS_2)).await;
+  let sender = register_user_device(Some(&MOCK_CLIENT_KEYS_1), None).await;
+  let receiver = register_user_device(Some(&MOCK_CLIENT_KEYS_2), None).await;
 
   // send message to connected client
   let mut receiver_socket = create_socket(&receiver).await.unwrap();
@@ -98,8 +98,8 @@
 
 #[tokio::test]
 async fn test_confirming_deleted_message() {
-  let sender = create_device(Some(&MOCK_CLIENT_KEYS_1)).await;
-  let receiver = create_device(Some(&MOCK_CLIENT_KEYS_2)).await;
+  let sender = register_user_device(Some(&MOCK_CLIENT_KEYS_1), None).await;
+  let receiver = register_user_device(Some(&MOCK_CLIENT_KEYS_2), None).await;
 
   // send message to connected client
   let mut receiver_socket = create_socket(&receiver).await.unwrap();
@@ -153,8 +153,8 @@
 
 #[tokio::test]
 async fn test_confirming() {
-  let sender = create_device(Some(&MOCK_CLIENT_KEYS_1)).await;
-  let receiver = create_device(Some(&MOCK_CLIENT_KEYS_2)).await;
+  let sender = register_user_device(Some(&MOCK_CLIENT_KEYS_1), None).await;
+  let receiver = register_user_device(Some(&MOCK_CLIENT_KEYS_2), None).await;
 
   // send message to connected client
   let mut receiver_socket = create_socket(&receiver).await.unwrap();
diff --git a/services/commtest/tests/tunnelbroker_sender_confirmation_tests.rs b/services/commtest/tests/tunnelbroker_sender_confirmation_tests.rs
--- a/services/commtest/tests/tunnelbroker_sender_confirmation_tests.rs
+++ b/services/commtest/tests/tunnelbroker_sender_confirmation_tests.rs
@@ -1,4 +1,4 @@
-use commtest::identity::device::create_device;
+use commtest::identity::device::register_user_device;
 use commtest::identity::olm_account_infos::{
   DEFAULT_CLIENT_KEYS, MOCK_CLIENT_KEYS_1, MOCK_CLIENT_KEYS_2,
 };
@@ -14,8 +14,8 @@
 
 #[tokio::test]
 async fn get_confirmation() {
-  let sender = create_device(Some(&MOCK_CLIENT_KEYS_1)).await;
-  let receiver = create_device(Some(&MOCK_CLIENT_KEYS_2)).await;
+  let sender = register_user_device(Some(&MOCK_CLIENT_KEYS_1), None).await;
+  let receiver = register_user_device(Some(&MOCK_CLIENT_KEYS_2), None).await;
 
   let client_message_id = "mockID".to_string();
 
@@ -53,7 +53,7 @@
 
 #[tokio::test]
 async fn get_serialization_error() {
-  let sender = create_device(Some(&DEFAULT_CLIENT_KEYS)).await;
+  let sender = register_user_device(Some(&DEFAULT_CLIENT_KEYS), None).await;
   let message = "some bad json".to_string();
 
   let mut sender_socket = create_socket(&sender).await.unwrap();
@@ -74,7 +74,7 @@
 
 #[tokio::test]
 async fn get_invalid_request_error() {
-  let sender = create_device(Some(&DEFAULT_CLIENT_KEYS)).await;
+  let sender = register_user_device(Some(&DEFAULT_CLIENT_KEYS), None).await;
 
   let mut sender_socket = create_socket(&sender).await.unwrap();
   sender_socket
diff --git a/services/commtest/tests/tunnelbroker_websocket_messages_tests.rs b/services/commtest/tests/tunnelbroker_websocket_messages_tests.rs
--- a/services/commtest/tests/tunnelbroker_websocket_messages_tests.rs
+++ b/services/commtest/tests/tunnelbroker_websocket_messages_tests.rs
@@ -1,4 +1,4 @@
-use commtest::identity::device::create_device;
+use commtest::identity::device::register_user_device;
 use commtest::identity::olm_account_infos::MOCK_CLIENT_KEYS_1;
 use commtest::tunnelbroker::socket::create_socket;
 use futures_util::{SinkExt, StreamExt};
@@ -8,7 +8,7 @@
 
 #[tokio::test]
 async fn test_ping_pong() {
-  let device = create_device(Some(&MOCK_CLIENT_KEYS_1)).await;
+  let device = register_user_device(Some(&MOCK_CLIENT_KEYS_1), None).await;
 
   let ping_message = vec![1, 2, 3, 4, 5];
 
@@ -32,7 +32,7 @@
 
 #[tokio::test]
 async fn test_close_message() {
-  let device = create_device(Some(&MOCK_CLIENT_KEYS_1)).await;
+  let device = register_user_device(Some(&MOCK_CLIENT_KEYS_1), None).await;
 
   let mut socket = create_socket(&device).await.unwrap();
   socket