Page MenuHomePhabricator
Differential D10579

[lib] Separate out keyserver utils in action-utils.js into a separate file
ClosedPublic
Actions

Authored by ashoat on Jan 8 2024, 11:40 AM.
Tags
None
Referenced Files
F5055722: D10579.diff
Tue, Mar 25, 4:44 PM
Unknown Object (File)
Tue, Mar 25, 6:37 AM
Unknown Object (File)
Sun, Mar 23, 6:42 AM
Unknown Object (File)
Sun, Mar 23, 6:42 AM
Unknown Object (File)
Sun, Mar 23, 6:42 AM
Unknown Object (File)
Sun, Mar 23, 6:42 AM
Unknown Object (File)
Sun, Mar 23, 4:01 AM
Unknown Object (File)
Sat, Mar 22, 3:40 PM
View All 81 Files
Subscribers
None

Details

Reviewers
inka
varun
tomek
Commits
rCOMMe10843579a7f: [lib] Separate out keyserver utils in action-utils.js into a separate file
Summary

action-utils.js is getting to be quite large, so I'm factoring these out.

Depends on D10578

Test Plan

Flow

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

ashoat created this revision.Jan 8 2024, 11:40 AM
ashoat published this revision for review.Jan 8 2024, 11:48 AM

Note – this was a pure move. None of the actual code was changed

Harbormaster failed remote builds in B25614: Diff 35409!Jan 8 2024, 12:11 PM
inka added a comment.Jan 9 2024, 3:37 AM

We have a keyserver-utils.js file in lib/shared/. Should we merge them?
I'm also not sure about ksconn folder name, I can't tell what exactly it is supposed to mean even though I know the contents, so I feel like it may be even more confusing for other people on the team

ashoat added a comment.Jan 9 2024, 6:04 AM

We have a keyserver-utils.js file in lib/shared/. Should we merge them?

This file just contains the utilities you created for useKeyserverCall stuff... I think it makes sense as its own logical unit. Maybe I'll just rename the file to reduce the ambiguity?

In D10579#306097, @inka wrote:

I'm also not sure about ksconn folder name, I can't tell what exactly it is supposed to mean even though I know the contents, so I feel like it may be even more confusing for other people on the team

Open to any other suggested name... I wasn't sure about ksconn either, was just thinking of "keyserver connection". How about keyserver-conn?

ashoat updated this revision to Diff 35434.Jan 9 2024, 6:28 AM

Rename

ashoat added a child revision: D10583: [lib][native][web] Move some types and basic functions out of action-utils.js.Jan 9 2024, 6:52 AM
Harbormaster completed remote builds in B25633: Diff 35434.Jan 9 2024, 7:05 AM
tomek accepted this revision.Jan 9 2024, 8:40 AM
inka accepted this revision.Jan 10 2024, 1:06 AM
This revision is now accepted and ready to land.Jan 10 2024, 1:06 AM
Closed by commit rCOMMe10843579a7f: [lib] Separate out keyserver utils in action-utils.js into a separate file (authored by ashoat). · Explain WhyJan 10 2024, 5:43 AM
This revision was automatically updated to reflect the committed changes.
ashoat added a commit: rCOMMe10843579a7f: [lib] Separate out keyserver utils in action-utils.js into a separate file.

Revision Contents
Changeset List

PathSize
lib/
actions/
2 lines
8 lines
2 lines
8 lines
2 lines
2 lines
2 lines
10 lines
keyserver-conn/
93 lines
keyserver-conn/
utils/
keyserver-call-utils.test.js
action-utils.test.js
2 lines
reducers/
6 lines
shared/
2 lines
utils/
86 lines
native/
chat/
settings/
6 lines
web/
redux/
2 lines

Diff 35480

View Options

lib/actions/activity-actions.js

  • This file was added.
