1use crate::{ObservedInventoryBatch, Platform, ResourceHeartbeat, StackState};
4use alien_error::AlienError;
5use bon::Builder;
6use indexmap::IndexMap;
7use serde::{Deserialize, Serialize};
8use std::collections::BTreeMap;
9
10use super::{DeploymentStatus, EnvironmentInfo, ReleaseInfo};
11
12#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
14#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
15#[serde(rename_all = "camelCase")]
16pub enum InitialSetupAuthority {
17 #[default]
20 ImportedHandoff,
21 DirectSetup,
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
27#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
28#[serde(rename_all = "camelCase")]
29pub struct SetupUpdateAuthorization {
30 pub nonce: String,
32 pub baseline_frozen_digest: String,
35 pub target_frozen_digest: String,
38 pub release_id: String,
40 pub setup_target: String,
42 pub setup_fingerprint: String,
44 pub setup_fingerprint_version: u32,
46}
47
48#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
50#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
51#[serde(rename_all = "camelCase")]
52pub struct SetupReportRefusal {
53 pub reason: String,
55 pub reported_release_id: String,
57 pub at: chrono::DateTime<chrono::Utc>,
59}
60
61#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
65#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
66#[serde(rename_all = "camelCase")]
67pub struct CloudSetupRequired {
68 pub release_id: String,
70 pub reason: String,
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
77#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
78#[serde(rename_all = "camelCase")]
79pub struct InstalledHelmRelease {
80 pub name: String,
82 pub namespace: String,
84}
85
86#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
88#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
89#[serde(rename_all = "camelCase")]
90pub struct CredentialRetry {
91 pub started_at: chrono::DateTime<chrono::Utc>,
93 pub status: DeploymentStatus,
95}
96
97#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
100#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
101#[serde(rename_all = "camelCase")]
102pub enum DeletionPolicy {
103 #[default]
104 Retain,
105 Erase,
106}
107
108#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
110#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
111#[serde(rename_all = "camelCase")]
112pub struct AirgappedReportMetadata {
113 #[serde(default, skip_serializing_if = "Option::is_none")]
115 pub written_at: Option<chrono::DateTime<chrono::Utc>>,
116 pub received_at: chrono::DateTime<chrono::Utc>,
118}
119
120#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
124#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
125#[serde(rename_all = "camelCase")]
126pub struct RuntimeMetadata {
127 #[serde(default)]
129 pub deletion_policy: DeletionPolicy,
130
131 #[serde(default, skip_serializing_if = "Option::is_none")]
133 pub airgapped_report: Option<AirgappedReportMetadata>,
134
135 #[serde(default, skip_serializing_if = "Option::is_none")]
139 pub operator_version: Option<String>,
140
141 #[serde(default, skip_serializing_if = "Option::is_none")]
143 pub credential_retry: Option<CredentialRetry>,
144
145 #[serde(default)]
148 pub initial_setup_authority: InitialSetupAuthority,
149
150 #[serde(default, skip_serializing_if = "super::is_false")]
153 pub automatic_setup: bool,
154
155 #[serde(default, skip_serializing_if = "super::is_false")]
161 pub first_setup_machines_unselected: bool,
162
163 #[serde(skip_serializing_if = "Option::is_none")]
166 pub last_synced_env_vars_hash: Option<String>,
167
168 #[serde(default, skip_serializing_if = "Vec::is_empty")]
172 pub last_synced_secret_names: Vec<String>,
173
174 #[serde(default, skip_serializing_if = "is_false")]
178 pub vault_credentials_revoked: bool,
179
180 #[serde(default, skip_serializing_if = "Option::is_none")]
185 pub retained_storage_protection_hash: Option<String>,
186
187 #[serde(default, skip_serializing_if = "Option::is_none")]
190 pub retained_storage_protection_confirmed_at: Option<chrono::DateTime<chrono::Utc>>,
191
192 #[serde(default, skip_serializing_if = "Option::is_none")]
195 pub retained_data_protection_started_at: Option<chrono::DateTime<chrono::Utc>>,
196
197 #[serde(skip_serializing_if = "Option::is_none")]
201 pub prepared_stack: Option<crate::Stack>,
202
203 #[serde(default, skip_serializing_if = "IndexMap::is_empty")]
211 pub persisted_gate_answers: GateAnswers,
212
213 #[serde(default, skip_serializing_if = "Option::is_none")]
216 pub pending_prepared_stack: Option<crate::Stack>,
217
218 #[serde(default, skip_serializing_if = "Option::is_none")]
223 pub pending_prepared_release_id: Option<String>,
224
225 #[serde(default, skip_serializing_if = "Option::is_none")]
228 pub setup_update_authorization: Option<SetupUpdateAuthorization>,
229
230 #[serde(default, skip_serializing_if = "Option::is_none")]
233 pub setup_report_refusal: Option<SetupReportRefusal>,
234
235 #[serde(default, skip_serializing_if = "Option::is_none")]
238 pub cloud_setup_required: Option<CloudSetupRequired>,
239
240 #[serde(default, skip_serializing_if = "Option::is_none")]
242 pub installed_helm_release: Option<InstalledHelmRelease>,
243
244 #[serde(default, skip_serializing_if = "Option::is_none")]
248 pub direct_setup_revision: Option<String>,
249
250 #[serde(default, skip_serializing_if = "is_false")]
255 pub registry_access_granted: bool,
256
257 #[serde(default, skip_serializing_if = "Option::is_none")]
261 pub registry_access: Option<RegistryAccess>,
262
263 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
266 pub setup_scaffolding: BTreeMap<String, SetupScaffolding>,
267
268 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
271 pub gcp_sandbox_scaffolding: BTreeMap<String, GcpSandboxScaffolding>,
272
273 #[serde(default, skip_serializing_if = "Vec::is_empty")]
277 pub deployer_secrets: Vec<crate::DeployerSecretReport>,
278
279 #[serde(default, skip_serializing_if = "Vec::is_empty")]
283 pub ai_access_checks: Vec<AiAccessCheck>,
284 #[serde(default, skip_serializing_if = "Option::is_none")]
288 pub deployer_secrets_checked_at: Option<chrono::DateTime<chrono::Utc>>,
289
290 #[serde(default, skip_serializing_if = "Vec::is_empty")]
295 pub resources_waiting_for_secrets: Vec<String>,
296}
297
298#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
300#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
301#[serde(rename_all = "camelCase")]
302pub struct AiAccessCheck {
303 pub resource_id: String,
305 pub model_id: String,
307 pub result: AiAccessCheckResult,
309 #[serde(default, skip_serializing_if = "Option::is_none")]
311 pub detail: Option<String>,
312 pub tested_at: chrono::DateTime<chrono::Utc>,
313}
314
315#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
316#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
317#[serde(rename_all = "kebab-case")]
318pub enum AiAccessCheckResult {
319 Verified,
320 Refused,
321 NotChecked,
322}
323
324#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
326#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
327#[serde(rename_all = "camelCase", tag = "type")]
328pub enum SetupScaffolding {
329 #[serde(rename_all = "camelCase")]
331 AwsSandbox {
332 build_role_name: String,
334 #[serde(default, skip_serializing_if = "Option::is_none")]
336 egress: Option<AwsSandboxEgressScaffolding>,
337 #[serde(default, skip_serializing_if = "Option::is_none")]
340 image_arn: Option<String>,
341 },
342}
343
344#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
352#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
353#[serde(rename_all = "camelCase")]
354pub struct GcpSandboxScaffolding {
355 pub image_repository: String,
357 pub write_role: String,
359 #[serde(default)]
361 pub writer_granted: bool,
362}
363
364#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
367#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
368#[serde(rename_all = "camelCase")]
369pub struct AwsSandboxEgressScaffolding {
370 pub operator_role_name: String,
372 #[serde(default, skip_serializing_if = "Option::is_none")]
374 pub security_group_id: Option<String>,
375 #[serde(default, skip_serializing_if = "Option::is_none")]
377 pub connector_arn: Option<String>,
378 #[serde(default, skip_serializing_if = "Option::is_none")]
381 pub connector_request: Option<String>,
382}
383
384impl SetupScaffolding {
385 pub fn fill_missing(&mut self, found: SetupScaffolding) {
388 match (self, found) {
389 (
390 SetupScaffolding::AwsSandbox {
391 egress, image_arn, ..
392 },
393 SetupScaffolding::AwsSandbox {
394 egress: found_egress,
395 image_arn: found_image_arn,
396 ..
397 },
398 ) => {
399 if image_arn.is_none() {
400 *image_arn = found_image_arn;
401 }
402 match (egress.as_mut(), found_egress) {
403 (None, found_egress) => *egress = found_egress,
404 (Some(recorded), Some(found)) => {
405 if recorded.security_group_id.is_none() {
406 recorded.security_group_id = found.security_group_id;
407 }
408 if recorded.connector_arn.is_none() {
409 recorded.connector_arn = found.connector_arn;
410 }
411 }
412 (Some(_), None) => {}
413 }
414 }
415 }
416 }
417}
418
419#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
421#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
422#[serde(rename_all = "camelCase")]
423pub struct RegistryAccess {
424 #[serde(default, skip_serializing_if = "Vec::is_empty")]
426 pub repositories: Vec<String>,
427
428 #[serde(default, skip_serializing_if = "Vec::is_empty")]
431 pub service_types: Vec<String>,
432
433 #[serde(default, skip_serializing_if = "Option::is_none")]
436 pub verifier: Option<String>,
437}
438
439#[derive(Debug, Clone, Serialize, Deserialize, Builder)]
447#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
448#[serde(rename_all = "camelCase")]
449pub struct DeploymentState {
450 pub status: DeploymentStatus,
452 pub platform: Platform,
454 #[serde(skip_serializing_if = "Option::is_none")]
456 pub current_release: Option<ReleaseInfo>,
457 #[serde(skip_serializing_if = "Option::is_none")]
459 pub target_release: Option<ReleaseInfo>,
460 #[serde(skip_serializing_if = "Option::is_none")]
462 pub stack_state: Option<StackState>,
463 #[serde(skip_serializing_if = "Option::is_none")]
467 pub error: Option<AlienError>,
468 #[serde(skip_serializing_if = "Option::is_none")]
470 pub environment_info: Option<EnvironmentInfo>,
471 #[serde(skip_serializing_if = "Option::is_none")]
473 pub runtime_metadata: Option<RuntimeMetadata>,
474 #[serde(default, skip_serializing_if = "is_false")]
477 pub retry_requested: bool,
478 pub protocol_version: u32,
483}
484
485impl DeploymentState {
486 pub fn has_desired(&self) -> bool {
489 self.current_release.is_some()
490 || self.target_release.is_some()
491 || self.stack_state.is_some()
492 }
493
494 pub fn unfinished_update(&self) -> Option<(&str, &crate::Stack)> {
499 let metadata = self.runtime_metadata.as_ref()?;
500 let stack = metadata.pending_prepared_stack.as_ref()?;
501 let prepared_from = metadata.pending_prepared_release_id.as_deref()?;
502 let target = self.target_release.as_ref()?.release_id.as_deref()?;
503 (prepared_from != target).then_some((prepared_from, stack))
504 }
505
506 pub fn applied_stack(&self) -> Option<&crate::Stack> {
509 self.unfinished_update()
510 .map(|(_, stack)| stack)
511 .or(self.target_release.as_ref().map(|release| &release.stack))
512 .or(self.current_release.as_ref().map(|release| &release.stack))
513 }
514}
515
516#[derive(Debug, Clone, Serialize, Deserialize)]
521#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
522#[serde(rename_all = "camelCase")]
523pub struct DeploymentStepResult {
524 pub state: DeploymentState,
526
527 #[serde(skip_serializing_if = "Option::is_none")]
531 pub suggested_delay_ms: Option<u64>,
532
533 #[serde(default, skip_serializing_if = "is_false")]
537 pub update_heartbeat: bool,
538
539 #[serde(
541 default,
542 rename = "resourceHeartbeats",
543 skip_serializing_if = "Vec::is_empty"
544 )]
545 pub heartbeats: Vec<ResourceHeartbeat>,
546
547 #[serde(
549 default,
550 rename = "observedInventoryBatches",
551 skip_serializing_if = "Vec::is_empty"
552 )]
553 pub observed_inventory_batches: Vec<ObservedInventoryBatch>,
554}
555
556pub(crate) fn is_false(b: &bool) -> bool {
557 !*b
558}
559
560pub type GateAnswers = IndexMap<String, bool>;
562
563pub const MIN_SUPPORTED_DEPLOYMENT_PROTOCOL_VERSION: u32 = 1;
565
566pub const CURRENT_DEPLOYMENT_PROTOCOL_VERSION: u32 = 4;
570
571pub const MAX_SUPPORTED_DEPLOYMENT_PROTOCOL_VERSION: u32 = 4;
573
574pub const GCP_FEDERATION_DEPLOYMENT_PROTOCOL_VERSION: u32 = 2;
576
577pub fn deployment_protocol_version_for_platform(
578 _platform: crate::Platform,
579 _base_platform: Option<crate::Platform>,
580) -> u32 {
581 CURRENT_DEPLOYMENT_PROTOCOL_VERSION
582}
583
584pub fn accepts_deployment_protocol_report(registered: u32, reported: u32) -> bool {
588 (MIN_SUPPORTED_DEPLOYMENT_PROTOCOL_VERSION..=MAX_SUPPORTED_DEPLOYMENT_PROTOCOL_VERSION)
589 .contains(®istered)
590 && (reported == registered
591 || (registered < CURRENT_DEPLOYMENT_PROTOCOL_VERSION
592 && reported == CURRENT_DEPLOYMENT_PROTOCOL_VERSION))
593}
594
595pub const DEPLOYMENT_PROTOCOL_VERSION: u32 = CURRENT_DEPLOYMENT_PROTOCOL_VERSION;
597
598#[cfg(test)]
599mod tests {
600 use super::*;
601 use crate::{Platform, ReleaseInfo, Stack, StackState};
602 use indexmap::IndexMap;
603
604 fn empty_stack() -> Stack {
605 Stack {
606 id: "stack_test".to_string(),
607 resources: IndexMap::new(),
608 inputs: vec![],
609 dynamic_container_repositories: Vec::new(),
610 dynamic_container_image_resources: Vec::new(),
611 extensions: Vec::new(),
612 operations: None,
613 built_architectures: Default::default(),
614 permissions: crate::PermissionsConfig::default(),
615 supported_platforms: None,
616 }
617 }
618
619 fn release_info(id: &str) -> ReleaseInfo {
620 ReleaseInfo {
621 release_id: Some(id.to_string()),
622 version: None,
623 description: None,
624 stack: empty_stack(),
625 signed: None,
626 signer_lists: Vec::new(),
627 }
628 }
629
630 fn state() -> DeploymentState {
631 DeploymentState {
632 status: DeploymentStatus::Pending,
633 platform: Platform::Kubernetes,
634 current_release: None,
635 target_release: None,
636 stack_state: None,
637 error: None,
638 environment_info: None,
639 runtime_metadata: None,
640 retry_requested: false,
641 protocol_version: DEPLOYMENT_PROTOCOL_VERSION,
642 }
643 }
644
645 #[test]
646 fn deployment_state_has_desired_when_release_or_stack_state_exists() {
647 let observe_only = state();
648 assert!(!observe_only.has_desired());
649
650 let mut current = state();
651 current.current_release = Some(release_info("rel_current"));
652 assert!(current.has_desired());
653
654 let mut target = state();
655 target.target_release = Some(release_info("rel_target"));
656 assert!(target.has_desired());
657
658 let mut imported = state();
659 imported.stack_state = Some(StackState::new(Platform::Kubernetes));
660 assert!(imported.has_desired());
661 }
662
663 #[test]
667 fn an_unfinished_update_applies_the_stack_it_was_prepared_from() {
668 let mut in_flight = empty_stack();
669 in_flight.id = "in-flight".to_string();
670 let mut deployment = state();
671 deployment.current_release = Some(release_info("rel_a"));
672 deployment.target_release = Some(release_info("rel_c"));
673 assert_eq!(deployment.unfinished_update(), None);
674 assert_eq!(
675 deployment.applied_stack(),
676 Some(&deployment.target_release.as_ref().unwrap().stack)
677 );
678
679 deployment.runtime_metadata = Some(RuntimeMetadata {
680 pending_prepared_stack: Some(in_flight.clone()),
681 pending_prepared_release_id: Some("rel_b".to_string()),
682 ..Default::default()
683 });
684 assert_eq!(deployment.unfinished_update(), Some(("rel_b", &in_flight)));
685 assert_eq!(deployment.applied_stack(), Some(&in_flight));
686
687 deployment
689 .runtime_metadata
690 .as_mut()
691 .unwrap()
692 .pending_prepared_release_id = Some("rel_c".to_string());
693 assert_eq!(deployment.unfinished_update(), None);
694 }
695
696 #[test]
697 fn runtime_metadata_from_before_secret_inventory_defaults_to_empty() {
698 let metadata: RuntimeMetadata = serde_json::from_value(serde_json::json!({
699 "lastSyncedEnvVarsHash": "old-hash"
700 }))
701 .expect("old runtime metadata remains readable");
702
703 assert_eq!(
704 metadata.last_synced_env_vars_hash.as_deref(),
705 Some("old-hash")
706 );
707 assert!(metadata.last_synced_secret_names.is_empty());
708 assert!(!metadata.vault_credentials_revoked);
709 assert!(metadata.retained_storage_protection_hash.is_none());
710 assert!(metadata.retained_storage_protection_confirmed_at.is_none());
711 assert!(metadata.pending_prepared_stack.is_none());
712 assert!(metadata.setup_update_authorization.is_none());
713 assert!(metadata.setup_scaffolding.is_empty());
714 }
715
716 #[test]
718 fn setup_scaffolding_round_trips_in_its_persisted_form() {
719 let persisted = serde_json::json!({
720 "initialSetupAuthority": "directSetup",
721 "setupScaffolding": {
722 "agents": { "type": "awsSandbox", "buildRoleName": "acme-agents-build" }
723 }
724 });
725 let metadata: RuntimeMetadata =
726 serde_json::from_value(persisted.clone()).expect("persisted record reads");
727 assert_eq!(
728 metadata.setup_scaffolding["agents"],
729 SetupScaffolding::AwsSandbox {
730 build_role_name: "acme-agents-build".to_string(),
731 egress: None,
732 image_arn: None,
733 }
734 );
735 assert_eq!(metadata.deletion_policy, DeletionPolicy::Retain);
736 let mut expected = persisted;
737 expected["deletionPolicy"] = serde_json::json!("retain");
738 assert_eq!(serde_json::to_value(&metadata).unwrap(), expected);
739 assert!(
740 serde_json::to_value(RuntimeMetadata::default()).unwrap()["setupScaffolding"].is_null(),
741 "state with no scaffolding serializes as it did before the field existed"
742 );
743 }
744
745 #[derive(Debug, Deserialize)]
748 #[serde(rename_all = "camelCase", tag = "type")]
749 #[allow(dead_code)]
750 enum PreviousSetupScaffolding {
751 #[serde(rename_all = "camelCase")]
752 AwsSandbox { build_role_name: String },
753 }
754
755 #[derive(Debug, Deserialize)]
756 #[serde(rename_all = "camelCase")]
757 struct PreviousRuntimeMetadata {
758 #[serde(default)]
759 setup_scaffolding: BTreeMap<String, PreviousSetupScaffolding>,
760 }
761
762 #[test]
765 fn a_gcp_sandbox_record_loads_in_the_previous_release() {
766 let mut metadata = RuntimeMetadata::default();
767 metadata.gcp_sandbox_scaffolding.insert(
768 "agents".to_string(),
769 GcpSandboxScaffolding {
770 image_repository: "acme-agents-img".to_string(),
771 write_role: "acme_agents_image_write".to_string(),
772 writer_granted: true,
773 },
774 );
775 metadata.setup_scaffolding.insert(
776 "other".to_string(),
777 SetupScaffolding::AwsSandbox {
778 build_role_name: "acme-other-build".to_string(),
779 egress: None,
780 image_arn: None,
781 },
782 );
783 let written = serde_json::to_value(&metadata).unwrap();
784 let previous: PreviousRuntimeMetadata =
785 serde_json::from_value(written.clone()).expect("previous release reads the state");
786 assert_eq!(previous.setup_scaffolding.len(), 1);
787 let current: RuntimeMetadata = serde_json::from_value(written).unwrap();
788 assert_eq!(current, metadata);
789
790 let as_a_variant = serde_json::json!({
792 "setupScaffolding": { "agents": { "type": "gcpSandbox", "imageRepository": "r" } }
793 });
794 assert!(
795 serde_json::from_value::<PreviousRuntimeMetadata>(as_a_variant).is_err(),
796 "the fixture reader refuses an unknown variant, which is why the record has its own field"
797 );
798 }
799
800 #[test]
801 fn filling_a_record_takes_only_what_it_lacks() {
802 let egress = |group: Option<&str>, connector: Option<&str>| AwsSandboxEgressScaffolding {
803 operator_role_name: "acme-agents-egress".to_string(),
804 security_group_id: group.map(str::to_string),
805 connector_arn: connector.map(str::to_string),
806 connector_request: None,
807 };
808 let record = |egress| SetupScaffolding::AwsSandbox {
809 build_role_name: "acme-agents-build".to_string(),
810 egress,
811 image_arn: None,
812 };
813
814 let mut partial = record(Some(egress(Some("sg-recorded"), None)));
815 partial.fill_missing(record(Some(egress(Some("sg-found"), Some("arn:found")))));
816 assert_eq!(
817 partial,
818 record(Some(egress(Some("sg-recorded"), Some("arn:found")))),
819 "a recorded id is the one teardown deletes"
820 );
821
822 let mut role_only = record(None);
823 role_only.fill_missing(record(Some(egress(Some("sg-found"), None))));
824 assert_eq!(role_only, record(Some(egress(Some("sg-found"), None))));
825
826 let image = |arn: Option<&str>| SetupScaffolding::AwsSandbox {
827 build_role_name: "acme-agents-build".to_string(),
828 egress: None,
829 image_arn: arn.map(str::to_string),
830 };
831 let mut without_image = image(None);
832 without_image.fill_missing(image(Some("arn:found")));
833 assert_eq!(without_image, image(Some("arn:found")));
834 let mut with_image = image(Some("arn:recorded"));
835 with_image.fill_missing(image(Some("arn:found")));
836 assert_eq!(with_image, image(Some("arn:recorded")));
837 }
838
839 #[test]
841 fn a_partial_egress_record_round_trips_in_its_persisted_form() {
842 let persisted = serde_json::json!({
843 "type": "awsSandbox",
844 "buildRoleName": "acme-agents-build",
845 "egress": {
846 "operatorRoleName": "acme-agents-egress",
847 "securityGroupId": "sg-0123"
848 }
849 });
850 let record: SetupScaffolding =
851 serde_json::from_value(persisted.clone()).expect("persisted record reads");
852 assert_eq!(
853 record,
854 SetupScaffolding::AwsSandbox {
855 build_role_name: "acme-agents-build".to_string(),
856 egress: Some(AwsSandboxEgressScaffolding {
857 operator_role_name: "acme-agents-egress".to_string(),
858 security_group_id: Some("sg-0123".to_string()),
859 connector_arn: None,
860 connector_request: None,
861 }),
862 image_arn: None,
863 }
864 );
865 assert_eq!(serde_json::to_value(&record).unwrap(), persisted);
866 }
867}