Files
call-recorder/crates/core/src/backend.rs
T
haukeandClaude Opus 5.5 3358de7888 fix #14740: fixed backend url per build, key bound to its server
- the backend URL is no longer a setting: one constant per build
  (release/dev) in src-tauri/src/backend.rs; Settings shows the server
  read-only; an old backend_url in settings.json is ignored
- the stored key records the backend it was created for; a key of
  another backend is discarded before any use and never stored
- a refused key is discarded only if it still is the stored one
- the keyring is never called while the settings are locked
- one upload per call at a time, also visible after a view switch
- opener plugin without its link-click script (it also ran in the
  remote login page); a login error says to reload the login page

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-06 15:18:05 +01:00

964 lines
33 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! The euvino admin backend: an admin's API key, minted with their browser
//! session, and the upload of call transcripts to the CRM with that key.
//!
//! The key goes only into the `X-Admin-Api-Key` header of `/admin/api/…`
//! requests, the session cookie only into the one request that creates the
//! key. Neither is ever logged or part of an error message.
use std::fmt;
use std::sync::Arc;
use async_trait::async_trait;
use chrono::{DateTime, Duration, Local};
use reqwest::Url;
use serde::Deserialize;
use serde_json::{json, Value};
use crate::http::{HttpBody, HttpRequest, HttpResponse, HttpTransport, Method};
/// The admin login page, relative to the backend URL.
const LOGIN_PATH: &str = "/euvadm";
const KEY_HEADER: &str = "X-Admin-Api-Key";
/// Longest key label the backend accepts, in characters.
const MAX_LABEL_CHARS: usize = 100;
/// The label of a key this app creates: "Gesprächsrekorder (<hostname>)",
/// at most 100 characters.
pub fn key_label(hostname: Option<&str>) -> String {
let app = "Gesprächsrekorder";
let label = match hostname.map(str::trim).filter(|host| !host.is_empty()) {
Some(host) => format!("{app} ({host})"),
None => app.to_string(),
};
label.chars().take(MAX_LABEL_CHARS).collect()
}
/// A key the backend just created. The key is shown only in this response.
#[derive(Clone, PartialEq)]
pub struct NewKey {
pub key: String,
pub expires_at: DateTime<Local>,
}
impl fmt::Debug for NewKey {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("NewKey")
.field("key", &"<redacted>")
.field("expires_at", &self.expires_at)
.finish()
}
}
/// What the backend knows about a key (`GET /admin/api/key`).
#[derive(Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct KeyInfo {
pub label: String,
/// The key's last characters, safe to show.
pub hint: String,
pub username: String,
pub created_at: DateTime<Local>,
pub expires_at: DateTime<Local>,
}
/// Why a backend request failed.
#[derive(Debug, Clone, PartialEq)]
pub enum BackendError {
/// Creating a key: the session is not (yet) logged in (redirect to the
/// login page, or 401).
NotLoggedIn,
/// Creating a key: the session cannot create one (not an admin, or an
/// impersonation).
Forbidden,
/// The key is unknown, expired or deleted, or its admin was disabled.
InvalidKey,
/// The backend cannot check the key right now (503).
Unavailable,
/// The backend refused the transcript (400/422), with its reason.
Rejected(String),
/// Any other status, with the backend's `error` message if it sent one.
Http(u16, String),
/// The backend could not be reached.
Transport(String),
}
impl BackendError {
/// The German message shown to the user.
pub fn user_message(&self) -> String {
match self {
BackendError::NotLoggedIn => "Nicht beim Backend angemeldet".to_string(),
BackendError::Forbidden => "Diese Anmeldung kann keinen Schlüssel erzeugen (z. B. bei \
Impersonation) – bitte als Admin selbst anmelden."
.to_string(),
BackendError::InvalidKey => {
"Backend-Schlüssel ungültig oder abgelaufen – bitte neu anmelden.".to_string()
}
BackendError::Unavailable => "Backend kann die Anmeldung gerade nicht prüfen – bitte \
später erneut versuchen."
.to_string(),
BackendError::Rejected(reason) => {
format!("Backend hat das Transkript abgelehnt: {reason}")
}
BackendError::Http(status, msg) if msg.is_empty() => {
format!("Backend-Fehler (HTTP {status})")
}
BackendError::Http(status, msg) => format!("Backend-Fehler (HTTP {status}): {msg}"),
BackendError::Transport(msg) => format!("Backend nicht erreichbar: {msg}"),
}
}
}
/// Client of the admin backend at one base URL.
#[derive(Clone)]
pub struct BackendClient {
transport: Arc<dyn HttpTransport>,
base_url: String,
}
impl BackendClient {
/// `base_url` is the backend's https origin (plus path prefix, if
/// any); a trailing slash is ignored.
pub fn new(transport: Arc<dyn HttpTransport>, base_url: &str) -> Self {
Self {
transport,
base_url: base_url.trim_end_matches('/').to_string(),
}
}
/// The backend this client talks to, without trailing slash. A key it
/// creates belongs to this backend only.
pub fn base_url(&self) -> &str {
&self.base_url
}
/// The admin login page the login window opens.
pub fn login_url(&self) -> String {
format!("{}{LOGIN_PATH}", self.base_url)
}
/// Where admins see and delete their keys (in the browser).
pub fn keys_page_url(&self) -> String {
format!("{}/admin/api-keys", self.base_url)
}
/// Whether `url`, a page the login window loaded, shows that the admin
/// is logged in: a page of the backend other than the login page.
pub fn is_logged_in_page(&self, url: &str) -> bool {
let (Ok(page), Ok(base)) = (Url::parse(url), Url::parse(&self.base_url)) else {
return false;
};
if page.origin() != base.origin() {
return false;
}
let login = format!("{}{LOGIN_PATH}", base.path().trim_end_matches('/'));
page.path() != login && !page.path().starts_with(&format!("{login}/"))
}
/// Creates a key with the admin's browser session (`cookie_header`, the
/// session's cookies as a `Cookie` header value). Redirects are not
/// followed: one to the login page means not logged in.
pub async fn create_key(
&self,
cookie_header: &str,
label: &str,
) -> Result<NewKey, BackendError> {
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Created {
key: String,
expires_at: DateTime<Local>,
}
let resp = self
.send(
Method::Post,
self.keys_page_url(),
("Cookie", cookie_header),
json!({ "label": label }),
)
.await?;
match resp.status {
200..=299 => match resp.json::<Created>() {
Ok(created) if !created.key.is_empty() => Ok(NewKey {
key: created.key,
expires_at: created.expires_at,
}),
_ => Err(unexpected(&resp)),
},
300..=399 | 401 => Err(BackendError::NotLoggedIn),
403 => Err(BackendError::Forbidden),
_ => Err(http_error(&resp)),
}
}
/// Checks `key` and returns what the backend knows about it.
pub async fn key_info(&self, key: &str) -> Result<KeyInfo, BackendError> {
let url = format!("{}/admin/api/key", self.base_url);
let resp = self
.send(Method::Get, url, (KEY_HEADER, key), Value::Null)
.await?;
match resp.status {
200..=299 => resp.json().map_err(|_| unexpected(&resp)),
_ => Err(api_error(&resp)),
}
}
/// Uploads a transcript; returns the id the CRM gave it.
pub async fn upload_transcript(&self, key: &str, text: &str) -> Result<String, BackendError> {
let url = format!("{}/admin/api/phone-transcripts", self.base_url);
let resp = self
.send(
Method::Post,
url,
(KEY_HEADER, key),
json!({ "text": text }),
)
.await?;
match resp.status {
200..=299 => match resp.json::<Value>().ok().and_then(|v| v.get("id").cloned()) {
Some(Value::Number(id)) => Ok(id.to_string()),
Some(Value::String(id)) if !id.is_empty() => Ok(id),
_ => Err(unexpected(&resp)),
},
400 | 422 => Err(BackendError::Rejected(rejection_reason(&resp))),
_ => Err(api_error(&resp)),
}
}
/// Sends a request with one credential header (`auth`) and a JSON body
/// (none for `Value::Null`). Redirects are never followed, so neither
/// the key nor the cookie can be forwarded to another host.
async fn send(
&self,
method: Method,
url: String,
auth: (&str, &str),
body: Value,
) -> Result<HttpResponse, BackendError> {
let req = HttpRequest {
method,
url,
headers: vec![
(auth.0.to_string(), auth.1.to_string()),
("Accept".to_string(), "application/json".to_string()),
],
body: match body {
Value::Null => HttpBody::Empty,
body => HttpBody::Json(body),
},
follow_redirects: false,
};
self.transport
.send(req)
.await
.map_err(|e| BackendError::Transport(e.to_string()))
}
}
/// What a page load in the login window leads to, given the result of
/// trying to create a key there.
#[derive(Debug, Clone, PartialEq)]
pub enum LoginStep {
/// The key: store it, close the window.
Done(NewKey),
/// Not logged in yet: keep waiting for the admin.
Wait,
/// The session can never create a key: close the window and fail with
/// this message.
Fail(String),
/// Something else went wrong: show this message and keep the window
/// open, so the admin can try again.
Retry(String),
}
impl LoginStep {
pub fn of(result: Result<NewKey, BackendError>) -> Self {
match result {
Ok(key) => LoginStep::Done(key),
Err(BackendError::NotLoggedIn) => LoginStep::Wait,
Err(e @ BackendError::Forbidden) => LoginStep::Fail(e.user_message()),
Err(e) => LoginStep::Retry(e.user_message()),
}
}
}
/// How a stored key fared when checked with the backend.
#[derive(Debug, Clone, PartialEq)]
pub enum KeyCheck {
Valid(KeyInfo),
/// Refused by the backend: forget it.
Invalid,
/// Not checkable right now (unreachable, 503, other error).
Unknown(BackendError),
}
impl BackendClient {
/// Checks a stored key ([`BackendClient::key_info`]).
pub async fn check_key(&self, key: &str) -> KeyCheck {
match self.key_info(key).await {
Ok(info) => KeyCheck::Valid(info),
Err(BackendError::InvalidKey) => KeyCheck::Invalid,
Err(e) => KeyCheck::Unknown(e),
}
}
}
/// A key from the keyring and the expiry stored with it.
#[derive(Clone, PartialEq)]
pub struct StoredKey {
pub key: String,
pub expires_at: Option<DateTime<Local>>,
}
impl fmt::Debug for StoredKey {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("StoredKey")
.field("key", &"<redacted>")
.field("expires_at", &self.expires_at)
.finish()
}
}
/// Whether `stored` is missing or expires within a minute of `now`, so a
/// login has to come first.
pub fn needs_login(stored: Option<&StoredKey>, now: DateTime<Local>) -> bool {
match stored {
None => true,
Some(stored) => stored
.expires_at
.is_some_and(|expires_at| expires_at <= now + Duration::minutes(1)),
}
}
/// The app's side of a login, for [`upload_with_login`].
#[async_trait]
pub trait Login: Send + Sync {
/// Runs the login flow; returns the new (already stored) key, or the
/// message why there is none.
async fn login(&self) -> Result<String, String>;
/// Forgets the stored key if it still is `refused`, the key the backend
/// just refused (a login meanwhile may have stored a new one).
async fn discard_key(&self, refused: &str);
}
/// Uploads `text` with the stored key, logging in first when there is no
/// usable key. A key the backend refuses is discarded, and after a new
/// login the upload is tried once more. Returns the CRM's id, or the
/// message to show.
pub async fn upload_with_login(
client: &BackendClient,
login: &dyn Login,
stored: Option<StoredKey>,
now: DateTime<Local>,
text: &str,
) -> Result<String, String> {
let key = match stored.filter(|stored| !needs_login(Some(stored), now)) {
Some(stored) => stored.key,
None => login.login().await?,
};
match client.upload_transcript(&key, text).await {
Err(BackendError::InvalidKey) => {
login.discard_key(&key).await;
let key = login.login().await?;
let result = client.upload_transcript(&key, text).await;
if result == Err(BackendError::InvalidKey) {
login.discard_key(&key).await;
}
result.map_err(|e| e.user_message())
}
result => result.map_err(|e| e.user_message()),
}
}
/// A 2xx answer whose body is not what the contract says.
fn unexpected(resp: &HttpResponse) -> BackendError {
BackendError::Http(resp.status, "unerwartete Antwort".to_string())
}
/// The error of an `/admin/api/…` request: refused key, backend unable to
/// check it, or any other status.
fn api_error(resp: &HttpResponse) -> BackendError {
match resp.status {
401 => BackendError::InvalidKey,
503 => BackendError::Unavailable,
_ => http_error(resp),
}
}
/// An unexpected status with the backend's `error` message, if any. Other
/// bodies (e.g. an HTML error page) are not passed on.
fn http_error(resp: &HttpResponse) -> BackendError {
let message = resp
.json::<Value>()
.ok()
.and_then(|body| body.get("error")?.as_str().map(str::to_string))
.unwrap_or_default();
BackendError::Http(resp.status, message)
}
/// Why the backend refused a transcript: its `errors`, else its `error`.
fn rejection_reason(resp: &HttpResponse) -> String {
let Ok(body) = resp.json::<Value>() else {
return String::new();
};
let errors: Vec<String> = body
.get("errors")
.and_then(Value::as_array)
.into_iter()
.flatten()
.map(|error| match error {
Value::String(text) => text.clone(),
other => other.to_string(),
})
.collect();
if errors.is_empty() {
body.get("error")
.and_then(Value::as_str)
.unwrap_or_default()
.to_string()
} else {
errors.join("; ")
}
}
#[cfg(test)]
mod tests {
use std::sync::Mutex;
use chrono::TimeZone;
use super::*;
use crate::http::TransportError;
use crate::testing::FakeTransport;
const BASE: &str = "https://backend.example";
const KEYS: &str = "https://backend.example/admin/api-keys";
const KEY_INFO: &str = "https://backend.example/admin/api/key";
const UPLOAD: &str = "https://backend.example/admin/api/phone-transcripts";
fn client() -> (Arc<FakeTransport>, BackendClient) {
let transport = Arc::new(FakeTransport::new());
let client = BackendClient::new(transport.clone(), BASE);
(transport, client)
}
fn at(y: i32, mo: u32, d: u32, h: u32, mi: u32) -> DateTime<Local> {
Local.with_ymd_and_hms(y, mo, d, h, mi, 0).unwrap()
}
fn json_body(req: &HttpRequest) -> Value {
match &req.body {
HttpBody::Json(value) => value.clone(),
other => panic!("expected a JSON body, got {other:?}"),
}
}
#[test]
fn the_key_label_names_the_computer_within_100_chars() {
assert_eq!(
key_label(Some("PC-VERTRIEB-3")),
"Gesprächsrekorder (PC-VERTRIEB-3)"
);
assert_eq!(key_label(Some(" ")), "Gesprächsrekorder");
assert_eq!(key_label(None), "Gesprächsrekorder");
let long = key_label(Some(&"x".repeat(200)));
assert_eq!(long.chars().count(), 100);
assert!(long.starts_with("Gesprächsrekorder (xxx"));
}
#[test]
fn login_and_keys_pages_are_under_the_base_url() {
let (_, client) = client();
assert_eq!(client.login_url(), "https://backend.example/euvadm");
assert_eq!(client.keys_page_url(), KEYS);
assert_eq!(client.base_url(), BASE);
let slash = BackendClient::new(Arc::new(FakeTransport::new()), "https://backend.example/");
assert_eq!(slash.login_url(), "https://backend.example/euvadm");
assert_eq!(slash.base_url(), BASE);
}
#[test]
fn a_backend_page_other_than_the_login_page_means_logged_in() {
let (_, client) = client();
assert!(client.is_logged_in_page("https://backend.example/admin"));
assert!(client.is_logged_in_page("https://backend.example/admin/dashboard?x=1"));
assert!(client.is_logged_in_page("https://backend.example/"));
assert!(!client.is_logged_in_page("https://backend.example/euvadm"));
assert!(!client.is_logged_in_page("https://backend.example/euvadm/login_check"));
assert!(!client.is_logged_in_page("https://other.example/admin"));
assert!(!client.is_logged_in_page("http://backend.example/admin"));
assert!(!client.is_logged_in_page("https://backend.example:8443/admin"));
assert!(!client.is_logged_in_page("about:blank"));
assert!(!client.is_logged_in_page("not a url"));
}
#[tokio::test]
async fn create_key_sends_the_session_cookie_and_label_without_following_redirects() {
let (transport, client) = client();
transport.expect(
Method::Post,
KEYS,
201,
r#"{"key":"euv_secret","expiresAt":"2027-11-06T10:00:00+01:00","label":"Gesprächsrekorder (PC)"}"#,
);
let key = client
.create_key("PHPSESSID=abc; other=1", "Gesprächsrekorder (PC)")
.await
.unwrap();
assert_eq!(key.key, "euv_secret");
assert_eq!(
key.expires_at,
DateTime::parse_from_rfc3339("2027-11-06T10:00:00+01:00").unwrap()
);
let req = &transport.requests()[0];
assert_eq!(req.header("Cookie"), Some("PHPSESSID=abc; other=1"));
assert_eq!(req.header(KEY_HEADER), None);
assert!(!req.follow_redirects);
assert_eq!(json_body(req), json!({"label": "Gesprächsrekorder (PC)"}));
assert!(!format!("{key:?}").contains("euv_secret"));
transport.assert_done();
}
#[tokio::test]
async fn create_key_maps_redirects_and_refusals() {
for (status, body, expected) in [
(302, "", BackendError::NotLoggedIn),
(401, "", BackendError::NotLoggedIn),
(
403,
r#"{"error":"admin session required"}"#,
BackendError::Forbidden,
),
(
500,
"<html>boom</html>",
BackendError::Http(500, String::new()),
),
(
400,
r#"{"error":"label too long"}"#,
BackendError::Http(400, "label too long".into()),
),
(
201,
r#"{"key":"euv_x"}"#,
BackendError::Http(201, "unerwartete Antwort".into()),
),
] {
let (transport, client) = client();
transport.expect(Method::Post, KEYS, status, body);
assert_eq!(
client.create_key("s=1", "l").await,
Err(expected),
"{status}"
);
}
}
#[tokio::test]
async fn key_info_sends_the_key_and_parses_the_answer() {
let (transport, client) = client();
transport.expect(
Method::Get,
KEY_INFO,
200,
r#"{"label":"Gesprächsrekorder (PC)","hint":"…x9f2","username":"hinrichs","createdAt":"2026-11-06T10:00:00+01:00","expiresAt":"2027-11-06T10:00:00+01:00"}"#,
);
let info = client.key_info("euv_secret").await.unwrap();
assert_eq!(info.username, "hinrichs");
assert_eq!(info.hint, "…x9f2");
assert_eq!(info.expires_at, at(2027, 11, 6, 10, 0));
let req = &transport.requests()[0];
assert_eq!(req.header(KEY_HEADER), Some("euv_secret"));
assert_eq!(req.header("Cookie"), None);
assert!(!req.follow_redirects);
transport.assert_done();
}
#[tokio::test]
async fn key_info_maps_refused_and_unavailable() {
for (status, body, expected) in [
(
401,
r#"{"error":"invalid api key"}"#,
BackendError::InvalidKey,
),
(
401,
r#"{"error":"api key required"}"#,
BackendError::InvalidKey,
),
(
503,
r#"{"error":"admin status unavailable"}"#,
BackendError::Unavailable,
),
] {
let (transport, client) = client();
transport.expect(Method::Get, KEY_INFO, status, body);
assert_eq!(client.key_info("euv_k").await, Err(expected), "{status}");
}
let (transport, client) = client();
transport.fail(Method::Get, KEY_INFO, TransportError::Timeout);
assert_eq!(
client.key_info("euv_k").await,
Err(BackendError::Transport("Zeitüberschreitung".into()))
);
}
#[tokio::test]
async fn upload_posts_the_text_with_the_key_and_returns_the_id() {
for (body, id) in [
(r#"{"id":4711}"#, "4711"),
(r#"{"id":"crm-0815"}"#, "crm-0815"),
] {
let (transport, client) = client();
transport.expect(Method::Post, UPLOAD, 201, body);
assert_eq!(
client.upload_transcript("euv_k", "Titel: Test").await,
Ok(id.into())
);
let req = &transport.requests()[0];
assert_eq!(req.header(KEY_HEADER), Some("euv_k"));
assert_eq!(req.header("Cookie"), None);
assert!(!req.follow_redirects);
assert_eq!(json_body(req), json!({"text": "Titel: Test"}));
}
}
#[tokio::test]
async fn upload_maps_rejections_and_auth_errors() {
for (status, body, expected) in [
(
400,
r#"{"error":"text required"}"#,
BackendError::Rejected("text required".into()),
),
(
422,
r#"{"error":"transcript rejected","errors":["Text zu lang","Kein Admin"]}"#,
BackendError::Rejected("Text zu lang; Kein Admin".into()),
),
(
422,
r#"{"error":"transcript rejected","errors":[]}"#,
BackendError::Rejected("transcript rejected".into()),
),
(
422,
r#"{"error":"transcript rejected","errors":[{"field":"text"}]}"#,
BackendError::Rejected(r#"{"field":"text"}"#.into()),
),
(
401,
r#"{"error":"invalid api key"}"#,
BackendError::InvalidKey,
),
(
503,
r#"{"error":"admin status unavailable"}"#,
BackendError::Unavailable,
),
(
201,
r#"{"id":null}"#,
BackendError::Http(201, "unerwartete Antwort".into()),
),
] {
let (transport, client) = client();
transport.expect(Method::Post, UPLOAD, status, body);
assert_eq!(
client.upload_transcript("euv_k", "x").await,
Err(expected),
"{body}"
);
}
}
#[test]
fn errors_have_german_messages_without_secrets() {
assert_eq!(
BackendError::Forbidden.user_message(),
"Diese Anmeldung kann keinen Schlüssel erzeugen (z. B. bei Impersonation) – bitte als Admin selbst anmelden."
);
assert_eq!(
BackendError::Unavailable.user_message(),
"Backend kann die Anmeldung gerade nicht prüfen – bitte später erneut versuchen."
);
assert_eq!(
BackendError::Rejected("text required".into()).user_message(),
"Backend hat das Transkript abgelehnt: text required"
);
assert_eq!(
BackendError::Transport("Zeitüberschreitung".into()).user_message(),
"Backend nicht erreichbar: Zeitüberschreitung"
);
assert_eq!(
BackendError::Http(500, String::new()).user_message(),
"Backend-Fehler (HTTP 500)"
);
assert_eq!(
BackendError::Http(400, "label too long".into()).user_message(),
"Backend-Fehler (HTTP 400): label too long"
);
assert_eq!(
BackendError::InvalidKey.user_message(),
"Backend-Schlüssel ungültig oder abgelaufen – bitte neu anmelden."
);
assert_eq!(
BackendError::NotLoggedIn.user_message(),
"Nicht beim Backend angemeldet"
);
}
#[test]
fn a_login_step_follows_from_the_create_key_result() {
let key = NewKey {
key: "euv_k".into(),
expires_at: at(2027, 1, 1, 0, 0),
};
assert_eq!(LoginStep::of(Ok(key.clone())), LoginStep::Done(key));
assert_eq!(
LoginStep::of(Err(BackendError::NotLoggedIn)),
LoginStep::Wait
);
assert_eq!(
LoginStep::of(Err(BackendError::Forbidden)),
LoginStep::Fail(BackendError::Forbidden.user_message())
);
for err in [
BackendError::Http(500, String::new()),
BackendError::Transport("weg".into()),
] {
assert_eq!(
LoginStep::of(Err(err.clone())),
LoginStep::Retry(err.user_message())
);
}
}
#[tokio::test]
async fn a_checked_key_is_valid_invalid_or_unknown() {
let (transport, client) = client();
transport.expect(
Method::Get,
KEY_INFO,
200,
r#"{"label":"l","hint":"h","username":"u","createdAt":"2026-11-06T10:00:00+01:00","expiresAt":"2027-11-06T10:00:00+01:00"}"#,
);
transport.expect(Method::Get, KEY_INFO, 401, r#"{"error":"invalid api key"}"#);
transport.expect(Method::Get, KEY_INFO, 503, "");
transport.fail(Method::Get, KEY_INFO, TransportError::Network("dns".into()));
assert!(
matches!(client.check_key("k").await, KeyCheck::Valid(info) if info.username == "u")
);
assert_eq!(client.check_key("k").await, KeyCheck::Invalid);
assert_eq!(
client.check_key("k").await,
KeyCheck::Unknown(BackendError::Unavailable)
);
assert_eq!(
client.check_key("k").await,
KeyCheck::Unknown(BackendError::Transport("Netzwerkfehler: dns".into()))
);
}
fn stored(key: &str, expires_at: Option<DateTime<Local>>) -> StoredKey {
StoredKey {
key: key.into(),
expires_at,
}
}
#[test]
fn a_missing_or_expiring_key_needs_a_login() {
let now = at(2026, 11, 6, 12, 0);
assert!(needs_login(None, now));
assert!(needs_login(Some(&stored("k", Some(now))), now));
assert!(needs_login(
Some(&stored("k", Some(now + chrono::Duration::seconds(60)))),
now
));
assert!(!needs_login(
Some(&stored("k", Some(now + chrono::Duration::seconds(61)))),
now
));
assert!(!needs_login(Some(&stored("k", None)), now));
assert!(!format!("{:?}", stored("euv_secret", None)).contains("euv_secret"));
}
/// Scripted [`Login`]: hands out the given results in order and
/// records the discarded keys.
struct FakeLogin {
results: Mutex<Vec<Result<String, String>>>,
logins: Mutex<usize>,
discarded: Mutex<Vec<String>>,
}
impl FakeLogin {
fn new(results: Vec<Result<String, String>>) -> Self {
Self {
results: Mutex::new(results),
logins: Mutex::new(0),
discarded: Mutex::new(Vec::new()),
}
}
fn counts(&self) -> (usize, usize) {
(
*self.logins.lock().unwrap(),
self.discarded.lock().unwrap().len(),
)
}
fn discarded(&self) -> Vec<String> {
self.discarded.lock().unwrap().clone()
}
}
#[async_trait]
impl Login for FakeLogin {
async fn login(&self) -> Result<String, String> {
*self.logins.lock().unwrap() += 1;
self.results.lock().unwrap().remove(0)
}
async fn discard_key(&self, refused: &str) {
self.discarded.lock().unwrap().push(refused.to_string());
}
}
fn now() -> DateTime<Local> {
at(2026, 11, 6, 12, 0)
}
fn valid(key: &str) -> Option<StoredKey> {
Some(stored(key, Some(at(2027, 11, 6, 12, 0))))
}
#[tokio::test]
async fn without_a_key_the_upload_logs_in_first() {
let (transport, client) = client();
transport.expect(Method::Post, UPLOAD, 201, r#"{"id":1}"#);
let login = FakeLogin::new(vec![Ok("euv_new".into())]);
let id = upload_with_login(&client, &login, None, now(), "t").await;
assert_eq!(id, Ok("1".into()));
assert_eq!(login.counts(), (1, 0));
assert_eq!(transport.requests()[0].header(KEY_HEADER), Some("euv_new"));
}
#[tokio::test]
async fn an_expired_key_is_replaced_before_the_upload() {
let (transport, client) = client();
transport.expect(Method::Post, UPLOAD, 201, r#"{"id":2}"#);
let login = FakeLogin::new(vec![Ok("euv_new".into())]);
let expired = Some(stored("euv_old", Some(now() - chrono::Duration::days(1))));
let id = upload_with_login(&client, &login, expired, now(), "t").await;
assert_eq!(id, Ok("2".into()));
assert_eq!(login.counts(), (1, 0));
assert_eq!(transport.requests()[0].header(KEY_HEADER), Some("euv_new"));
}
#[tokio::test]
async fn a_valid_key_uploads_without_a_login() {
let (transport, client) = client();
transport.expect(Method::Post, UPLOAD, 201, r#"{"id":3}"#);
let login = FakeLogin::new(vec![]);
let id = upload_with_login(&client, &login, valid("euv_k"), now(), "t").await;
assert_eq!(id, Ok("3".into()));
assert_eq!(login.counts(), (0, 0));
}
#[tokio::test]
async fn a_refused_key_is_discarded_and_the_upload_retried_once_after_a_login() {
let (transport, client) = client();
transport.expect(Method::Post, UPLOAD, 401, r#"{"error":"invalid api key"}"#);
transport.expect(Method::Post, UPLOAD, 201, r#"{"id":"crm-9"}"#);
let login = FakeLogin::new(vec![Ok("euv_new".into())]);
let id = upload_with_login(&client, &login, valid("euv_old"), now(), "t").await;
assert_eq!(id, Ok("crm-9".into()));
assert_eq!(login.counts(), (1, 1));
assert_eq!(login.discarded(), ["euv_old"]);
let keys: Vec<_> = transport
.requests()
.iter()
.map(|r| r.header(KEY_HEADER).unwrap().to_string())
.collect();
assert_eq!(keys, ["euv_old", "euv_new"]);
transport.assert_done();
}
#[tokio::test]
async fn a_key_refused_twice_ends_in_an_error_without_looping() {
let (transport, client) = client();
transport.expect(Method::Post, UPLOAD, 401, r#"{"error":"invalid api key"}"#);
transport.expect(Method::Post, UPLOAD, 401, r#"{"error":"invalid api key"}"#);
let login = FakeLogin::new(vec![Ok("euv_new".into())]);
let result = upload_with_login(&client, &login, valid("euv_old"), now(), "t").await;
assert_eq!(result, Err(BackendError::InvalidKey.user_message()));
assert_eq!(login.counts(), (1, 2));
assert_eq!(login.discarded(), ["euv_old", "euv_new"]);
transport.assert_done();
}
#[tokio::test]
async fn an_unavailable_backend_fails_without_a_login() {
let (transport, client) = client();
transport.expect(
Method::Post,
UPLOAD,
503,
r#"{"error":"admin status unavailable"}"#,
);
let login = FakeLogin::new(vec![]);
let result = upload_with_login(&client, &login, valid("euv_k"), now(), "t").await;
assert_eq!(result, Err(BackendError::Unavailable.user_message()));
assert_eq!(login.counts(), (0, 0));
}
#[tokio::test]
async fn a_failed_login_stops_the_upload() {
let (transport, client) = client();
let login = FakeLogin::new(vec![Err("Anmeldung abgebrochen".into())]);
let result = upload_with_login(&client, &login, None, now(), "t").await;
assert_eq!(result, Err("Anmeldung abgebrochen".into()));
assert!(transport.requests().is_empty());
}
#[tokio::test]
async fn an_unreachable_backend_is_reported() {
let (transport, client) = client();
transport.fail(Method::Post, UPLOAD, TransportError::Network("dns".into()));
let login = FakeLogin::new(vec![]);
let result = upload_with_login(&client, &login, valid("euv_k"), now(), "t").await;
assert_eq!(
result,
Err("Backend nicht erreichbar: Netzwerkfehler: dns".into())
);
assert_eq!(login.counts(), (0, 0));
}
}