use std::str::FromStr;
use commtest::identity::device::{
login_user_device, logout_user_device, register_user_device, DEVICE_TYPE,
PLACEHOLDER_CODE_VERSION,
};
use commtest::service_addr;
use grpc_clients::identity::get_auth_client;
use grpc_clients::identity::protos::authenticated::GetDeviceListRequest;
use grpc_clients::identity::DeviceType;
use serde::Deserialize;
// 1. register user with android device
// 2. register a web device
// 3. remove android device
// 4. register ios device
// 5. get device list - should have 4 updates:
// - [android]
// - [android, web]
// - [web]
// - [ios, web] - mobile should be first
#[tokio::test]
async fn test_device_list_updates() {
use commtest::identity::olm_account_infos::{
DEFAULT_CLIENT_KEYS as DEVICE_KEYS_ANDROID,
MOCK_CLIENT_KEYS_1 as DEVICE_KEYS_WEB,
MOCK_CLIENT_KEYS_2 as DEVICE_KEYS_IOS,
};
// Create viewer (user that doesn't change devices)
let viewer = register_user_device(None, None).await;
let mut auth_client = get_auth_client(
&service_addr::IDENTITY_GRPC.to_string(),
viewer.user_id.clone(),
viewer.device_id,
viewer.access_token,
PLACEHOLDER_CODE_VERSION,
DEVICE_TYPE.to_string(),
)
.await
.expect("Couldn't connect to identity service");
let android_device_id =
&DEVICE_KEYS_ANDROID.primary_identity_public_keys.ed25519;
let web_device_id = &DEVICE_KEYS_WEB.primary_identity_public_keys.ed25519;
let ios_device_id = &DEVICE_KEYS_IOS.primary_identity_public_keys.ed25519;
// 1. Register user with primary Android device
let android =
register_user_device(Some(&DEVICE_KEYS_ANDROID), Some(DeviceType::Android))
.await;
let user_id = android.user_id.clone();
let username = android.username.clone();
// 2. Log in a web device
let _web =
login_user_device(&username, Some(&DEVICE_KEYS_WEB), Some(DeviceType::Web))
.await;
// 3. Remove android device
logout_user_device(android).await;
// 4. Log in an iOS device
let _ios =
login_user_device(&username, Some(&DEVICE_KEYS_IOS), Some(DeviceType::Ios))
.await;
// Get device list updates for the user
let request = GetDeviceListRequest {
user_id,
since_timestamp: None,
};
let response = auth_client
.get_device_list_for_user(request)
.await
.expect("Get device list request failed")
.into_inner();
let device_lists_response: Vec<Vec<String>> = response
.device_list_updates
.into_iter()
.map(|update| {
let update: DeviceListUpdate = serde_json::from_str(&update)
.expect("Failed to parse device list update");
let device_list: RawDeviceList = update
.raw_device_list
.parse()
.expect("Failed to parse raw device list");
device_list.devices
})
.collect();
let expected_device_list: Vec<Vec<String>> = vec![
vec![android_device_id.into()],
vec![android_device_id.into(), web_device_id.into()],
vec![web_device_id.into()],
vec![ios_device_id.into(), web_device_id.into()],
];
assert_eq!(device_lists_response, expected_device_list);
}
// See GetDeviceListResponse in identity_authenticated.proto
// for details on the response format.
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(unused)]
struct RawDeviceList {
devices: Vec<String>,
timestamp: i64,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct DeviceListUpdate {
raw_device_list: String,
}
impl FromStr for RawDeviceList {
type Err = serde_json::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
// The device list payload is sent as an escaped JSON payload.
// Escaped double quotes need to be trimmed before attempting to deserialize
serde_json::from_str(&s.replace(r#"\""#, r#"""#))
}
}
View Options

lib/actions/entry-actions.js

