Skip to main content

kaniop_radius/reconcile/
identity.rs

1//! Deterministic Kanidm identity for individual RADIUS custom resources, and
2//! the executors that ensure and delete it.
3//!
4//! A Kubernetes object name is reusable after deletion. Kanidm accounts live
5//! outside Kubernetes garbage collection, so using only namespace/name would
6//! accidentally adopt a previous or unrelated account after recreation.
7//! Instead the immutable Kubernetes UID identifies the account. Always inspect
8//! existing account ownership metadata before updating it; a matching computed
9//! name alone must never authorize adoption.
10//!
11//! Each CR owns exactly one account, joined to the built-in
12//! `idm_radius_servers` group *additively*: only this account's membership
13//! edge is ever added or removed, never `group_set_members`, which could
14//! revoke unrelated RADIUS instances. Deleting the account removes every
15//! token on it. Call the executors only after namespace authorization, the
16//! restore guard and input validation.
17
18use kanidm_client::{ClientError, KanidmClient};
19use kanidm_proto::internal::OperationError;
20use kanidm_proto::v1::Entry;
21use kaniop_k8s_util::types::normalize_spn;
22use kaniop_operator::metrics::{
23    ControllerMetrics, KANIDM_OP_ADD_MEMBERS, KANIDM_OP_CREATE, KANIDM_OP_DELETE, KANIDM_OP_GET,
24    KANIDM_OP_REMOVE_MEMBERS, KANIDM_OUTCOME_CHANGED, KANIDM_OUTCOME_UNCHANGED,
25};
26use kube::ResourceExt;
27use thiserror::Error;
28use uuid::Uuid;
29
30use crate::crd::KanidmRadiusServer;
31use crate::reconcile::error::{ExecError, ExecResult, kanidm_error};
32use crate::reconcile::sdk;
33
34/// Built-in Kanidm group whose members may act as RADIUS servers.
35pub const RADIUS_GROUP: &str = "idm_radius_servers";
36const ENTRY_MANAGER: &str = "idm_admin";
37
38const RADIUS_ACCOUNT_PREFIX: &str = "kaniop_radius_";
39const DISPLAY_NAME_PREFIX: &str = "Kaniop RADIUS: ";
40
41#[derive(Clone, Debug, PartialEq, Eq)]
42pub struct RadiusIdentity {
43    /// Stable across controller restarts, distinct across CR re-creations.
44    pub account_name: String,
45    /// A human-readable ownership marker for the Kanidm display name.
46    pub display_name: String,
47}
48
49#[derive(Debug, Error, PartialEq, Eq)]
50pub enum RadiusIdentityError {
51    #[error("RADIUS resource requires a valid Kubernetes UID")]
52    InvalidUid,
53    #[error("RADIUS resource requires a namespace and a name")]
54    MissingObjectIdentity,
55}
56
57impl RadiusIdentity {
58    pub fn new(namespace: &str, name: &str, uid: &str) -> Result<Self, RadiusIdentityError> {
59        if namespace.is_empty() || name.is_empty() {
60            return Err(RadiusIdentityError::MissingObjectIdentity);
61        }
62        let uid = Uuid::parse_str(uid).map_err(|_| RadiusIdentityError::InvalidUid)?;
63        // Kanidm account names permit ASCII underscores. The UID's 128 bits
64        // avoid name collision between independent RADIUS resources without
65        // requiring a shared lock or incrementing counter.
66        let account_name = format!("{RADIUS_ACCOUNT_PREFIX}{}", uid.simple());
67        let display_name = format!(
68            "{DISPLAY_NAME_PREFIX}{namespace}/{name} [{}]",
69            uid.hyphenated()
70        );
71        Ok(Self {
72            account_name,
73            display_name,
74        })
75    }
76
77    /// Do not silently adopt an account if an operator restart finds an
78    /// already-existing Kanidm entry. The caller must inspect the account's
79    /// display name and return an ownership conflict when this is false.
80    pub fn matches_existing_display_name(&self, display_name: &str) -> bool {
81        self.display_name == display_name
82    }
83
84    /// Identity of a CR, from its namespace, name and immutable UID.
85    pub fn for_resource(radius: &KanidmRadiusServer) -> Result<Self, RadiusIdentityError> {
86        let namespace = radius
87            .namespace()
88            .ok_or(RadiusIdentityError::MissingObjectIdentity)?;
89        let uid = radius
90            .metadata
91            .uid
92            .as_deref()
93            .ok_or(RadiusIdentityError::InvalidUid)?;
94        Self::new(&namespace, &radius.name_any(), uid)
95    }
96}
97
98/// What exists in Kanidm under this identity's account name.
99#[derive(Clone, Copy, Debug, PartialEq, Eq)]
100pub enum AccountState {
101    Absent,
102    /// The display-name marker names this CR (namespace, name and UID).
103    Owned,
104    /// An account with this name exists without our marker.
105    Foreign,
106}
107
108/// Classify a fetched account. Only the exact marker authorizes use; never
109/// update an existing account to *make it match* (silent adoption).
110pub fn account_state(entry: Option<&Entry>, identity: &RadiusIdentity) -> AccountState {
111    match entry {
112        None => AccountState::Absent,
113        Some(entry)
114            if entry.attrs.get("displayname").is_some_and(|names| {
115                names.len() == 1 && identity.matches_existing_display_name(&names[0])
116            }) =>
117        {
118            AccountState::Owned
119        }
120        Some(_) => AccountState::Foreign,
121    }
122}
123
124/// Is `account` in a `member` attribute list (names or SPNs)?
125pub fn is_member(members: &[String], account: &str) -> bool {
126    let wanted = normalize_spn(account);
127    members.iter().any(|member| normalize_spn(member) == wanted)
128}
129
130fn is_conflict(error: &ClientError) -> bool {
131    matches!(error, ClientError::Http(status, _, _) if status.as_u16() == 409)
132}
133
134/// A delete of something that is already gone.
135pub(crate) fn is_not_found(error: &ClientError) -> bool {
136    matches!(error, ClientError::Http(status, _, _) if status.as_u16() == 404)
137        || matches!(
138            error,
139            ClientError::Http(_, Some(OperationError::NoMatchingEntries), _)
140        )
141}
142
143/// What [`ensure_identity`] changed.
144#[derive(Clone, Copy, Debug, PartialEq, Eq)]
145pub struct IdentityOutcome {
146    pub account_created: bool,
147    pub membership_added: bool,
148}
149
150async fn get_account(
151    client: &KanidmClient,
152    metrics: &ControllerMetrics,
153    identity: &RadiusIdentity,
154) -> ExecResult<AccountState> {
155    let entry = sdk::call(
156        metrics,
157        KANIDM_OP_GET,
158        KANIDM_OUTCOME_UNCHANGED,
159        client.idm_service_account_get(&identity.account_name),
160    )
161    .await
162    .map_err(|e| kanidm_error("get", "RADIUS service account", e))?;
163    Ok(account_state(entry.as_ref(), identity))
164}
165
166async fn members(client: &KanidmClient, metrics: &ControllerMetrics) -> ExecResult<Vec<String>> {
167    Ok(sdk::call(
168        metrics,
169        KANIDM_OP_GET,
170        KANIDM_OUTCOME_UNCHANGED,
171        client.idm_group_get_members(RADIUS_GROUP),
172    )
173    .await
174    .map_err(|e| kanidm_error("get members of", RADIUS_GROUP, e))?
175    .unwrap_or_default())
176}
177
178/// Ensure the per-CR account (created, never adopted) and its own membership
179/// edge in `idm_radius_servers`. Mints, rotates and revokes nothing.
180///
181/// A same-named account without our display-name marker is
182/// [`ExecError::AccountNotOwned`].
183pub async fn ensure_identity(
184    client: &KanidmClient,
185    metrics: &ControllerMetrics,
186    identity: &RadiusIdentity,
187) -> ExecResult<IdentityOutcome> {
188    let name = &identity.account_name;
189    let mut account_created = false;
190    match get_account(client, metrics, identity).await? {
191        AccountState::Owned => {}
192        AccountState::Foreign => return Err(not_owned(identity)),
193        AccountState::Absent => {
194            match sdk::call(
195                metrics,
196                KANIDM_OP_CREATE,
197                KANIDM_OUTCOME_CHANGED,
198                client.idm_service_account_create(name, &identity.display_name, ENTRY_MANAGER),
199            )
200            .await
201            {
202                Ok(()) => account_created = true,
203                // A concurrent reconcile may have created it; verify the
204                // marker instead of adopting.
205                Err(error) if is_conflict(&error) => {
206                    if get_account(client, metrics, identity).await? != AccountState::Owned {
207                        return Err(not_owned(identity));
208                    }
209                }
210                Err(error) => {
211                    return Err(kanidm_error("create", "RADIUS service account", error));
212                }
213            }
214        }
215    }
216
217    let membership_added = if is_member(&members(client, metrics).await?, name) {
218        false
219    } else {
220        sdk::call(
221            metrics,
222            KANIDM_OP_ADD_MEMBERS,
223            KANIDM_OUTCOME_CHANGED,
224            client.idm_group_add_members(RADIUS_GROUP, &[name.as_str()]),
225        )
226        .await
227        .map_err(|e| kanidm_error("add member to", RADIUS_GROUP, e))?;
228        true
229    };
230    Ok(IdentityOutcome {
231        account_created,
232        membership_added,
233    })
234}
235
236fn not_owned(identity: &RadiusIdentity) -> ExecError {
237    ExecError::AccountNotOwned {
238        account: identity.account_name.clone(),
239    }
240}
241
242/// What [`delete_identity`] found and did.
243#[derive(Clone, Copy, Debug, PartialEq, Eq)]
244pub enum DeleteOutcome {
245    /// The account was already gone.
246    AlreadyAbsent,
247    /// Membership edge removed (if present) and account deleted. Every token
248    /// on the account went with it.
249    Deleted,
250}
251
252/// Remove exactly this CR's membership edge, then delete its account. Call
253/// only after the workload has drained. An account without our marker is
254/// [`ExecError::AccountNotOwned`] and is left untouched (the finalizer turns
255/// that into a skip with a Warning event).
256pub async fn delete_identity(
257    client: &KanidmClient,
258    metrics: &ControllerMetrics,
259    identity: &RadiusIdentity,
260) -> ExecResult<DeleteOutcome> {
261    let name = &identity.account_name;
262    match get_account(client, metrics, identity).await? {
263        AccountState::Absent => return Ok(DeleteOutcome::AlreadyAbsent),
264        AccountState::Foreign => return Err(not_owned(identity)),
265        AccountState::Owned => {}
266    }
267    if is_member(&members(client, metrics).await?, name) {
268        // Only this UID-scoped edge; never the group's other members.
269        sdk::call(
270            metrics,
271            KANIDM_OP_REMOVE_MEMBERS,
272            KANIDM_OUTCOME_CHANGED,
273            client.idm_group_remove_members(RADIUS_GROUP, &[name.as_str()]),
274        )
275        .await
276        .map_err(|e| kanidm_error("remove member from", RADIUS_GROUP, e))?;
277    }
278    match sdk::call(
279        metrics,
280        KANIDM_OP_DELETE,
281        KANIDM_OUTCOME_CHANGED,
282        client.idm_service_account_delete(name),
283    )
284    .await
285    {
286        Ok(()) => Ok(DeleteOutcome::Deleted),
287        Err(error) if is_not_found(&error) => Ok(DeleteOutcome::AlreadyAbsent),
288        Err(error) => Err(kanidm_error("delete", "RADIUS service account", error)),
289    }
290}
291
292#[cfg(test)]
293mod tests {
294    use super::*;
295
296    const FIRST_UID: &str = "d10066c3-4599-4487-972d-26bb42587a32";
297    const SECOND_UID: &str = "ad8cf3d5-b2a9-44d6-b257-058554ab09d5";
298
299    #[test]
300    fn identity_is_stable_across_reconciliation() {
301        let a = RadiusIdentity::new("network", "radius", FIRST_UID).unwrap();
302        let b = RadiusIdentity::new("network", "radius", FIRST_UID).unwrap();
303        assert_eq!(a, b);
304        assert_eq!(
305            a.account_name,
306            "kaniop_radius_d10066c345994487972d26bb42587a32"
307        );
308        assert!(a.matches_existing_display_name(&a.display_name));
309    }
310
311    #[test]
312    fn same_name_recreated_with_new_uid_does_not_adopt_previous_account() {
313        let old = RadiusIdentity::new("network", "radius", FIRST_UID).unwrap();
314        let new = RadiusIdentity::new("network", "radius", SECOND_UID).unwrap();
315        assert_ne!(old.account_name, new.account_name);
316        assert!(!new.matches_existing_display_name(&old.display_name));
317    }
318
319    #[test]
320    fn different_resources_cannot_share_the_same_uid_identity_marker() {
321        // An unexpectedly reused UID would not be sufficient to authorize an
322        // existing account with different namespace/name metadata.
323        let a = RadiusIdentity::new("network-a", "radius", FIRST_UID).unwrap();
324        let b = RadiusIdentity::new("network-b", "radius", FIRST_UID).unwrap();
325        assert_eq!(a.account_name, b.account_name);
326        assert!(!b.matches_existing_display_name(&a.display_name));
327    }
328
329    #[test]
330    fn rejects_absent_or_non_uuid_uid() {
331        assert_eq!(
332            RadiusIdentity::new("network", "radius", ""),
333            Err(RadiusIdentityError::InvalidUid)
334        );
335        assert_eq!(
336            RadiusIdentity::new("network", "radius", "wrong-uid"),
337            Err(RadiusIdentityError::InvalidUid)
338        );
339        assert_eq!(
340            RadiusIdentity::new("", "radius", FIRST_UID),
341            Err(RadiusIdentityError::MissingObjectIdentity)
342        );
343    }
344
345    #[test]
346    fn forged_display_name_causes_ownership_conflict() {
347        let identity = RadiusIdentity::new("network", "radius", FIRST_UID).unwrap();
348        assert!(!identity.matches_existing_display_name("Someone else's service account"));
349    }
350}
351
352#[cfg(test)]
353mod executor_tests {
354    use std::sync::{Arc, Mutex};
355
356    use serde_json::{Value, json};
357
358    use super::*;
359    use crate::reconcile::kanidm_mock::{self, Request};
360
361    const UID: &str = "d10066c3-4599-4487-972d-26bb42587a32";
362    const ACCOUNT: &str = "kaniop_radius_d10066c345994487972d26bb42587a32";
363    const ACCOUNT_PATH: &str = "/v1/service_account/kaniop_radius_d10066c345994487972d26bb42587a32";
364    const MEMBERS_PATH: &str = "/v1/group/idm_radius_servers/_attr/member";
365
366    fn identity() -> RadiusIdentity {
367        RadiusIdentity::new("network", "campus", UID).unwrap()
368    }
369
370    fn entry_json(display_name: &str) -> String {
371        json!({"attrs": {"displayname": [display_name]}}).to_string()
372    }
373
374    /// Fake Kanidm state: the account (display name) and group members.
375    #[derive(Default)]
376    struct World {
377        account: Option<String>,
378        members: Vec<String>,
379        create_conflicts: bool,
380    }
381
382    fn handler(world: Arc<Mutex<World>>) -> impl Fn(&Request) -> (u16, String) + Send + Sync {
383        move |req| {
384            let mut w = world.lock().unwrap();
385            match (req.method.as_str(), req.path.as_str()) {
386                ("GET", ACCOUNT_PATH) => match &w.account {
387                    Some(name) => (200, entry_json(name)),
388                    None => (200, "null".into()),
389                },
390                ("GET", MEMBERS_PATH) => (200, serde_json::to_string(&w.members).unwrap()),
391                ("POST", "/v1/service_account") => {
392                    if w.create_conflicts {
393                        return (409, "{}".into());
394                    }
395                    let body: Value = serde_json::from_str(&req.body).unwrap();
396                    w.account = Some(body["attrs"]["displayname"][0].as_str().unwrap().into());
397                    (200, "null".into())
398                }
399                ("POST", MEMBERS_PATH) => {
400                    let added: Vec<String> = serde_json::from_str(&req.body).unwrap();
401                    w.members.extend(added);
402                    (200, "null".into())
403                }
404                ("DELETE", MEMBERS_PATH) => {
405                    let removed: Vec<String> = serde_json::from_str(&req.body).unwrap();
406                    w.members.retain(|m| !removed.contains(m));
407                    (200, "null".into())
408                }
409                ("DELETE", ACCOUNT_PATH) => {
410                    w.account = None;
411                    (200, "null".into())
412                }
413                _ => (500, "{}".into()),
414            }
415        }
416    }
417
418    #[test]
419    fn account_state_requires_the_exact_marker() {
420        let id = identity();
421        let owned: Entry =
422            serde_json::from_value(json!({"attrs": {"displayname": [id.display_name.clone()]}}))
423                .unwrap();
424        assert_eq!(account_state(Some(&owned), &id), AccountState::Owned);
425        assert_eq!(account_state(None, &id), AccountState::Absent);
426        let other: Entry =
427            serde_json::from_value(json!({"attrs": {"displayname": ["Someone else"]}})).unwrap();
428        assert_eq!(account_state(Some(&other), &id), AccountState::Foreign);
429        let none: Entry = serde_json::from_value(json!({"attrs": {}})).unwrap();
430        assert_eq!(account_state(Some(&none), &id), AccountState::Foreign);
431        let two: Entry = serde_json::from_value(
432            json!({"attrs": {"displayname": [id.display_name.clone(), "x"]}}),
433        )
434        .unwrap();
435        assert_eq!(account_state(Some(&two), &id), AccountState::Foreign);
436    }
437
438    #[test]
439    fn membership_matches_names_and_spns() {
440        let members = vec![
441            "other@idm.example.com".to_string(),
442            format!("{ACCOUNT}@idm.example.com"),
443        ];
444        assert!(is_member(&members, ACCOUNT));
445        assert!(!is_member(&members[..1], ACCOUNT));
446        assert!(!is_member(&[], ACCOUNT));
447    }
448
449    #[test]
450    fn identity_for_resource_uses_namespace_name_and_uid() {
451        let radius: KanidmRadiusServer = serde_json::from_value(json!({
452            "apiVersion": "kaniop.rs/v1beta1", "kind": "KanidmRadiusServer",
453            "metadata": {"name": "campus", "namespace": "network", "uid": UID},
454            "spec": {
455                "kanidmRef": {"name": "idm"},
456                "authorization": {"requiredGroups": ["allowed@idm.example.com"]},
457                "clients": [{
458                    "name": "nas",
459                    "ipaddr": "192.0.2.1",
460                    "sharedSecretRef": {"name": "nas-secret", "key": "nas"}
461                }],
462                "radiusTls": {"secretRef": {"name": "radius-tls"}}
463            }
464        }))
465        .unwrap();
466        assert_eq!(RadiusIdentity::for_resource(&radius).unwrap(), identity());
467        let mut no_uid = radius.clone();
468        no_uid.metadata.uid = None;
469        assert_eq!(
470            RadiusIdentity::for_resource(&no_uid),
471            Err(RadiusIdentityError::InvalidUid)
472        );
473    }
474
475    #[tokio::test]
476    async fn ensure_creates_account_and_adds_only_its_own_membership() {
477        let world = Arc::new(Mutex::new(World {
478            members: vec!["unrelated_radius_server".into()],
479            ..Default::default()
480        }));
481        let mock = kanidm_mock::start(handler(world.clone())).await;
482        let outcome = ensure_identity(&mock.client, &mock.metrics, &identity())
483            .await
484            .unwrap();
485        assert_eq!(
486            outcome,
487            IdentityOutcome {
488                account_created: true,
489                membership_added: true
490            }
491        );
492        let w = world.lock().unwrap();
493        assert_eq!(w.account.as_deref(), Some(identity().display_name.as_str()));
494        assert_eq!(w.members, ["unrelated_radius_server", ACCOUNT]);
495        // Additive membership only: never a set/purge of the group.
496        assert!(
497            mock.writes().iter().all(|r| r.method == "POST"
498                && (r.path == "/v1/service_account" || r.path == MEMBERS_PATH))
499        );
500    }
501
502    #[tokio::test]
503    async fn ensure_is_idempotent() {
504        let world = Arc::new(Mutex::new(World {
505            account: Some(identity().display_name),
506            members: vec![ACCOUNT.into()],
507            ..Default::default()
508        }));
509        let mock = kanidm_mock::start(handler(world)).await;
510        let outcome = ensure_identity(&mock.client, &mock.metrics, &identity())
511            .await
512            .unwrap();
513        assert_eq!(
514            outcome,
515            IdentityOutcome {
516                account_created: false,
517                membership_added: false
518            }
519        );
520        assert!(mock.writes().is_empty());
521    }
522
523    #[tokio::test]
524    async fn ensure_never_adopts_a_foreign_account() {
525        let world = Arc::new(Mutex::new(World {
526            account: Some("Hand-made RADIUS account".into()),
527            ..Default::default()
528        }));
529        let mock = kanidm_mock::start(handler(world.clone())).await;
530        let error = ensure_identity(&mock.client, &mock.metrics, &identity())
531            .await
532            .unwrap_err();
533        assert!(matches!(error, ExecError::AccountNotOwned { .. }));
534        assert!(mock.writes().is_empty(), "no update, membership or delete");
535        assert_eq!(
536            world.lock().unwrap().account.as_deref(),
537            Some("Hand-made RADIUS account")
538        );
539    }
540
541    #[tokio::test]
542    async fn ensure_after_a_create_conflict_verifies_the_marker() {
543        // Lost the creation race to a reconcile that wrote the marker.
544        let world = Arc::new(Mutex::new(World::default()));
545        let calls = Arc::new(Mutex::new(0));
546        let (w, c) = (world.clone(), calls.clone());
547        let inner = handler(world.clone());
548        let mock = kanidm_mock::start(move |req| {
549            if req.method == "GET" && req.path == ACCOUNT_PATH {
550                let mut n = c.lock().unwrap();
551                *n += 1;
552                if *n == 2 {
553                    // After our 409, the other writer's account is visible.
554                    w.lock().unwrap().account = Some(identity().display_name);
555                }
556            }
557            if req.method == "POST" && req.path == "/v1/service_account" {
558                return (409, "{}".into());
559            }
560            inner(req)
561        })
562        .await;
563        let outcome = ensure_identity(&mock.client, &mock.metrics, &identity())
564            .await
565            .unwrap();
566        assert!(!outcome.account_created);
567        assert!(outcome.membership_added);
568
569        // The same race against a foreign account is a conflict.
570        let world = Arc::new(Mutex::new(World {
571            create_conflicts: true,
572            ..Default::default()
573        }));
574        let (w, c) = (world.clone(), Arc::new(Mutex::new(0)));
575        let inner = handler(world);
576        let mock = kanidm_mock::start(move |req| {
577            if req.method == "GET" && req.path == ACCOUNT_PATH {
578                let mut n = c.lock().unwrap();
579                *n += 1;
580                if *n == 2 {
581                    w.lock().unwrap().account = Some("Foreign".into());
582                }
583            }
584            inner(req)
585        })
586        .await;
587        assert!(matches!(
588            ensure_identity(&mock.client, &mock.metrics, &identity()).await,
589            Err(ExecError::AccountNotOwned { .. })
590        ));
591    }
592
593    #[tokio::test]
594    async fn delete_removes_only_our_edge_then_the_account() {
595        let world = Arc::new(Mutex::new(World {
596            account: Some(identity().display_name),
597            members: vec!["unrelated_radius_server".into(), ACCOUNT.into()],
598            ..Default::default()
599        }));
600        let mock = kanidm_mock::start(handler(world.clone())).await;
601        assert_eq!(
602            delete_identity(&mock.client, &mock.metrics, &identity())
603                .await
604                .unwrap(),
605            DeleteOutcome::Deleted
606        );
607        let w = world.lock().unwrap();
608        assert!(w.account.is_none());
609        assert_eq!(w.members, ["unrelated_radius_server"]);
610        let writes = mock.writes();
611        assert_eq!(writes[0].path, MEMBERS_PATH);
612        assert_eq!(writes[0].body, format!("[\"{ACCOUNT}\"]"));
613        assert_eq!(writes[1].path, ACCOUNT_PATH);
614    }
615
616    #[tokio::test]
617    async fn delete_absent_account_is_success_and_foreign_is_untouched() {
618        let mock = kanidm_mock::start(handler(Arc::new(Mutex::new(World::default())))).await;
619        assert_eq!(
620            delete_identity(&mock.client, &mock.metrics, &identity())
621                .await
622                .unwrap(),
623            DeleteOutcome::AlreadyAbsent
624        );
625        assert!(mock.writes().is_empty());
626
627        let world = Arc::new(Mutex::new(World {
628            account: Some("Not ours".into()),
629            members: vec![ACCOUNT.into()],
630            ..Default::default()
631        }));
632        let mock = kanidm_mock::start(handler(world.clone())).await;
633        let error = delete_identity(&mock.client, &mock.metrics, &identity())
634            .await
635            .unwrap_err();
636        assert!(matches!(error, ExecError::AccountNotOwned { .. }));
637        assert!(mock.writes().is_empty());
638        assert!(world.lock().unwrap().account.is_some());
639    }
640
641    #[tokio::test]
642    async fn delete_treats_a_vanished_account_as_done() {
643        let world = Arc::new(Mutex::new(World {
644            account: Some(identity().display_name),
645            ..Default::default()
646        }));
647        let inner = handler(world);
648        let mock = kanidm_mock::start(move |req| {
649            if req.method == "DELETE" && req.path == ACCOUNT_PATH {
650                return (404, "\"NoMatchingEntries\"".into());
651            }
652            inner(req)
653        })
654        .await;
655        assert_eq!(
656            delete_identity(&mock.client, &mock.metrics, &identity())
657                .await
658                .unwrap(),
659            DeleteOutcome::AlreadyAbsent
660        );
661    }
662
663    #[tokio::test]
664    async fn kanidm_outage_keeps_its_source() {
665        let mock = kanidm_mock::start(|_| (503, "{}".into())).await;
666        let error = ensure_identity(&mock.client, &mock.metrics, &identity())
667            .await
668            .unwrap_err();
669        assert!(matches!(error, ExecError::Api(_)));
670    }
671}