// Copyright 2022 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.

//! test_list_tool generates test-list.json.

use {
    anyhow::Error,
    fidl::encoding::decode_persistent,
    fidl_fuchsia_component_decl::Component,
    fidl_fuchsia_data as fdata, fuchsia_archive, fuchsia_pkg,
    fuchsia_url::pkg_url::PkgUrl,
    maplit::btreeset,
    serde::{Deserialize, Serialize},
    serde_json,
    std::{
        cmp::{Eq, PartialEq},
        fmt::Debug,
        fs,
        io::Read,
        path::PathBuf,
    },
    structopt::StructOpt,
    test_list::{ExecutionEntry, FuchsiaComponentExecutionEntry, TestList, TestListEntry, TestTag},
};

const META_FAR_PREFIX: &'static str = "meta/";
const TEST_REALM_FACET_NAME: &'static str = "fuchsia.test.type";
const HERMETIC_TEST_REALM: &'static str = "hermetic";
const HERMETIC_TIER_2_TEST_REALM: &'static str = "hermetic-tier-2";

mod error;
mod opts;

#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
struct TestsJsonEntry {
    test: TestEntry,
}

#[derive(Debug, Eq, PartialEq, Serialize, Deserialize, Default)]
struct TestEntry {
    name: String,
    label: String,
    cpu: String,
    os: String,
    package_url: Option<String>,
    package_manifests: Option<Vec<String>>,
    log_settings: Option<LogSettings>,
    build_rule: Option<String>,
    has_generated_manifest: Option<bool>,
    wrapped_legacy_test: Option<bool>,
}

#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
struct LogSettings {
    max_severity: Option<diagnostics_data::Severity>,
}

/// This struct contains the set of tags that can be added to tests in the fuchsia.git build.
#[derive(Default, Debug, PartialEq, Eq)]
struct FuchsiaTestTags {
    os: Option<String>,
    cpu: Option<String>,
    scope: Option<String>,
    realm: Option<String>,
    hermetic: Option<bool>,
    legacy_test: Option<bool>,
}

impl FuchsiaTestTags {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn into_vec(self) -> Vec<TestTag> {
        let string_to_val = |v: Option<String>| v.unwrap_or_else(|| "".to_string());
        let bool_to_val = |v: Option<bool>| match v {
            None => "".to_string(),
            Some(true) => "true".to_string(),
            Some(false) => "false".to_string(),
        };
        btreeset![
            TestTag { key: "os".to_string(), value: string_to_val(self.os) },
            TestTag { key: "cpu".to_string(), value: string_to_val(self.cpu) },
            TestTag { key: "scope".to_string(), value: string_to_val(self.scope) },
            TestTag { key: "realm".to_string(), value: string_to_val(self.realm) },
            TestTag { key: "hermetic".to_string(), value: bool_to_val(self.hermetic) },
            TestTag { key: "legacy_test".to_string(), value: bool_to_val(self.legacy_test) },
        ]
        .into_iter()
        .collect()
    }
}

impl TestEntry {
    fn get_max_log_severity(&self) -> Option<diagnostics_data::Severity> {
        self.log_settings.as_ref().map(|settings| settings.max_severity).unwrap_or(None)
    }
}

fn find_meta_far(build_dir: &PathBuf, manifest_path: String) -> Result<PathBuf, Error> {
    let package_manifest =
        fuchsia_pkg::PackageManifest::try_load_from(build_dir.join(&manifest_path))?;

    for blob in package_manifest.blobs() {
        if blob.path.eq(META_FAR_PREFIX) {
            return Ok(build_dir.join(&blob.source_path));
        }
    }
    Err(error::TestListToolError::MissingMetaBlob(manifest_path).into())
}

fn cm_decl_from_meta_far(meta_far_path: &PathBuf, cm_path: &str) -> Result<Component, Error> {
    let mut meta_far = fs::File::open(meta_far_path)?;
    let mut far_reader = fuchsia_archive::Reader::new(&mut meta_far)?;
    let cm_contents = far_reader.read_file(cm_path)?;
    let decl: Component = decode_persistent(&cm_contents)?;
    Ok(decl)
}

