| // Copyright 2026 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| use anyhow::{Context, Result}; | |
| use argh::FromArgs; | |
| use serde::{Deserialize, Serialize}; | |
| use std::collections::{BTreeMap, HashMap, HashSet}; | |
| use std::fs; | |
| use std::path::{Path, PathBuf}; | |
| use valico::json_schema; | |
| use walkdir::WalkDir; | |
| const INPUT_SCHEMA: &str = include_str!("../testing_input.schema.json"); | |
| #[derive(FromArgs)] | |
| /// Testing metadata collector tool. | |
| struct Args { | |
| /// path to the fuchsia directory. | |
| #[argh(option)] | |
| fuchsia_dir: PathBuf, | |
| /// path to the output JSON file. | |
| #[argh(option)] | |
| output: PathBuf, | |
| /// path to the output depfile. | |
| #[argh(option)] | |
| depfile: PathBuf, | |
| } | |
| #[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)] | |
| struct Coverage { | |
| #[serde(skip_serializing_if = "Option::is_none")] | |
| category: Option<String>, | |
| #[serde(skip_serializing_if = "Option::is_none")] | |
| subcategory: Option<String>, | |
| #[serde(skip_serializing_if = "Option::is_none")] | |
| pub tags: Option<Vec<String>>, | |
| #[serde(skip_serializing_if = "Option::is_none")] | |
| pub inherit_tags: Option<bool>, | |
| } | |
| #[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)] | |
| struct TestingMetadataSource { | |
| #[serde(skip_serializing_if = "Option::is_none")] | |
| coverage: Option<Coverage>, | |
| } | |
| #[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)] | |
| struct TestingMetadataDirectoryOutput { | |
| #[serde(skip_serializing_if = "Option::is_none")] | |
| coverage: Option<Coverage>, | |
| parent_directory: String, | |
| } | |
| #[derive(Debug, Serialize, Deserialize, PartialEq)] | |
| struct MetadataOutput { | |
| metadata: BTreeMap<String, TestingMetadataDirectoryOutput>, | |
| version: u32, | |
| } | |
| fn main() -> Result<()> { | |
| let args: Args = argh::from_env(); | |
| collect_metadata(args) | |
| } | |
| fn collect_metadata(args: Args) -> Result<()> { | |
| let abs_fuchsia_dir = if args.fuchsia_dir.is_absolute() { | |
| args.fuchsia_dir.clone() | |
| } else { | |
| std::env::current_dir()?.join(&args.fuchsia_dir) | |
| }; | |
| let abs_fuchsia_dir = fs::canonicalize(&abs_fuchsia_dir) | |
| .with_context(|| format!("failed to canonicalize fuchsia-dir: {:?}", abs_fuchsia_dir))?; | |
| let mut metadata_map: HashMap<PathBuf, TestingMetadataSource> = HashMap::new(); | |
| let mut dep_files = Vec::new(); | |
| let ignore_files = HashSet::from(["out", "prebuilt", "third_party"]); | |
| // Load the schema for validation. | |
| let mut scope = json_schema::Scope::new(); | |
| let schema_json: serde_json::Value = serde_json::from_str(INPUT_SCHEMA)?; | |
| let schema = scope | |
| .compile_and_return(schema_json, false) | |
| .map_err(|e| anyhow::anyhow!("invalid input schema: {:?}", e))?; | |
| let mut validation_errors = Vec::new(); | |
| let mut all_dirs = Vec::new(); | |
| for entry in WalkDir::new(&abs_fuchsia_dir).into_iter().filter_entry(|e| { | |
| if e.file_type().is_dir() { | |
| let name = e.file_name().to_string_lossy(); | |
| if e.depth() == 1 && (name.starts_with('.') || ignore_files.contains(name.as_ref())) { | |
| return false; | |
| } | |
| } | |
| true | |
| }) { | |
| let entry = entry.context("failed to read directory entry")?; | |
| if entry.file_type().is_dir() { | |
| let rel_dir = entry.path().strip_prefix(&abs_fuchsia_dir)?; | |
| if rel_dir == Path::new("") { | |
| all_dirs.push(PathBuf::from("")); | |
| } else { | |
| all_dirs.push(rel_dir.to_path_buf()); | |
| } | |
| continue; | |
| } | |
| if entry.file_name() != "TESTING.json5" { | |
| continue; | |
| } | |
| let path = entry.path(); | |
| let content = | |
| fs::read_to_string(path).with_context(|| format!("failed to read {:?}", path))?; | |
| let json_value: serde_json::Value = match serde_json5::from_str(&content) { | |
| Ok(v) => v, | |
| Err(e) => { | |
| validation_errors.push(anyhow::anyhow!("failed to parse {:?}: {e:?}", path)); | |
| continue; | |
| } | |
| }; | |
| // Validate the input file against the schema. | |
| let validate_result = schema.validate(&json_value); | |
| if !validate_result.is_valid() { | |
| validation_errors.push(anyhow::anyhow!( | |
| "file {:?} does not match schema: {:?}", | |
| path, | |
| validate_result.errors | |
| )); | |
| continue; | |
| } | |
| let source: TestingMetadataSource = serde_json::from_value(json_value) | |
| .with_context(|| format!("failed to decode {:?}", path))?; | |
| let rel_dir = entry | |
| .path() | |
| .parent() | |
| .unwrap() | |
| .strip_prefix(&abs_fuchsia_dir) | |
| .context("failed to get relative path")?; | |
| let key = if rel_dir == Path::new("") { PathBuf::from("") } else { rel_dir.to_path_buf() }; | |
| metadata_map.insert(key, source); | |
| let rel_path = path | |
| .strip_prefix(&abs_fuchsia_dir) | |
| .context("failed to get relative path for depfile")?; | |
| if !rel_path.is_absolute() { | |
| // CQ has a check that depfiles are not absolute. We can add the relative paths from | |
| // local builds here, but in CQ we have to skip adding depfiles. | |
| // | |
| // Fortunately, in CQ we do not modify the TESTING.json5 files directly, and the | |
| // dependency on build.ninja should be sufficient to ensure that this file is | |
| // regenerated following a new gn gen. | |
| dep_files.push(args.fuchsia_dir.join(rel_path)); | |
| } | |
| } | |
| if !validation_errors.is_empty() { | |
| // Validation failed, join all errors in a string and return. | |
| return Err(anyhow::anyhow!( | |
| "validation errors:\n{}", | |
| validation_errors.iter().map(|e| e.to_string()).collect::<Vec<_>>().join("\n"), | |
| )); | |
| } | |
| let mut final_metadata = BTreeMap::new(); | |
| for dir in all_dirs { | |
| let mut merged_source = TestingMetadataDirectoryOutput::default(); | |
| let mut components = Vec::new(); | |
| let mut p = dir.as_path(); | |
| while p != Path::new("") && p != Path::new(".") { | |
| components.push(p); | |
| p = match p.parent() { | |
| Some(parent) => parent, | |
| None => break, | |
| }; | |
| } | |
| components.push(Path::new("")); | |
| components.reverse(); | |
| for component in components { | |
| if let Some(source) = metadata_map.get(component) { | |
| merged_source.parent_directory = component.to_string_lossy().into_owned(); | |
| merge_metadata(&mut merged_source, source); | |
| } | |
| } | |
| final_metadata.insert(dir.to_string_lossy().into_owned(), merged_source); | |
| } | |
| let output_json = MetadataOutput { metadata: final_metadata, version: 1 }; | |
| let json_content = | |
| serde_json::to_string_pretty(&output_json).context("failed to serialize JSON")?; | |
| if let Some(parent) = args.output.parent() { | |
| fs::create_dir_all(parent)?; | |
| } | |
| fs::write(&args.output, json_content) | |
| .with_context(|| format!("failed to write output: {:?}", args.output))?; | |
| let mut depfile_content = format!("{}:", args.output.to_string_lossy()); | |
| // Rebuild the testing list if gn gen is run too. | |
| dep_files.push(PathBuf::from("build.ninja")); | |
| dep_files.sort(); | |
| for dep in dep_files { | |
| depfile_content.push_str(&format!(" {}", dep.to_string_lossy())); | |
| } | |
| if let Some(parent) = args.depfile.parent() { | |
| fs::create_dir_all(parent)?; | |
| } | |
| fs::write(&args.depfile, depfile_content) | |
| .with_context(|| format!("failed to write depfile: {:?}", args.depfile))?; | |
| Ok(()) | |
| } | |
| fn merge_metadata(target: &mut TestingMetadataDirectoryOutput, source: &TestingMetadataSource) { | |
| if let Some(source_cov) = &source.coverage { | |
| if target.coverage.is_none() { | |
| target.coverage = Some(Coverage::default()); | |
| } | |
| let target_cov = target.coverage.as_mut().unwrap(); | |
| if let Some(cat) = &source_cov.category { | |
| target_cov.category = Some(cat.clone()); | |
| } | |
| if let Some(subcat) = &source_cov.subcategory { | |
| target_cov.subcategory = Some(subcat.clone()); | |
| } | |
| if let Some(inherit) = source_cov.inherit_tags { | |
| if !inherit { | |
| target_cov.tags = None; | |
| } | |
| } | |
| if let Some(tags) = &source_cov.tags { | |
| if target_cov.tags.is_none() { | |
| target_cov.tags = Some(Vec::new()); | |
| } | |
| target_cov.tags.as_mut().unwrap().extend(tags.iter().cloned()); | |
| } | |
| } | |
| } | |
| #[cfg(test)] | |
| mod tests { | |
| use super::*; | |
| use pretty_assertions::assert_eq; | |
| const OUTPUT_SCHEMA: &str = include_str!("../testing_metadata.schema.json"); | |
| #[test] | |
| fn test_integration() -> Result<()> { | |
| let temp = tempfile::tempdir()?; | |
| let root = temp.path(); | |
| // Create TESTING.json5 at root | |
| fs::write( | |
| root.join("TESTING.json5"), | |
| r#"{ | |
| "coverage": { | |
| "category": "root_cat", | |
| "tags": ["tag1"] | |
| } | |
| }"#, | |
| )?; | |
| // Create a subdirectory with its own TESTING.json5 | |
| let sub = root.join("sub"); | |
| fs::create_dir(&sub)?; | |
| fs::write( | |
| sub.join("TESTING.json5"), | |
| r#"{ | |
| "coverage": { | |
| "subcategory": "sub_cat", | |
| "tags": ["tag2"] | |
| } | |
| }"#, | |
| )?; | |
| // Create another subdirectory without its own TESTING.toml | |
| let testdir = sub.join("testdir"); | |
| fs::create_dir(&testdir)?; | |
| let nested = testdir.join("nested"); | |
| fs::create_dir(&nested)?; | |
| fs::write( | |
| nested.join("TESTING.json5"), | |
| r#"{ | |
| "coverage": { | |
| "category": "nested_cat", | |
| "subcategory": "nested_subcat", | |
| "inherit_tags": false, | |
| "tags": ["nested_tag"] | |
| } | |
| }"#, | |
| )?; | |
| let output = root.join("out.json"); | |
| let depfile = root.join("out.d"); | |
| let args = Args { | |
| fuchsia_dir: root.to_path_buf(), | |
| output: output.clone(), | |
| depfile: depfile.clone(), | |
| }; | |
| collect_metadata(args)?; | |
| let json_content = fs::read_to_string(output)?; | |
| let result_json: serde_json::Value = serde_json::from_str(&json_content)?; | |
| let mut scope = json_schema::Scope::new(); | |
| let schema_json: serde_json::Value = serde_json::from_str(OUTPUT_SCHEMA)?; | |
| let schema = scope | |
| .compile_and_return(schema_json, false) | |
| .map_err(|e| anyhow::anyhow!("invalid output schema: {:?}", e))?; | |
| let validate_result = schema.validate(&result_json); | |
| if !validate_result.is_valid() { | |
| panic!("output does not match schema: {:?}", validate_result.errors); | |
| } | |
| let result: MetadataOutput = serde_json::from_value(result_json)?; | |
| let expected_output = r#" | |
| { | |
| "version": 1, | |
| "metadata": { | |
| "": { | |
| "coverage": { | |
| "category": "root_cat", | |
| "tags": ["tag1"] | |
| }, | |
| "parent_directory": "" | |
| }, | |
| "sub": { | |
| "coverage": { | |
| "category": "root_cat", | |
| "subcategory": "sub_cat", | |
| "tags": ["tag1", "tag2"] | |
| }, | |
| "parent_directory": "sub" | |
| }, | |
| "sub/testdir": { | |
| "coverage": { | |
| "category": "root_cat", | |
| "subcategory": "sub_cat", | |
| "tags": ["tag1", "tag2"] | |
| }, | |
| "parent_directory": "sub" | |
| }, | |
| "sub/testdir/nested": { | |
| "coverage": { | |
| "category": "nested_cat", | |
| "subcategory": "nested_subcat", | |
| "tags": ["nested_tag"] | |
| }, | |
| "parent_directory": "sub/testdir/nested" | |
| } | |
| } | |
| } | |
| "#; | |
| let expected: MetadataOutput = serde_json::from_str(expected_output)?; | |
| assert_eq!(result, expected); | |
| // Check depfile | |
| let dep_content = fs::read_to_string(depfile)?; | |
| assert!(dep_content.contains("TESTING.json5")); | |
| Ok(()) | |
| } | |
| #[test] | |
| fn test_validation_errors() -> Result<()> { | |
| let temp = tempfile::tempdir()?; | |
| let root = temp.path(); | |
| // Create a valid TESTING.json5 | |
| let valid_dir = root.join("valid"); | |
| fs::create_dir(&valid_dir)?; | |
| fs::write( | |
| valid_dir.join("TESTING.json5"), | |
| r#"{ | |
| "coverage": { | |
| "category": "valid_cat" | |
| } | |
| }"#, | |
| )?; | |
| // Create an invalid TESTING.json5 (parse error) | |
| let invalid_parse_dir = root.join("invalid_parse"); | |
| fs::create_dir(&invalid_parse_dir)?; | |
| fs::write( | |
| invalid_parse_dir.join("TESTING.json5"), | |
| r#"{ | |
| "coverage": { | |
| "category": "invalid_parse" | |
| } | |
| "invalid": | |
| }"#, | |
| )?; | |
| // Create an invalid TESTING.json5 (schema error) | |
| let invalid_schema_dir = root.join("invalid_schema"); | |
| fs::create_dir(&invalid_schema_dir)?; | |
| fs::write( | |
| invalid_schema_dir.join("TESTING.json5"), | |
| r#"{ | |
| "coverage": { | |
| "category": 123 | |
| } | |
| }"#, | |
| )?; | |
| let output = root.join("out.json"); | |
| let depfile = root.join("out.d"); | |
| let args = Args { | |
| fuchsia_dir: root.to_path_buf(), | |
| output: output.clone(), | |
| depfile: depfile.clone(), | |
| }; | |
| let result = collect_metadata(args); | |
| assert!(result.is_err()); | |
| let err_msg = result.unwrap_err().to_string(); | |
| assert!(err_msg.contains("validation errors:")); | |
| assert!(err_msg.contains("failed to parse")); | |
| assert!(err_msg.contains("does not match schema")); | |
| Ok(()) | |
| } | |
| } |