Skip to main content

kaniop_operator/kanidm/reconcile/
transport.rs

1use kaniop_backup_core::crd::{
2    AuthMethod, CaBundleRef, EncryptionKeyRef, KanidmBackupRepository, KanidmBackupSchedule,
3};
4use kube::ResourceExt;
5use tracing::debug;
6
7use crate::kanidm::crd::Kanidm;
8use crate::kanidm::restore::RESTORE_ANNOTATION;
9
10pub const TRANSPORT_SIDECAR_NAME: &str = "data-mover-transport";
11
12#[derive(Debug, Clone)]
13pub struct TransportSidecarConfig {
14    pub operation_doc_json: String,
15    pub auth_method: AuthMethod,
16    pub ca_bundle_ref: Option<CaBundleRef>,
17    pub encryption_key_ref: Option<EncryptionKeyRef>,
18}
19
20#[derive(Debug, Clone)]
21pub struct BackupConfig {
22    pub schedule: String,
23    pub local_versions: u32,
24    pub transport: Option<TransportSidecarConfig>,
25}
26
27pub fn backup_target_validation_error(kanidm: &Kanidm) -> Option<String> {
28    let pvc_backed = kanidm.spec.storage.as_ref().is_some_and(|storage| {
29        storage.volume_claim_template.is_some()
30            && storage.empty_dir.is_none()
31            && storage.ephemeral.is_none()
32    });
33    if !pvc_backed {
34        return Some("backup requires PVC-backed storage".to_string());
35    }
36
37    let primary_count = kanidm
38        .spec
39        .replica_groups
40        .iter()
41        .filter(|group| group.primary_node)
42        .count();
43    if primary_count != 1 {
44        return Some(format!(
45            "backup requires exactly one primary replica group; found {primary_count}"
46        ));
47    }
48
49    None
50}
51
52pub fn resolve_backup_config(
53    kanidm: &Kanidm,
54    schedules: &[KanidmBackupSchedule],
55    repositories: &[KanidmBackupRepository],
56) -> Option<BackupConfig> {
57    let kanidm_name = kanidm.name_any();
58    let matching_schedules: Vec<_> = schedules
59        .iter()
60        .filter(|schedule| schedule.spec.kanidm_ref.name == kanidm_name)
61        .collect();
62
63    if matching_schedules.len() != 1 {
64        if matching_schedules.len() > 1 {
65            debug!(
66                kanidm = %kanidm_name,
67                schedules = matching_schedules.len(),
68                "multiple KanidmBackupSchedules target Kanidm; backup configuration is disabled"
69            );
70        }
71        return None;
72    }
73
74    let schedule = matching_schedules[0];
75    if schedule.spec.suspend || kanidm.annotations().contains_key(RESTORE_ANNOTATION) {
76        return None;
77    }
78
79    if let Some(reason) = backup_target_validation_error(kanidm) {
80        debug!(kanidm = %kanidm_name, %reason, "invalid Kanidm backup target");
81        return None;
82    }
83
84    Some(BackupConfig {
85        schedule: schedule.spec.schedule.clone(),
86        local_versions: schedule.spec.local_versions,
87        transport: resolve_transport_sidecar_config(kanidm, schedule, repositories),
88    })
89}
90
91fn resolve_transport_sidecar_config(
92    kanidm: &Kanidm,
93    schedule: &KanidmBackupSchedule,
94    repositories: &[KanidmBackupRepository],
95) -> Option<TransportSidecarConfig> {
96    let kanidm_name = kanidm.name_any();
97    if kanidm.status.is_none() {
98        debug!(
99            kanidm = %kanidm_name,
100            "Kanidm status not yet populated, deferring transport sidecar injection"
101        );
102        return None;
103    }
104
105    let kanidm_version = kanidm
106        .status
107        .as_ref()
108        .and_then(|status| status.version.as_ref())
109        .map(|version| version.image_tag.clone())
110        .unwrap_or_default();
111    if kanidm_version.is_empty() {
112        debug!(
113            kanidm = %kanidm_name,
114            "Kanidm version not yet populated, deferring transport sidecar injection"
115        );
116        return None;
117    }
118
119    let repo_name = &schedule.spec.repository_ref.name;
120    let repository = repositories
121        .iter()
122        .find(|repo| repo.name_any() == *repo_name)?;
123    if !is_repository_ready(repository) {
124        return None;
125    }
126    if !is_encryption_key_ready(repository) {
127        debug!(
128            kanidm = %kanidm_name,
129            repository = %repo_name,
130            "EncryptionKeyReady is False, deferring transport sidecar injection"
131        );
132        return None;
133    }
134    // New repositories must be marked usage-locked by the repository controller
135    // before transport can upload, avoiding a race with webhook immutability checks.
136    // Legacy repositories without this field remain covered by the old fail-closed guard.
137    if repository
138        .status
139        .as_ref()
140        .is_some_and(|status| status.usage_started == Some(false))
141    {
142        debug!(
143            kanidm = %kanidm_name,
144            repository = %repo_name,
145            "Repository usage lock not yet established, deferring transport sidecar injection"
146        );
147        return None;
148    }
149
150    let operation_doc_json = build_transport_operation_doc(kanidm, repository)?;
151    let encryption_key_ref = repository
152        .spec
153        .encryption
154        .as_ref()
155        .and_then(|e| e.key_ref.clone());
156    Some(TransportSidecarConfig {
157        operation_doc_json,
158        auth_method: repository.spec.authentication.writer.clone(),
159        ca_bundle_ref: repository.spec.s3.ca_bundle_ref.clone(),
160        encryption_key_ref,
161    })
162}
163
164fn is_repository_ready(repo: &KanidmBackupRepository) -> bool {
165    repo.status
166        .as_ref()
167        .and_then(|status| {
168            status
169                .conditions
170                .iter()
171                .find(|condition| condition.type_ == "Ready")
172                .map(|condition| condition.status == "True" && condition.reason == "Accepted")
173        })
174        .unwrap_or(false)
175}
176
177fn is_encryption_key_ready(repo: &KanidmBackupRepository) -> bool {
178    let has_client_side = repo
179        .spec
180        .encryption
181        .as_ref()
182        .is_some_and(|e| e.mode == kaniop_backup_core::crd::EncryptionMode::ClientSide);
183    if !has_client_side {
184        return true;
185    }
186    repo.status
187        .as_ref()
188        .and_then(|status| {
189            status
190                .conditions
191                .iter()
192                .find(|condition| condition.type_ == "EncryptionKeyReady")
193                .map(|condition| condition.status == "True")
194        })
195        .unwrap_or(false)
196}
197
198fn build_transport_operation_doc(
199    kanidm: &Kanidm,
200    repository: &KanidmBackupRepository,
201) -> Option<String> {
202    // `namespaceUid` on the wire carries the Kubernetes namespace NAME, not the Namespace object
203    // UID; it selects the `tenants/<x>` keyspace segment that discovery scans (misnomer tracked in
204    // issue #1084).
205    let namespace = kanidm.namespace().unwrap_or_default();
206    let kanidm_uid = kanidm.metadata.uid.clone().unwrap_or_default();
207    let kanidm_name = kanidm.name_any();
208    let domain = kanidm.spec.domain.clone();
209    let kanidm_version = kanidm
210        .status
211        .as_ref()
212        .and_then(|status| status.version.as_ref())
213        .map(|version| version.image_tag.clone())
214        .unwrap_or_default();
215
216    let s3 = &repository.spec.s3;
217    let encryption = repository.spec.encryption.as_ref();
218    let doc = serde_json::json!({
219        "apiVersion": "backup.kaniop.rs/v1alpha1",
220        "kind": "OperationDocument",
221        "operation": "transport",
222        "watchDir": "/data/backups",
223        "filePrefix": "backup-",
224        "fileSuffix": ".json.gz",
225        "pollIntervalSecs": 60,
226        "minFileAgeSecs": 120,
227        "bucket": s3.bucket,
228        "prefix": s3.prefix,
229        "endpoint": s3.endpoint,
230        "region": s3.region,
231        "forcePathStyle": s3.force_path_style,
232        "insecure": s3.insecure,
233        "caBundlePath": s3.ca_bundle_ref.as_ref().map(|_| kaniop_backup_core::auth::ca_bundle_path()),
234        "namespaceUid": namespace,
235        "kanidmUid": kanidm_uid,
236        "kanidmName": kanidm_name,
237        "domain": domain,
238        "kanidmVersion": kanidm_version,
239        "imageDigest": null,
240        "consistency": "kanidm-online",
241        "reason": "scheduled",
242        "encryptionMode": encryption.map(|value| serde_json::json!(value.mode)),
243        "encryptionKeyId": encryption.and_then(|value| value.key_id.clone()),
244        "maxConcurrentParts": 4,
245        "maxRetries": 3
246    });
247
248    serde_json::to_string(&doc).ok()
249}
250
251#[cfg(test)]
252mod tests {
253    use super::*;
254    use kaniop_backup_core::crd::{
255        AuthMethod, EncryptionKeyRef, EncryptionMode, KanidmBackupRepositorySpec,
256        KanidmBackupScheduleSpec, RepositoryAuthentication, RepositoryEncryption, S3Config,
257        ScheduleKanidmRef, ScheduleRepositoryRef, SecretRef,
258    };
259    use kube::api::ObjectMeta;
260
261    use crate::kanidm::crd::{
262        KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate, ReplicaGroup,
263    };
264
265    fn make_kanidm_with_status(name: &str, namespace: &str, version_tag: Option<&str>) -> Kanidm {
266        let status = version_tag.map(|tag| crate::kanidm::crd::KanidmStatus {
267            version: Some(crate::kanidm::crd::KanidmVersionStatus {
268                image_tag: tag.to_string(),
269                upgrade_check_result: crate::kanidm::crd::KanidmUpgradeCheckResult::Passed,
270                compatibility_result: crate::kanidm::crd::VersionCompatibilityResult::Compatible,
271            }),
272            ..Default::default()
273        });
274        Kanidm {
275            metadata: ObjectMeta {
276                name: Some(name.to_string()),
277                namespace: Some(namespace.to_string()),
278                uid: Some("kanidm-uid-123".to_string()),
279                ..Default::default()
280            },
281            spec: KanidmSpec {
282                domain: "idm.example.com".to_string(),
283                storage: Some(KanidmStorage {
284                    volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
285                    ..Default::default()
286                }),
287                replica_groups: vec![ReplicaGroup {
288                    name: "default".to_string(),
289                    replicas: 1,
290                    primary_node: true,
291                    ..Default::default()
292                }],
293                ..Default::default()
294            },
295            status,
296        }
297    }
298
299    fn make_schedule(
300        name: &str,
301        kanidm_name: &str,
302        repo_name: &str,
303        suspend: bool,
304    ) -> KanidmBackupSchedule {
305        KanidmBackupSchedule {
306            metadata: ObjectMeta {
307                name: Some(name.to_string()),
308                namespace: Some("default".to_string()),
309                ..Default::default()
310            },
311            spec: KanidmBackupScheduleSpec {
312                kanidm_ref: ScheduleKanidmRef {
313                    name: kanidm_name.to_string(),
314                },
315                repository_ref: ScheduleRepositoryRef {
316                    name: repo_name.to_string(),
317                },
318                schedule: "0 2 * * *".to_string(),
319                time_zone: "UTC".to_string(),
320                suspend,
321                concurrency_policy: "Forbid".to_string(),
322                jitter_seconds: None,
323                local_versions: 7,
324                retention: None,
325            },
326            status: None,
327        }
328    }
329
330    fn make_repository(name: &str, ready: bool) -> KanidmBackupRepository {
331        let method = AuthMethod {
332            workload_identity: None,
333            secret_ref: Some(SecretRef {
334                name: "backup-secret".to_string(),
335            }),
336        };
337        let mut repo = KanidmBackupRepository {
338            metadata: ObjectMeta {
339                name: Some(name.to_string()),
340                namespace: Some("default".to_string()),
341                ..Default::default()
342            },
343            spec: KanidmBackupRepositorySpec {
344                s3: S3Config {
345                    bucket: "test-bucket".to_string(),
346                    prefix: "backups".to_string(),
347                    region: "us-east-1".to_string(),
348                    endpoint: "https://s3.example.com".to_string(),
349                    force_path_style: false,
350                    ca_bundle_ref: None,
351                    insecure: false,
352                },
353                authentication: RepositoryAuthentication {
354                    writer: method.clone(),
355                    reader: method.clone(),
356                    deleter: method,
357                },
358                encryption: None,
359                limits: None,
360            },
361            status: None,
362        };
363        if ready {
364            repo.status = Some(kaniop_backup_core::crd::KanidmBackupRepositoryStatus {
365                observed_generation: Some(1),
366                usage_started: None,
367                conditions: vec![k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
368                    type_: "Ready".to_string(),
369                    status: "True".to_string(),
370                    observed_generation: Some(1),
371                    last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
372                        k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
373                    ),
374                    reason: "Accepted".to_string(),
375                    message: "Repository configuration accepted".to_string(),
376                }],
377            });
378        }
379        repo
380    }
381
382    #[test]
383    fn no_schedule_means_no_backup_config() {
384        let kanidm = make_kanidm_with_status("test-kanidm", "default", None);
385        assert!(resolve_backup_config(&kanidm, &[], &[]).is_none());
386    }
387
388    #[test]
389    fn suspended_schedule_disables_native_backup_and_transport() {
390        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
391        let schedule = make_schedule("sched", "test-kanidm", "repo", true);
392        let repo = make_repository("repo", true);
393        assert!(resolve_backup_config(&kanidm, &[schedule], &[repo]).is_none());
394    }
395
396    #[test]
397    fn schedule_drives_native_backup_even_when_repository_is_not_ready() {
398        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
399        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
400        let repo = make_repository("repo", false);
401        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
402        assert_eq!(config.schedule, "0 2 * * *");
403        assert_eq!(config.local_versions, 7);
404        assert!(config.transport.is_none());
405    }
406
407    #[test]
408    fn native_backup_does_not_wait_for_kanidm_status() {
409        let kanidm = make_kanidm_with_status("test-kanidm", "default", None);
410        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
411        let repo = make_repository("repo", true);
412        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
413        assert!(config.transport.is_none());
414    }
415
416    #[test]
417    fn unlocked_repository_cannot_start_transport() {
418        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
419        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
420        let mut repo = make_repository("repo", true);
421        repo.status.as_mut().unwrap().usage_started = Some(false);
422        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
423        assert!(config.transport.is_none());
424    }
425
426    #[test]
427    fn disabled_upgrade_checks_still_render_backup_transport_and_source_version() {
428        let mut kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.12.0"));
429        kanidm.spec.disable_upgrade_checks = true;
430        let version = kanidm.status.as_mut().unwrap().version.as_mut().unwrap();
431        version.upgrade_check_result = crate::kanidm::crd::KanidmUpgradeCheckResult::Skipped;
432        version.compatibility_result = crate::kanidm::crd::VersionCompatibilityResult::NotChecked;
433
434        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
435        let repo = make_repository("repo", true);
436        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
437        let transport = config
438            .transport
439            .expect("transport must not depend on upgrade checks");
440        let operation: serde_json::Value =
441            serde_json::from_str(&transport.operation_doc_json).unwrap();
442        assert_eq!(operation["kanidmVersion"], "1.12.0");
443    }
444
445    #[test]
446    fn ready_repository_adds_transport() {
447        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
448        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
449        let repo = make_repository("repo", true);
450        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
451        let transport = config.transport.expect("transport should be configured");
452        assert!(transport.operation_doc_json.contains("transport"));
453        assert!(transport.operation_doc_json.contains("test-bucket"));
454    }
455
456    #[test]
457    fn multiple_schedules_fail_closed_even_if_one_is_suspended() {
458        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
459        let schedule1 = make_schedule("sched1", "test-kanidm", "repo1", false);
460        let schedule2 = make_schedule("sched2", "test-kanidm", "repo2", true);
461        let repo1 = make_repository("repo1", true);
462        let repo2 = make_repository("repo2", true);
463        assert!(resolve_backup_config(&kanidm, &[schedule1, schedule2], &[repo1, repo2]).is_none());
464    }
465
466    #[test]
467    fn invalid_backup_target_fails_closed() {
468        let mut kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
469        kanidm.spec.storage = None;
470        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
471        let repo = make_repository("repo", true);
472        assert!(resolve_backup_config(&kanidm, &[schedule], &[repo]).is_none());
473    }
474
475    #[test]
476    fn transport_config_includes_encryption_key_ref_when_client_side() {
477        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
478        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
479        let mut repo = make_repository("repo", true);
480        repo.spec.encryption = Some(RepositoryEncryption {
481            mode: EncryptionMode::ClientSide,
482            key_id: None,
483            key_ref: Some(EncryptionKeyRef {
484                name: "kek-secret".to_string(),
485                key: "encryption-key".to_string(),
486            }),
487        });
488        repo.status.as_mut().unwrap().conditions.push(
489            k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
490                type_: "EncryptionKeyReady".to_string(),
491                status: "True".to_string(),
492                observed_generation: Some(1),
493                last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
494                    k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
495                ),
496                reason: "KeyPresent".to_string(),
497                message: "Key available".to_string(),
498            },
499        );
500        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
501        let transport = config.transport.expect("transport should be configured");
502        assert!(transport.encryption_key_ref.is_some());
503        assert_eq!(transport.encryption_key_ref.unwrap().name, "kek-secret");
504    }
505
506    #[test]
507    fn transport_config_omits_encryption_key_ref_when_no_encryption() {
508        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
509        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
510        let repo = make_repository("repo", true);
511        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
512        let transport = config.transport.expect("transport should be configured");
513        assert!(transport.encryption_key_ref.is_none());
514    }
515
516    #[test]
517    fn transport_config_omits_encryption_key_ref_when_provider_managed() {
518        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
519        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
520        let mut repo = make_repository("repo", true);
521        repo.spec.encryption = Some(RepositoryEncryption {
522            mode: EncryptionMode::ProviderManaged,
523            key_id: None,
524            key_ref: None,
525        });
526        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
527        let transport = config.transport.expect("transport should be configured");
528        assert!(transport.encryption_key_ref.is_none());
529    }
530
531    #[test]
532    fn is_encryption_key_ready_true_when_no_encryption() {
533        let repo = make_repository("repo", true);
534        assert!(is_encryption_key_ready(&repo));
535    }
536
537    #[test]
538    fn is_encryption_key_ready_true_when_provider_managed() {
539        let mut repo = make_repository("repo", true);
540        repo.spec.encryption = Some(RepositoryEncryption {
541            mode: EncryptionMode::ProviderManaged,
542            key_id: None,
543            key_ref: None,
544        });
545        assert!(is_encryption_key_ready(&repo));
546    }
547
548    #[test]
549    fn is_encryption_key_ready_false_when_client_side_no_status() {
550        let mut repo = make_repository("repo", true);
551        repo.spec.encryption = Some(RepositoryEncryption {
552            mode: EncryptionMode::ClientSide,
553            key_id: None,
554            key_ref: Some(EncryptionKeyRef {
555                name: "kek-secret".to_string(),
556                key: "encryption-key".to_string(),
557            }),
558        });
559        repo.status
560            .as_mut()
561            .unwrap()
562            .conditions
563            .retain(|c| c.type_ != "EncryptionKeyReady");
564        assert!(!is_encryption_key_ready(&repo));
565    }
566
567    #[test]
568    fn is_encryption_key_ready_false_when_client_side_condition_false() {
569        let mut repo = make_repository("repo", true);
570        repo.spec.encryption = Some(RepositoryEncryption {
571            mode: EncryptionMode::ClientSide,
572            key_id: None,
573            key_ref: Some(EncryptionKeyRef {
574                name: "kek-secret".to_string(),
575                key: "encryption-key".to_string(),
576            }),
577        });
578        repo.status.as_mut().unwrap().conditions.push(
579            k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
580                type_: "EncryptionKeyReady".to_string(),
581                status: "False".to_string(),
582                observed_generation: Some(1),
583                last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
584                    k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
585                ),
586                reason: "MissingSecret".to_string(),
587                message: "Secret not found".to_string(),
588            },
589        );
590        assert!(!is_encryption_key_ready(&repo));
591    }
592
593    #[test]
594    fn is_encryption_key_ready_true_when_client_side_condition_true() {
595        let mut repo = make_repository("repo", true);
596        repo.spec.encryption = Some(RepositoryEncryption {
597            mode: EncryptionMode::ClientSide,
598            key_id: None,
599            key_ref: Some(EncryptionKeyRef {
600                name: "kek-secret".to_string(),
601                key: "encryption-key".to_string(),
602            }),
603        });
604        repo.status.as_mut().unwrap().conditions.push(
605            k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
606                type_: "EncryptionKeyReady".to_string(),
607                status: "True".to_string(),
608                observed_generation: Some(1),
609                last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
610                    k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
611                ),
612                reason: "KeyPresent".to_string(),
613                message: "Key available".to_string(),
614            },
615        );
616        assert!(is_encryption_key_ready(&repo));
617    }
618
619    #[test]
620    fn transport_not_injected_when_encryption_key_not_ready() {
621        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
622        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
623        let mut repo = make_repository("repo", true);
624        repo.spec.encryption = Some(RepositoryEncryption {
625            mode: EncryptionMode::ClientSide,
626            key_id: None,
627            key_ref: Some(EncryptionKeyRef {
628                name: "kek-secret".to_string(),
629                key: "encryption-key".to_string(),
630            }),
631        });
632        repo.status.as_mut().unwrap().conditions.push(
633            k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
634                type_: "EncryptionKeyReady".to_string(),
635                status: "False".to_string(),
636                observed_generation: Some(1),
637                last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
638                    k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
639                ),
640                reason: "MissingSecret".to_string(),
641                message: "Secret not found".to_string(),
642            },
643        );
644        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
645        assert!(
646            config.transport.is_none(),
647            "sidecar must not be injected when KEK is missing"
648        );
649    }
650
651    #[test]
652    fn transport_injected_when_encryption_key_ready() {
653        let kanidm = make_kanidm_with_status("test-kanidm", "default", Some("1.0.0"));
654        let schedule = make_schedule("sched", "test-kanidm", "repo", false);
655        let mut repo = make_repository("repo", true);
656        repo.spec.encryption = Some(RepositoryEncryption {
657            mode: EncryptionMode::ClientSide,
658            key_id: None,
659            key_ref: Some(EncryptionKeyRef {
660                name: "kek-secret".to_string(),
661                key: "encryption-key".to_string(),
662            }),
663        });
664        repo.status.as_mut().unwrap().conditions.push(
665            k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition {
666                type_: "EncryptionKeyReady".to_string(),
667                status: "True".to_string(),
668                observed_generation: Some(1),
669                last_transition_time: k8s_openapi::apimachinery::pkg::apis::meta::v1::Time(
670                    k8s_openapi::jiff::Timestamp::new(1704067200, 0).unwrap(),
671                ),
672                reason: "KeyPresent".to_string(),
673                message: "Key available".to_string(),
674            },
675        );
676        let config = resolve_backup_config(&kanidm, &[schedule], &[repo]).unwrap();
677        assert!(
678            config.transport.is_some(),
679            "sidecar should be injected when KEK is ready"
680        );
681    }
682}