fn update_tags_from_facets(
    test_tags: &mut FuchsiaTestTags,
    facets: &fdata::Dictionary,
) -> Result<(), Error> {
    for facet in facets.entries.as_ref().unwrap_or(&vec![]) {
        // TODO(rudymathu): CFv1 tests should not have a hermetic tag.
        if facet.key.eq(TEST_REALM_FACET_NAME) {
            let val = facet
                .value
                .as_ref()
                .ok_or(error::TestListToolError::NullFacet(facet.key.clone()))?;
            match &**val {
                fdata::DictionaryValue::Str(s) => {
                    test_tags.realm = Some(s.to_string());
                    test_tags.hermetic = Some(s.eq(HERMETIC_TEST_REALM));
                    return Ok(());
                }
                _ => {
                    return Err(error::TestListToolError::InvalidFacetValue(
                        facet.key.clone(),
                        format!("{:?}", val),
                    )
                    .into());
                }
            }
        }
    }
    test_tags.realm = Some(HERMETIC_TEST_REALM.to_string());
    test_tags.hermetic = Some(true);
    Ok(())
}

fn to_test_list_entry(test_entry: &TestEntry) -> TestListEntry {
    let execution = match &test_entry.package_url {
        Some(url) => Some(ExecutionEntry::FuchsiaComponent(FuchsiaComponentExecutionEntry {
            component_url: url.to_string(),
            test_args: vec![],
            timeout_seconds: None,
            test_filters: None,
            also_run_disabled_tests: false,
            parallel: None,
            max_severity_logs: test_entry.get_max_log_severity(),
        })),
        None => None,
    };

    TestListEntry {
        name: test_entry.name.clone(),
        labels: vec![test_entry.label.clone()],
        tags: vec![],
        execution,
    }
}

fn update_tags_with_test_entry(tags: &mut FuchsiaTestTags, test_entry: &TestEntry) {
    let realm = &tags.realm;
    let (build_rule, has_generated_manifest, wrapped_legacy_test) = (
        test_entry.build_rule.as_ref().map(|s| s.as_str()),
        test_entry.has_generated_manifest.unwrap_or_default(),
        test_entry.wrapped_legacy_test.unwrap_or_default(),
    );

    // Determine the type of a test as follows:
    // - A "host" test is run from a host binary.
    // - A "unit" test is in a hermetic realm with a generated manifest.
    // - An "integration" test is in a hermetic realm with a custom manifest.
    // - A "system" test is any test in a non-hermetic realm.
    // - "unknown" means we do not have knowledge of the build rule being used.
    // - "uncategorized" means we otherwise could not match the test.

    let test_type = if test_entry.name.starts_with("host_") {
        "host"
    } else {
        match (build_rule, has_generated_manifest, wrapped_legacy_test, realm) {
            (_, _, true, _) => "wrapped_legacy",
            (_, _, false, Some(realm))
                if realm != HERMETIC_TEST_REALM && realm != HERMETIC_TIER_2_TEST_REALM =>
            {
                "system"
            }
            (Some("fuchsia_unittest_package"), true, _, _) => "unit",
            (Some("fuchsia_unittest_package"), false, _, _) => "integration",
            (Some("fuchsia_test_package"), true, _, _) => "unit",
            (Some("fuchsia_test_package"), false, _, _) => "integration",
            (None, _, _, _) => "unknown",
            _ => "uncategorized",
        }
    };

    tags.os = Some(test_entry.os.clone());
    tags.cpu = Some(test_entry.cpu.clone());
    tags.scope = Some(test_type.to_string());
}

fn main() -> Result<(), Error> {
    run_tool()
}

fn read_tests_json(file: &PathBuf) -> Result<Vec<TestsJsonEntry>, Error> {
    let mut buffer = String::new();
    fs::File::open(&file)?.read_to_string(&mut buffer)?;
    let t: Vec<TestsJsonEntry> = serde_json::from_str(&buffer)?;
    Ok(t)
}

fn update_tags_from_manifest(
    test_tags: &mut FuchsiaTestTags,
    package_url: String,
    meta_far_path: &PathBuf,
) -> Result<(), Error> {
    let pkg_url = PkgUrl::parse(&package_url)?;
    let cm_path =
        pkg_url.resource().ok_or(error::TestListToolError::InvalidPackageURL(package_url))?;
    // CFv1 manifests don't generate the same FIDL declarations, so just skip generating tags
    // from them.
    if &cm_path[cm_path.len() - 3..] == "cmx" {
        test_tags.legacy_test = Some(true);
        Ok(())
    } else {
        let decl = cm_decl_from_meta_far(&meta_far_path, cm_path)?;
        update_tags_from_facets(test_tags, &decl.facets.unwrap_or(fdata::Dictionary::EMPTY))?;
        Ok(())
    }
}

