use std::collections::{BTreeMap, VecDeque};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Mutex, MutexGuard, Weak};
use std::time::Duration;
use base64::engine::general_purpose::STANDARD as BASE64;
use base64::Engine;
use serde::{Deserialize, Serialize};
use serde_json::json;
use crate::desktop::{
delete_json, get_json, offline_only, patch_json, post_json, DesktopCall, GAMES_PATH_PREFIX,
OFFLINE_ONLY_ENV,
};
use crate::error::{ErrorCode, SdkError};
use crate::session::SessionInner;
const CALL_TIMEOUT: Duration = Duration::from_secs(5);
pub(crate) const IN_LOBBY_POLL: Duration = Duration::from_secs(5);
pub const MAX_LOBBY_PAYLOAD_LEN: usize = 4096;
pub const JOIN_CODE_LEN: usize = 6;
pub const MAX_LOBBY_METADATA_PAIRS: usize = 16;
pub const MAX_LOBBY_METADATA_KEY_LEN: usize = 32;
pub const MAX_LOBBY_METADATA_VALUE_LEN: usize = 128;
pub const MAX_LOBBY_METADATA_BYTES: usize = 2048;
pub const MAX_LOBBY_SEARCH_RESULTS: u8 = 50;
const MAX_ID_LEN: usize = 64;
const MAX_QUEUED_EVENTS: usize = 256;
const MAX_SEEN_EVENT_IDS: usize = 256;
const BASE64_LEN_LIMIT: usize = MAX_LOBBY_PAYLOAD_LEN.div_ceil(3) * 4;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Visibility {
Friends,
Code,
FriendsAndCode,
Public,
}
impl Visibility {
pub fn as_str(&self) -> &'static str {
match self {
Self::Friends => "friends",
Self::Code => "code",
Self::FriendsAndCode => "friends_and_code",
Self::Public => "public",
}
}
}
impl std::fmt::Display for Visibility {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Lobby {
pub lobby_id: String,
pub join_code: Option<String>,
pub host_user_id: String,
pub host_payload: Vec<u8>,
pub members: Vec<LobbyMember>,
pub max_players: u8,
pub metadata: BTreeMap<String, String>,
}
#[derive(Debug, Clone, Copy)]
pub struct LobbyOptions<'a> {
pub max_players: u8,
pub visibility: Visibility,
pub payload: &'a [u8],
pub metadata: &'a [(&'a str, &'a str)],
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LobbyQuery {
pub filters: Vec<(String, String)>,
pub has_free_slot: bool,
pub limit: u8,
}
impl Default for LobbyQuery {
fn default() -> Self {
Self {
filters: Vec::new(),
has_free_slot: true,
limit: 20,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LobbySummary {
pub lobby_id: String,
pub host_user_id: String,
pub host_pseudo: String,
pub members: u8,
pub max_players: u8,
pub metadata: BTreeMap<String, String>,
pub host_is_friend: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LobbyMember {
pub user_id: String,
pub pseudo: String,
pub payload: Vec<u8>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum LobbyEvent {
Invite {
lobby_id: String,
join_code: Option<String>,
from_user_id: String,
pseudo: String,
},
MemberJoined {
lobby_id: String,
user_id: String,
pseudo: String,
payload: Vec<u8>,
},
MemberLeft { lobby_id: String, user_id: String },
LobbyClosed { lobby_id: String },
LobbyUpdated {
lobby_id: String,
metadata: BTreeMap<String, String>,
},
Resync,
}
impl LobbyEvent {
pub fn lobby_id(&self) -> Option<&str> {
match self {
Self::Invite { lobby_id, .. }
| Self::MemberJoined { lobby_id, .. }
| Self::MemberLeft { lobby_id, .. }
| Self::LobbyClosed { lobby_id }
| Self::LobbyUpdated { lobby_id, .. } => Some(lobby_id),
Self::Resync => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LobbyPollingState {
Off,
Active,
Unavailable,
}
impl LobbyPollingState {
pub fn as_str(&self) -> &'static str {
match self {
Self::Off => "off",
Self::Active => "active",
Self::Unavailable => "unavailable",
}
}
}
impl std::fmt::Display for LobbyPollingState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug)]
struct Shared {
polling: LobbyPollingState,
cursor: Option<String>,
events: VecDeque<(u64, LobbyEvent)>,
next_seq: u64,
seen: VecDeque<String>,
lobbies: Vec<String>,
}
#[derive(Debug)]
pub(crate) struct P2pState {
armed: AtomicBool,
shared: Mutex<Shared>,
launch_code: Mutex<Option<Option<String>>>,
waker: Mutex<Option<Weak<SessionInner>>>,
}
impl P2pState {
pub(crate) fn new() -> Self {
Self {
armed: AtomicBool::new(false),
shared: Mutex::new(Shared {
polling: LobbyPollingState::Off,
cursor: None,
events: VecDeque::new(),
next_seq: 0,
seen: VecDeque::new(),
lobbies: Vec::new(),
}),
launch_code: Mutex::new(None),
waker: Mutex::new(None),
}
}
pub(crate) fn set_waker(&self, waker: Weak<SessionInner>) {
*self.waker.lock().unwrap_or_else(|e| e.into_inner()) = Some(waker);
}
fn notify(&self) {
let waker = self
.waker
.lock()
.unwrap_or_else(|e| e.into_inner())
.as_ref()
.and_then(Weak::upgrade);
if let Some(session) = waker {
session.wake_now();
}
}
fn lock(&self) -> MutexGuard<'_, Shared> {
self.shared.lock().unwrap_or_else(|e| e.into_inner())
}
fn arm(&self) {
if self.armed.load(Ordering::Relaxed) {
return;
}
let mut shared = self.lock();
if shared.polling == LobbyPollingState::Unavailable {
return;
}
shared.polling = LobbyPollingState::Active;
self.armed.store(true, Ordering::Relaxed);
drop(shared);
self.notify();
}
pub(crate) fn armed(&self) -> bool {
self.armed.load(Ordering::Relaxed)
}
pub(crate) fn polling(&self) -> LobbyPollingState {
self.lock().polling
}
pub(crate) fn poll_period(&self, tick: Duration) -> Duration {
if self.lock().lobbies.is_empty() {
tick
} else {
IN_LOBBY_POLL.min(tick)
}
}
fn enter(&self, lobby_id: &str) {
let mut shared = self.lock();
if !shared.lobbies.iter().any(|open| open == lobby_id) {
shared.lobbies.push(lobby_id.to_string());
}
drop(shared);
self.notify();
}
fn exit(&self, lobby_id: &str) {
self.lock().lobbies.retain(|open| open != lobby_id);
self.notify();
}
fn take_events(&self) -> Vec<LobbyEvent> {
let mut shared = self.lock();
shared.events.drain(..).map(|(_, event)| event).collect()
}
pub(crate) fn events_json(&self) -> (String, Option<u64>) {
let shared = self.lock();
let rendered = render_events(shared.events.iter().map(|(_, event)| event));
(rendered, shared.events.back().map(|(seq, _)| *seq))
}
pub(crate) fn discard(&self, through: u64) {
let mut shared = self.lock();
while shared
.events
.front()
.is_some_and(|(seq, _)| *seq <= through)
{
shared.events.pop_front();
}
}
fn ingest(&self, events: Vec<Incoming>, cursor: Option<String>) {
let mut shared = self.lock();
if let Some(cursor) = cursor.filter(|value| !value.is_empty()) {
shared.cursor = Some(cursor);
}
for Incoming { id, event } in events {
if let Some(id) = &id {
if shared.seen.contains(id) {
continue;
}
if shared.seen.len() >= MAX_SEEN_EVENT_IDS {
shared.seen.pop_front();
}
shared.seen.push_back(id.clone());
}
if let LobbyEvent::LobbyClosed { lobby_id } = &event {
shared.lobbies.retain(|open| open != lobby_id);
}
if shared.events.len() >= MAX_QUEUED_EVENTS {
shared.events.pop_front();
}
let seq = shared.next_seq;
shared.next_seq += 1;
shared.events.push_back((seq, event));
}
}
fn retire(&self) {
let mut shared = self.lock();
self.armed.store(false, Ordering::Relaxed);
shared.polling = LobbyPollingState::Unavailable;
}
}
pub(crate) fn poll_once(game_id: &str, state: &P2pState) -> Option<SdkError> {
let cursor = state.lock().cursor.clone();
let response: WireEvents =
match get_json(&events_path(game_id, cursor.as_deref()), CALL_TIMEOUT) {
Ok(response) => response,
Err(call) => {
let err = call.into_sdk_error();
if err.error_code() == ErrorCode::FeatureUnavailable {
state.retire();
return None;
}
return Some(err);
}
};
let mut events: Vec<Incoming> = Vec::new();
if response.dropped {
events.push(Incoming {
id: None,
event: LobbyEvent::Resync,
});
}
events.extend(response.events.into_iter().filter_map(map_event));
state.ingest(events, response.cursor);
None
}
#[derive(Debug)]
struct Incoming {
id: Option<String>,
event: LobbyEvent,
}
#[derive(Debug)]
pub struct P2p<'a> {
game_id: &'a str,
state: &'a P2pState,
}
impl<'a> P2p<'a> {
pub(crate) fn new(game_id: &'a str, state: &'a P2pState) -> Self {
state.arm();
Self { game_id, state }
}
pub fn create_lobby(
&self,
max_players: u8,
visibility: Visibility,
payload: &[u8],
) -> Result<Lobby, SdkError> {
self.create(LobbyOptions {
max_players,
visibility,
payload,
metadata: &[],
})
}
pub fn create(&self, options: LobbyOptions<'_>) -> Result<Lobby, SdkError> {
let encoded = encode_payload(options.payload)?;
let metadata = metadata_arg(options.metadata.iter().copied())?;
self.guard_offline("Creating a lobby")?;
let body = json!({
"max_players": options.max_players,
"visibility": options.visibility.as_str(),
"payload": encoded,
"metadata": metadata,
});
let wire: WireLobby = post_json(&self.lobbies_path(), Some(body), CALL_TIMEOUT)
.map_err(DesktopCall::into_sdk_error)?;
self.entered(map_lobby(wire)?)
}
pub fn join_by_code(&self, join_code: &str, payload: &[u8]) -> Result<Lobby, SdkError> {
let code = normalize_join_code(join_code)?;
let encoded = encode_payload(payload)?;
self.guard_offline("Joining a lobby")?;
let body = json!({ "join_code": code, "payload": encoded });
let wire: WireLobby = post_json(
&format!("{}/join", self.lobbies_path()),
Some(body),
CALL_TIMEOUT,
)
.map_err(|call| call.into_sdk_error().with_context("join_code", &code))?;
self.entered(map_lobby(wire)?)
}
pub fn join(&self, lobby_id: &str, payload: &[u8]) -> Result<Lobby, SdkError> {
validate_id("lobby_id", lobby_id)?;
let encoded = encode_payload(payload)?;
self.guard_offline("Joining a lobby")?;
let body = json!({ "payload": encoded });
let wire: WireLobby = post_json(
&format!("{}/{lobby_id}/join", self.lobbies_path()),
Some(body),
CALL_TIMEOUT,
)
.map_err(|call| call.into_sdk_error().with_context("lobby_id", lobby_id))?;
self.entered(map_lobby(wire)?)
}
pub fn get_lobby(&self, lobby_id: &str) -> Result<Lobby, SdkError> {
validate_id("lobby_id", lobby_id)?;
self.guard_offline("Reading a lobby")?;
let wire: WireLobby =
get_json(&format!("{}/{lobby_id}", self.lobbies_path()), CALL_TIMEOUT)
.map_err(|call| call.into_sdk_error().with_context("lobby_id", lobby_id))?;
map_lobby(wire)
}
pub fn set_metadata(
&self,
lobby_id: &str,
metadata: &[(&str, &str)],
) -> Result<Lobby, SdkError> {
validate_id("lobby_id", lobby_id)?;
let metadata = metadata_arg(metadata.iter().copied())?;
self.guard_offline("Changing a lobby")?;
let body = json!({ "metadata": metadata });
let wire: WireLobby = patch_json(
&format!("{}/{lobby_id}/metadata", self.lobbies_path()),
Some(body),
CALL_TIMEOUT,
)
.map_err(|call| call.into_sdk_error().with_context("lobby_id", lobby_id))?;
map_lobby(wire)
}
pub fn search(&self, query: &LobbyQuery) -> Result<Vec<LobbySummary>, SdkError> {
if query.limit == 0 || query.limit > MAX_LOBBY_SEARCH_RESULTS {
return Err(
SdkError::invalid_argument("The search limit is out of range.")
.with_context("limit", query.limit)
.with_context("max", MAX_LOBBY_SEARCH_RESULTS),
);
}
let filters = metadata_arg(
query
.filters
.iter()
.map(|(key, value)| (key.as_str(), value.as_str())),
)?;
self.guard_offline("Searching for lobbies")?;
let wire: WireSearch = get_json(&search_path(self.game_id, query, &filters), CALL_TIMEOUT)
.map_err(DesktopCall::into_sdk_error)?;
Ok(wire.lobbies.into_iter().filter_map(map_summary).collect())
}
pub fn invite(&self, lobby_id: &str, to_user_id: &str) -> Result<(), SdkError> {
validate_id("lobby_id", lobby_id)?;
validate_id("to_user_id", to_user_id)?;
self.guard_offline("Inviting a friend")?;
let body = json!({ "to_user_id": to_user_id });
let _: WireOk = post_json(
&format!("{}/{lobby_id}/invite", self.lobbies_path()),
Some(body),
CALL_TIMEOUT,
)
.map_err(|call| {
call.into_sdk_error()
.with_context("lobby_id", lobby_id)
.with_context("to_user_id", to_user_id)
})?;
Ok(())
}
pub fn leave(&self, lobby_id: &str) -> Result<(), SdkError> {
validate_id("lobby_id", lobby_id)?;
self.guard_offline("Leaving a lobby")?;
let sent: Result<WireOk, DesktopCall> = post_json(
&format!("{}/{lobby_id}/leave", self.lobbies_path()),
None,
CALL_TIMEOUT,
);
self.left(lobby_id, sent)
}
pub fn close(&self, lobby_id: &str) -> Result<(), SdkError> {
validate_id("lobby_id", lobby_id)?;
self.guard_offline("Closing a lobby")?;
let sent: Result<WireOk, DesktopCall> =
delete_json(&format!("{}/{lobby_id}", self.lobbies_path()), CALL_TIMEOUT);
self.left(lobby_id, sent)
}
pub fn launch_join_code(&self) -> Option<String> {
let mut cached = self
.state
.launch_code
.lock()
.unwrap_or_else(|e| e.into_inner());
if let Some(code) = cached.as_ref() {
return code.clone();
}
if offline_only() {
return None;
}
let fetched = match get_json::<WireLaunchContext>(
&format!("{GAMES_PATH_PREFIX}/{}/launch-context", self.game_id),
CALL_TIMEOUT,
) {
Ok(context) => context
.join_code
.and_then(|code| normalize_join_code(&code).ok()),
Err(call) => {
if call.into_sdk_error().error_code() != ErrorCode::FeatureUnavailable {
return None;
}
None
}
};
*cached = Some(fetched.clone());
fetched
}
pub fn poll_events(&self) -> Vec<LobbyEvent> {
self.state.take_events()
}
pub(crate) fn events_json(&self) -> (String, Option<u64>) {
self.state.events_json()
}
pub(crate) fn discard(&self, through: u64) {
self.state.discard(through);
}
fn left(&self, lobby_id: &str, sent: Result<WireOk, DesktopCall>) -> Result<(), SdkError> {
let Err(call) = sent else {
self.state.exit(lobby_id);
return Ok(());
};
let error = call.into_sdk_error().with_context("lobby_id", lobby_id);
if matches!(
error.error_code(),
ErrorCode::LobbyNotFound | ErrorCode::LobbyClosed
) {
self.state.exit(lobby_id);
}
Err(error)
}
fn entered(&self, lobby: Lobby) -> Result<Lobby, SdkError> {
self.state.enter(&lobby.lobby_id);
Ok(lobby)
}
fn lobbies_path(&self) -> String {
format!("{GAMES_PATH_PREFIX}/{}/lobbies", self.game_id)
}
fn guard_offline(&self, action: &str) -> Result<(), SdkError> {
if !offline_only() {
return Ok(());
}
Err(SdkError::network_required(format!(
"{action} needs the Arcane desktop app, and the SDK is running in offline-only mode."
))
.with_hint(format!(
"Unset {OFFLINE_ONLY_ENV} to let the SDK contact the Arcane desktop app."
))
.with_context("env", OFFLINE_ONLY_ENV))
}
}
pub(crate) fn encode_payload(payload: &[u8]) -> Result<String, SdkError> {
if payload.len() > MAX_LOBBY_PAYLOAD_LEN {
return Err(
SdkError::invalid_argument("The lobby payload is larger than Arcane carries.")
.with_hint(
"Send a reference your own netcode can resolve — an address or a ticket — \
not the data itself.",
)
.with_context("length", payload.len())
.with_context("max_length", MAX_LOBBY_PAYLOAD_LEN),
);
}
Ok(BASE64.encode(payload))
}
fn is_metadata_key(key: &str) -> bool {
!key.is_empty()
&& key.len() <= MAX_LOBBY_METADATA_KEY_LEN
&& key
.bytes()
.all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_')
}
pub(crate) fn metadata_arg<'k>(
pairs: impl Iterator<Item = (&'k str, &'k str)>,
) -> Result<BTreeMap<String, String>, SdkError> {
let mut metadata = BTreeMap::new();
for (key, value) in pairs {
if !is_metadata_key(key) {
return Err(
SdkError::invalid_argument("A lobby metadata key is malformed.")
.with_hint("Keys are 1 to 32 characters of a-z, 0-9 and _.")
.with_context("key", key),
);
}
if value.chars().count() > MAX_LOBBY_METADATA_VALUE_LEN {
return Err(
SdkError::invalid_argument("A lobby metadata value is too long.")
.with_context("key", key)
.with_context("max_length", MAX_LOBBY_METADATA_VALUE_LEN),
);
}
metadata.insert(key.to_string(), value.to_string());
}
if metadata.len() > MAX_LOBBY_METADATA_PAIRS {
return Err(
SdkError::invalid_argument("A lobby carries too many metadata pairs.")
.with_context("pairs", metadata.len())
.with_context("max", MAX_LOBBY_METADATA_PAIRS),
);
}
let bytes = serde_json::to_vec(&metadata)
.map(|v| v.len())
.unwrap_or(usize::MAX);
if bytes > MAX_LOBBY_METADATA_BYTES {
return Err(SdkError::invalid_argument(
"The lobby metadata is over 2048 bytes as JSON.",
)
.with_context("bytes", bytes)
.with_context("max_bytes", MAX_LOBBY_METADATA_BYTES));
}
Ok(metadata)
}
fn search_path(game_id: &str, query: &LobbyQuery, filters: &BTreeMap<String, String>) -> String {
let mut path = format!(
"{GAMES_PATH_PREFIX}/{game_id}/lobbies/search?has_free_slot={}&limit={}",
query.has_free_slot, query.limit
);
for (key, value) in filters {
path.push_str(&format!("&meta.{key}={}", encode_query(value)));
}
path
}
pub(crate) fn decode_payload_arg(raw: &str) -> Option<Vec<u8>> {
let raw = raw.trim();
if raw.len() > BASE64_LEN_LIMIT {
return None;
}
let decoded = BASE64.decode(raw).ok()?;
(decoded.len() <= MAX_LOBBY_PAYLOAD_LEN).then_some(decoded)
}
pub(crate) fn normalize_join_code(join_code: &str) -> Result<String, SdkError> {
let code = join_code.trim().to_ascii_uppercase();
let malformed = SdkError::invalid_argument("That is not an Arcane join code.")
.with_hint(
"Join codes are 6 characters long, from `A`–`Z` without `I` or `O` and \
`2`–`9`. Check what the player typed.",
)
.with_context("join_code", join_code)
.with_context("expected_length", JOIN_CODE_LEN);
if code.chars().count() != JOIN_CODE_LEN {
return Err(malformed);
}
if !code
.chars()
.all(|c| matches!(c, 'A'..='H' | 'J'..='N' | 'P'..='Z' | '2'..='9'))
{
return Err(malformed);
}
Ok(code)
}
pub(crate) fn validate_id(field: &str, value: &str) -> Result<(), SdkError> {
let malformed = |reason: &str| {
SdkError::invalid_argument(format!("The {field} is {reason}."))
.with_hint(
"Pass the value Arcane gave you — ids are ASCII letters, digits and `-`, \
up to 64 characters.",
)
.with_context("field", field)
.with_context(field, value)
};
if value.is_empty() {
return Err(malformed("empty"));
}
if value.len() > MAX_ID_LEN {
return Err(malformed("too long"));
}
if !value.chars().all(|c| c.is_ascii_alphanumeric() || c == '-') {
return Err(malformed("not an Arcane id"));
}
Ok(())
}
#[derive(Debug, Deserialize)]
struct WireOk {
#[serde(default)]
#[allow(dead_code)]
ok: bool,
}
#[derive(Debug, Deserialize)]
struct WireLaunchContext {
#[serde(default)]
join_code: Option<String>,
}
#[derive(Debug, Deserialize)]
struct WireLobby {
#[serde(default)]
lobby_id: String,
#[serde(default)]
join_code: Option<String>,
#[serde(default)]
host_user_id: String,
#[serde(default)]
host_payload: Option<String>,
#[serde(default)]
max_players: u8,
#[serde(default)]
metadata: BTreeMap<String, String>,
#[serde(default)]
members: Vec<WireMember>,
}
#[derive(Debug, Deserialize)]
struct WireSearch {
#[serde(default)]
lobbies: Vec<WireSummary>,
}
#[derive(Debug, Deserialize)]
struct WireSummary {
#[serde(default)]
lobby_id: String,
#[serde(default)]
host_user_id: String,
#[serde(default)]
host_pseudo: String,
#[serde(default)]
members: u8,
#[serde(default)]
max_players: u8,
#[serde(default)]
metadata: BTreeMap<String, String>,
#[serde(default)]
host_is_friend: bool,
}
#[derive(Debug, Deserialize)]
struct WireMember {
#[serde(default)]
user_id: String,
#[serde(default)]
pseudo: String,
#[serde(default)]
payload: Option<String>,
}
#[derive(Debug, Deserialize)]
struct WireEvents {
#[serde(default)]
events: Vec<WireEvent>,
#[serde(default)]
cursor: Option<String>,
#[serde(default)]
dropped: bool,
}
#[derive(Debug, Deserialize)]
struct WireEvent {
#[serde(default)]
id: Option<String>,
#[serde(rename = "type", default)]
kind: String,
#[serde(default)]
lobby_id: String,
#[serde(default)]
join_code: Option<String>,
#[serde(default)]
from_user_id: Option<String>,
#[serde(default)]
user_id: Option<String>,
#[serde(default)]
pseudo: Option<String>,
#[serde(default)]
payload: Option<String>,
#[serde(default)]
metadata: Option<BTreeMap<String, String>>,
}
fn map_summary(wire: WireSummary) -> Option<LobbySummary> {
if wire.lobby_id.trim().is_empty() {
return None;
}
Some(LobbySummary {
lobby_id: wire.lobby_id,
host_user_id: wire.host_user_id,
host_pseudo: wire.host_pseudo,
members: wire.members,
max_players: wire.max_players,
metadata: wire.metadata,
host_is_friend: wire.host_is_friend,
})
}
fn map_lobby(wire: WireLobby) -> Result<Lobby, SdkError> {
if wire.lobby_id.trim().is_empty() {
return Err(
SdkError::arcane_unavailable("Arcane desktop returned a lobby without an id.")
.with_hint("The Arcane desktop app may be older than this SDK — update it.")
.with_context("field", "lobby_id"),
);
}
Ok(Lobby {
lobby_id: wire.lobby_id,
join_code: wire.join_code.filter(|code| !code.trim().is_empty()),
host_user_id: wire.host_user_id,
host_payload: decode_payload(wire.host_payload.as_deref(), "host_payload")?,
members: wire
.members
.into_iter()
.map(|member| {
Ok(LobbyMember {
user_id: member.user_id,
pseudo: member.pseudo,
payload: decode_payload(member.payload.as_deref(), "payload")?,
})
})
.collect::<Result<Vec<_>, SdkError>>()?,
max_players: wire.max_players,
metadata: wire.metadata,
})
}
fn map_event(wire: WireEvent) -> Option<Incoming> {
let lobby_id = wire.lobby_id;
if lobby_id.is_empty() {
return None;
}
let payload = || decode_payload(wire.payload.as_deref(), "payload").unwrap_or_default();
let event = match wire.kind.as_str() {
"invite" => LobbyEvent::Invite {
lobby_id,
join_code: wire.join_code.filter(|code| !code.trim().is_empty()),
from_user_id: wire.from_user_id.unwrap_or_default(),
pseudo: wire.pseudo.unwrap_or_default(),
},
"member_joined" => LobbyEvent::MemberJoined {
lobby_id,
user_id: wire.user_id.unwrap_or_default(),
pseudo: wire.pseudo.unwrap_or_default(),
payload: payload(),
},
"member_left" => LobbyEvent::MemberLeft {
lobby_id,
user_id: wire.user_id.unwrap_or_default(),
},
"lobby_closed" => LobbyEvent::LobbyClosed { lobby_id },
"lobby_updated" => LobbyEvent::LobbyUpdated {
lobby_id,
metadata: wire.metadata.unwrap_or_default(),
},
_ => return None,
};
Some(Incoming { id: wire.id, event })
}
fn decode_payload(encoded: Option<&str>, field: &str) -> Result<Vec<u8>, SdkError> {
let Some(encoded) = encoded.map(str::trim).filter(|value| !value.is_empty()) else {
return Ok(Vec::new());
};
let malformed = |detail: String| {
SdkError::arcane_unavailable(format!("Unexpected Arcane desktop payload: {detail}"))
.with_hint("The Arcane desktop app must relay a payload untouched — update it.")
.with_context("field", field)
};
if encoded.len() > BASE64_LEN_LIMIT {
return Err(malformed(format!(
"it is longer than the {MAX_LOBBY_PAYLOAD_LEN} bytes Arcane carries"
)));
}
let decoded = BASE64
.decode(encoded)
.map_err(|e| malformed(e.to_string()))?;
if decoded.len() > MAX_LOBBY_PAYLOAD_LEN {
return Err(malformed(format!(
"it is longer than the {MAX_LOBBY_PAYLOAD_LEN} bytes Arcane carries"
)));
}
Ok(decoded)
}
fn events_path(game_id: &str, cursor: Option<&str>) -> String {
let base = format!("{GAMES_PATH_PREFIX}/{game_id}/lobbies/events");
match cursor {
Some(cursor) => format!("{base}?after={}", encode_query(cursor)),
None => base,
}
}
fn encode_query(value: &str) -> String {
let mut encoded = String::with_capacity(value.len());
for byte in value.as_bytes() {
match byte {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => {
encoded.push(*byte as char)
}
_ => encoded.push_str(&format!("%{byte:02X}")),
}
}
encoded
}
#[derive(Serialize)]
struct JsonLobby<'a> {
lobby_id: &'a str,
join_code: Option<&'a str>,
host_user_id: &'a str,
host_payload: String,
members: Vec<JsonMember<'a>>,
max_players: u8,
metadata: &'a BTreeMap<String, String>,
}
#[derive(Serialize)]
struct JsonSearch<'a> {
lobbies: Vec<JsonSummary<'a>>,
}
#[derive(Serialize)]
struct JsonSummary<'a> {
lobby_id: &'a str,
host_user_id: &'a str,
host_pseudo: &'a str,
members: u8,
max_players: u8,
metadata: &'a BTreeMap<String, String>,
host_is_friend: bool,
}
#[derive(Serialize)]
struct JsonMember<'a> {
user_id: &'a str,
pseudo: &'a str,
payload: String,
}
#[derive(Serialize)]
struct JsonEvents<'a> {
events: Vec<JsonEvent<'a>>,
}
#[derive(Serialize)]
#[serde(tag = "type", rename_all = "snake_case")]
enum JsonEvent<'a> {
Invite {
lobby_id: &'a str,
join_code: Option<&'a str>,
from_user_id: &'a str,
pseudo: &'a str,
},
MemberJoined {
lobby_id: &'a str,
user_id: &'a str,
pseudo: &'a str,
payload: String,
},
MemberLeft {
lobby_id: &'a str,
user_id: &'a str,
},
LobbyClosed {
lobby_id: &'a str,
},
LobbyUpdated {
lobby_id: &'a str,
metadata: &'a BTreeMap<String, String>,
},
Resync,
}
pub(crate) fn to_json(lobby: &Lobby) -> String {
let rendered = JsonLobby {
lobby_id: &lobby.lobby_id,
join_code: lobby.join_code.as_deref(),
host_user_id: &lobby.host_user_id,
host_payload: BASE64.encode(&lobby.host_payload),
members: lobby
.members
.iter()
.map(|member| JsonMember {
user_id: &member.user_id,
pseudo: &member.pseudo,
payload: BASE64.encode(&member.payload),
})
.collect(),
max_players: lobby.max_players,
metadata: &lobby.metadata,
};
serde_json::to_string(&rendered).unwrap_or_else(|_| r#"{"lobby_id":""}"#.to_string())
}
pub(crate) fn summaries_to_json(lobbies: &[LobbySummary]) -> String {
let rendered = JsonSearch {
lobbies: lobbies
.iter()
.map(|lobby| JsonSummary {
lobby_id: &lobby.lobby_id,
host_user_id: &lobby.host_user_id,
host_pseudo: &lobby.host_pseudo,
members: lobby.members,
max_players: lobby.max_players,
metadata: &lobby.metadata,
host_is_friend: lobby.host_is_friend,
})
.collect(),
};
serde_json::to_string(&rendered).unwrap_or_else(|_| r#"{"lobbies":[]}"#.to_string())
}
fn render_events<'a>(events: impl Iterator<Item = &'a LobbyEvent>) -> String {
let rendered = JsonEvents {
events: events
.map(|event| match event {
LobbyEvent::Invite {
lobby_id,
join_code,
from_user_id,
pseudo,
} => JsonEvent::Invite {
lobby_id,
join_code: join_code.as_deref(),
from_user_id,
pseudo,
},
LobbyEvent::MemberJoined {
lobby_id,
user_id,
pseudo,
payload,
} => JsonEvent::MemberJoined {
lobby_id,
user_id,
pseudo,
payload: BASE64.encode(payload),
},
LobbyEvent::MemberLeft { lobby_id, user_id } => {
JsonEvent::MemberLeft { lobby_id, user_id }
}
LobbyEvent::LobbyClosed { lobby_id } => JsonEvent::LobbyClosed { lobby_id },
LobbyEvent::LobbyUpdated { lobby_id, metadata } => {
JsonEvent::LobbyUpdated { lobby_id, metadata }
}
LobbyEvent::Resync => JsonEvent::Resync,
})
.collect(),
};
serde_json::to_string(&rendered).unwrap_or_else(|_| r#"{"events":[]}"#.to_string())
}
#[cfg(test)]
mod tests {
use super::*;
fn parse_lobby(raw: &str) -> Lobby {
map_lobby(serde_json::from_str(raw).expect("wire lobby")).expect("mapped lobby")
}
const LOBBY: &str = r#"{
"lobby_id": "lobby-1",
"join_code": "K7P3QX",
"host_user_id": "user-host",
"host_payload": "dWRwOi8vMTAuMC4wLjE6Nzc3Nw==",
"visibility": "friends_and_code",
"max_players": 4,
"members": [
{"user_id":"user-host","pseudo":"Ada","payload":"dWRwOi8vMTAuMC4wLjE6Nzc3Nw=="},
{"user_id":"user-b","pseudo":"Bo","payload":null}
],
"expires_at": "2026-05-01T12:34:56Z"
}"#;
#[test]
fn a_payload_survives_the_base64_round_trip() {
let payload: Vec<u8> = (0u8..=255).collect();
let encoded = encode_payload(&payload).expect("encoded");
assert_eq!(
decode_payload(Some(&encoded), "payload").expect("decoded"),
payload
);
assert_eq!(encode_payload(b"").expect("empty"), "");
assert_eq!(
decode_payload(Some(""), "payload").expect("empty"),
Vec::<u8>::new()
);
assert_eq!(
decode_payload(None, "payload").expect("absent"),
Vec::<u8>::new()
);
}
#[test]
fn a_payload_at_the_limit_is_accepted_and_one_byte_over_is_not() {
assert!(encode_payload(&vec![7u8; MAX_LOBBY_PAYLOAD_LEN]).is_ok());
let err = encode_payload(&vec![7u8; MAX_LOBBY_PAYLOAD_LEN + 1]).expect_err("too long");
assert_eq!(err.code(), "invalid_argument");
assert!(err
.context()
.iter()
.any(|(k, v)| k == "length" && v == &(MAX_LOBBY_PAYLOAD_LEN + 1).to_string()));
}
#[test]
fn a_c_abi_payload_argument_decodes_or_is_refused() {
assert_eq!(decode_payload_arg("aGk=").expect("base64"), b"hi");
assert_eq!(decode_payload_arg("").expect("empty"), Vec::<u8>::new());
assert!(decode_payload_arg("not base64!!").is_none());
}
#[test]
fn a_join_code_is_uppercased_before_it_is_checked() {
assert_eq!(normalize_join_code("k7p3qx").expect("lowercase"), "K7P3QX");
assert_eq!(normalize_join_code(" K7P3QX ").expect("padded"), "K7P3QX");
}
#[test]
fn the_ambiguous_characters_are_not_join_codes() {
for code in [
"", "K7P3Q", "K7P3QXY", "K7P3Q0", "K7P3Q1", "K7P3QI", "K7P3QO", "K7-3QX", "K7P3Q ",
"K7P3Q✨",
] {
let err = normalize_join_code(code).expect_err("accepted {code}");
assert_eq!(err.code(), "invalid_argument", "accepted {code:?}");
}
}
#[test]
fn ids_are_checked_before_they_reach_a_url() {
assert!(validate_id("lobby_id", "lobby-1").is_ok());
assert!(validate_id("lobby_id", &"a".repeat(MAX_ID_LEN)).is_ok());
for bad in [
"",
"lobby/../evil",
"lobby 1",
"lobby?x=1",
"lobby#f",
"lobbÿ",
] {
let err = validate_id("lobby_id", bad).expect_err("accepted");
assert_eq!(err.code(), "invalid_argument", "accepted {bad:?}");
}
assert_eq!(
validate_id("lobby_id", &"a".repeat(MAX_ID_LEN + 1))
.expect_err("too long")
.code(),
"invalid_argument"
);
}
#[test]
fn the_wire_lobby_maps_onto_the_public_struct() {
let lobby = parse_lobby(LOBBY);
assert_eq!(lobby.lobby_id, "lobby-1");
assert_eq!(lobby.join_code.as_deref(), Some("K7P3QX"));
assert_eq!(lobby.host_user_id, "user-host");
assert_eq!(lobby.host_payload, b"udp://10.0.0.1:7777");
assert_eq!(lobby.max_players, 4);
assert_eq!(lobby.members.len(), 2);
assert_eq!(lobby.members[0].pseudo, "Ada");
assert_eq!(lobby.members[0].payload, b"udp://10.0.0.1:7777");
assert!(lobby.members[1].payload.is_empty());
}
#[test]
fn a_null_join_code_reads_as_no_code() {
let lobby = parse_lobby(
r#"{"lobby_id":"lobby-1","join_code":null,"host_user_id":"user-host",
"max_players":2,"members":[]}"#,
);
assert_eq!(lobby.join_code, None);
assert!(lobby.host_payload.is_empty());
}
#[test]
fn a_payload_that_is_not_base64_fails_the_lobby_rather_than_reading_as_empty() {
let wire: WireLobby = serde_json::from_str(
r#"{"lobby_id":"lobby-1","host_user_id":"u","host_payload":"not base64!!","members":[]}"#,
)
.expect("wire lobby");
let err = map_lobby(wire).expect_err("bad base64");
assert_eq!(err.code(), "arcane_unavailable");
assert!(err
.context()
.iter()
.any(|(k, v)| k == "field" && v == "host_payload"));
}
fn parse_events(raw: &str) -> Vec<LobbyEvent> {
parse_incoming(raw)
.into_iter()
.map(|incoming| incoming.event)
.collect()
}
fn parse_incoming(raw: &str) -> Vec<Incoming> {
let wire: WireEvents = serde_json::from_str(raw).expect("wire events");
wire.events.into_iter().filter_map(map_event).collect()
}
fn queued(events: Vec<LobbyEvent>) -> Vec<Incoming> {
events
.into_iter()
.map(|event| Incoming { id: None, event })
.collect()
}
#[test]
fn every_event_type_maps_and_unknown_ones_are_skipped() {
let events = parse_events(
r#"{"events":[
{"id":"1","type":"invite","lobby_id":"lobby-1","join_code":"K7P3QX",
"from_user_id":"user-a","pseudo":"Ada"},
{"id":"2","type":"member_joined","lobby_id":"lobby-1","user_id":"user-b",
"pseudo":"Bo","payload":"dWRwOi8vMTAuMC4wLjI6Nzc3Nw=="},
{"id":"3","type":"member_left","lobby_id":"lobby-1","user_id":"user-b"},
{"id":"4","type":"lobby_closed","lobby_id":"lobby-1"},
{"id":"5","type":"lobby_renamed","lobby_id":"lobby-1"},
{"id":"6","type":"invite","lobby_id":""}
],"cursor":"c-2"}"#,
);
assert_eq!(events.len(), 4, "{events:?}");
assert_eq!(
events[0],
LobbyEvent::Invite {
lobby_id: "lobby-1".into(),
join_code: Some("K7P3QX".into()),
from_user_id: "user-a".into(),
pseudo: "Ada".into(),
}
);
assert_eq!(
events[1],
LobbyEvent::MemberJoined {
lobby_id: "lobby-1".into(),
user_id: "user-b".into(),
pseudo: "Bo".into(),
payload: b"udp://10.0.0.2:7777".to_vec(),
}
);
assert_eq!(events[2].lobby_id(), Some("lobby-1"));
assert_eq!(
events[3],
LobbyEvent::LobbyClosed {
lobby_id: "lobby-1".into()
}
);
}
#[test]
fn an_event_payload_that_is_not_base64_arrives_empty() {
let events = parse_events(
r#"{"events":[{"type":"member_joined","lobby_id":"lobby-1","user_id":"user-b",
"pseudo":"Bo","payload":"not base64!!"}]}"#,
);
assert_eq!(
events[0],
LobbyEvent::MemberJoined {
lobby_id: "lobby-1".into(),
user_id: "user-b".into(),
pseudo: "Bo".into(),
payload: Vec::new(),
}
);
}
#[test]
fn the_events_path_carries_the_cursor_only_once_there_is_one() {
assert_eq!(
events_path("7c9e6f21-4b58-4a3d-8e10-5d2f9b0c1a34", None),
"/v1/games/7c9e6f21-4b58-4a3d-8e10-5d2f9b0c1a34/lobbies/events"
);
assert_eq!(
events_path("7c9e6f21-4b58-4a3d-8e10-5d2f9b0c1a34", Some("c-2")),
"/v1/games/7c9e6f21-4b58-4a3d-8e10-5d2f9b0c1a34/lobbies/events?after=c-2"
);
assert_eq!(
events_path("7c9e6f21-4b58-4a3d-8e10-5d2f9b0c1a34", Some("a b&c=1/2")),
"/v1/games/7c9e6f21-4b58-4a3d-8e10-5d2f9b0c1a34/lobbies/events?after=a%20b%26c%3D1%2F2"
);
}
fn state() -> P2pState {
P2pState::new()
}
#[test]
fn polling_is_off_until_the_accessor_is_built() {
let state = state();
assert_eq!(state.polling(), LobbyPollingState::Off);
assert!(!state.armed());
P2p::new("7c9e6f21-4b58-4a3d-8e10-5d2f9b0c1a34", &state);
assert_eq!(state.polling(), LobbyPollingState::Active);
assert!(state.armed());
}
#[test]
fn an_unavailable_desktop_retires_polling_for_good() {
let state = state();
P2p::new("7c9e6f21-4b58-4a3d-8e10-5d2f9b0c1a34", &state);
state.retire();
assert!(!state.armed());
assert_eq!(state.polling(), LobbyPollingState::Unavailable);
P2p::new("7c9e6f21-4b58-4a3d-8e10-5d2f9b0c1a34", &state);
assert!(!state.armed(), "a later p2p() call must not re-arm polling");
assert_eq!(state.polling(), LobbyPollingState::Unavailable);
}
#[test]
fn the_poll_period_drops_to_five_seconds_inside_a_lobby() {
let state = state();
let tick = Duration::from_secs(60);
assert_eq!(state.poll_period(tick), tick);
state.enter("lobby-1");
assert_eq!(state.poll_period(tick), IN_LOBBY_POLL);
assert_eq!(
state.poll_period(Duration::from_millis(50)),
Duration::from_millis(50),
"the poll never runs slower than the session tick"
);
state.exit("lobby-1");
assert_eq!(state.poll_period(tick), tick);
}
#[test]
fn a_closed_lobby_event_clears_the_in_lobby_state() {
let state = state();
state.enter("lobby-1");
state.enter("lobby-2");
state.ingest(
queued(vec![LobbyEvent::LobbyClosed {
lobby_id: "lobby-1".into(),
}]),
Some("c-2".into()),
);
assert_eq!(state.poll_period(Duration::from_secs(60)), IN_LOBBY_POLL);
state.exit("lobby-2");
assert_eq!(
state.poll_period(Duration::from_secs(60)),
Duration::from_secs(60)
);
assert_eq!(state.lock().cursor.as_deref(), Some("c-2"));
}
#[test]
fn an_empty_cursor_does_not_replace_the_one_we_have() {
let state = state();
state.ingest(Vec::new(), Some("c-1".into()));
state.ingest(Vec::new(), None);
state.ingest(Vec::new(), Some(String::new()));
assert_eq!(state.lock().cursor.as_deref(), Some("c-1"));
}
#[test]
fn events_are_drained_once_and_in_order() {
let state = state();
state.ingest(
queued(vec![
LobbyEvent::MemberLeft {
lobby_id: "lobby-1".into(),
user_id: "user-b".into(),
},
LobbyEvent::LobbyClosed {
lobby_id: "lobby-1".into(),
},
]),
None,
);
let first = state.take_events();
assert_eq!(first.len(), 2);
assert_eq!(first[0].lobby_id(), Some("lobby-1"));
assert!(matches!(first[1], LobbyEvent::LobbyClosed { .. }));
assert!(state.take_events().is_empty());
}
#[test]
fn the_queue_is_bounded_and_drops_the_oldest_events() {
let state = state();
for index in 0..MAX_QUEUED_EVENTS + 10 {
state.ingest(
queued(vec![LobbyEvent::MemberLeft {
lobby_id: format!("lobby-{index}"),
user_id: "user-b".into(),
}]),
None,
);
}
let drained = state.take_events();
assert_eq!(drained.len(), MAX_QUEUED_EVENTS);
assert_eq!(drained[0].lobby_id(), Some("lobby-10"));
}
#[test]
fn rendering_the_queue_does_not_drain_it_and_discard_takes_exactly_what_was_rendered() {
let state = state();
state.ingest(
queued(vec![LobbyEvent::MemberLeft {
lobby_id: "lobby-1".into(),
user_id: "user-b".into(),
}]),
None,
);
let (rendered, through) = state.events_json();
assert_eq!(through, Some(0));
assert_eq!(
rendered,
r#"{"events":[{"type":"member_left","lobby_id":"lobby-1","user_id":"user-b"}]}"#
);
state.ingest(
queued(vec![LobbyEvent::LobbyClosed {
lobby_id: "lobby-1".into(),
}]),
None,
);
state.discard(through.expect("a rendered event"));
let left = state.take_events();
assert_eq!(left.len(), 1, "an event queued after the render survives");
assert!(matches!(left[0], LobbyEvent::LobbyClosed { .. }));
}
#[test]
fn discarding_drops_what_was_rendered_even_when_the_queue_evicted_in_between() {
let state = state();
state.ingest(
queued(vec![LobbyEvent::MemberLeft {
lobby_id: "rendered".into(),
user_id: "user-b".into(),
}]),
None,
);
let (_, through) = state.events_json();
for index in 0..MAX_QUEUED_EVENTS {
state.ingest(
queued(vec![LobbyEvent::MemberLeft {
lobby_id: format!("later-{index}"),
user_id: "user-b".into(),
}]),
None,
);
}
state.discard(through.expect("a rendered event"));
let left = state.take_events();
assert_eq!(
left.len(),
MAX_QUEUED_EVENTS,
"discard drops the events it rendered, never the ones that replaced them"
);
assert!(left
.iter()
.all(|event| event.lobby_id() != Some("rendered")));
}
#[test]
fn an_event_arcane_sends_twice_is_delivered_once() {
let state = state();
let repeat = || {
vec![Incoming {
id: Some("event-1".into()),
event: LobbyEvent::MemberLeft {
lobby_id: "lobby-1".into(),
user_id: "user-b".into(),
},
}]
};
state.ingest(repeat(), Some("c-1".into()));
state.ingest(repeat(), Some("c-1".into()));
state.ingest(repeat(), None);
assert_eq!(
state.take_events().len(),
1,
"a replayed id is dropped, whatever the cursor did"
);
}
#[test]
fn an_event_without_an_id_is_still_delivered() {
let state = state();
state.ingest(
queued(vec![LobbyEvent::LobbyClosed {
lobby_id: "lobby-1".into(),
}]),
None,
);
state.ingest(
queued(vec![LobbyEvent::LobbyClosed {
lobby_id: "lobby-1".into(),
}]),
None,
);
assert_eq!(state.take_events().len(), 2);
}
#[test]
fn the_lobby_json_keeps_the_documented_field_order() {
let rendered = to_json(&parse_lobby(LOBBY));
assert_eq!(
rendered,
r#"{"lobby_id":"lobby-1","join_code":"K7P3QX","host_user_id":"user-host","host_payload":"dWRwOi8vMTAuMC4wLjE6Nzc3Nw==","members":[{"user_id":"user-host","pseudo":"Ada","payload":"dWRwOi8vMTAuMC4wLjE6Nzc3Nw=="},{"user_id":"user-b","pseudo":"Bo","payload":""}],"max_players":4,"metadata":{}}"#
);
}
#[test]
fn every_event_renders_with_its_type_first() {
let rendered = render_events(
[
LobbyEvent::Invite {
lobby_id: "lobby-1".into(),
join_code: None,
from_user_id: "user-a".into(),
pseudo: "Ada".into(),
},
LobbyEvent::MemberJoined {
lobby_id: "lobby-1".into(),
user_id: "user-b".into(),
pseudo: "Bo".into(),
payload: b"hi".to_vec(),
},
]
.iter(),
);
let parsed: serde_json::Value = serde_json::from_str(&rendered).expect("json");
assert_eq!(parsed["events"][0]["type"], "invite");
assert_eq!(parsed["events"][0]["join_code"], serde_json::Value::Null);
assert_eq!(parsed["events"][1]["type"], "member_joined");
assert_eq!(parsed["events"][1]["payload"], "aGk=");
assert!(rendered.starts_with(r#"{"events":[{"type":"invite","lobby_id":"lobby-1""#));
}
#[test]
fn an_empty_queue_still_renders_a_valid_document() {
let (rendered, through) = state().events_json();
assert_eq!(rendered, r#"{"events":[]}"#);
assert_eq!(through, None);
}
#[test]
fn a_dropped_answer_becomes_a_resync_event() {
let wire: WireEvents = serde_json::from_str(
r#"{"events":[{"id":"1","type":"lobby_closed","lobby_id":"lobby-1"}],
"cursor":"c-2","dropped":true}"#,
)
.expect("wire events");
assert!(wire.dropped);
assert_eq!(
render_events([LobbyEvent::Resync].iter()),
r#"{"events":[{"type":"resync"}]}"#
);
assert_eq!(LobbyEvent::Resync.lobby_id(), None);
}
#[test]
fn an_inbound_payload_larger_than_the_limit_is_refused() {
let oversized = BASE64.encode(vec![7u8; MAX_LOBBY_PAYLOAD_LEN + 1]);
let err = decode_payload(Some(&oversized), "host_payload").expect_err("too long");
assert_eq!(err.code(), "arcane_unavailable");
assert!(err
.context()
.iter()
.any(|(k, v)| k == "field" && v == "host_payload"));
assert!(
decode_payload(Some(&BASE64.encode(vec![7u8; MAX_LOBBY_PAYLOAD_LEN])), "p").is_ok()
);
assert!(decode_payload_arg(&oversized).is_none());
}
#[test]
fn an_oversized_payload_fails_a_lobby_and_empties_an_event() {
let oversized = BASE64.encode(vec![7u8; MAX_LOBBY_PAYLOAD_LEN + 1]);
let wire: WireLobby = serde_json::from_str(&format!(
r#"{{"lobby_id":"lobby-1","host_user_id":"u","host_payload":"{oversized}",
"members":[]}}"#
))
.expect("wire lobby");
assert_eq!(
map_lobby(wire).expect_err("oversized").code(),
"arcane_unavailable"
);
let events = parse_events(&format!(
r#"{{"events":[{{"type":"member_joined","lobby_id":"lobby-1","user_id":"user-b",
"pseudo":"Bo","payload":"{oversized}"}}]}}"#
));
assert_eq!(
events[0],
LobbyEvent::MemberJoined {
lobby_id: "lobby-1".into(),
user_id: "user-b".into(),
pseudo: "Bo".into(),
payload: Vec::new(),
}
);
}
#[test]
fn a_lobby_without_an_id_is_not_a_lobby() {
let wire: WireLobby = serde_json::from_str(r#"{}"#).expect("wire lobby");
let err = map_lobby(wire).expect_err("no lobby_id");
assert_eq!(err.code(), "arcane_unavailable");
assert!(err
.context()
.iter()
.any(|(k, v)| k == "field" && v == "lobby_id"));
}
#[test]
fn metadata_is_checked_before_any_call() {
let ok = metadata_arg([("mode", "coop"), ("map_2", "harbor")].into_iter()).expect("valid");
assert_eq!(ok.get("mode").map(String::as_str), Some("coop"));
for key in [
"",
"Mode",
"game-mode",
"a b",
&"k".repeat(MAX_LOBBY_METADATA_KEY_LEN + 1),
] {
let err = metadata_arg([(key, "v")].into_iter()).expect_err(key);
assert_eq!(err.code(), "invalid_argument");
}
let long = "é".repeat(MAX_LOBBY_METADATA_VALUE_LEN + 1);
assert_eq!(
metadata_arg([("mode", long.as_str())].into_iter())
.expect_err("too long")
.code(),
"invalid_argument"
);
let fits = "é".repeat(MAX_LOBBY_METADATA_VALUE_LEN);
assert!(metadata_arg([("mode", fits.as_str())].into_iter()).is_ok());
let keys: Vec<String> = (0..=MAX_LOBBY_METADATA_PAIRS)
.map(|i| format!("k{i}"))
.collect();
let pairs = keys.iter().map(|k| (k.as_str(), "v"));
assert_eq!(
metadata_arg(pairs).expect_err("too many").code(),
"invalid_argument"
);
}
#[test]
fn a_search_path_carries_every_filter_encoded() {
let query = LobbyQuery {
filters: vec![
("mode".into(), "co op".into()),
("map".into(), "a&b".into()),
],
has_free_slot: false,
limit: 5,
};
let filters = metadata_arg(query.filters.iter().map(|(k, v)| (k.as_str(), v.as_str())))
.expect("filters");
assert_eq!(
search_path("game-1", &query, &filters),
format!(
"{GAMES_PATH_PREFIX}/game-1/lobbies/search?has_free_slot=false&limit=5&meta.map=a%26b&meta.mode=co%20op"
)
);
}
#[test]
fn a_lobby_carries_its_metadata_and_defaults_to_none() {
let lobby = parse_lobby(LOBBY);
assert!(lobby.metadata.is_empty());
let lobby = parse_lobby(
r#"{"lobby_id":"lobby-1","host_user_id":"u","visibility":"public",
"max_players":4,"members":[],"metadata":{"mode":"coop"}}"#,
);
assert_eq!(lobby.metadata.get("mode").map(String::as_str), Some("coop"));
}
#[test]
fn search_results_map_and_render_back_to_json() {
let wire: WireSearch = serde_json::from_str(
r#"{"lobbies":[
{"lobby_id":"lobby-1","host_user_id":"u1","host_pseudo":"Ada","members":1,
"max_players":4,"metadata":{"mode":"coop"},"host_is_friend":true},
{"host_user_id":"u2"}
]}"#,
)
.expect("wire search");
let lobbies: Vec<LobbySummary> = wire.lobbies.into_iter().filter_map(map_summary).collect();
assert_eq!(lobbies.len(), 1);
assert_eq!(lobbies[0].host_pseudo, "Ada");
assert!(lobbies[0].host_is_friend);
let rendered: serde_json::Value =
serde_json::from_str(&summaries_to_json(&lobbies)).expect("json");
assert_eq!(rendered["lobbies"][0]["lobby_id"], "lobby-1");
assert_eq!(rendered["lobbies"][0]["metadata"]["mode"], "coop");
assert_eq!(rendered["lobbies"][0]["members"], 1);
}
#[test]
fn a_lobby_updated_event_carries_the_new_metadata() {
let events = parse_events(
r#"{"events":[{"type":"lobby_updated","lobby_id":"lobby-1","metadata":{"map":"docks"}}]}"#,
);
let mut metadata = BTreeMap::new();
metadata.insert("map".to_string(), "docks".to_string());
assert_eq!(
events,
vec![LobbyEvent::LobbyUpdated {
lobby_id: "lobby-1".into(),
metadata
}]
);
let rendered: serde_json::Value =
serde_json::from_str(&render_events(events.iter())).expect("json");
assert_eq!(rendered["events"][0]["type"], "lobby_updated");
assert_eq!(rendered["events"][0]["metadata"]["map"], "docks");
}
}