  • This file was added.
use std::str::FromStr;
use commtest::identity::device::{
login_user_device, logout_user_device, register_user_device, DEVICE_TYPE,
PLACEHOLDER_CODE_VERSION,
};
use commtest::service_addr;
use grpc_clients::identity::get_auth_client;
use grpc_clients::identity::protos::authenticated::GetDeviceListRequest;
use grpc_clients::identity::DeviceType;
use serde::Deserialize;
// 1. register user with android device
// 2. register a web device
// 3. remove android device
// 4. register ios device
// 5. get device list - should have 4 updates:
// - [android]
// - [android, web]
// - [web]
// - [ios, web] - mobile should be first
#[tokio::test]
async fn test_device_list_updates() {
use commtest::identity::olm_account_infos::{
DEFAULT_CLIENT_KEYS as DEVICE_KEYS_ANDROID,
MOCK_CLIENT_KEYS_1 as DEVICE_KEYS_WEB,
MOCK_CLIENT_KEYS_2 as DEVICE_KEYS_IOS,
};
// Create viewer (user that doesn't change devices)
let viewer = register_user_device(None, None).await;
let mut auth_client = get_auth_client(
&service_addr::IDENTITY_GRPC.to_string(),
viewer.user_id.clone(),
viewer.device_id,
viewer.access_token,
PLACEHOLDER_CODE_VERSION,
DEVICE_TYPE.to_string(),
)
.await
.expect("Couldn't connect to identity service");
let android_device_id =
&DEVICE_KEYS_ANDROID.primary_identity_public_keys.ed25519;
let web_device_id = &DEVICE_KEYS_WEB.primary_identity_public_keys.ed25519;
let ios_device_id = &DEVICE_KEYS_IOS.primary_identity_public_keys.ed25519;
// 1. Register user with primary Android device
let android =
register_user_device(Some(&DEVICE_KEYS_ANDROID), Some(DeviceType::Android))
.await;
let user_id = android.user_id.clone();
let username = android.username.clone();
// 2. Log in a web device
let _web =
login_user_device(&username, Some(&DEVICE_KEYS_WEB), Some(DeviceType::Web))
.await;
// 3. Remove android device
logout_user_device(android).await;
// 4. Log in an iOS device
let _ios =
login_user_device(&username, Some(&DEVICE_KEYS_IOS), Some(DeviceType::Ios))
.await;
// Get device list updates for the user
let request = GetDeviceListRequest {
user_id,
since_timestamp: None,
};
let response = auth_client
.get_device_list_for_user(request)
.await
.expect("Get device list request failed")
.into_inner();
let device_lists_response: Vec<Vec<String>> = response
.device_list_updates
.into_iter()
.map(|update| {
let update: DeviceListUpdate = serde_json::from_str(&update)
.expect("Failed to parse device list update");
let device_list: RawDeviceList = update
.raw_device_list
.parse()
.expect("Failed to parse raw device list");
device_list.devices
})
.collect();
let expected_device_list: Vec<Vec<String>> = vec![
vec![android_device_id.into()],
vec![android_device_id.into(), web_device_id.into()],
vec![web_device_id.into()],
vec![ios_device_id.into(), web_device_id.into()],
];
assert_eq!(device_lists_response, expected_device_list);
}
// See GetDeviceListResponse in identity_authenticated.proto
// for details on the response format.
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(unused)]
struct RawDeviceList {
devices: Vec<String>,
timestamp: i64,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct DeviceListUpdate {
raw_device_list: String,
}
impl FromStr for RawDeviceList {
type Err = serde_json::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
// The device list payload is sent as an escaped JSON payload.
// Escaped double quotes need to be trimmed before attempting to deserialize
serde_json::from_str(&s.replace(r#"\""#, r#"""#))
}
}
View Options

lib/actions/link-actions.js