fn write_depfile(depfile: &PathBuf, output: &PathBuf, inputs: &Vec<PathBuf>) -> Result<(), Error> {
    if inputs.len() == 0 {
        return Ok(());
    }
    let contents = format!(
        "{}: {}\n",
        output.display(),
        &inputs.iter().map(|i| format!(" {}", i.display())).collect::<String>(),
    );
    fs::write(depfile, contents)?;
    Ok(())
}

fn run_tool() -> Result<(), Error> {
    let opt = opts::Opt::from_args();
    opt.validate()?;

    let tests_json = read_tests_json(&opt.input)?;
    let mut test_list = TestList { tests: vec![] };
    let mut inputs: Vec<PathBuf> = vec![];

    for entry in tests_json {
        // Construct the base TestListEntry.
        let mut test_list_entry = to_test_list_entry(&entry.test);
        let mut test_tags = FuchsiaTestTags::new();
        let pkg_manifests = entry.test.package_manifests.clone().unwrap_or(vec![]);

        // Aggregate any tags from the component manifest of the test.
        if entry.test.package_url.is_some() && pkg_manifests.len() > 0 {
            let pkg_url = entry.test.package_url.clone().unwrap();
            let pkg_manifest = pkg_manifests[0].clone();
            inputs.push(pkg_manifest.clone().into());

            let res = find_meta_far(&opt.build_dir, pkg_manifest.clone());
            if res.is_err() {
                println!(
                    "error finding meta.far file in package manifest {}: {:?}",
                    &pkg_manifest,
                    res.unwrap_err()
                );
                continue;
            }
            let meta_far_path = res.unwrap();
            inputs.push(meta_far_path.clone());

            // Find additional tags. Note that this can override existing tags (e.g. to set the test type based on realm)
            match update_tags_from_manifest(&mut test_tags, pkg_url.clone(), &meta_far_path) {
                Err(e) => {
                    println!("error processing manifest for package URL {}: {:?}", &pkg_url, e)
                }
                _ => {}
            }
        }

        update_tags_with_test_entry(&mut test_tags, &entry.test);
        test_list_entry.tags = test_tags.into_vec();
        test_list.tests.push(test_list_entry);
    }
    let test_list_json = serde_json::to_string_pretty(&test_list)?;
    fs::write(&opt.output, test_list_json)?;
    if let Some(depfile) = opt.depfile {
        write_depfile(&depfile, &opt.output, &inputs)?;
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use {super::*, tempfile::tempdir};

    #[test]
    fn test_find_meta_far() {
        let build_dir = tempdir().expect("failed to get tempdir");
        let package_manifest_path = "package_manifest.json";

        // Test the working case.
        let mut contents = r#"
            {
                "version": "1",
                "repository": "fuchsia.com",
                "package": {
                    "name": "echo-integration-test",
                    "version": "0"
                },
                "blobs": [
                    {
                        "source_path": "obj/build/components/tests/echo-integration-test/meta.far",
                        "path": "meta/",
                        "merkle": "0ec72cdf55fec3e0cc3dd47e86b95ee62c974ebaebea1d05769fea3fc4edca0b",
                        "size": 36864
                    }
                ]
            }"#;
        fs::write(build_dir.path().join(package_manifest_path), contents)
            .expect("failed to write fake package manifest");
        assert_eq!(
            find_meta_far(&build_dir.path().to_path_buf(), package_manifest_path.into()).unwrap(),
            build_dir.path().join("obj/build/components/tests/echo-integration-test/meta.far"),
        );

        // Test the error case.
        contents = r#"
            {
                "version": "1",
                "repository": "fuchsia.com",
                "package": {
                    "name": "echo-integration-test",
                    "version": "0"
                },
                "blobs": []
            }"#;
        fs::write(build_dir.path().join(package_manifest_path), contents)
            .expect("failed to write fake package manifest");
        let err = find_meta_far(&build_dir.path().to_path_buf(), package_manifest_path.into())
            .expect_err("find_meta_far failed unexpectedly");
        match err.downcast_ref::<error::TestListToolError>() {
            Some(error::TestListToolError::MissingMetaBlob(path)) => {
                assert_eq!(package_manifest_path.to_string(), *path)
            }
            Some(e) => panic!("find_meta_far returned incorrect TestListToolError: {:?}", e),
            None => panic!("find_meta_far returned non TestListToolError: {:?}", err),
        }
    }

    #[test]
    fn test_update_tags_from_facets() {
        // Test that empty facets return the hermetic tags.
        let mut facets = fdata::Dictionary::EMPTY;
        let mut tags = FuchsiaTestTags::default();
        update_tags_from_facets(&mut tags, &facets).expect("failed get tags in tags_from_facets");
        let hermetic_tags = FuchsiaTestTags {
            realm: Some(HERMETIC_TEST_REALM.to_string()),
            hermetic: Some(true),
            ..FuchsiaTestTags::default()
        };
        assert_eq!(tags, hermetic_tags);

        // Test that a facet of fuchsia.test: tests returns hermetic tags.
        let mut tags = FuchsiaTestTags::default();
        facets.entries = Some(vec![fdata::DictionaryEntry {
            key: TEST_REALM_FACET_NAME.to_string(),
            value: Some(Box::new(fdata::DictionaryValue::Str(HERMETIC_TEST_REALM.to_string()))),
        }]);
        update_tags_from_facets(&mut tags, &facets).expect("failed get tags in tags_from_facets");
        assert_eq!(tags, hermetic_tags);

        // Test that a null fuchsia.test facet returns a NullFacet error.
        let mut tags = FuchsiaTestTags::default();
        facets.entries = Some(vec![fdata::DictionaryEntry {
            key: TEST_REALM_FACET_NAME.to_string(),
            value: None,
        }]);
        let err = update_tags_from_facets(&mut tags, &facets)
            .expect_err("tags_from_facets succeeded on null facet value");
        match err.downcast_ref::<error::TestListToolError>() {
            Some(error::TestListToolError::NullFacet(key)) => {
                assert_eq!(*key, TEST_REALM_FACET_NAME.to_string());
            }
            Some(e) => panic!("tags_from_facets returned incorrect TestListToolError: {:?}", e),
            None => panic!("tags_from_facets returned non-TestListToolError: {:?}", err),
        }

        // Test that an invalid fuchsia.test facet returns an InvalidFacetValue error.
        let mut tags = FuchsiaTestTags::default();
        facets.entries = Some(vec![fdata::DictionaryEntry {
            key: TEST_REALM_FACET_NAME.to_string(),
            value: Some(Box::new(fdata::DictionaryValue::StrVec(vec![
                HERMETIC_TEST_REALM.to_string()
            ]))),
        }]);
        let err = update_tags_from_facets(&mut tags, &facets)
            .expect_err("tags_from_facets succeeded on null facet value");
        match err.downcast_ref::<error::TestListToolError>() {
            Some(error::TestListToolError::InvalidFacetValue(k, _)) => {
                assert_eq!(*k, TEST_REALM_FACET_NAME.to_string());
            }
            Some(e) => panic!("tags_from_facets returned incorrect TestListToolError: {:?}", e),
            None => panic!("tags_from_facets returned non-TestListToolError: {:?}", err),
        }
    }

    #[test]
    fn test_to_test_list_entry() {
        let make_test_entry = |log_settings| TestEntry {
            name: "test-name".to_string(),
            label: "test-label".to_string(),
            cpu: "x64".to_string(),
            os: "fuchsia".to_string(),
            package_url: Some(
                "fuchsia-pkg://fuchsia.com/echo-integration-test#meta/echo-client-test.cm"
                    .to_string(),
            ),
            package_manifests: Some(vec![
                "obj/build/components/tests/echo-integration-test/package_manifest.json"
                    .to_string(),
            ]),
            log_settings,
            ..TestEntry::default()
        };

        let host_test_entry = TestEntry {
            name: "test-name".to_string(),
            label: "test-label".to_string(),
            cpu: "x64".to_string(),
            os: "linux".to_string(),
            log_settings: None,
            package_url: None,
            package_manifests: None,
            ..TestEntry::default()
        };

        let make_expected_test_list_entry = |max_severity_logs| TestListEntry {
            name: "test-name".to_string(),
            labels: vec!["test-label".to_string()],
            tags: vec![],
            execution: Some(ExecutionEntry::FuchsiaComponent(FuchsiaComponentExecutionEntry {
                component_url:
                    "fuchsia-pkg://fuchsia.com/echo-integration-test#meta/echo-client-test.cm"
                        .to_string(),
                test_args: vec![],
                timeout_seconds: None,
                test_filters: None,
                also_run_disabled_tests: false,
                parallel: None,
                max_severity_logs,
            })),
        };

        // Default severity.
        let test_list_entry = to_test_list_entry(&make_test_entry(None));
        assert_eq!(test_list_entry, make_expected_test_list_entry(None),);

        // Inner default severity.
        let test_list_entry =
            to_test_list_entry(&make_test_entry(Some(LogSettings { max_severity: None })));
        assert_eq!(test_list_entry, make_expected_test_list_entry(None),);

        // Explicit severity
        let test_list_entry = to_test_list_entry(&make_test_entry(Some(LogSettings {
            max_severity: Some(diagnostics_data::Severity::Error),
        })));
        assert_eq!(
            test_list_entry,
            make_expected_test_list_entry(Some(diagnostics_data::Severity::Error))
        );

        // Host test
        let test_list_entry = to_test_list_entry(&host_test_entry);
        assert_eq!(
            test_list_entry,
            TestListEntry {
                name: "test-name".to_string(),
                labels: vec!["test-label".to_string()],
                tags: vec![],
                execution: None,
            }
        )
    }

    #[test]
    fn test_update_tags_from_test_entry() {
        let cases = vec![
            (
                TestEntry {
                    cpu: "x64".to_string(),
                    os: "fuchsia".to_string(),
                    ..TestEntry::default()
                },
                FuchsiaTestTags { ..FuchsiaTestTags::default() },
                vec![
                    TestTag { key: "cpu".to_string(), value: "x64".to_string() },
                    TestTag { key: "hermetic".to_string(), value: "".to_string() },
                    TestTag { key: "legacy_test".to_string(), value: "".to_string() },
                    TestTag { key: "os".to_string(), value: "fuchsia".to_string() },
                    TestTag { key: "realm".to_string(), value: "".to_string() },
                    TestTag { key: "scope".to_string(), value: "unknown".to_string() },
                ],
            ),
            (
                TestEntry {
                    cpu: "x64".to_string(),
                    os: "fuchsia".to_string(),
                    wrapped_legacy_test: Some(true),
                    ..TestEntry::default()
                },
                FuchsiaTestTags { ..FuchsiaTestTags::default() },
                vec![
                    TestTag { key: "cpu".to_string(), value: "x64".to_string() },
                    TestTag { key: "hermetic".to_string(), value: "".to_string() },
                    TestTag { key: "legacy_test".to_string(), value: "".to_string() },
                    TestTag { key: "os".to_string(), value: "fuchsia".to_string() },
                    TestTag { key: "realm".to_string(), value: "".to_string() },
                    TestTag { key: "scope".to_string(), value: "wrapped_legacy".to_string() },
                ],
            ),
            (
                TestEntry {
                    cpu: "x64".to_string(),
                    os: "fuchsia".to_string(),
                    wrapped_legacy_test: Some(false),
                    build_rule: Some("fuchsia_unittest_package".to_string()),
                    has_generated_manifest: Some(true),
                    ..TestEntry::default()
                },
                FuchsiaTestTags { ..FuchsiaTestTags::default() },
                vec![
                    TestTag { key: "cpu".to_string(), value: "x64".to_string() },
                    TestTag { key: "hermetic".to_string(), value: "".to_string() },
                    TestTag { key: "legacy_test".to_string(), value: "".to_string() },
                    TestTag { key: "os".to_string(), value: "fuchsia".to_string() },
                    TestTag { key: "realm".to_string(), value: "".to_string() },
                    TestTag { key: "scope".to_string(), value: "unit".to_string() },
                ],
            ),
            (
                TestEntry {
                    cpu: "x64".to_string(),
                    os: "fuchsia".to_string(),
                    wrapped_legacy_test: Some(false),
                    build_rule: Some("fuchsia_unittest_package".to_string()),
                    has_generated_manifest: Some(false),
                    ..TestEntry::default()
                },
                FuchsiaTestTags { ..FuchsiaTestTags::default() },
                vec![
                    TestTag { key: "cpu".to_string(), value: "x64".to_string() },
                    TestTag { key: "hermetic".to_string(), value: "".to_string() },
                    TestTag { key: "legacy_test".to_string(), value: "".to_string() },
                    TestTag { key: "os".to_string(), value: "fuchsia".to_string() },
                    TestTag { key: "realm".to_string(), value: "".to_string() },
                    TestTag { key: "scope".to_string(), value: "integration".to_string() },
                ],
            ),
            (
                TestEntry {
                    cpu: "x64".to_string(),
                    os: "fuchsia".to_string(),
                    wrapped_legacy_test: Some(false),
                    build_rule: Some("fuchsia_test_package".to_string()),
                    has_generated_manifest: Some(true),
                    ..TestEntry::default()
                },
                FuchsiaTestTags { ..FuchsiaTestTags::default() },
                vec![
                    TestTag { key: "cpu".to_string(), value: "x64".to_string() },
                    TestTag { key: "hermetic".to_string(), value: "".to_string() },
                    TestTag { key: "legacy_test".to_string(), value: "".to_string() },
                    TestTag { key: "os".to_string(), value: "fuchsia".to_string() },
                    TestTag { key: "realm".to_string(), value: "".to_string() },
                    TestTag { key: "scope".to_string(), value: "unit".to_string() },
                ],
            ),
            (
                TestEntry {
                    cpu: "x64".to_string(),
                    os: "fuchsia".to_string(),
                    wrapped_legacy_test: Some(false),
                    build_rule: Some("fuchsia_test_package".to_string()),
                    has_generated_manifest: Some(false),
                    ..TestEntry::default()
                },
                FuchsiaTestTags { ..FuchsiaTestTags::default() },
                vec![
                    TestTag { key: "cpu".to_string(), value: "x64".to_string() },
                    TestTag { key: "hermetic".to_string(), value: "".to_string() },
                    TestTag { key: "legacy_test".to_string(), value: "".to_string() },
                    TestTag { key: "os".to_string(), value: "fuchsia".to_string() },
                    TestTag { key: "realm".to_string(), value: "".to_string() },
                    TestTag { key: "scope".to_string(), value: "integration".to_string() },
                ],
            ),
            (
                TestEntry {
                    cpu: "x64".to_string(),
                    os: "fuchsia".to_string(),
                    wrapped_legacy_test: Some(false),
                    build_rule: Some("fuchsia_test_package".to_string()),
                    has_generated_manifest: Some(true),
                    ..TestEntry::default()
                },
                FuchsiaTestTags {
                    realm: Some("hermetic-tier-2".to_string()),
                    hermetic: Some(true),
                    ..FuchsiaTestTags::default()
                },
                vec![
                    TestTag { key: "cpu".to_string(), value: "x64".to_string() },
                    TestTag { key: "hermetic".to_string(), value: "true".to_string() },
                    TestTag { key: "legacy_test".to_string(), value: "".to_string() },
                    TestTag { key: "os".to_string(), value: "fuchsia".to_string() },
                    TestTag { key: "realm".to_string(), value: "hermetic-tier-2".to_string() },
                    TestTag { key: "scope".to_string(), value: "unit".to_string() },
                ],
            ),
            (
                TestEntry {
                    cpu: "x64".to_string(),
                    os: "fuchsia".to_string(),
                    wrapped_legacy_test: Some(false),
                    build_rule: Some("fuchsia_test_package".to_string()),
                    has_generated_manifest: Some(false),
                    ..TestEntry::default()
                },
                FuchsiaTestTags {
                    realm: Some("hermetic-tier-2".to_string()),
                    hermetic: Some(true),
                    ..FuchsiaTestTags::default()
                },
                vec![
                    TestTag { key: "cpu".to_string(), value: "x64".to_string() },
                    TestTag { key: "hermetic".to_string(), value: "true".to_string() },
                    TestTag { key: "legacy_test".to_string(), value: "".to_string() },
                    TestTag { key: "os".to_string(), value: "fuchsia".to_string() },
                    TestTag { key: "realm".to_string(), value: "hermetic-tier-2".to_string() },
                    TestTag { key: "scope".to_string(), value: "integration".to_string() },
                ],
            ),
            (
                TestEntry {
                    cpu: "x64".to_string(),
                    os: "fuchsia".to_string(),
                    wrapped_legacy_test: Some(false),
                    build_rule: Some("fuchsia_test_package".to_string()),
                    has_generated_manifest: Some(false),
                    ..TestEntry::default()
                },
                FuchsiaTestTags { realm: Some("vulkan".to_string()), ..FuchsiaTestTags::default() },
                vec![
                    TestTag { key: "cpu".to_string(), value: "x64".to_string() },
                    TestTag { key: "hermetic".to_string(), value: "".to_string() },
                    TestTag { key: "legacy_test".to_string(), value: "".to_string() },
                    TestTag { key: "os".to_string(), value: "fuchsia".to_string() },
                    TestTag { key: "realm".to_string(), value: "vulkan".to_string() },
                    TestTag { key: "scope".to_string(), value: "system".to_string() },
                ],
            ),
            (
                TestEntry {
                    cpu: "x64".to_string(),
                    os: "linux".to_string(),
                    name: "host_x64/test".to_string(),
                    ..TestEntry::default()
                },
                FuchsiaTestTags { ..FuchsiaTestTags::default() },
                vec![
                    TestTag { key: "cpu".to_string(), value: "x64".to_string() },
                    TestTag { key: "hermetic".to_string(), value: "".to_string() },
                    TestTag { key: "legacy_test".to_string(), value: "".to_string() },
                    TestTag { key: "os".to_string(), value: "linux".to_string() },
                    TestTag { key: "realm".to_string(), value: "".to_string() },
                    TestTag { key: "scope".to_string(), value: "host".to_string() },
                ],
            ),
        ];

        for (entry, mut tags, expected) in cases.into_iter() {
            update_tags_with_test_entry(&mut tags, &entry);
            assert_eq!(tags.into_vec(), expected, "entry was {:?}", entry);
        }
    }

    #[test]
    fn test_read_tests_json() {
        let data = r#"
            [
                {
                    "test": {
                        "cpu": "x64",
                        "label": "//build/components/tests:echo-integration-test_test_echo-client-test(//build/toolchain/fuchsia:x64)",
                        "log_settings": {
                            "max_severity": "WARN"
                        },
                        "name": "fuchsia-pkg://fuchsia.com/echo-integration-test#meta/echo-client-test.cm",
                        "os": "fuchsia",
                        "package_label": "//build/components/tests:echo-integration-test(//build/toolchain/fuchsia:x64)",
                        "package_manifests": [
                            "obj/build/components/tests/echo-integration-test/package_manifest.json"
                        ],
                        "package_url": "fuchsia-pkg://fuchsia.com/echo-integration-test#meta/echo-client-test.cm"
                    }
                }
            ]"#;
        let dir = tempdir().expect("failed to get tempdir");
        let tests_json_path = dir.path().join("tests.json");
        fs::write(&tests_json_path, data).expect("failed to write tests.json to tempfile");
        let tests_json = read_tests_json(&tests_json_path).expect("read_tests_json() failed");
        assert_eq!(
            tests_json,
            vec![
                TestsJsonEntry{
                    test: TestEntry{
                        name: "fuchsia-pkg://fuchsia.com/echo-integration-test#meta/echo-client-test.cm".to_string(),
                        label: "//build/components/tests:echo-integration-test_test_echo-client-test(//build/toolchain/fuchsia:x64)".to_string(),
                        cpu: "x64".to_string(),
                        os: "fuchsia".to_string(),
                        package_url: Some("fuchsia-pkg://fuchsia.com/echo-integration-test#meta/echo-client-test.cm".to_string()),
                        package_manifests: Some(vec![
                            "obj/build/components/tests/echo-integration-test/package_manifest.json".to_string(),
                        ]),
                        log_settings: Some(LogSettings { max_severity: Some(diagnostics_data::Severity::Warn) }),
                        ..TestEntry::default()
                    },
                }
            ],
        );
    }
}