use std::sync::Arc;
use serde::Serialize;
use serde_json::Value;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::{DelopayError, Result};
use crate::core::models::user::{
AddUserResponse, AuthResponse, InviteUsersResponse, LoginHistoryResponse, ParentGroupInfo,
PhoneOtpResponse, PhoneOtpVerifyResponse, RecoveryCodesResponse, TokenResponse, TotpResponse,
UserInLineage, UserResponse, UserSessionListResponse, UserSessionRevokeResponse,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct Users {
inner: Arc<Inner>,
}
impl Users {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn sign_up(&self, params: &SignUpRequest) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/user/signup", Some(&body), &[], None)
.await
}
pub async fn sign_up_with_merchant(
&self,
params: &SignUpWithMerchantRequest,
) -> Result<AuthResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/user/signup", Some(&body), &[], None)
.await
}
pub async fn sign_in(&self, params: &SignInRequest) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/user/signin", Some(&body), &[], None)
.await
}
pub async fn sign_out(&self) -> Result<Value> {
self.inner
.request(HttpMethod::Post, "/user/signout", None, &[], None)
.await
}
pub async fn sign_in_oidc(&self, params: &Value) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/user/oidc", Some(&body), &[], None)
.await
}
pub async fn list_login_activity(
&self,
params: Option<&LoginHistoryParams>,
) -> Result<LoginHistoryResponse> {
let query = params.map(LoginHistoryParams::to_query).unwrap_or_default();
self.inner
.request(
HttpMethod::Get,
"/user/me/login-activity",
None,
&query,
None,
)
.await
}
pub async fn list_active_sessions(&self) -> Result<UserSessionListResponse> {
self.inner
.request(HttpMethod::Get, "/user/me/sessions", None, &[], None)
.await
}
pub async fn revoke_session(&self, session_id: &str) -> Result<UserSessionRevokeResponse> {
let path = format!("/user/me/sessions/{}/revoke", encode_segment(session_id));
self.inner
.request(HttpMethod::Post, &path, None, &[], None)
.await
}
pub async fn details(&self) -> Result<UserResponse> {
self.inner
.request(HttpMethod::Get, "/user", None, &[], None)
.await
}
pub async fn update(&self, params: &UpdateUserDetailsRequest) -> Result<UserResponse> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/user/update", Some(&body), &[], None)
.await
}
pub async fn delete_account(&self, params: &DeleteAccountRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Delete, "/user/account", Some(&body), &[], None)
.await
}
pub async fn change_password(&self, params: &ChangePasswordRequest) -> Result<UserResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/change-password",
Some(&body),
&[],
None,
)
.await
}
pub async fn rotate_password(&self, params: &ResetPasswordRequest) -> Result<UserResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/rotate-password",
Some(&body),
&[],
None,
)
.await
}
pub async fn forgot_password(&self, params: &ForgotPasswordRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/forgot-password",
Some(&body),
&[],
None,
)
.await
}
pub async fn reset_password(&self, params: &ResetPasswordRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/reset-password",
Some(&body),
&[],
None,
)
.await
}
pub async fn from_email(&self, params: &FromEmailRequest) -> Result<TokenResponse> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/user/from-email", Some(&body), &[], None)
.await
}
pub async fn verify_email(&self, params: &Value) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/verify-email",
Some(&body),
&[],
None,
)
.await
}
pub async fn send_verification_email(&self, params: &ForgotPasswordRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/verify-email-request",
Some(&body),
&[],
None,
)
.await
}
pub async fn create_merchant(&self, params: &Value) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/create-merchant",
Some(&body),
&[],
None,
)
.await
}
pub async fn switch_merchant(&self, params: &SwitchMerchantRequest) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/switch/merchant",
Some(&body),
&[],
None,
)
.await
}
pub async fn switch_profile(&self, params: &SwitchProfileRequest) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/switch/profile",
Some(&body),
&[],
None,
)
.await
}
pub async fn list_merchants(&self) -> Result<Vec<Value>> {
self.inner
.request(HttpMethod::Get, "/user/list/merchant", None, &[], None)
.await
}
pub async fn list_profiles(&self) -> Result<Vec<Value>> {
self.inner
.request(HttpMethod::Get, "/user/list/profile", None, &[], None)
.await
}
pub async fn list_invitations(&self) -> Result<Vec<Value>> {
self.inner
.request(HttpMethod::Get, "/user/list/invitation", None, &[], None)
.await
}
pub async fn parent_list(&self) -> Result<Vec<Value>> {
self.inner
.request(HttpMethod::Get, "/user/parent/list", None, &[], None)
.await
}
pub async fn invite_users(
&self,
params: &[InviteUsersRequest],
) -> Result<Vec<InviteUsersResponse>> {
for p in params {
p.validate()?;
}
let body = to_json_vec(¶ms)?;
self.inner
.request(
HttpMethod::Post,
"/user/employees/invite",
Some(&body),
&[],
None,
)
.await
}
pub async fn add_user(&self, params: &AddUserRequest) -> Result<AddUserResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/employees/add",
Some(&body),
&[],
None,
)
.await
}
pub async fn impersonate_employee(
&self,
params: &ImpersonateEmployeeRequest,
) -> Result<TokenResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/employees/impersonate",
Some(&body),
&[],
None,
)
.await
}
pub async fn accept_invitation(&self, params: &Value) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/employees/invite/accept",
Some(&body),
&[],
None,
)
.await
}
pub async fn accept_invite_from_email(
&self,
params: &FromEmailRequest,
) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/accept-invite-from-email",
Some(&body),
&[],
None,
)
.await
}
pub async fn resend_invite(&self, params: &Value) -> Result<Value> {
self.post_open("/user/resend-invite", params).await
}
pub async fn list_user_roles(&self, params: Option<&Value>) -> Result<Vec<Value>> {
let body = match params {
Some(p) => Some(to_json_vec(p)?),
None => None,
};
self.inner
.request(
HttpMethod::Post,
"/user/employees",
body.as_deref(),
&[],
None,
)
.await
}
pub async fn update_user_role(&self, params: &UpdateUserRoleRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/employees/update-role",
Some(&body),
&[],
None,
)
.await
}
pub async fn delete_user_role(&self, params: &DeleteUserRoleRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Delete,
"/user/employees/delete",
Some(&body),
&[],
None,
)
.await
}
pub async fn list_users_in_lineage(
&self,
params: Option<&ListUsersInLineageParams>,
) -> Result<Vec<UserInLineage>> {
let query = params
.map(ListUsersInLineageParams::to_query)
.unwrap_or_default();
self.inner
.request(HttpMethod::Get, "/user/employees/list", None, &query, None)
.await
}
pub async fn check_2fa_status(&self) -> Result<Value> {
self.inner
.request(HttpMethod::Get, "/user/2fa", None, &[], None)
.await
}
pub async fn begin_totp(&self) -> Result<TotpResponse> {
self.inner
.request(HttpMethod::Get, "/user/2fa/totp/begin", None, &[], None)
.await
}
pub async fn verify_totp(&self, params: &VerifyTotpRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/2fa/totp/verify",
Some(&body),
&[],
None,
)
.await
}
pub async fn update_totp(&self, params: &VerifyTotpRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Put,
"/user/2fa/totp/verify",
Some(&body),
&[],
None,
)
.await
}
pub async fn reset_totp(&self) -> Result<Value> {
self.inner
.request(HttpMethod::Get, "/user/2fa/totp/reset", None, &[], None)
.await
}
pub async fn generate_recovery_codes(&self) -> Result<RecoveryCodesResponse> {
self.inner
.request(
HttpMethod::Get,
"/user/2fa/recovery-code/generate",
None,
&[],
None,
)
.await
}
pub async fn verify_recovery_code(&self, params: &Value) -> Result<AuthResponse> {
self.post_open("/user/2fa/recovery-code/verify", params)
.await
}
pub async fn terminate_2fa(
&self,
query: Option<&Terminate2faQueryParams>,
) -> Result<TokenResponse> {
let query = query
.map(Terminate2faQueryParams::to_query)
.unwrap_or_default();
self.inner
.request(HttpMethod::Get, "/user/2fa/terminate", None, &query, None)
.await
}
pub async fn send_phone_otp(&self, params: &PhoneOtpRequest) -> Result<PhoneOtpResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/phone/send-otp",
Some(&body),
&[],
None,
)
.await
}
pub async fn verify_phone_otp(
&self,
params: &PhoneOtpVerifyRequest,
) -> Result<PhoneOtpVerifyResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/phone/verify-otp",
Some(&body),
&[],
None,
)
.await
}
pub async fn create_auth_method(&self, params: &Value) -> Result<Value> {
self.post_open("/user/auth", params).await
}
pub async fn update_auth_method(&self, params: &Value) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Put, "/user/auth", Some(&body), &[], None)
.await
}
pub async fn list_auth_methods(&self) -> Result<Vec<Value>> {
self.inner
.request(HttpMethod::Get, "/user/auth/list", None, &[], None)
.await
}
pub async fn auth_url(&self) -> Result<Value> {
self.inner
.request(HttpMethod::Get, "/user/auth/url", None, &[], None)
.await
}
pub async fn select_auth(&self, params: &Value) -> Result<Value> {
self.post_open("/user/auth/select", params).await
}
pub async fn transfer_key(&self, params: &Value) -> Result<Value> {
self.post_open("/user/key/transfer", params).await
}
pub async fn list_roles(&self, params: Option<&ListRolesParams>) -> Result<Vec<Value>> {
let query = params.map(ListRolesParams::to_query).unwrap_or_default();
self.inner
.request(HttpMethod::Get, "/user/role/list", None, &query, None)
.await
}
pub async fn list_invitable_roles(
&self,
params: Option<&ListInvitableRolesParams>,
) -> Result<Vec<Value>> {
let query = params
.map(ListInvitableRolesParams::to_query)
.unwrap_or_default();
self.inner
.request(
HttpMethod::Get,
"/user/role/list/invite",
None,
&query,
None,
)
.await
}
pub async fn list_updatable_roles(&self) -> Result<Vec<Value>> {
self.inner
.request(HttpMethod::Get, "/user/role/list/update", None, &[], None)
.await
}
pub async fn role_permissions(&self) -> Result<Vec<ParentGroupInfo>> {
self.inner
.request(HttpMethod::Get, "/user/role", None, &[], None)
.await
}
pub async fn create_role(&self, params: &Value) -> Result<Value> {
self.post_open("/user/role", params).await
}
pub async fn retrieve_role(&self, role_id: &str) -> Result<Value> {
let path = format!("/user/role/{}", encode_segment(role_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn update_role(&self, role_id: &str, params: &Value) -> Result<Value> {
let path = format!("/user/role/{}", encode_segment(role_id));
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn delete_role(&self, role_id: &str) -> Result<Value> {
let path = format!("/user/role/{}", encode_segment(role_id));
self.inner
.request(HttpMethod::Delete, &path, None, &[], None)
.await
}
async fn post_open<T: serde::de::DeserializeOwned>(
&self,
path: &str,
params: &Value,
) -> Result<T> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, path, Some(&body), &[], None)
.await
}
}
#[derive(Clone, Default, Serialize)]
pub struct SignUpRequest {
pub email: String,
pub password: String,
}
impl std::fmt::Debug for SignUpRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SignUpRequest")
.field("email", &self.email)
.field("password", &"[redacted]")
.finish()
}
}
impl SignUpRequest {
pub fn new(email: impl Into<String>, password: impl Into<String>) -> Self {
Self {
email: email.into(),
password: password.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct SignUpWithMerchantRequest {
pub name: String,
pub email: String,
pub password: String,
pub company_name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_type: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl std::fmt::Debug for SignUpWithMerchantRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SignUpWithMerchantRequest")
.field("name", &self.name)
.field("email", &self.email)
.field("password", &"[redacted]")
.field("company_name", &self.company_name)
.field("organization_type", &self.organization_type)
.field("extra", &self.extra)
.finish()
}
}
const SIGN_UP_WITH_MERCHANT_REQUEST_NAMED: &[&str] = &[
"name",
"email",
"password",
"company_name",
"organization_type",
];
impl ValidateRequest for SignUpWithMerchantRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if SIGN_UP_WITH_MERCHANT_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on \
SignUpWithMerchantRequest"
)));
}
}
Ok(())
}
}
impl SignUpWithMerchantRequest {
pub fn new(
name: impl Into<String>,
email: impl Into<String>,
password: impl Into<String>,
company_name: impl Into<String>,
) -> Self {
Self {
name: name.into(),
email: email.into(),
password: password.into(),
company_name: company_name.into(),
..Default::default()
}
}
#[must_use]
pub fn organization_type(mut self, organization_type: impl Into<String>) -> Self {
self.organization_type = Some(organization_type.into());
self
}
}
#[derive(Clone, Default, Serialize)]
pub struct SignInRequest {
pub email: String,
pub password: String,
}
impl std::fmt::Debug for SignInRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SignInRequest")
.field("email", &self.email)
.field("password", &"[redacted]")
.finish()
}
}
impl SignInRequest {
pub fn new(email: impl Into<String>, password: impl Into<String>) -> Self {
Self {
email: email.into(),
password: password.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct ChangePasswordRequest {
pub old_password: String,
pub new_password: String,
}
impl std::fmt::Debug for ChangePasswordRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ChangePasswordRequest")
.field("old_password", &"[redacted]")
.field("new_password", &"[redacted]")
.finish()
}
}
impl ChangePasswordRequest {
pub fn new(old_password: impl Into<String>, new_password: impl Into<String>) -> Self {
Self {
old_password: old_password.into(),
new_password: new_password.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct DeleteAccountRequest {
pub password: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub totp_code: Option<String>,
}
impl std::fmt::Debug for DeleteAccountRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeleteAccountRequest")
.field("password", &"[redacted]")
.field("totp_code", &self.totp_code.as_ref().map(|_| "[redacted]"))
.finish()
}
}
impl DeleteAccountRequest {
pub fn new(password: impl Into<String>) -> Self {
Self {
password: password.into(),
totp_code: None,
}
}
#[must_use]
pub fn totp_code(mut self, totp_code: impl Into<String>) -> Self {
self.totp_code = Some(totp_code.into());
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ForgotPasswordRequest {
pub email: String,
}
impl ForgotPasswordRequest {
pub fn new(email: impl Into<String>) -> Self {
Self {
email: email.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct ResetPasswordRequest {
pub token: String,
pub password: String,
}
impl std::fmt::Debug for ResetPasswordRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ResetPasswordRequest")
.field("token", &"[redacted]")
.field("password", &"[redacted]")
.finish()
}
}
impl ResetPasswordRequest {
pub fn new(token: impl Into<String>, password: impl Into<String>) -> Self {
Self {
token: token.into(),
password: password.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct FromEmailRequest {
pub token: String,
}
impl std::fmt::Debug for FromEmailRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("FromEmailRequest")
.field("token", &"[redacted]")
.finish()
}
}
impl FromEmailRequest {
pub fn new(token: impl Into<String>) -> Self {
Self {
token: token.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct SwitchMerchantRequest {
pub merchant_id: String,
}
impl SwitchMerchantRequest {
pub fn new(merchant_id: impl Into<String>) -> Self {
Self {
merchant_id: merchant_id.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct SwitchProfileRequest {
pub profile_id: String,
}
impl SwitchProfileRequest {
pub fn new(profile_id: impl Into<String>) -> Self {
Self {
profile_id: profile_id.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ImpersonateEmployeeRequest {
pub email: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub role_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_id: Option<String>,
}
impl ImpersonateEmployeeRequest {
pub fn new(email: impl Into<String>) -> Self {
Self {
email: email.into(),
..Default::default()
}
}
#[must_use]
pub fn role_id(mut self, role_id: impl Into<String>) -> Self {
self.role_id = Some(role_id.into());
self
}
#[must_use]
pub fn profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.profile_id = Some(profile_id.into());
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct InviteUsersRequest {
pub email: String,
pub name: String,
pub role_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_ids: Option<Vec<String>>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const INVITE_USERS_REQUEST_NAMED: &[&str] = &["email", "name", "role_id", "profile_ids"];
impl ValidateRequest for InviteUsersRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if INVITE_USERS_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on InviteUsersRequest"
)));
}
}
Ok(())
}
}
impl InviteUsersRequest {
pub fn new(
email: impl Into<String>,
name: impl Into<String>,
role_id: impl Into<String>,
) -> Self {
Self {
email: email.into(),
name: name.into(),
role_id: role_id.into(),
..Default::default()
}
}
#[must_use]
pub fn profile_ids(mut self, profile_ids: Vec<String>) -> Self {
self.profile_ids = Some(profile_ids);
self
}
}
#[derive(Clone, Default, Serialize)]
pub struct AddUserRequest {
pub email: String,
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
pub role_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_ids: Option<Vec<String>>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl std::fmt::Debug for AddUserRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AddUserRequest")
.field("email", &self.email)
.field("name", &self.name)
.field("password", &self.password.as_ref().map(|_| "[redacted]"))
.field("role_id", &self.role_id)
.field("profile_ids", &self.profile_ids)
.field("extra", &self.extra)
.finish()
}
}
const ADD_USER_REQUEST_NAMED: &[&str] = &["email", "name", "password", "role_id", "profile_ids"];
impl ValidateRequest for AddUserRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if ADD_USER_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on AddUserRequest"
)));
}
}
Ok(())
}
}
impl AddUserRequest {
pub fn new(
email: impl Into<String>,
name: impl Into<String>,
role_id: impl Into<String>,
) -> Self {
Self {
email: email.into(),
name: name.into(),
role_id: role_id.into(),
..Default::default()
}
}
#[must_use]
pub fn password(mut self, password: impl Into<String>) -> Self {
self.password = Some(password.into());
self
}
#[must_use]
pub fn profile_ids(mut self, profile_ids: Vec<String>) -> Self {
self.profile_ids = Some(profile_ids);
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateUserRoleRequest {
pub email: String,
pub role_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_id: Option<String>,
}
impl UpdateUserRoleRequest {
pub fn new(email: impl Into<String>, role_id: impl Into<String>) -> Self {
Self {
email: email.into(),
role_id: role_id.into(),
profile_id: None,
}
}
#[must_use]
pub fn profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.profile_id = Some(profile_id.into());
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct DeleteUserRoleRequest {
pub email: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_id: Option<String>,
}
impl DeleteUserRoleRequest {
pub fn new(email: impl Into<String>) -> Self {
Self {
email: email.into(),
profile_id: None,
}
}
#[must_use]
pub fn profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.profile_id = Some(profile_id.into());
self
}
}
#[derive(Clone, Default, Serialize)]
pub struct VerifyTotpRequest {
pub totp: String,
}
impl std::fmt::Debug for VerifyTotpRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("VerifyTotpRequest")
.field("totp", &"[redacted]")
.finish()
}
}
impl VerifyTotpRequest {
pub fn new(totp: impl Into<String>) -> Self {
Self { totp: totp.into() }
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PhoneOtpRequest {
pub phone_number: String,
}
impl PhoneOtpRequest {
pub fn new(phone_number: impl Into<String>) -> Self {
Self {
phone_number: phone_number.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct PhoneOtpVerifyRequest {
pub phone_number: String,
pub code: String,
}
impl std::fmt::Debug for PhoneOtpVerifyRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PhoneOtpVerifyRequest")
.field("phone_number", &self.phone_number)
.field("code", &"[redacted]")
.finish()
}
}
impl PhoneOtpVerifyRequest {
pub fn new(phone_number: impl Into<String>, code: impl Into<String>) -> Self {
Self {
phone_number: phone_number.into(),
code: code.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateUserDetailsRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
impl UpdateUserDetailsRequest {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn name(mut self, name: impl Into<String>) -> Self {
self.name = Some(name.into());
self
}
}
#[derive(Debug, Clone, Default)]
pub struct LoginHistoryParams {
pub limit: Option<i64>,
pub offset: Option<i64>,
}
impl LoginHistoryParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = self.limit {
q.push(("limit", v.to_string()));
}
if let Some(v) = self.offset {
q.push(("offset", v.to_string()));
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct Terminate2faQueryParams {
pub skip_two_factor_auth: Option<bool>,
}
impl Terminate2faQueryParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = self.skip_two_factor_auth {
q.push(("skip_two_factor_auth", v.to_string()));
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct ListUsersInLineageParams {
pub entity_type: Option<String>,
pub profile_id: Option<String>,
}
impl ListUsersInLineageParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = &self.entity_type {
q.push(("entity_type", v.clone()));
}
if let Some(v) = &self.profile_id {
q.push(("profile_id", v.clone()));
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct ListInvitableRolesParams {
pub entity_type: Option<String>,
}
impl ListInvitableRolesParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = &self.entity_type {
q.push(("entity_type", v.clone()));
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct ListRolesParams {
pub groups: Option<bool>,
pub entity_type: Option<String>,
}
impl ListRolesParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = self.groups {
q.push(("groups", v.to_string()));
}
if let Some(v) = &self.entity_type {
q.push(("entity_type", v.clone()));
}
q
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const OK: &str = r#"{"ok":true}"#;
const EMPTY_LIST: &str = "[]";
const AUTH: &str = r#"{"token":"jwt-secret-1","token_type":"bearer","expires":3600}"#;
const TOKEN: &str = r#"{"token":"spt-secret-1","token_type":"reset_password"}"#;
const USER: &str = r#"{"merchant_id":"mer_1","name":"Ada","email":"ada@example.com",
"role_id":"role_1","is_two_factor_auth_setup":true,"profile_id":"pro_1",
"entity_type":"merchant","version":"v2"}"#;
const ADDED_USER: &str = r#"{"user_id":"usr_1","email":"bob@example.com","name":"Bob",
"is_verified":false,"is_active":true,"password":"generated-pw"}"#;
#[test]
fn sign_up_request_debug_redacts_the_password() {
let req = SignUpRequest::new("ada@example.com", "hunter2-sign-up");
let rendered = format!("{req:?}");
assert!(!rendered.contains("hunter2-sign-up"), "{rendered}");
assert!(rendered.contains("ada@example.com"), "{rendered}");
}
#[test]
fn sign_up_with_merchant_request_debug_redacts_the_password() {
let req = SignUpWithMerchantRequest::new(
"Ada",
"ada@example.com",
"hunter2-merchant",
"Analytical Engines Ltd",
);
let rendered = format!("{req:?}");
assert!(!rendered.contains("hunter2-merchant"), "{rendered}");
assert!(rendered.contains("Analytical Engines Ltd"), "{rendered}");
}
#[test]
fn sign_in_request_debug_redacts_the_password() {
let req = SignInRequest::new("ada@example.com", "hunter2-sign-in");
let rendered = format!("{req:?}");
assert!(!rendered.contains("hunter2-sign-in"), "{rendered}");
assert!(rendered.contains("ada@example.com"), "{rendered}");
}
#[test]
fn change_password_request_debug_redacts_both_passwords() {
let req = ChangePasswordRequest::new("old-secret-pw", "new-secret-pw");
let rendered = format!("{req:?}");
assert!(!rendered.contains("old-secret-pw"), "{rendered}");
assert!(!rendered.contains("new-secret-pw"), "{rendered}");
}
#[test]
fn delete_account_request_debug_redacts_password_and_totp() {
let req = DeleteAccountRequest::new("delete-me-pw").totp_code("123456");
let rendered = format!("{req:?}");
assert!(!rendered.contains("delete-me-pw"), "{rendered}");
assert!(!rendered.contains("123456"), "{rendered}");
assert!(rendered.contains("Some("), "{rendered}");
}
#[test]
fn delete_account_request_debug_shows_none_when_no_totp() {
let req = DeleteAccountRequest::new("delete-me-pw");
assert!(format!("{req:?}").contains("totp_code: None"));
}
#[test]
fn reset_password_request_debug_redacts_token_and_password() {
let req = ResetPasswordRequest::new("email-token-abc", "brand-new-pw");
let rendered = format!("{req:?}");
assert!(!rendered.contains("email-token-abc"), "{rendered}");
assert!(!rendered.contains("brand-new-pw"), "{rendered}");
}
#[test]
fn from_email_request_debug_redacts_the_token() {
let req = FromEmailRequest::new("email-token-xyz");
assert!(!format!("{req:?}").contains("email-token-xyz"));
}
#[test]
fn add_user_request_debug_redacts_the_password() {
let req =
AddUserRequest::new("bob@example.com", "Bob", "role_1").password("generated-pw-9000");
let rendered = format!("{req:?}");
assert!(!rendered.contains("generated-pw-9000"), "{rendered}");
assert!(rendered.contains("bob@example.com"), "{rendered}");
}
#[test]
fn add_user_request_debug_shows_none_when_password_omitted() {
let req = AddUserRequest::new("bob@example.com", "Bob", "role_1");
assert!(format!("{req:?}").contains("password: None"));
}
#[test]
fn verify_totp_request_debug_redacts_the_code() {
let req = VerifyTotpRequest::new("987654");
assert!(!format!("{req:?}").contains("987654"));
}
#[test]
fn phone_otp_verify_request_debug_redacts_the_code() {
let req = PhoneOtpVerifyRequest::new("+441234567890", "246810");
let rendered = format!("{req:?}");
assert!(!rendered.contains("246810"), "{rendered}");
assert!(rendered.contains("+441234567890"), "{rendered}");
}
#[test]
fn sign_up_with_merchant_request_named_fields_are_complete() {
let req = SignUpWithMerchantRequest::new("Ada", "ada@example.com", "pw", "Co")
.organization_type("company");
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
SIGN_UP_WITH_MERCHANT_REQUEST_NAMED.contains(&key.as_str()),
"SIGN_UP_WITH_MERCHANT_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn invite_users_request_named_fields_are_complete() {
let req = InviteUsersRequest::new("bob@example.com", "Bob", "role_1")
.profile_ids(vec!["pro_1".to_string()]);
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
INVITE_USERS_REQUEST_NAMED.contains(&key.as_str()),
"INVITE_USERS_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn add_user_request_named_fields_are_complete() {
let req = AddUserRequest::new("bob@example.com", "Bob", "role_1")
.password("pw")
.profile_ids(vec!["pro_1".to_string()]);
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
ADD_USER_REQUEST_NAMED.contains(&key.as_str()),
"ADD_USER_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn validate_rejects_extra_keys_colliding_with_named_fields() {
let mut add = AddUserRequest::new("bob@example.com", "Bob", "role_1");
add.extra.insert("role_id".to_string(), json!("role_2"));
assert!(matches!(
add.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
let mut invite = InviteUsersRequest::new("bob@example.com", "Bob", "role_1");
invite.extra.insert("email".to_string(), json!("x@y.z"));
assert!(matches!(
invite.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
let mut signup = SignUpWithMerchantRequest::new("Ada", "a@b.c", "pw", "Co");
signup
.extra
.insert("company_name".to_string(), json!("Other"));
assert!(matches!(
signup.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
}
#[tokio::test]
async fn add_user_validation_runs_before_the_request_is_sent() {
let (client, mock) = client_with(vec![]);
let mut req = AddUserRequest::new("bob@example.com", "Bob", "role_1");
req.extra.insert("name".to_string(), json!("Robert"));
client.users().add_user(&req).await.unwrap_err();
assert_eq!(mock.call_count(), 0, "no request may leave the client");
}
#[tokio::test]
async fn auth_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(AUTH),
Step::ok(AUTH),
Step::ok(AUTH),
Step::ok(OK),
]);
let users = client.users();
let signed_up = users
.sign_up(&SignUpRequest::new("ada@example.com", "pw"))
.await
.unwrap();
assert_eq!(signed_up.token, "jwt-secret-1");
assert_eq!(signed_up.token_type.as_deref(), Some("bearer"));
assert_eq!(signed_up.expires, Some(3600));
users
.sign_up_with_merchant(&SignUpWithMerchantRequest::new(
"Ada",
"ada@example.com",
"pw",
"Analytical Engines",
))
.await
.unwrap();
users
.sign_in(&SignInRequest::new("ada@example.com", "pw"))
.await
.unwrap();
users.sign_out().await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("POST", "https://api.test/user/signup")
);
assert_eq!(seen[0].body_json()["email"], "ada@example.com");
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("POST", "https://api.test/user/signup")
);
assert_eq!(seen[1].body_json()["company_name"], "Analytical Engines");
assert_eq!(
(seen[2].method, seen[2].url.as_str()),
("POST", "https://api.test/user/signin")
);
assert_eq!(seen[2].body_json()["password"], "pw");
assert_eq!(
(seen[3].method, seen[3].url.as_str()),
("POST", "https://api.test/user/signout")
);
assert!(seen[3].body.is_none(), "signout must not send a body");
}
#[tokio::test]
async fn sign_in_oidc_posts_the_open_body() {
let (client, mock) = client_with(vec![Step::ok(AUTH)]);
client
.users()
.sign_in_oidc(&json!({"code": "oidc_code_1"}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/oidc");
assert_eq!(seen[0].body_json()["code"], "oidc_code_1");
}
#[tokio::test]
async fn login_activity_and_sessions_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(
r#"{"entries":[{"id":"lh_1","event_type":"signin_success","failure_reason":null,
"auth_method":"password","ip_address":"203.0.113.7","user_agent":"curl",
"country_code":"GB","city":"London","latitude":51.5,"longitude":-0.12,
"created_at":"2026-01-01T00:00:00Z"}],
"total_count":1,"offset":0,"limit":25}"#,
),
Step::ok(r#"{"entries":[],"total_count":0,"offset":100,"limit":50}"#),
Step::ok(
r#"{"sessions":[{"id":"ses_1","auth_method":"password","ip_address":null,
"user_agent":null,"country_code":null,"city":null,
"created_at":"2026-01-01T00:00:00Z","last_seen_at":"2026-01-02T00:00:00Z",
"expires_at":"2026-01-08T00:00:00Z","is_current":true}]}"#,
),
Step::ok(r#"{"revoked":true}"#),
]);
let users = client.users();
let activity = users.list_login_activity(None).await.unwrap();
assert_eq!(activity.total_count, 1);
assert_eq!(activity.entries[0].event_type, "signin_success");
assert_eq!(activity.entries[0].city.as_deref(), Some("London"));
users
.list_login_activity(Some(&LoginHistoryParams {
limit: Some(50),
offset: Some(100),
}))
.await
.unwrap();
let sessions = users.list_active_sessions().await.unwrap();
assert_eq!(sessions.sessions[0].id, "ses_1");
assert!(sessions.sessions[0].is_current);
let revoked = users.revoke_session("ses/1 a").await.unwrap();
assert!(revoked.revoked);
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("GET", "https://api.test/user/me/login-activity")
);
assert_eq!(
seen[1].url,
"https://api.test/user/me/login-activity?limit=50&offset=100"
);
assert_eq!(
(seen[2].method, seen[2].url.as_str()),
("GET", "https://api.test/user/me/sessions")
);
assert_eq!(
(seen[3].method, seen[3].url.as_str()),
(
"POST",
"https://api.test/user/me/sessions/ses%2F1%20a/revoke"
)
);
}
#[tokio::test]
async fn profile_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![Step::ok(USER), Step::ok(USER), Step::ok(OK)]);
let users = client.users();
let me = users.details().await.unwrap();
assert_eq!(me.email, "ada@example.com");
assert!(me.is_two_factor_auth_setup);
assert_eq!(me.theme_id, None);
users
.update(&UpdateUserDetailsRequest::new().name("Ada L."))
.await
.unwrap();
users
.delete_account(&DeleteAccountRequest::new("pw").totp_code("123456"))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("GET", "https://api.test/user")
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("POST", "https://api.test/user/update")
);
assert_eq!(seen[1].body_json()["name"], "Ada L.");
assert_eq!(
(seen[2].method, seen[2].url.as_str()),
("DELETE", "https://api.test/user/account")
);
assert_eq!(seen[2].body_json()["totp_code"], "123456");
}
#[tokio::test]
async fn password_and_email_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(USER),
Step::ok(USER),
Step::ok(OK),
Step::ok(OK),
Step::ok(r#"{"token":"spt-1","token_type":"totp"}"#),
Step::ok(AUTH),
Step::ok(OK),
]);
let users = client.users();
users
.change_password(&ChangePasswordRequest::new("old", "new"))
.await
.unwrap();
users
.rotate_password(&ResetPasswordRequest::new("tok", "rotated"))
.await
.unwrap();
users
.forgot_password(&ForgotPasswordRequest::new("ada@example.com"))
.await
.unwrap();
users
.reset_password(&ResetPasswordRequest::new("tok", "reset"))
.await
.unwrap();
let exchanged = users
.from_email(&FromEmailRequest::new("email-tok"))
.await
.unwrap();
assert_eq!(exchanged.token_type, "totp");
users
.verify_email(&json!({"token": "verify-tok"}))
.await
.unwrap();
users
.send_verification_email(&ForgotPasswordRequest::new("ada@example.com"))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("POST", "https://api.test/user/change-password"),
("POST", "https://api.test/user/rotate-password"),
("POST", "https://api.test/user/forgot-password"),
("POST", "https://api.test/user/reset-password"),
("POST", "https://api.test/user/from-email"),
("POST", "https://api.test/user/verify-email"),
("POST", "https://api.test/user/verify-email-request"),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!((seen[i].method, seen[i].url.as_str()), (*method, *url));
}
assert_eq!(seen[0].body_json()["old_password"], "old");
assert_eq!(seen[1].body_json()["password"], "rotated");
assert_eq!(seen[2].body_json()["email"], "ada@example.com");
assert_eq!(seen[3].body_json()["password"], "reset");
assert_eq!(seen[4].body_json()["token"], "email-tok");
assert_eq!(seen[5].body_json()["token"], "verify-tok");
assert_eq!(seen[6].body_json()["email"], "ada@example.com");
}
#[tokio::test]
async fn switching_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(AUTH),
Step::ok(AUTH),
Step::ok(AUTH),
Step::ok(EMPTY_LIST),
Step::ok(EMPTY_LIST),
Step::ok(EMPTY_LIST),
Step::ok(EMPTY_LIST),
]);
let users = client.users();
users
.create_merchant(&json!({"merchant_name": "Acme"}))
.await
.unwrap();
let switched = users
.switch_merchant(&SwitchMerchantRequest::new("mer_1"))
.await
.unwrap();
assert_eq!(switched.token, "jwt-secret-1");
users
.switch_profile(&SwitchProfileRequest::new("pro_1"))
.await
.unwrap();
users.list_merchants().await.unwrap();
users.list_profiles().await.unwrap();
users.list_invitations().await.unwrap();
users.parent_list().await.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("POST", "https://api.test/user/create-merchant"),
("POST", "https://api.test/user/switch/merchant"),
("POST", "https://api.test/user/switch/profile"),
("GET", "https://api.test/user/list/merchant"),
("GET", "https://api.test/user/list/profile"),
("GET", "https://api.test/user/list/invitation"),
("GET", "https://api.test/user/parent/list"),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!((seen[i].method, seen[i].url.as_str()), (*method, *url));
}
assert_eq!(seen[0].body_json()["merchant_name"], "Acme");
assert_eq!(seen[1].body_json()["merchant_id"], "mer_1");
assert_eq!(seen[2].body_json()["profile_id"], "pro_1");
}
#[tokio::test]
async fn invite_users_posts_a_json_array() {
let (client, mock) = client_with(vec![Step::ok(
r#"[{"email":"bob@example.com","is_email_sent":false,"password":"temp-pw","error":null},
{"email":"eve@example.com","is_email_sent":true}]"#,
)]);
let out = client
.users()
.invite_users(&[
InviteUsersRequest::new("bob@example.com", "Bob", "role_1"),
InviteUsersRequest::new("eve@example.com", "Eve", "role_2")
.profile_ids(vec!["pro_9".to_string()]),
])
.await
.unwrap();
assert_eq!(out.len(), 2);
assert!(!out[0].is_email_sent);
assert_eq!(out[0].password.as_deref(), Some("temp-pw"));
assert!(out[1].is_email_sent);
assert_eq!(out[1].password, None);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/employees/invite");
let body = seen[0].body_json();
assert!(body.is_array(), "invite body must be a JSON array: {body}");
assert_eq!(body[0]["email"], "bob@example.com");
assert_eq!(body[1]["profile_ids"][0], "pro_9");
}
#[tokio::test]
async fn employee_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(ADDED_USER),
Step::ok(TOKEN),
Step::ok(AUTH),
Step::ok(AUTH),
Step::ok(OK),
Step::ok(EMPTY_LIST),
Step::ok(EMPTY_LIST),
Step::ok(OK),
Step::ok(OK),
Step::ok(
r#"[{"user_id":"usr_1","email":"bob@example.com",
"roles":[{"role_id":"role_1","role_name":"Admin"}]}]"#,
),
Step::ok(EMPTY_LIST),
]);
let users = client.users();
let added = users
.add_user(&AddUserRequest::new("bob@example.com", "Bob", "role_1").password("pw"))
.await
.unwrap();
assert_eq!(added.user_id, "usr_1");
assert!(added.is_active);
let impersonation = users
.impersonate_employee(
&ImpersonateEmployeeRequest::new("bob@example.com").profile_id("pro_1"),
)
.await
.unwrap();
assert_eq!(impersonation.token, "spt-secret-1");
users
.accept_invitation(&json!({"token": "invite-tok"}))
.await
.unwrap();
users
.accept_invite_from_email(&FromEmailRequest::new("email-tok"))
.await
.unwrap();
users
.resend_invite(&json!({"email": "bob@example.com"}))
.await
.unwrap();
users.list_user_roles(None).await.unwrap();
users
.list_user_roles(Some(&json!({"entity_type": "merchant"})))
.await
.unwrap();
users
.update_user_role(
&UpdateUserRoleRequest::new("bob@example.com", "role_2").profile_id("pro_1"),
)
.await
.unwrap();
users
.delete_user_role(&DeleteUserRoleRequest::new("bob@example.com").profile_id("pro_1"))
.await
.unwrap();
let lineage = users.list_users_in_lineage(None).await.unwrap();
assert_eq!(lineage[0].user_id, "usr_1");
assert_eq!(lineage[0].roles[0].role_name, "Admin");
users
.list_users_in_lineage(Some(&ListUsersInLineageParams {
entity_type: Some("profile".to_string()),
profile_id: Some("pro_1".to_string()),
}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("POST", "https://api.test/user/employees/add"),
("POST", "https://api.test/user/employees/impersonate"),
("POST", "https://api.test/user/employees/invite/accept"),
("POST", "https://api.test/user/accept-invite-from-email"),
("POST", "https://api.test/user/resend-invite"),
("POST", "https://api.test/user/employees"),
("POST", "https://api.test/user/employees"),
("POST", "https://api.test/user/employees/update-role"),
("DELETE", "https://api.test/user/employees/delete"),
("GET", "https://api.test/user/employees/list"),
(
"GET",
"https://api.test/user/employees/list?entity_type=profile&profile_id=pro_1",
),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!(
(seen[i].method, seen[i].url.as_str()),
(*method, *url),
"call {i}"
);
}
assert_eq!(seen[0].body_json()["password"], "pw");
assert_eq!(seen[1].body_json()["profile_id"], "pro_1");
assert_eq!(seen[2].body_json()["token"], "invite-tok");
assert_eq!(seen[3].body_json()["token"], "email-tok");
assert_eq!(seen[4].body_json()["email"], "bob@example.com");
assert!(seen[5].body.is_none());
assert_eq!(seen[6].body_json()["entity_type"], "merchant");
assert_eq!(seen[7].body_json()["role_id"], "role_2");
assert_eq!(seen[8].body_json()["email"], "bob@example.com");
}
#[tokio::test]
async fn two_factor_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(OK),
Step::ok(
r#"{"secret":{"secret":"JBSWY3DPEHPK3PXP",
"totp_url":"otpauth://totp/x?secret=JBSWY3DPEHPK3PXP"}}"#,
),
Step::ok(OK),
Step::ok(OK),
Step::ok(OK),
Step::ok(r#"{"recovery_codes":["aaaa-bbbb","cccc-dddd"]}"#),
Step::ok(AUTH),
Step::ok(TOKEN),
Step::ok(TOKEN),
]);
let users = client.users();
users.check_2fa_status().await.unwrap();
let totp = users.begin_totp().await.unwrap();
let enrolment = totp.secret.as_ref().expect("not yet enrolled");
assert_eq!(enrolment.secret, "JBSWY3DPEHPK3PXP");
assert!(enrolment.totp_url.starts_with("otpauth://"));
users
.verify_totp(&VerifyTotpRequest::new("111111"))
.await
.unwrap();
users
.update_totp(&VerifyTotpRequest::new("222222"))
.await
.unwrap();
users.reset_totp().await.unwrap();
let codes = users.generate_recovery_codes().await.unwrap();
assert_eq!(codes.recovery_codes, vec!["aaaa-bbbb", "cccc-dddd"]);
users
.verify_recovery_code(&json!({"recovery_code": "abcd-efgh"}))
.await
.unwrap();
let next = users.terminate_2fa(None).await.unwrap();
assert_eq!(next.token_type, "reset_password");
users
.terminate_2fa(Some(&Terminate2faQueryParams {
skip_two_factor_auth: Some(true),
}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("GET", "https://api.test/user/2fa"),
("GET", "https://api.test/user/2fa/totp/begin"),
("POST", "https://api.test/user/2fa/totp/verify"),
("PUT", "https://api.test/user/2fa/totp/verify"),
("GET", "https://api.test/user/2fa/totp/reset"),
("GET", "https://api.test/user/2fa/recovery-code/generate"),
("POST", "https://api.test/user/2fa/recovery-code/verify"),
("GET", "https://api.test/user/2fa/terminate"),
(
"GET",
"https://api.test/user/2fa/terminate?skip_two_factor_auth=true",
),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!(
(seen[i].method, seen[i].url.as_str()),
(*method, *url),
"call {i}"
);
}
assert_eq!(seen[2].body_json()["totp"], "111111");
assert_eq!(seen[3].body_json()["totp"], "222222");
assert_eq!(seen[6].body_json()["recovery_code"], "abcd-efgh");
}
#[tokio::test]
async fn phone_otp_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(r#"{"message":"sent"}"#),
Step::ok(r#"{"verified":true}"#),
]);
let users = client.users();
let sent = users
.send_phone_otp(&PhoneOtpRequest::new("+441234567890"))
.await
.unwrap();
assert_eq!(sent.message, "sent");
let verified = users
.verify_phone_otp(&PhoneOtpVerifyRequest::new("+441234567890", "246810"))
.await
.unwrap();
assert!(verified.verified);
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("POST", "https://api.test/user/phone/send-otp")
);
assert_eq!(seen[0].body_json()["phone_number"], "+441234567890");
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("POST", "https://api.test/user/phone/verify-otp")
);
assert_eq!(seen[1].body_json()["code"], "246810");
}
#[tokio::test]
async fn auth_method_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(OK),
Step::ok(OK),
Step::ok(EMPTY_LIST),
Step::ok(OK),
Step::ok(OK),
Step::ok(OK),
]);
let users = client.users();
users
.create_auth_method(&json!({"auth_type": "oidc"}))
.await
.unwrap();
users
.update_auth_method(&json!({"auth_id": "auth_1"}))
.await
.unwrap();
users.list_auth_methods().await.unwrap();
users.auth_url().await.unwrap();
users
.select_auth(&json!({"auth_id": "auth_1"}))
.await
.unwrap();
users
.transfer_key(&json!({"merchant_id": "mer_1"}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("POST", "https://api.test/user/auth"),
("PUT", "https://api.test/user/auth"),
("GET", "https://api.test/user/auth/list"),
("GET", "https://api.test/user/auth/url"),
("POST", "https://api.test/user/auth/select"),
("POST", "https://api.test/user/key/transfer"),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!(
(seen[i].method, seen[i].url.as_str()),
(*method, *url),
"call {i}"
);
}
assert_eq!(seen[0].body_json()["auth_type"], "oidc");
assert_eq!(seen[1].body_json()["auth_id"], "auth_1");
assert_eq!(seen[4].body_json()["auth_id"], "auth_1");
assert_eq!(seen[5].body_json()["merchant_id"], "mer_1");
}
#[tokio::test]
async fn role_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(EMPTY_LIST),
Step::ok(EMPTY_LIST),
Step::ok(EMPTY_LIST),
Step::ok(EMPTY_LIST),
Step::ok(EMPTY_LIST),
Step::ok(
r#"[{"name":"Operations","resources":["payment"],"scopes":["Read","Write"]}]"#,
),
Step::ok(OK),
Step::ok(OK),
Step::ok(OK),
Step::ok(OK),
]);
let users = client.users();
users.list_roles(None).await.unwrap();
users
.list_roles(Some(&ListRolesParams {
groups: Some(true),
entity_type: Some("merchant".to_string()),
}))
.await
.unwrap();
users.list_invitable_roles(None).await.unwrap();
users
.list_invitable_roles(Some(&ListInvitableRolesParams {
entity_type: Some("merchant".to_string()),
}))
.await
.unwrap();
users.list_updatable_roles().await.unwrap();
let permissions = users.role_permissions().await.unwrap();
assert_eq!(permissions[0].name, "Operations");
assert_eq!(permissions[0].scopes, vec!["Read", "Write"]);
users
.create_role(&json!({"role_name": "Ops"}))
.await
.unwrap();
users.retrieve_role("role/1 a").await.unwrap();
users
.update_role("role/1 a", &json!({"role_name": "Ops2"}))
.await
.unwrap();
users.delete_role("role/1 a").await.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("GET", "https://api.test/user/role/list"),
(
"GET",
"https://api.test/user/role/list?groups=true&entity_type=merchant",
),
("GET", "https://api.test/user/role/list/invite"),
(
"GET",
"https://api.test/user/role/list/invite?entity_type=merchant",
),
("GET", "https://api.test/user/role/list/update"),
("GET", "https://api.test/user/role"),
("POST", "https://api.test/user/role"),
("GET", "https://api.test/user/role/role%2F1%20a"),
("PUT", "https://api.test/user/role/role%2F1%20a"),
("DELETE", "https://api.test/user/role/role%2F1%20a"),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!(
(seen[i].method, seen[i].url.as_str()),
(*method, *url),
"call {i}"
);
}
assert_eq!(seen[6].body_json()["role_name"], "Ops");
assert_eq!(seen[8].body_json()["role_name"], "Ops2");
}
}