  • This file was added.
use std::str::FromStr;
use commtest::identity::device::{
login_user_device, logout_user_device, register_user_device, DEVICE_TYPE,
PLACEHOLDER_CODE_VERSION,
};
use commtest::service_addr;
use grpc_clients::identity::get_auth_client;
use grpc_clients::identity::protos::authenticated::GetDeviceListRequest;
use grpc_clients::identity::DeviceType;
use serde::Deserialize;
// 1. register user with android device
// 2. register a web device
// 3. remove android device
// 4. register ios device
// 5. get device list - should have 4 updates:
// - [android]
// - [android, web]
// - [web]
// - [ios, web] - mobile should be first
#[tokio::test]
async fn test_device_list_updates() {
use commtest::identity::olm_account_infos::{
DEFAULT_CLIENT_KEYS as DEVICE_KEYS_ANDROID,
MOCK_CLIENT_KEYS_1 as DEVICE_KEYS_WEB,
MOCK_CLIENT_KEYS_2 as DEVICE_KEYS_IOS,
};
// Create viewer (user that doesn't change devices)
let viewer = register_user_device(None, None).await;
let mut auth_client = get_auth_client(
&service_addr::IDENTITY_GRPC.to_string(),
viewer.user_id.clone(),
viewer.device_id,
viewer.access_token,
PLACEHOLDER_CODE_VERSION,
DEVICE_TYPE.to_string(),
)
.await
.expect("Couldn't connect to identity service");
let android_device_id =
&DEVICE_KEYS_ANDROID.primary_identity_public_keys.ed25519;
let web_device_id = &DEVICE_KEYS_WEB.primary_identity_public_keys.ed25519;
let ios_device_id = &DEVICE_KEYS_IOS.primary_identity_public_keys.ed25519;
// 1. Register user with primary Android device
let android =
register_user_device(Some(&DEVICE_KEYS_ANDROID), Some(DeviceType::Android))
.await;
let user_id = android.user_id.clone();
let username = android.username.clone();
// 2. Log in a web device
let _web =
login_user_device(&username, Some(&DEVICE_KEYS_WEB), Some(DeviceType::Web))
.await;
// 3. Remove android device
logout_user_device(android).await;
// 4. Log in an iOS device
let _ios =
login_user_device(&username, Some(&DEVICE_KEYS_IOS), Some(DeviceType::Ios))
.await;
// Get device list updates for the user
let request = GetDeviceListRequest {
user_id,
since_timestamp: None,
};
let response = auth_client
.get_device_list_for_user(request)
.await
.expect("Get device list request failed")
.into_inner();
let device_lists_response: Vec<Vec<String>> = response
.device_list_updates
.into_iter()
.map(|update| {
let update: DeviceListUpdate = serde_json::from_str(&update)
.expect("Failed to parse device list update");
let device_list: RawDeviceList = update
.raw_device_list
.parse()
.expect("Failed to parse raw device list");
device_list.devices
})
.collect();
let expected_device_list: Vec<Vec<String>> = vec![
vec![android_device_id.into()],
vec![android_device_id.into(), web_device_id.into()],
vec![web_device_id.into()],
vec![ios_device_id.into(), web_device_id.into()],
];
assert_eq!(device_lists_response, expected_device_list);
}
// See GetDeviceListResponse in identity_authenticated.proto
// for details on the response format.
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(unused)]
struct RawDeviceList {
devices: Vec<String>,
timestamp: i64,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct DeviceListUpdate {
raw_device_list: String,
}
impl FromStr for RawDeviceList {
type Err = serde_json::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
// The device list payload is sent as an escaped JSON payload.
// Escaped double quotes need to be trimmed before attempting to deserialize
serde_json::from_str(&s.replace(r#"\""#, r#"""#))
}
}
View Options

lib/actions/message-actions.js

