TC-3071 add upload advisory and delete advisory scale test

Author: bxf12315

scenarios/full-20250604.json5

@@ -111,5 +111,6 @@
     "urn:uuid:01973122-384d-7002-886f-11dddf5040ad",
     "urn:uuid:01973122-3a0e-73f0-9596-baceb84383aa",
     "urn:uuid:01973122-3bdd-78a3-898a-fb67c06387ed"
-  ]
+  ],
+  "upload_advisory_file": "./test-data/advisories/rhba-2024_11505.json.xz"
 }

src/main.rs

@@ -211,7 +211,7 @@ async fn main() -> Result<(), anyhow::Error> {
                 "RestAPIUserDelete",
                 wait_time_from,
                 wait_time_to,
-                custom_client,
+                custom_client.clone(),
             )?
             .set_weight(1)?
             // With 100 SBOM IDs this ensure they all delete something in the sequential situation
@@ -225,6 +225,21 @@ async fn main() -> Result<(), anyhow::Error> {
             }
             s
         })
+        .register_scenario({
+            let mut s = create_scenario(
+                "RestAPIUploadAndDeleteFiles",
+                wait_time_from,
+                wait_time_to,
+                custom_client,
+            )?
+            .set_weight(1)?;
+
+            if let Some(file) = &scenario.upload_advisory_file {
+                // Use sequential transaction execution to ensure immediate deletion after upload
+                s = s.register_transaction(tx!(upload_and_immediately_delete(file.to_string())));
+            }
+            s
+        })
         // .register_scenario(
         //     scenario!("GraphQLUser")
         //         // .set_weight(1)?

src/restapi.rs

@@ -1,4 +1,4 @@
-use goose::goose::{GooseUser, TransactionResult};
+use goose::goose::{GooseUser, TransactionError, TransactionResult};
 use serde_json::json;
 use std::sync::{
     Arc,
@@ -8,6 +8,54 @@ use urlencoding::encode;
 
 use crate::utils::DisplayVec;
 
+/// Upload file and return advisory ID
+pub async fn upload_advisory_and_get_id(
+    advisory_file: String,
+    user: &mut GooseUser,
+) -> Result<String, Box<TransactionError>> {
+    let file_bytes = tokio::fs::read(&advisory_file).await.map_err(|e| {
+        Box::new(TransactionError::Custom(format!(
+            "Failed to read file {}: {}",
+            advisory_file, e
+        )))
+    })?;
+
+    let response = user.post("/api/v2/advisory", file_bytes).await?;
+    let v = response.response?.json::<serde_json::Value>().await?;
+
+    let advisory_id = v["id"]
+        .as_str()
+        .ok_or_else(|| {
+            Box::new(TransactionError::Custom(
+                "Missing advisory ID in response".to_string(),
+            ))
+        })?
+        .to_string();
+
+    Ok(advisory_id)
+}
+
+/// Delete advisory by ID
+pub async fn delete_advisory_by_id(advisory_id: String, user: &mut GooseUser) -> TransactionResult {
+    let uri = format!("/api/v2/advisory/{}", advisory_id);
+    user.delete(&uri).await?;
+    Ok(())
+}
+
+/// Sequential execution: upload and then immediately delete
+pub async fn upload_and_immediately_delete(
+    advisory_file: String,
+    user: &mut GooseUser,
+) -> TransactionResult {
+    // 1. Upload file and get ID
+    let advisory_id = upload_advisory_and_get_id(advisory_file, user).await?;
+
+    // 2. Immediately delete (no waiting required)
+    delete_advisory_by_id(advisory_id, user).await?;
+
+    Ok(())
+}
+
 pub async fn list_advisory(user: &mut GooseUser) -> TransactionResult {
     let _response = user.get("/api/v2/advisory").await?;
 

src/scenario/mod.rs

@@ -1,11 +1,10 @@
 mod purl;
 
 use crate::{scenario::purl::CanonicalPurl, utils::DisplayVec};
-use anyhow::{Context, anyhow};
+use anyhow::{Context, anyhow, bail};
 use serde_json::Value;
 use sqlx::{Executor, Row, postgres::PgRow};
-use std::io::BufReader;
-
+use std::{io::BufReader, path::PathBuf};
 /// implement to that we can explicitly state what we want
 mod required {
     use serde::{
@@ -96,6 +95,9 @@ pub(crate) struct Scenario {
 
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub delete_sbom_pool: Option<Vec<String>>,
+
+    #[serde(with = "required")]
+    pub upload_advisory_file: Option<String>,
 }
 
 impl Scenario {
@@ -136,6 +138,9 @@ impl Scenario {
                 .collect(),
         );
 
+        // Get advisory file paths from the advisories subdirectory within UPLOAD_FILE_PATH
+        let advisory_files = loader.load_advisory_files()?;
+
         Ok(Self {
             get_sbom: large_sbom_digest.clone(),
             get_sbom_advisories: large_sbom_digest.clone(),
@@ -150,6 +155,9 @@ impl Scenario {
             get_purl_details,
             get_recommendations: recommendations_purl,
             delete_sbom_pool,
+            upload_advisory_file: advisory_files
+                .first()
+                .map(|p| p.to_string_lossy().to_string()),
         })
     }
 }
@@ -356,6 +364,51 @@ LIMIT 100
             .map(|row| row.get::<String, _>("id"))
             .collect())
     }
+
+    /// Load advisory files from UPLOAD_FILE_PATH directory, or fall back to CARGO_MANIFEST_DIR
+    fn load_advisory_files(&self) -> anyhow::Result<Vec<PathBuf>> {
+        // Try UPLOAD_FILE_PATH first, then fall back to CARGO_MANIFEST_DIR
+        let base_path = std::env::var("UPLOAD_FILE_PATH")
+            .or_else(|_| Ok::<String, std::env::VarError>(env!("CARGO_MANIFEST_DIR").to_string()))
+            .ok()
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "Neither UPLOAD_FILE_PATH nor CARGO_MANIFEST_DIR environment variables are set"
+                )
+            })?;
+
+        let advisories_dir: PathBuf = [&base_path, "advisories"].iter().collect();
+
+        let entries = std::fs::read_dir(&advisories_dir).with_context(|| {
+            format!(
+                "failed to read advisories directory: {}",
+                advisories_dir.display()
+            )
+        })?;
+
+        let files: Vec<PathBuf> = entries
+            .filter_map(|entry| {
+                let path = entry.ok()?.path();
+                if path.extension()? == "xz" {
+                    Some(path)
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        if files.is_empty() {
+            bail!("No advisory files found in {}", advisories_dir.display());
+        } else {
+            log::info!(
+                "Found {} advisory files in {}",
+                files.len(),
+                advisories_dir.display()
+            );
+        }
+
+        Ok(files)
+    }
 }
 
 #[cfg(test)]