Skip to main content

kaniop_operator/kanidm/controller/
mod.rs

1pub mod context;
2
3use super::controller::context::{Context, Stores};
4use super::crd::Kanidm;
5use super::reconcile::{
6    reconcile_kanidm,
7    secret::{SECRET_TYPE_LABEL, SecretType},
8};
9
10use crate::backoff_reconciler;
11use crate::controller::{
12    ControllerId, RELOAD_BUFFER_SIZE, ResourceReflector, SUBSCRIBE_BUFFER_SIZE, State,
13    check_api_queryable, check_api_queryable_optional, create_subscriber, create_watcher,
14};
15use kaniop_backup_core::crd::{KanidmBackupRepository, KanidmBackupSchedule};
16use kaniop_k8s_util::error::Error;
17
18use std::sync::Arc;
19
20use futures::FutureExt;
21use futures::StreamExt;
22use futures::TryStreamExt;
23use futures::channel::mpsc;
24use futures::future::BoxFuture;
25use gateway_api::apis::standard::backendtlspolicies::BackendTLSPolicy;
26use gateway_api::apis::standard::httproutes::HTTPRoute;
27use k8s_openapi::api::apps::v1::{Deployment, StatefulSet};
28use k8s_openapi::api::core::v1::{ConfigMap, Namespace, Secret, Service};
29use k8s_openapi::api::networking::v1::Ingress;
30use kube::ResourceExt;
31use kube::api::{Api, PartialObjectMeta};
32use kube::client::Client;
33use kube::runtime::controller::{self, Controller};
34use kube::runtime::reflector::ObjectRef;
35use kube::runtime::reflector::store::Writer;
36use kube::runtime::reflector::{ReflectHandle, Store};
37use kube::runtime::{WatchStreamExt, metadata_watcher, watcher};
38use tokio::time::Duration;
39use tracing::{debug, error, info, trace};
40
41pub const CONTROLLER_ID: ControllerId = "kanidm";
42
43fn create_replica_cert_watcher(
44    api: Api<Secret>,
45    writer: Writer<Secret>,
46    ctx: Arc<Context>,
47) -> BoxFuture<'static, ()> {
48    let replica_cert_label = serde_plain::to_string(&SecretType::ReplicaCert).unwrap();
49
50    watcher(
51        api,
52        watcher::Config::default().labels(&format!("{}={}", SECRET_TYPE_LABEL, replica_cert_label)),
53    )
54    .default_backoff()
55    .reflect_shared(writer)
56    .for_each(move |res| {
57        let ctx = ctx.clone();
58        async move {
59            match res {
60                Ok(event) => {
61                    trace!(?event, "watched replica cert event");
62                    match event {
63                        watcher::Event::InitApply(secret) | watcher::Event::Apply(secret) => {
64                            debug!(
65                                namespace = secret.namespace().unwrap(),
66                                name = secret.name_any(),
67                                "init or apply event for replica cert secret trigger reconcile"
68                            );
69                            let _ignore_errors = ctx.insert_repl_cert_exp(&secret).await.map_err(
70                                |e| error!(error = %e, "failed to get replica cert expiration, automatic certificate renewal may be affected"),
71                            );
72                        }
73                        watcher::Event::Delete(secret) => {
74                            debug!(
75                                namespace = secret.namespace().unwrap(),
76                                name = secret.name_any(),
77                                "delete event for replica cert secret"
78                            );
79                            ctx.remove_repl_cert_exp(&ObjectRef::from(&secret))
80                                .await;
81                            ctx.remove_repl_cert_host(&ObjectRef::from(&secret))
82                                .await;
83                        }
84                        _ => {}
85                    }
86                }
87                Err(e) => {
88                    error!(error = %e, "unexpected error when watching replica cert secrets");
89                    ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
90                }
91            }
92        }
93    })
94    .boxed()
95}
96
97/// Map a TLS secret event to the Kanidm objects that mount it.
98///
99/// The TLS secret is user-provided (e.g. created by cert-manager), so it
100/// carries neither kaniop labels nor owner references pointing to the Kanidm:
101/// match by namespace and effective TLS secret name against the Kanidm store.
102fn map_tls_secret_to_kanidms(
103    kanidm_store: &Store<Kanidm>,
104    secret: &PartialObjectMeta<Secret>,
105) -> Vec<ObjectRef<Kanidm>> {
106    kanidm_store
107        .state()
108        .into_iter()
109        .filter(|kanidm| {
110            kanidm.namespace() == secret.namespace()
111                && kanidm.effective_tls_secret_name() == secret.name_any()
112        })
113        .map(|kanidm| ObjectRef::from(kanidm.as_ref()))
114        .collect()
115}
116
117/// Map a KanidmBackupSchedule event to the Kanidm object it references.
118///
119/// The schedule's spec.kanidmRef.name identifies the target Kanidm in the same namespace.
120fn map_schedule_to_kanidm(
121    kanidm_store: &Store<Kanidm>,
122    schedule: &KanidmBackupSchedule,
123) -> Vec<ObjectRef<Kanidm>> {
124    let namespace = schedule.namespace();
125    let kanidm_name = &schedule.spec.kanidm_ref.name;
126
127    kanidm_store
128        .state()
129        .into_iter()
130        .filter(|kanidm| kanidm.namespace() == namespace && kanidm.name_any() == *kanidm_name)
131        .map(|kanidm| ObjectRef::from(kanidm.as_ref()))
132        .collect()
133}
134
135/// Map a KanidmBackupRepository event to all Kanidm objects in the same namespace.
136///
137/// Any Kanidm in the namespace might reference this repository through a schedule,
138/// so we trigger reconciliation for all of them.
139fn map_repository_to_kanidms(
140    kanidm_store: &Store<Kanidm>,
141    repository: &KanidmBackupRepository,
142) -> Vec<ObjectRef<Kanidm>> {
143    let namespace = repository.namespace();
144
145    kanidm_store
146        .state()
147        .into_iter()
148        .filter(|kanidm| kanidm.namespace() == namespace)
149        .map(|kanidm| ObjectRef::from(kanidm.as_ref()))
150        .collect()
151}
152
153#[allow(clippy::too_many_arguments)]
154fn run_controller(
155    kanidm_watcher: impl futures::Stream<Item = Result<Kanidm, watcher::Error>> + Send + 'static,
156    kanidm_store: Store<Kanidm>,
157    statefulset_subscriber: ReflectHandle<StatefulSet>,
158    service_subscriber: ReflectHandle<Service>,
159    ingress_subscriber: ReflectHandle<Ingress>,
160    secret_subscriber: ReflectHandle<Secret>,
161    replica_cert_secret_subscriber: ReflectHandle<Secret>,
162    tls_secret_trigger: impl futures::Stream<Item = Result<PartialObjectMeta<Secret>, watcher::Error>>
163    + Send
164    + 'static,
165    schedule_trigger: impl futures::Stream<Item = Result<KanidmBackupSchedule, watcher::Error>>
166    + Send
167    + 'static,
168    repository_trigger: impl futures::Stream<Item = Result<KanidmBackupRepository, watcher::Error>>
169    + Send
170    + 'static,
171    http_route_subscriber: Option<ReflectHandle<HTTPRoute>>,
172    backend_tls_policy_subscriber: Option<ReflectHandle<BackendTLSPolicy>>,
173    deployment_subscriber: ReflectHandle<Deployment>,
174    config_map_subscriber: ReflectHandle<ConfigMap>,
175    reload_rx: mpsc::Receiver<()>,
176    ctx: Arc<Context>,
177) -> BoxFuture<'static, ()> {
178    let kanidm_store_for_tls = kanidm_store.clone();
179    let kanidm_store_for_schedule = kanidm_store.clone();
180    let kanidm_store_for_repository = kanidm_store.clone();
181    let mut controller = Controller::for_stream(kanidm_watcher, kanidm_store)
182        .with_config(controller::Config::default().debounce(Duration::from_millis(500)))
183        .owns_shared_stream(statefulset_subscriber)
184        .owns_shared_stream(service_subscriber)
185        .owns_shared_stream(ingress_subscriber)
186        .owns_shared_stream(secret_subscriber)
187        .owns_shared_stream(replica_cert_secret_subscriber)
188        .owns_shared_stream(deployment_subscriber)
189        .owns_shared_stream(config_map_subscriber)
190        .watches_stream(tls_secret_trigger, move |secret| {
191            map_tls_secret_to_kanidms(&kanidm_store_for_tls, &secret)
192        })
193        .watches_stream(schedule_trigger, move |schedule| {
194            map_schedule_to_kanidm(&kanidm_store_for_schedule, &schedule)
195        })
196        .watches_stream(repository_trigger, move |repository| {
197            map_repository_to_kanidms(&kanidm_store_for_repository, &repository)
198        });
199
200    if let Some(subscriber) = http_route_subscriber {
201        controller = controller.owns_shared_stream(subscriber);
202    }
203
204    if let Some(subscriber) = backend_tls_policy_subscriber {
205        controller = controller.owns_shared_stream(subscriber);
206    }
207
208    controller
209        .reconcile_all_on(reload_rx.map(|_| ()))
210        .shutdown_on_signal()
211        .run(
212            backoff_reconciler!(reconcile_kanidm),
213            |_obj, _error: &Error, _ctx| unreachable!(),
214            ctx,
215        )
216        .filter_map(|x| async move { std::result::Result::ok(x) })
217        .for_each(|_| futures::future::ready(()))
218        .boxed()
219}
220
221/// Initialize Kanidm controller and shared state
222pub async fn run(
223    state: State,
224    client: Client,
225    namespace_api: Api<Namespace>,
226    namespace_r: ResourceReflector<Namespace>,
227    kanidm_api: Api<Kanidm>,
228    kanidm_r: ResourceReflector<Kanidm>,
229) {
230    let statefulset = check_api_queryable::<StatefulSet>(client.clone()).await;
231    let service = check_api_queryable::<Service>(client.clone()).await;
232    let ingress = check_api_queryable::<Ingress>(client.clone()).await;
233    let secret = check_api_queryable::<Secret>(client.clone()).await;
234    let http_route_api = check_api_queryable_optional::<HTTPRoute>(client.clone()).await;
235    let backend_tls_policy_api =
236        check_api_queryable_optional::<BackendTLSPolicy>(client.clone()).await;
237    let deployment = check_api_queryable::<Deployment>(client.clone()).await;
238    let config_map = check_api_queryable::<ConfigMap>(client.clone()).await;
239
240    let statefulset_r = create_subscriber::<StatefulSet>(SUBSCRIBE_BUFFER_SIZE);
241    let service_r = create_subscriber::<Service>(SUBSCRIBE_BUFFER_SIZE);
242    let ingress_r = create_subscriber::<Ingress>(SUBSCRIBE_BUFFER_SIZE);
243    let secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
244    let replica_cert_secret_r = create_subscriber::<Secret>(SUBSCRIBE_BUFFER_SIZE);
245    let deployment_r = create_subscriber::<Deployment>(SUBSCRIBE_BUFFER_SIZE);
246    let config_map_r = create_subscriber::<ConfigMap>(SUBSCRIBE_BUFFER_SIZE);
247
248    let (reload_tx, reload_rx) = mpsc::channel(RELOAD_BUFFER_SIZE);
249
250    let http_route_r = if http_route_api.is_some() {
251        Some(create_subscriber::<HTTPRoute>(SUBSCRIBE_BUFFER_SIZE))
252    } else {
253        None
254    };
255
256    let backend_tls_policy_r = if backend_tls_policy_api.is_some() {
257        Some(create_subscriber::<BackendTLSPolicy>(SUBSCRIBE_BUFFER_SIZE))
258    } else {
259        None
260    };
261
262    let stores = Stores {
263        stateful_set_store: statefulset_r.store,
264        service_store: service_r.store,
265        ingress_store: ingress_r.store,
266        secret_store: secret_r.store,
267        http_route_store: http_route_r.as_ref().map(|r| r.store.clone()),
268        backend_tls_policy_store: backend_tls_policy_r.as_ref().map(|r| r.store.clone()),
269        deployment_store: deployment_r.store,
270        config_map_store: config_map_r.store,
271    };
272
273    let ctx = Arc::new(Context::new(
274        state.to_context(client.clone(), CONTROLLER_ID),
275        stores,
276    ));
277    let kaniop_ctx = Arc::new(ctx.kaniop_ctx.clone());
278
279    let statefulset_watcher = create_watcher(
280        statefulset,
281        statefulset_r.writer,
282        reload_tx.clone(),
283        CONTROLLER_ID,
284        kaniop_ctx.clone(),
285    );
286    let service_watcher = create_watcher(
287        service,
288        service_r.writer,
289        reload_tx.clone(),
290        CONTROLLER_ID,
291        kaniop_ctx.clone(),
292    );
293    let ingress_watcher = create_watcher(
294        ingress,
295        ingress_r.writer,
296        reload_tx.clone(),
297        CONTROLLER_ID,
298        kaniop_ctx.clone(),
299    );
300    let secret_watcher = create_watcher(
301        secret.clone(),
302        secret_r.writer,
303        reload_tx.clone(),
304        CONTROLLER_ID,
305        kaniop_ctx.clone(),
306    );
307    let deployment_watcher = create_watcher(
308        deployment,
309        deployment_r.writer,
310        reload_tx.clone(),
311        CONTROLLER_ID,
312        kaniop_ctx.clone(),
313    );
314    let config_map_watcher = create_watcher(
315        config_map,
316        config_map_r.writer,
317        reload_tx.clone(),
318        CONTROLLER_ID,
319        kaniop_ctx.clone(),
320    );
321
322    let replica_cert_secrets_watcher =
323        create_replica_cert_watcher(secret.clone(), replica_cert_secret_r.writer, ctx.clone());
324
325    // TLS secrets are user-provided (e.g. created by cert-manager) and carry no
326    // kaniop label to filter on: watch metadata of `kubernetes.io/tls` secrets
327    // and let the mapper match them by name against the Kanidm store.
328    let tls_secret_metrics_ctx = kaniop_ctx.clone();
329    let tls_secret_trigger = metadata_watcher(
330        secret,
331        watcher::Config::default()
332            .fields("type=kubernetes.io/tls")
333            .any_semantic(),
334    )
335    .default_backoff()
336    .touched_objects()
337    .inspect_err(move |e| {
338        error!(error = %e, "unexpected error when watching TLS secrets");
339        tls_secret_metrics_ctx.metrics.watch_operations_failed_inc();
340    });
341
342    // Watch KanidmBackupSchedule and KanidmBackupRepository to trigger Kanidm reconciliation
343    // when backup configuration changes (e.g., schedule suspension, repository readiness).
344    let schedule_api = check_api_queryable_optional::<KanidmBackupSchedule>(client.clone()).await;
345    let repository_api =
346        check_api_queryable_optional::<KanidmBackupRepository>(client.clone()).await;
347
348    let schedule_trigger = match schedule_api {
349        Some(api) => watcher(api, watcher::Config::default().any_semantic())
350            .default_backoff()
351            .touched_objects()
352            .boxed(),
353        None => futures::stream::pending().boxed(),
354    };
355
356    let repository_trigger = match repository_api {
357        Some(api) => watcher(api, watcher::Config::default().any_semantic())
358            .default_backoff()
359            .touched_objects()
360            .boxed(),
361        None => futures::stream::pending().boxed(),
362    };
363
364    let namespace_watcher = watcher(namespace_api, watcher::Config::default().any_semantic())
365        .default_backoff()
366        .reflect(namespace_r.writer)
367        .for_each(|res| {
368            let ctx = ctx.clone();
369            async move {
370                match res {
371                    Ok(event) => trace!(?event, "received namespace event"),
372                    Err(e) => {
373                        error!(error = %e, "unexpected error when watching namespace");
374                        ctx.kaniop_ctx.metrics.watch_operations_failed_inc();
375                    }
376                }
377            }
378        });
379
380    info!(controller = CONTROLLER_ID, "starting controller");
381    let kanidm_watcher = watcher(kanidm_api, watcher::Config::default().any_semantic())
382        .default_backoff()
383        .reflect(kanidm_r.writer)
384        .touched_objects();
385
386    let (http_route_watcher, http_route_subscriber) = match (http_route_api, http_route_r) {
387        (Some(api), Some(r)) => {
388            let watcher = create_watcher(
389                api,
390                r.writer,
391                reload_tx.clone(),
392                CONTROLLER_ID,
393                kaniop_ctx.clone(),
394            );
395            (Some(watcher), Some(r.subscriber))
396        }
397        _ => (None, None),
398    };
399
400    let (backend_tls_policy_watcher, backend_tls_policy_subscriber) =
401        match (backend_tls_policy_api, backend_tls_policy_r) {
402            (Some(api), Some(r)) => {
403                let watcher = create_watcher(api, r.writer, reload_tx, CONTROLLER_ID, kaniop_ctx);
404                (Some(watcher), Some(r.subscriber))
405            }
406            _ => (None, None),
407        };
408
409    let kanidm_controller = run_controller(
410        kanidm_watcher,
411        kanidm_r.store,
412        statefulset_r.subscriber,
413        service_r.subscriber,
414        ingress_r.subscriber,
415        secret_r.subscriber,
416        replica_cert_secret_r.subscriber,
417        tls_secret_trigger,
418        schedule_trigger,
419        repository_trigger,
420        http_route_subscriber,
421        backend_tls_policy_subscriber,
422        deployment_r.subscriber,
423        config_map_r.subscriber,
424        reload_rx,
425        ctx.clone(),
426    );
427
428    ctx.kaniop_ctx.metrics.ready_set(1);
429    tokio::select! {
430        _ = kanidm_controller => {},
431        _ = namespace_watcher => {},
432        _ = statefulset_watcher => {},
433        _ = service_watcher => {},
434        _ = ingress_watcher => {},
435        _ = secret_watcher => {},
436        _ = http_route_watcher.unwrap_or(futures::future::pending().boxed()) => {},
437        _ = backend_tls_policy_watcher.unwrap_or(futures::future::pending().boxed()) => {},
438        _ = replica_cert_secrets_watcher => {},
439        _ = deployment_watcher => {},
440        _ = config_map_watcher => {},
441    }
442}
443
444#[cfg(test)]
445mod tests {
446    use super::{map_repository_to_kanidms, map_schedule_to_kanidm, map_tls_secret_to_kanidms};
447    use crate::kanidm::crd::{Kanidm, KanidmSpec};
448
449    use k8s_openapi::api::core::v1::Secret;
450    use kaniop_backup_core::crd::{
451        AuthMethod, KanidmBackupRepository, KanidmBackupRepositorySpec, KanidmBackupSchedule,
452        KanidmBackupScheduleSpec, RepositoryAuthentication, S3Config, ScheduleKanidmRef,
453        ScheduleRepositoryRef, SecretRef,
454    };
455    use kube::api::{ObjectMeta, PartialObjectMeta};
456    use kube::runtime::reflector;
457    use kube::runtime::watcher;
458
459    fn kanidm(name: &str, namespace: &str, tls_secret_name: Option<&str>) -> Kanidm {
460        Kanidm {
461            metadata: ObjectMeta {
462                name: Some(name.to_string()),
463                namespace: Some(namespace.to_string()),
464                ..Default::default()
465            },
466            spec: KanidmSpec {
467                domain: "idm.example.com".to_string(),
468                tls_secret_name: tls_secret_name.map(str::to_string),
469                ..Default::default()
470            },
471            ..Default::default()
472        }
473    }
474
475    fn secret_meta(name: &str, namespace: &str) -> PartialObjectMeta<Secret> {
476        PartialObjectMeta {
477            metadata: ObjectMeta {
478                name: Some(name.to_string()),
479                namespace: Some(namespace.to_string()),
480                ..Default::default()
481            },
482            ..Default::default()
483        }
484    }
485
486    #[test]
487    fn test_map_tls_secret_to_kanidms() {
488        let (store, mut writer) = reflector::store();
489        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
490        writer.apply_watcher_event(&watcher::Event::Apply(kanidm(
491            "b",
492            "ns1",
493            Some("custom-tls"),
494        )));
495        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
496
497        // default secret name `{name}-tls`
498        let refs = map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns1"));
499        assert_eq!(refs.len(), 1);
500        assert_eq!(refs[0].name, "a");
501
502        // explicit `tlsSecretName`
503        let refs = map_tls_secret_to_kanidms(&store, &secret_meta("custom-tls", "ns1"));
504        assert_eq!(refs.len(), 1);
505        assert_eq!(refs[0].name, "b");
506
507        // same name in another namespace does not match
508        assert!(map_tls_secret_to_kanidms(&store, &secret_meta("a-tls", "ns2")).is_empty());
509
510        // unrelated secret matches nothing
511        assert!(map_tls_secret_to_kanidms(&store, &secret_meta("other", "ns1")).is_empty());
512    }
513
514    fn schedule(name: &str, namespace: &str, kanidm_name: &str) -> KanidmBackupSchedule {
515        KanidmBackupSchedule {
516            metadata: ObjectMeta {
517                name: Some(name.to_string()),
518                namespace: Some(namespace.to_string()),
519                ..Default::default()
520            },
521            spec: KanidmBackupScheduleSpec {
522                kanidm_ref: ScheduleKanidmRef {
523                    name: kanidm_name.to_string(),
524                },
525                repository_ref: ScheduleRepositoryRef {
526                    name: "repo".to_string(),
527                },
528                schedule: "0 2 * * *".to_string(),
529                time_zone: "UTC".to_string(),
530                suspend: false,
531                concurrency_policy: "Forbid".to_string(),
532                jitter_seconds: None,
533                local_versions: 7,
534                retention: None,
535            },
536            status: None,
537        }
538    }
539
540    fn repository(name: &str, namespace: &str) -> KanidmBackupRepository {
541        KanidmBackupRepository {
542            metadata: ObjectMeta {
543                name: Some(name.to_string()),
544                namespace: Some(namespace.to_string()),
545                ..Default::default()
546            },
547            spec: KanidmBackupRepositorySpec {
548                s3: S3Config {
549                    bucket: "bucket".to_string(),
550                    prefix: "".to_string(),
551                    region: String::new(),
552                    endpoint: String::new(),
553                    force_path_style: false,
554                    ca_bundle_ref: None,
555                    insecure: false,
556                },
557                authentication: RepositoryAuthentication {
558                    writer: AuthMethod {
559                        workload_identity: None,
560                        secret_ref: Some(SecretRef {
561                            name: "s".to_string(),
562                        }),
563                    },
564                    reader: AuthMethod {
565                        workload_identity: None,
566                        secret_ref: Some(SecretRef {
567                            name: "s".to_string(),
568                        }),
569                    },
570                    deleter: AuthMethod {
571                        workload_identity: None,
572                        secret_ref: Some(SecretRef {
573                            name: "s".to_string(),
574                        }),
575                    },
576                },
577                encryption: None,
578                limits: None,
579            },
580            status: None,
581        }
582    }
583
584    #[test]
585    fn test_map_schedule_to_kanidm_correct_ref() {
586        let (store, mut writer) = reflector::store();
587        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
588        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("b", "ns1", None)));
589
590        let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns1", "a"));
591        assert_eq!(refs.len(), 1);
592        assert_eq!(refs[0].name, "a");
593    }
594
595    #[test]
596    fn test_map_schedule_to_kanidm_wrong_namespace() {
597        let (store, mut writer) = reflector::store();
598        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
599
600        let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns2", "a"));
601        assert!(refs.is_empty());
602    }
603
604    #[test]
605    fn test_map_schedule_to_kanidm_other_kanidm() {
606        let (store, mut writer) = reflector::store();
607        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
608
609        let refs = map_schedule_to_kanidm(&store, &schedule("sched", "ns1", "nonexistent"));
610        assert!(refs.is_empty());
611    }
612
613    #[test]
614    fn test_map_repository_to_kanidms_fans_out() {
615        let (store, mut writer) = reflector::store();
616        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
617        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("b", "ns1", None)));
618        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("c", "ns2", None)));
619
620        let refs = map_repository_to_kanidms(&store, &repository("repo", "ns1"));
621        assert_eq!(refs.len(), 2);
622        let names: Vec<_> = refs.iter().map(|r| r.name.as_str()).collect();
623        assert!(names.contains(&"a"));
624        assert!(names.contains(&"b"));
625    }
626
627    #[test]
628    fn test_map_repository_to_kanidms_ignores_other_namespaces() {
629        let (store, mut writer) = reflector::store();
630        writer.apply_watcher_event(&watcher::Event::Apply(kanidm("a", "ns1", None)));
631
632        let refs = map_repository_to_kanidms(&store, &repository("repo", "ns2"));
633        assert!(refs.is_empty());
634    }
635}