  • This file was added.
use std::str::FromStr;
use commtest::identity::device::{
login_user_device, logout_user_device, register_user_device, DEVICE_TYPE,
PLACEHOLDER_CODE_VERSION,
};
use commtest::service_addr;
use grpc_clients::identity::get_auth_client;
use grpc_clients::identity::protos::authenticated::GetDeviceListRequest;
use grpc_clients::identity::DeviceType;
use serde::Deserialize;
// 1. register user with android device
// 2. register a web device
// 3. remove android device
// 4. register ios device
// 5. get device list - should have 4 updates:
// - [android]
// - [android, web]
// - [web]
// - [ios, web] - mobile should be first
#[tokio::test]
async fn test_device_list_updates() {
use commtest::identity::olm_account_infos::{
DEFAULT_CLIENT_KEYS as DEVICE_KEYS_ANDROID,
MOCK_CLIENT_KEYS_1 as DEVICE_KEYS_WEB,
MOCK_CLIENT_KEYS_2 as DEVICE_KEYS_IOS,
};
// Create viewer (user that doesn't change devices)
let viewer = register_user_device(None, None).await;
let mut auth_client = get_auth_client(
&service_addr::IDENTITY_GRPC.to_string(),
viewer.user_id.clone(),
viewer.device_id,
viewer.access_token,
PLACEHOLDER_CODE_VERSION,
DEVICE_TYPE.to_string(),
)
.await
.expect("Couldn't connect to identity service");
let android_device_id =
&DEVICE_KEYS_ANDROID.primary_identity_public_keys.ed25519;
let web_device_id = &DEVICE_KEYS_WEB.primary_identity_public_keys.ed25519;
let ios_device_id = &DEVICE_KEYS_IOS.primary_identity_public_keys.ed25519;
// 1. Register user with primary Android device
let android =
register_user_device(Some(&DEVICE_KEYS_ANDROID), Some(DeviceType::Android))
.await;
let user_id = android.user_id.clone();
let username = android.username.clone();
// 2. Log in a web device
let _web =
login_user_device(&username, Some(&DEVICE_KEYS_WEB), Some(DeviceType::Web))
.await;
// 3. Remove android device
logout_user_device(android).await;
// 4. Log in an iOS device
let _ios =
login_user_device(&username, Some(&DEVICE_KEYS_IOS), Some(DeviceType::Ios))
.await;
// Get device list updates for the user
let request = GetDeviceListRequest {
user_id,
since_timestamp: None,
};
let response = auth_client
.get_device_list_for_user(request)
.await
.expect("Get device list request failed")
.into_inner();
let device_lists_response: Vec<Vec<String>> = response
.device_list_updates
.into_iter()
.map(|update| {
let update: DeviceListUpdate = serde_json::from_str(&update)
.expect("Failed to parse device list update");
let device_list: RawDeviceList = update
.raw_device_list
.parse()
.expect("Failed to parse raw device list");
device_list.devices
})
.collect();
let expected_device_list: Vec<Vec<String>> = vec![
vec![android_device_id.into()],
vec![android_device_id.into(), web_device_id.into()],
vec![web_device_id.into()],
vec![ios_device_id.into(), web_device_id.into()],
];
assert_eq!(device_lists_response, expected_device_list);
}
// See GetDeviceListResponse in identity_authenticated.proto
// for details on the response format.
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(unused)]
struct RawDeviceList {
devices: Vec<String>,
timestamp: i64,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct DeviceListUpdate {
raw_device_list: String,
}
impl FromStr for RawDeviceList {
type Err = serde_json::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
// The device list payload is sent as an escaped JSON payload.
// Escaped double quotes need to be trimmed before attempting to deserialize
serde_json::from_str(&s.replace(r#"\""#, r#"""#))
}
}
View Options

lib/actions/message-report-actions.js

