add a test

Author: hawkw

nexus/db-queries/src/db/datastore/fm.rs

@@ -990,7 +990,7 @@ mod tests {
             .collect::<BTreeSet<_>>();
         assert_eq!(dbg!(&listed_orphans), &orphans_v1);
 
-        // Next, create a new sitrep which descends from sitrep 0.
+        // Next, create a new sitrep which descends from sitrep 1.
         let sitrep2 = fm::Sitrep {
             metadata: fm::SitrepMetadata {
                 id: SitrepUuid::new_v4(),
@@ -1006,7 +1006,7 @@ mod tests {
             .await
             .expect("inserting child sitrep should succeed");
 
-        // Now, create some orphaned sitreps which also descend from sitreo 0.
+        // Now, create some orphaned sitreps which also descend from sitrep 1.
         let mut orphans_v2 = BTreeSet::new();
         for i in 1..5 {
             insert_orphan(

nexus/src/app/background/tasks/fm_sitrep_gc.rs

@@ -175,3 +175,173 @@ impl SitrepGc {
         status
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::Utc;
+    use nexus_db_queries::db::datastore::fm::InsertSitrepError;
+    use nexus_db_queries::db::pub_test_utils::TestDatabase;
+    use nexus_types::fm;
+    use omicron_common::api::external::Error;
+    use omicron_test_utils::dev;
+    use omicron_uuid_kinds::CollectionUuid;
+    use omicron_uuid_kinds::OmicronZoneUuid;
+    use omicron_uuid_kinds::SitrepUuid;
+    use std::collections::BTreeSet;
+
+    #[tokio::test]
+    async fn test_orphaned_sitrep_gc() {
+        let logctx = dev::test_setup_log("test_orphaned_sitrep_gc");
+        let db = TestDatabase::new_with_datastore(&logctx.log).await;
+        let (opctx, datastore) = (db.opctx(), db.datastore());
+
+        let mut task = SitrepGc::new(datastore.clone());
+
+        // First, insert an initial sitrep. This should succeed.
+        let sitrep1 = fm::Sitrep {
+            metadata: fm::SitrepMetadata {
+                id: SitrepUuid::new_v4(),
+                inv_collection_id: CollectionUuid::new_v4(),
+                creator_id: OmicronZoneUuid::new_v4(),
+                comment: "test sitrep v1".to_string(),
+                time_created: Utc::now(),
+                parent_sitrep_id: None,
+            },
+        };
+        datastore
+            .fm_sitrep_insert(&opctx, &sitrep1)
+            .await
+            .expect("inserting initial sitrep should succeed");
+
+        // Now, create some orphaned sitreps which also have no parent.
+        let mut orphans = BTreeSet::new();
+        for i in 1..5 {
+            insert_orphan(&datastore, &opctx, &mut orphans, None, 1, i).await;
+        }
+
+        // Next, create a new sitrep which descends from sitrep 1.
+        let sitrep2 = fm::Sitrep {
+            metadata: fm::SitrepMetadata {
+                id: SitrepUuid::new_v4(),
+                inv_collection_id: CollectionUuid::new_v4(),
+                creator_id: OmicronZoneUuid::new_v4(),
+                comment: "test sitrep v2".to_string(),
+                time_created: Utc::now(),
+                parent_sitrep_id: Some(sitrep1.metadata.id),
+            },
+        };
+        datastore
+            .fm_sitrep_insert(&opctx, &sitrep2)
+            .await
+            .expect("inserting child sitrep should succeed");
+
+        // Now, create some orphaned sitreps which also descend from sitrep 1.
+        for i in 1..4 {
+            insert_orphan(
+                &datastore,
+                &opctx,
+                &mut orphans,
+                Some(sitrep1.metadata.id),
+                2,
+                i,
+            )
+            .await;
+        }
+
+        // Make sure the orphans exist.
+        for &id in &orphans {
+            match datastore.fm_sitrep_metadata_read(&opctx, id).await {
+                Ok(_) => {}
+                Err(Error::NotFound { .. }) => {
+                    panic!("orphaned sitrep {id} should exist");
+                }
+                Err(e) => {
+                    panic!(
+                        "unexpected error reading orphaned sitrep {id}: {e}"
+                    );
+                }
+            }
+        }
+
+        // Activate the background task.
+        let status = dbg!(task.actually_activate(opctx).await);
+
+        // Now, the orphans should all be gone.
+        for &id in &orphans {
+            match datastore.fm_sitrep_metadata_read(&opctx, id).await {
+                Ok(_) => {
+                    panic!(
+                        "orphaned sitrep {id} should have been deleted, \
+                         but it appears to still exist!"
+                    )
+                }
+                Err(Error::NotFound { .. }) => {
+                    // Okay, it's gone.
+                }
+                Err(e) => {
+                    panic!(
+                        "unexpected error reading orphaned sitrep {id}: {e}"
+                    );
+                }
+            }
+        }
+        // But the non-orphaned sitreps should still be there!
+        datastore
+            .fm_sitrep_metadata_read(&opctx, sitrep1.id())
+            .await
+            .expect("sitrep 1 should still exist");
+        datastore
+            .fm_sitrep_metadata_read(&opctx, sitrep2.id())
+            .await
+            .expect("sitrep 2 should still exist");
+
+        assert_eq!(status.errors, Vec::<String>::new());
+        assert_eq!(status.versions_scanned, 2);
+        assert_eq!(
+            status.orphaned_sitreps.get(&1),
+            Some(&OrphanedSitreps { found: 4, deleted: 4 })
+        );
+        assert_eq!(
+            status.orphaned_sitreps.get(&2),
+            Some(&OrphanedSitreps { found: 3, deleted: 3 })
+        );
+
+        db.terminate().await;
+        logctx.cleanup_successful();
+    }
+
+    async fn insert_orphan(
+        datastore: &DataStore,
+        opctx: &OpContext,
+        orphans: &mut BTreeSet<SitrepUuid>,
+        parent_sitrep_id: Option<SitrepUuid>,
+        v: usize,
+        i: usize,
+    ) {
+        let sitrep = fm::Sitrep {
+            metadata: fm::SitrepMetadata {
+                id: SitrepUuid::new_v4(),
+                inv_collection_id: CollectionUuid::new_v4(),
+                creator_id: OmicronZoneUuid::new_v4(),
+                comment: format!("test sitrep v{i}; orphan {i}"),
+                time_created: Utc::now(),
+                parent_sitrep_id,
+            },
+        };
+        match datastore.fm_sitrep_insert(&opctx, &sitrep).await {
+            Ok(_) => {
+                panic!("inserting sitrep v{v} orphan {i} should not succeed")
+            }
+            Err(InsertSitrepError::ParentNotCurrent(id)) => {
+                orphans.insert(id);
+            }
+            Err(InsertSitrepError::Other(e)) => {
+                panic!(
+                    "expected inserting sitrep v{v} orphan {i} to fail because \
+                     its parent is out of date, but saw an unexpected error: {e}"
+                );
+            }
+        }
+    }
+}