  • This file was added.
use std::str::FromStr;
use commtest::identity::device::{
login_user_device, logout_user_device, register_user_device, DEVICE_TYPE,
PLACEHOLDER_CODE_VERSION,
};
use commtest::service_addr;
use grpc_clients::identity::get_auth_client;
use grpc_clients::identity::protos::authenticated::GetDeviceListRequest;
use grpc_clients::identity::DeviceType;
use serde::Deserialize;
// 1. register user with android device
// 2. register a web device
// 3. remove android device
// 4. register ios device
// 5. get device list - should have 4 updates:
// - [android]
// - [android, web]
// - [web]
// - [ios, web] - mobile should be first
#[tokio::test]
async fn test_device_list_updates() {
use commtest::identity::olm_account_infos::{
DEFAULT_CLIENT_KEYS as DEVICE_KEYS_ANDROID,
MOCK_CLIENT_KEYS_1 as DEVICE_KEYS_WEB,
MOCK_CLIENT_KEYS_2 as DEVICE_KEYS_IOS,
};
// Create viewer (user that doesn't change devices)
let viewer = register_user_device(None, None).await;
let mut auth_client = get_auth_client(
&service_addr::IDENTITY_GRPC.to_string(),
viewer.user_id.clone(),
viewer.device_id,
viewer.access_token,
PLACEHOLDER_CODE_VERSION,
DEVICE_TYPE.to_string(),
)
.await
.expect("Couldn't connect to identity service");
let android_device_id =
&DEVICE_KEYS_ANDROID.primary_identity_public_keys.ed25519;
let web_device_id = &DEVICE_KEYS_WEB.primary_identity_public_keys.ed25519;
let ios_device_id = &DEVICE_KEYS_IOS.primary_identity_public_keys.ed25519;
// 1. Register user with primary Android device
let android =
register_user_device(Some(&DEVICE_KEYS_ANDROID), Some(DeviceType::Android))
.await;
let user_id = android.user_id.clone();
let username = android.username.clone();
// 2. Log in a web device
let _web =
login_user_device(&username, Some(&DEVICE_KEYS_WEB), Some(DeviceType::Web))
.await;
// 3. Remove android device
logout_user_device(android).await;
// 4. Log in an iOS device
let _ios =
login_user_device(&username, Some(&DEVICE_KEYS_IOS), Some(DeviceType::Ios))
.await;
// Get device list updates for the user
let request = GetDeviceListRequest {
user_id,
since_timestamp: None,
};
let response = auth_client
.get_device_list_for_user(request)
.await
.expect("Get device list request failed")
.into_inner();
let device_lists_response: Vec<Vec<String>> = response
.device_list_updates
.into_iter()
.map(|update| {
let update: DeviceListUpdate = serde_json::from_str(&update)
.expect("Failed to parse device list update");
let device_list: RawDeviceList = update
.raw_device_list
.parse()
.expect("Failed to parse raw device list");
device_list.devices
})
.collect();
let expected_device_list: Vec<Vec<String>> = vec![
vec![android_device_id.into()],
vec![android_device_id.into(), web_device_id.into()],
vec![web_device_id.into()],
vec![ios_device_id.into(), web_device_id.into()],
];
assert_eq!(device_lists_response, expected_device_list);
}
// See GetDeviceListResponse in identity_authenticated.proto
// for details on the response format.
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(unused)]
struct RawDeviceList {
devices: Vec<String>,
timestamp: i64,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct DeviceListUpdate {
raw_device_list: String,
}
impl FromStr for RawDeviceList {
type Err = serde_json::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
// The device list payload is sent as an escaped JSON payload.
// Escaped double quotes need to be trimmed before attempting to deserialize
serde_json::from_str(&s.replace(r#"\""#, r#"""#))
}
}
View Options

lib/actions/thread-actions.js

  • This file was added.
use std::str::FromStr;
use commtest::identity::device::{
login_user_device, logout_user_device, register_user_device, DEVICE_TYPE,
PLACEHOLDER_CODE_VERSION,
};
use commtest::service_addr;
use grpc_clients::identity::get_auth_client;
use grpc_clients::identity::protos::authenticated::GetDeviceListRequest;
use grpc_clients::identity::DeviceType;
use serde::Deserialize;
// 1. register user with android device
// 2. register a web device
// 3. remove android device
// 4. register ios device
// 5. get device list - should have 4 updates:
// - [android]
// - [android, web]
// - [web]
// - [ios, web] - mobile should be first
#[tokio::test]
async fn test_device_list_updates() {
use commtest::identity::olm_account_infos::{
DEFAULT_CLIENT_KEYS as DEVICE_KEYS_ANDROID,
MOCK_CLIENT_KEYS_1 as DEVICE_KEYS_WEB,
MOCK_CLIENT_KEYS_2 as DEVICE_KEYS_IOS,
};
// Create viewer (user that doesn't change devices)
let viewer = register_user_device(None, None).await;
let mut auth_client = get_auth_client(
&service_addr::IDENTITY_GRPC.to_string(),
viewer.user_id.clone(),
viewer.device_id,
viewer.access_token,
PLACEHOLDER_CODE_VERSION,
DEVICE_TYPE.to_string(),
)
.await
.expect("Couldn't connect to identity service");
let android_device_id =
&DEVICE_KEYS_ANDROID.primary_identity_public_keys.ed25519;
let web_device_id = &DEVICE_KEYS_WEB.primary_identity_public_keys.ed25519;
let ios_device_id = &DEVICE_KEYS_IOS.primary_identity_public_keys.ed25519;
// 1. Register user with primary Android device
let android =
register_user_device(Some(&DEVICE_KEYS_ANDROID), Some(DeviceType::Android))
.await;
let user_id = android.user_id.clone();
let username = android.username.clone();
// 2. Log in a web device
let _web =
login_user_device(&username, Some(&DEVICE_KEYS_WEB), Some(DeviceType::Web))
.await;
// 3. Remove android device
logout_user_device(android).await;
// 4. Log in an iOS device
let _ios =
login_user_device(&username, Some(&DEVICE_KEYS_IOS), Some(DeviceType::Ios))
.await;
// Get device list updates for the user
let request = GetDeviceListRequest {
user_id,
since_timestamp: None,
};
let response = auth_client
.get_device_list_for_user(request)
.await
.expect("Get device list request failed")
.into_inner();
let device_lists_response: Vec<Vec<String>> = response
.device_list_updates
.into_iter()
.map(|update| {
let update: DeviceListUpdate = serde_json::from_str(&update)
.expect("Failed to parse device list update");
let device_list: RawDeviceList = update
.raw_device_list
.parse()
.expect("Failed to parse raw device list");
device_list.devices
})
.collect();
let expected_device_list: Vec<Vec<String>> = vec![
vec![android_device_id.into()],
vec![android_device_id.into(), web_device_id.into()],
vec![web_device_id.into()],
vec![ios_device_id.into(), web_device_id.into()],
];
assert_eq!(device_lists_response, expected_device_list);
}
// See GetDeviceListResponse in identity_authenticated.proto
// for details on the response format.
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(unused)]
struct RawDeviceList {
devices: Vec<String>,
timestamp: i64,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct DeviceListUpdate {
raw_device_list: String,
}
impl FromStr for RawDeviceList {
type Err = serde_json::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
// The device list payload is sent as an escaped JSON payload.
// Escaped double quotes need to be trimmed before attempting to deserialize
serde_json::from_str(&s.replace(r#"\""#, r#"""#))
}
}
View Options

lib/actions/upload-actions.js

Loading...
View Options

lib/actions/user-actions.js

Loading...
View Options

lib/keyserver-conn/keyserver-call-utils.js

Loading...
View Options

lib/keyserver-conn/keyserver-call-utils.test.js

Loading...
View Options

lib/reducers/calendar-filters-reducer.js

Loading...
View Options

lib/shared/message-utils.js

Loading...
View Options

lib/utils/action-utils.js

Loading...
View Options

lib/utils/action-utils.test.js

Loading...
View Options

native/chat/settings/thread-settings-push-notifs.react.js

Loading...
View Options

web/redux/action-types.js

Loading...