// Copyright 2018 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 crate::cml;
use cm_json::{self, Error, JsonSchema, CML_SCHEMA, CMX_SCHEMA, CM_SCHEMA};
use serde_json::Value;
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::io::Read;
use std::path::Path;

/// Read in and parse one or more manifest files. Returns an Err() if any file is not valid
/// or Ok(()) if all files are valid.
///
/// The primary JSON schemas are taken from cm_json, selected based on the file extension,
/// is used to determine the validity of each input file. Extra schemas to validate against can be
/// optionally provided.
pub fn validate<P: AsRef<Path>>(
    files: &[P],
    extra_schemas: &[(P, Option<String>)],
) -> Result<(), Error> {
    if files.is_empty() {
        return Err(Error::invalid_args("No files provided"));
    }

    for filename in files {
        validate_file(filename.as_ref(), extra_schemas)?;
    }
    Ok(())
}

/// Read in and parse .cml file. Returns a cml::Document if the file is valid, or an Error if not.
pub fn parse_cml(value: Value) -> Result<cml::Document, Error> {
    cm_json::validate_json(&value, CML_SCHEMA)?;
    let document: cml::Document = serde_json::from_value(value)
        .map_err(|e| Error::parse(format!("Couldn't read input as struct: {}", e)))?;
    let mut ctx = ValidationContext {
        document: &document,
        all_children: HashSet::new(),
        all_collections: HashSet::new(),
    };
    ctx.validate()?;
    Ok(document)
}

/// Read in and parse a single manifest file, and return an Error if the given file is not valid.
/// If the file is a .cml file and is valid, will return Some(cml::Document), and for other valid
/// files returns None.
///
/// Internal single manifest file validation function, used to implement the two public validate
/// functions.
fn validate_file<P: AsRef<Path>>(
    file: &Path,
    extra_schemas: &[(P, Option<String>)],
) -> Result<(), Error> {
    const BAD_EXTENSION: &str = "Input file does not have a component manifest extension \
                                 (.cm, .cml, or .cmx)";
    let mut buffer = String::new();
    File::open(&file)?.read_to_string(&mut buffer)?;

    // Validate based on file extension.
    let ext = file.extension().and_then(|e| e.to_str());
    let v = match ext {
        Some("cmx") => {
            let v = cm_json::from_json_str(&buffer)?;
            cm_json::validate_json(&v, CMX_SCHEMA)?;
            v
        }
        Some("cm") => {
            let v = cm_json::from_json_str(&buffer)?;
            cm_json::validate_json(&v, CM_SCHEMA)?;
            v
        }
        Some("cml") => {
            let v = cm_json::from_json5_str(&buffer)?;
            parse_cml(v.clone())?;
            v
        }
        _ => {
            return Err(Error::invalid_args(BAD_EXTENSION));
        }
    };

    // Validate against any extra schemas provided.
    for extra_schema in extra_schemas {
        let schema = JsonSchema::new_from_file(&extra_schema.0.as_ref())?;
        cm_json::validate_json(&v, &schema).map_err(|e| match (&e, &extra_schema.1) {
            (Error::Validate { schema_name, err }, Some(extra_msg)) => Error::Validate {
                schema_name: schema_name.clone(),
                err: format!("{}\n{}", err, extra_msg),
            },
            _ => e,
        })?;
    }
    Ok(())
}

struct ValidationContext<'a> {
    document: &'a cml::Document,
    all_children: HashSet<&'a str>,
    all_collections: HashSet<&'a str>,
}

type PathMap<'a> = HashMap<String, HashSet<&'a str>>;

impl<'a> ValidationContext<'a> {
    fn validate(&mut self) -> Result<(), Error> {
        // Populate the sets of children and collections.
        self.all_children = self.document.all_children()?;
        self.all_collections = self.document.all_collections()?;

        // Validate "expose".
        if let Some(exposes) = self.document.expose.as_ref() {
            let mut target_paths = HashMap::new();
            for expose in exposes.iter() {
                self.validate_expose(&expose, &mut target_paths)?;
            }
        }

        // Validate "offer".
        if let Some(offers) = self.document.offer.as_ref() {
            let mut target_paths = HashMap::new();
            for offer in offers.iter() {
                self.validate_offer(&offer, &mut target_paths)?;
            }
        }

        Ok(())
    }

    fn validate_expose(
        &self,
        expose: &'a cml::Expose,
        prev_target_paths: &mut PathMap<'a>,
    ) -> Result<(), Error> {
        self.validate_source("expose", expose)?;
        self.validate_target("expose", expose, expose, &mut HashSet::new(), prev_target_paths)
    }

    fn validate_offer(
        &self,
        offer: &'a cml::Offer,
        prev_target_paths: &mut PathMap<'a>,
    ) -> Result<(), Error> {
        self.validate_source("offer", offer)?;
        let from_caps = cml::REFERENCE_RE.captures(&offer.from);
        let from_child = match &from_caps {
            Some(caps) => Some(&caps[0]),
            None => None,
        };
        let mut prev_targets = HashSet::new();
        for to in offer.to.iter() {
            // Check that any referenced child in the target name is valid.
            if let Some(caps) = cml::REFERENCE_RE.captures(&to.dest) {
                if !self.all_children.contains(&caps[1]) && !self.all_collections.contains(&caps[1])
                {
                    return Err(Error::validate(format!(
                        "\"{}\" is an \"offer\" target but it does not appear in \"children\" \
                        or \"collections\"",
                        &to.dest,
                    )));
                }
            }

            // Check that the capability is not being re-offered to a target that exposed it.
            if let Some(from_child) = &from_child {
                if from_child == &to.dest {
                    return Err(Error::validate(format!(
                        "Offer target \"{}\" is same as source",
                        &to.dest,
                    )));
                }
            }

            // Perform common target validation.
            self.validate_target("offer", offer, to, &mut prev_targets, prev_target_paths)?;
        }
        Ok(())
    }

    /// Validates that a source capability is valid, i.e. that any referenced child is valid.
    /// - `keyword` is the keyword for the clause ("offer" or "expose").
    fn validate_source<T>(&self, keyword: &str, source_obj: &'a T) -> Result<(), Error>
    where
        T: cml::FromClause + cml::CapabilityClause,
    {
        if let Some(caps) = cml::REFERENCE_RE.captures(source_obj.from()) {
            if !self.all_children.contains(&caps[1]) {
                return Err(Error::validate(format!(
                    "\"{}\" is an \"{}\" source but it does not appear in \"children\"",
                    source_obj.from(),
                    keyword,
                )));
            }
        }
        Ok(())
    }

    /// Validates that a target is valid, i.e. that it does not duplicate the path of any capability
    /// and any referenced child is valid.
    /// - `keyword` is the keyword for the clause ("offer" or "expose").
    /// - `source_obj` is the object containing the source capability info. This is needed for the
    ///   default path.
    /// - `target_obj` is the object containing the target capability info.
    /// - `prev_target` holds target names collected for this source capability so far.
    /// - `prev_target_paths` holds target paths collected so far.
    fn validate_target<T, U>(
        &self,
        keyword: &str,
        source_obj: &'a T,
        target_obj: &'a U,
        prev_targets: &mut HashSet<&'a str>,
        prev_target_paths: &mut PathMap<'a>,
    ) -> Result<(), Error>
    where
        T: cml::CapabilityClause,
        U: cml::DestClause + cml::AsClause,
    {
        // Get the source capability's path.
        let source_path = if let Some(p) = source_obj.service().as_ref() {
            p
        } else if let Some(p) = source_obj.directory().as_ref() {
            p
        } else {
            return Err(Error::internal(format!("no capability path")));
        };

        // Get the target capability's path (defaults to the source path).
        let ref target_path = match &target_obj.r#as() {
            Some(a) => a,
            None => source_path,
        };

        // Check that target path is not a duplicate of another capability.
        let target_name = target_obj.dest().unwrap_or("");
        let paths_for_target =
            prev_target_paths.entry(target_name.to_string()).or_insert(HashSet::new());
        if !paths_for_target.insert(target_path) {
            return match target_name {
                "" => Err(Error::validate(format!(
                    "\"{}\" is a duplicate \"{}\" target path",
                    target_path, keyword
                ))),
                _ => Err(Error::validate(format!(
                    "\"{}\" is a duplicate \"{}\" target path for \"{}\"",
                    target_path, keyword, target_name
                ))),
            };
        }

        // Check that the target is not a duplicate of a previous target (for this source).
        if let Some(target_name) = target_obj.dest() {
            if !prev_targets.insert(target_name) {
                return Err(Error::validate(format!(
                    "\"{}\" is a duplicate \"{}\" target for \"{}\"",
                    target_name, keyword, source_path
                )));
            }
        }

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use lazy_static::lazy_static;
    use serde_json::json;
    use std::io::Write;
    use tempfile::TempDir;

    macro_rules! test_validate_cm {
        (
            $(
                $test_name:ident => {
                    input = $input:expr,
                    result = $result:expr,
                },
            )+
        ) => {
            $(
                #[test]
                fn $test_name() {
                    validate_test("test.cm", $input, $result);
                }
            )+
        }
    }

    macro_rules! test_validate_cml {
        (
            $(
                $test_name:ident => {
                    input = $input:expr,
                    result = $result:expr,
                },
            )+
        ) => {
            $(
                #[test]
                fn $test_name() {
                    validate_test("test.cml", $input, $result);
                }
            )+
        }
    }

    macro_rules! test_validate_cmx {
        (
            $(
                $test_name:ident => {
                    input = $input:expr,
                    result = $result:expr,
                },
            )+
        ) => {
            $(
                #[test]
                fn $test_name() {
                    validate_test("test.cmx", $input, $result);
                }
            )+
        }
    }

    fn validate_test(
        filename: &str,
        input: serde_json::value::Value,
        expected_result: Result<(), Error>,
    ) {
        let input_str = format!("{}", input);
        validate_json_str(filename, &input_str, expected_result);
    }

    fn validate_json_str(filename: &str, input: &str, expected_result: Result<(), Error>) {
        let tmp_dir = TempDir::new().unwrap();
        let tmp_file_path = tmp_dir.path().join(filename);

        File::create(&tmp_file_path).unwrap().write_all(input.as_bytes()).unwrap();

        let result = validate(&vec![tmp_file_path], &[]);
        assert_eq!(format!("{:?}", result), format!("{:?}", expected_result));
    }

    #[test]
    fn test_validate_invalid_json_fails() {
        let tmp_dir = TempDir::new().unwrap();
        let tmp_file_path = tmp_dir.path().join("test.cm");

        File::create(&tmp_file_path).unwrap().write_all(b"{,}").unwrap();

        let result = validate(&vec![tmp_file_path], &[]);
        let expected_result: Result<(), Error> = Err(Error::parse(
            "Couldn't read input as JSON: key must be a string at line 1 column 2",
        ));
        assert_eq!(format!("{:?}", result), format!("{:?}", expected_result));
    }

    #[test]
    fn test_json5_parse_number() {
        let json: Value = cm_json::from_json5_str("1").expect("couldn't parse");
        if let Value::Number(n) = json {
            assert!(n.is_i64());
        } else {
            panic!("{:?} is not a number", json);
        }
    }

    // TODO: Consider converting these tests to a golden test

    test_validate_cm! {
        // program
        test_cm_empty_json => {
            input = json!({}),
            result = Ok(()),
        },
        test_cm_program => {
            input = json!({"program": { "foo": 55 }}),
            result = Ok(()),
        },

        // uses
        test_cm_uses => {
            input = json!({
                "uses": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.boot.Log",
                            "target_path": "/svc/fuchsia.logger.Log"
                        }
                    },
                    {
                        "directory": {
                            "source_path": "/data/assets",
                            "target_path": "/data/kitten_assets"
                        }
                    }
                ]
            }),
            result = Ok(()),
        },
        test_cm_uses_missing_variant => {
            input = json!({
                "uses": [ {} ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "OneOf conditions are not met at /uses/0")),
        },

        // exposes
        test_cm_exposes => {
            input = json!({
                "exposes": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.ui.Scenic",
                            "source": {
                                "myself": {}
                            },
                            "target_path": "/svc/fuchsia.ui.Scenic"
                        }
                    },
                    {
                        "directory": {
                            "source_path": "/data/assets",
                            "source": {
                                "child": {
                                    "name": "cat_viewer"
                                }
                            },
                            "target_path": "/data/kitten_assets"
                        }
                    }
                ]
            }),
            result = Ok(()),
        },
        test_cm_exposes_missing_variant => {
            input = json!({
                "exposes": [ {} ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "OneOf conditions are not met at /exposes/0")),
        },
        test_cm_exposes_source_missing_variant => {
            input = json!({
                "exposes": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.ui.Scenic",
                            "source": {},
                            "target_path": "/svc/fuchsia.ui.Scenic"
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "OneOf conditions are not met at /exposes/0/service/source")),
        },
        test_cm_exposes_source_multiple_variants => {
            input = json!({
                "exposes": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.ui.Scenic",
                            "source": {
                                "myself": {},
                                "child": {
                                    "name": "foo"
                                }
                            },
                            "target_path": "/svc/fuchsia.ui.Scenic"
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "OneOf conditions are not met at /exposes/0/service/source")),
        },
        test_cm_exposes_source_bad_child_name => {
            input = json!({
                "exposes": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.ui.Scenic",
                            "source": {
                                "child": {
                                    "name": "bad^"
                                }
                            },
                            "target_path": "/svc/fuchsia.ui.Scenic"
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "Pattern condition is not met at /exposes/0/service/source/child/name")),
        },

        // offers
        test_cm_offers => {
            input = json!({
                "offers": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.logger.LogSink",
                            "source": {
                                "realm": {}
                            },
                            "targets": [
                                {
                                    "target_path": "/svc/fuchsia.logger.SysLog",
                                    "dest": {
                                        "child": {
                                            "name": "viewer"
                                        }
                                    }
                                }
                            ]
                        }
                    },
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.ui.Scenic",
                            "source": {
                                "myself": {}
                            },
                            "targets": [
                                {
                                    "target_path": "/svc/fuchsia.ui.Scenic",
                                    "dest": {
                                        "child": {
                                            "name": "user_shell"
                                        }
                                    }
                                },
                                {
                                    "target_path": "/services/fuchsia.ui.Scenic",
                                    "dest": {
                                        "collection": {
                                            "name": "modular"
                                        }
                                    }
                                }
                            ]
                        }
                    },
                    {
                        "directory": {
                            "source_path": "/data/assets",
                            "source": {
                                "child": {
                                    "name": "cat_provider"
                                }
                            },
                            "targets": [
                                {
                                    "target_path": "/data/kitten_assets",
                                    "dest": {
                                        "child": {
                                            "name": "cat_viewer"
                                        }
                                    }
                                },
                                {
                                    "target_path": "/data/artifacts",
                                    "dest": {
                                        "collection": {
                                            "name": "tests"
                                        }
                                    }
                                }
                            ]
                        }
                    }
                ]
            }),
            result = Ok(()),
        },
        test_cm_offers_all_valid_chars => {
            input = json!({
                "offers": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.logger.LogSink",
                            "source": {
                                "child": {
                                    "name": "abcdefghijklmnopqrstuvwxyz0123456789_-."
                                }
                            },
                            "targets": [
                                {
                                    "target_path": "/svc/fuchsia.logger.SysLog",
                                    "dest": {
                                        "child": {
                                            "name": "abcdefghijklmnopqrstuvwxyz0123456789_-."
                                        }
                                    }
                                }
                            ]
                        }
                    }
                ]
            }),
            result = Ok(()),
        },
        test_cm_offers_missing_variant => {
            input = json!({
                "offers": [ {} ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "OneOf conditions are not met at /offers/0")),
        },
        test_cm_offers_source_missing_variant => {
            input = json!({
                "offers": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.ui.Scenic",
                            "source": {},
                            "targets": [
                                {
                                    "target_path": "/svc/fuchsia.ui.Scenic",
                                    "dest": {
                                        "child": {
                                            "name": "user_shell"
                                        }
                                    }
                                }
                            ]
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "OneOf conditions are not met at /offers/0/service/source")),
        },
        test_cm_offers_source_multiple_variants => {
            input = json!({
                "offers": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.ui.Scenic",
                            "source": {
                                "myself": {},
                                "child": {
                                    "name": "foo"
                                }
                            },
                            "targets": [
                                {
                                    "target_path": "/svc/fuchsia.ui.Scenic",
                                    "dest": {
                                        "child": {
                                            "name": "user_shell"
                                        }
                                    }
                                }
                            ]
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "OneOf conditions are not met at /offers/0/service/source")),
        },
        test_cm_offers_source_bad_child_name => {
            input = json!({
                "offers": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.ui.Scenic",
                            "source": {
                                "child": {
                                    "name": "bad^"
                                }
                            },
                            "targets": [
                                {
                                    "target_path": "/svc/fuchsia.ui.Scenic",
                                    "dest": {
                                        "child": {
                                            "name": "user_shell"
                                        }
                                    }
                                }
                            ]
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "Pattern condition is not met at /offers/0/service/source/child/name")),
        },
        test_cm_offers_target_missing_props => {
            input = json!({
                "offers": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.ui.Scenic",
                            "source": {
                                "child": {
                                    "name": "cat_viewer"
                                }
                            },
                            "targets": [ {} ]
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "This property is required at /offers/0/service/targets/0/dest, This property is required at /offers/0/service/targets/0/target_path")),
        },
        test_cm_offers_target_bad_child_name => {
            input = json!({
                "offers": [
                    {
                        "service": {
                            "source_path": "/svc/fuchsia.ui.Scenic",
                            "source": {
                                "myself": {}
                            },
                            "targets": [
                                {
                                    "target_path": "/svc/fuchsia.ui.Scenic",
                                    "dest": {
                                        "child": {
                                            "name": "bad^"
                                        }
                                    }
                                }
                            ]
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "Pattern condition is not met at /offers/0/service/targets/0/dest/child/name")),
        },

        // children
        test_cm_children => {
            input = json!({
                "children": [
                    {
                        "name": "system-logger2",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                        "startup": "lazy"
                    },
                    {
                        "name": "abc123_-",
                        "url": "https://www.google.com/gmail",
                        "startup": "eager"
                    }
                ]
            }),
            result = Ok(()),
        },
        test_cm_children_missing_props => {
            input = json!({
                "children": [ {} ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "This property is required at /children/0/name, This property is required at /children/0/startup, This property is required at /children/0/url")),
        },
        test_cm_children_bad_name => {
            input = json!({
                "children": [
                    {
                        "name": "bad^",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                        "startup": "lazy"
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "Pattern condition is not met at /children/0/name")),
        },

        // collections
        test_cm_collections => {
            input = json!({
                "collections": [
                    {
                        "name": "modular",
                        "durability": "persistent"
                    },
                    {
                        "name": "tests",
                        "durability": "transient"
                    }
                ]
            }),
            result = Ok(()),
        },
        test_cm_collections_missing_props => {
            input = json!({
                "collections": [ {} ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "This property is required at /collections/0/durability, This property is required at /collections/0/name")),
        },
        test_cm_collections_bad_name => {
            input = json!({
                "collections": [
                    {
                        "name": "bad^",
                        "durability": "persistent"
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "Pattern condition is not met at /collections/0/name")),
        },

        // facets
        test_cm_facets => {
            input = json!({
                "facets": {
                    "metadata": {
                        "title": "foo",
                        "authors": [ "me", "you" ],
                        "year": 2018
                    }
                }
            }),
            result = Ok(()),
        },
        test_cm_facets_wrong_type => {
            input = json!({
                "facets": 55
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "Type of the value is wrong at /facets")),
        },

        // constraints
        test_cm_path => {
            input = json!({
                "uses": [
                    {
                        "directory": {
                            "source_path": "/foo/?!@#$%/Bar",
                            "target_path": "/bar/&*()/Baz"
                        }
                    }
                ]
            }),
            result = Ok(()),
        },
        test_cm_path_invalid_empty => {
            input = json!({
                "uses": [
                    {
                        "directory": {
                            "source_path": "",
                            "target_path": "/bar"
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "MinLength condition is not met at /uses/0/directory/source_path, Pattern condition is not met at /uses/0/directory/source_path")),
        },
        test_cm_path_invalid_root => {
            input = json!({
                "uses": [
                    {
                        "directory": {
                            "source_path": "/",
                            "target_path": "/bar"
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "Pattern condition is not met at /uses/0/directory/source_path")),
        },
        test_cm_path_invalid_relative => {
            input = json!({
                "uses": [
                    {
                        "directory": {
                            "source_path": "foo/bar",
                            "target_path": "/bar"
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "Pattern condition is not met at /uses/0/directory/source_path")),
        },
        test_cm_path_invalid_trailing => {
            input = json!({
                "uses": [
                    {
                        "directory": {
                            "source_path": "/foo/bar/",
                            "target_path": "/bar"
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "Pattern condition is not met at /uses/0/directory/source_path")),
        },
        test_cm_path_too_long => {
            input = json!({
                "uses": [
                    {
                        "directory": {
                            "source_path": format!("/{}", "a".repeat(1024)),
                            "target_path": "/bar"
                        }
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "MaxLength condition is not met at /uses/0/directory/source_path")),
        },
        test_cm_name => {
            input = json!({
                "children": [
                    {
                        "name": "abcdefghijklmnopqrstuvwxyz0123456789_-.",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                        "startup": "lazy"
                    }
                ]
            }),
            result = Ok(()),
        },
        test_cm_name_invalid => {
            input = json!({
                "children": [
                    {
                        "name": "#bad",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                        "startup": "lazy"
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "Pattern condition is not met at /children/0/name")),
        },
        test_cm_name_too_long => {
            input = json!({
                "children": [
                    {
                        "name": "a".repeat(101),
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                        "startup": "lazy"
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "MaxLength condition is not met at /children/0/name")),
        },
        test_cm_url => {
            input = json!({
                "children": [
                    {
                        "name": "logger",
                        "url": "my+awesome-scheme.2://abc123!@#$%.com",
                        "startup": "lazy"
                    }
                ]
            }),
            result = Ok(()),
        },
        test_cm_url_invalid => {
            input = json!({
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://",
                        "startup": "lazy"
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "Pattern condition is not met at /children/0/url")),
        },
        test_cm_url_too_long => {
            input = json!({
                "children": [
                    {
                        "name": "logger",
                        "url": &format!("fuchsia-pkg://{}", "a".repeat(4083)),
                        "startup": "lazy"
                    }
                ]
            }),
            result = Err(Error::validate_schema(CM_SCHEMA, "MaxLength condition is not met at /children/0/url")),
        },
    }

    #[test]
    fn test_cml_json5() {
        let input = r##"{
            "expose": [
                // Here are some services to expose.
                { "service": "/loggers/fuchsia.logger.Log", "from": "#logger", },
                { "directory": "/volumes/blobfs", "from": "self", },
            ],
            "children": [
                {
                    'name': 'logger',
                    'url': 'fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm',
                },
            ],
        }"##;
        validate_json_str("test.cml", input, Ok(()));
    }

    test_validate_cml! {
        // program
        test_cml_empty_json => {
            input = json!({}),
            result = Ok(()),
        },
        test_cml_program => {
            input = json!({"program": { "binary": "bin/app" }}),
            result = Ok(()),
        },
        test_cml_program_no_binary => {
            input = json!({"program": {}}),
            result = Err(Error::validate_schema(CML_SCHEMA, "This property is required at /program/binary")),
        },

        // use
        test_cml_use => {
            input = json!({
                "use": [
                  { "service": "/fonts/CoolFonts", "as": "/svc/fuchsia.fonts.Provider" },
                  { "directory": "/data/assets" }
                ]
            }),
            result = Ok(()),
        },
        test_cml_use_missing_props => {
            input = json!({
                "use": [ { "as": "/svc/fuchsia.logger.Log" } ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "OneOf conditions are not met at /use/0")),
        },

        // expose
        test_cml_expose => {
            input = json!({
                "expose": [
                    {
                        "service": "/loggers/fuchsia.logger.Log",
                        "from": "#logger",
                        "as": "/svc/logger"
                    },
                    { "directory": "/volumes/blobfs", "from": "self" }
                ],
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm"
                    }
                ]
            }),
            result = Ok(()),
        },
        test_cml_expose_all_valid_chars => {
            input = json!({
                "expose": [
                    { "service": "/loggers/fuchsia.logger.Log", "from": "#abcdefghijklmnopqrstuvwxyz0123456789_-." }
                ],
                "children": [
                    {
                        "name": "abcdefghijklmnopqrstuvwxyz0123456789_-.",
                        "url": "https://www.google.com/gmail"
                    }
                ]
            }),
            result = Ok(()),
        },
        test_cml_expose_missing_props => {
            input = json!({
                "expose": [ {} ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "OneOf conditions are not met at /expose/0, This property is required at /expose/0/from")),
        },
        test_cml_expose_missing_from => {
            input = json!({
                "expose": [
                    { "service": "/loggers/fuchsia.logger.Log", "from": "#missing" }
                ]
            }),
            result = Err(Error::validate("\"#missing\" is an \"expose\" source but it does not appear in \"children\"")),
        },
        test_cml_expose_duplicate_target_paths => {
            input = json!({
                "expose": [
                    { "service": "/fonts/CoolFonts", "from": "self" },
                    { "service": "/svc/logger", "from": "#logger", "as": "/thing" },
                    { "directory": "/thing", "from": "self" }
                ],
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm"
                    }
                ]
            }),
            result = Err(Error::validate("\"/thing\" is a duplicate \"expose\" target path")),
        },
        test_cml_expose_bad_from => {
            input = json!({
                "expose": [ {
                    "service": "/loggers/fuchsia.logger.Log", "from": "realm"
                } ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "Pattern condition is not met at /expose/0/from")),
        },

        // offer
        test_cml_offer => {
            input = json!({
                "offer": [
                    {
                        "service": "/svc/fuchsia.logger.Log",
                        "from": "#logger",
                        "to": [
                            { "dest": "#echo_server" },
                            { "dest": "#modular", "as": "/svc/fuchsia.logger.SysLog" }
                        ]
                    },
                    {
                        "service": "/svc/fuchsia.fonts.Provider",
                        "from": "realm",
                        "to": [
                            { "dest": "#echo_server" },
                        ]
                    },
                    {
                        "directory": "/data/assets",
                        "from": "self",
                        "to": [
                            { "dest": "#echo_server" },
                        ]
                    },
                    {
                        "directory": "/data/index",
                        "from": "realm",
                        "to": [
                            { "dest": "#modular" },
                        ]
                    },
                ],
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm"
                    },
                    {
                        "name": "echo_server",
                        "url": "fuchsia-pkg://fuchsia.com/echo/stable#meta/echo_server.cm"
                    }
                ],
                "collections": [
                    {
                        "name": "modular",
                        "durability": "persistent",
                    },
                ]
            }),
            result = Ok(()),
        },
        test_cml_offer_all_valid_chars => {
            input = json!({
                "offer": [
                    {
                        "service": "/svc/fuchsia.logger.Log",
                        "from": "#abcdefghijklmnopqrstuvwxyz0123456789_-from",
                        "to": [
                            {
                                "dest": "#abcdefghijklmnopqrstuvwxyz0123456789_-to",
                            },
                        ],
                    }
                ],
                "children": [
                    {
                        "name": "abcdefghijklmnopqrstuvwxyz0123456789_-from",
                        "url": "https://www.google.com/gmail"
                    },
                    {
                        "name": "abcdefghijklmnopqrstuvwxyz0123456789_-to",
                        "url": "https://www.google.com/gmail"
                    },
                ]
            }),
            result = Ok(()),
        },
        test_cml_offer_missing_props => {
            input = json!({
                "offer": [ {} ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "OneOf conditions are not met at /offer/0, This property is required at /offer/0/from, This property is required at /offer/0/to")),
        },
        test_cml_offer_missing_from => {
            input = json!({
                    "offer": [ {
                        "service": "/svc/fuchsia.logger.Log",
                        "from": "#missing",
                        "to": [
                            { "dest": "#echo_server" },
                        ]
                    } ]
                }),
            result = Err(Error::validate("\"#missing\" is an \"offer\" source but it does not appear in \"children\"")),
        },
        test_cml_offer_bad_from => {
            input = json!({
                    "offer": [ {
                        "service": "/svc/fuchsia.logger.Log",
                        "from": "#invalid@",
                        "to": [
                            { "dest": "#echo_server" },
                        ]
                    } ]
                }),
            result = Err(Error::validate_schema(CML_SCHEMA, "Pattern condition is not met at /offer/0/from")),
        },
        test_cml_offer_empty_targets => {
            input = json!({
                "offer": [ {
                    "service": "/svc/fuchsia.logger.Log",
                    "from": "#logger",
                    "to": []
                } ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "MinItems condition is not met at /offer/0/to")),
        },
        test_cml_offer_target_missing_props => {
            input = json!({
                "offer": [ {
                    "service": "/svc/fuchsia.logger.Log",
                    "from": "#logger",
                    "to": [
                        { "as": "/svc/fuchsia.logger.SysLog" }
                    ]
                } ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "This property is required at /offer/0/to/0/dest")),
        },
        test_cml_offer_target_missing_to => {
            input = json!({
                "offer": [ {
                    "service": "/snvc/fuchsia.logger.Log",
                    "from": "#logger",
                    "to": [
                        { "dest": "#missing" }
                    ]
                } ],
                "children": [ {
                    "name": "logger",
                    "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm"
                } ]
            }),
            result = Err(Error::validate("\"#missing\" is an \"offer\" target but it does not appear in \"children\" or \"collections\"")),
        },
        test_cml_offer_target_bad_to => {
            input = json!({
                "offer": [ {
                    "service": "/svc/fuchsia.logger.Log",
                    "from": "#logger",
                    "to": [
                        { "dest": "self", "as": "/svc/fuchsia.logger.SysLog" }
                    ]
                } ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "Pattern condition is not met at /offer/0/to/0/dest")),
        },
        test_cml_offer_target_equals_from => {
            input = json!({
                "offer": [ {
                    "service": "/svc/fuchsia.logger.Log",
                    "from": "#logger",
                    "to": [
                        { "dest": "#logger", "as": "/svc/fuchsia.logger.SysLog", },
                    ],
                } ],
                "children": [ {
                    "name": "logger", "url": "fuchsia-pkg://fuchsia.com/logger#meta/logger.cm",
                } ],
            }),
            result = Err(Error::validate("Offer target \"#logger\" is same as source")),
        },
        test_cml_offer_duplicate_target_paths => {
            input = json!({
                "offer": [
                    {
                        "service": "/svc/logger",
                        "from": "self",
                        "to": [
                            { "dest": "#echo_server", "as": "/thing" },
                            { "dest": "#scenic" }
                        ]
                    },
                    {
                        "directory": "/thing",
                        "from": "realm",
                        "to": [
                            { "dest": "#echo_server" }
                        ]
                    }
                ],
                "children": [
                    {
                        "name": "scenic",
                        "url": "fuchsia-pkg://fuchsia.com/scenic/stable#meta/scenic.cm"
                    },
                    {
                        "name": "echo_server",
                        "url": "fuchsia-pkg://fuchsia.com/echo/stable#meta/echo_server.cm"
                    }
                ]
            }),
            result = Err(Error::validate("\"/thing\" is a duplicate \"offer\" target path for \"#echo_server\"")),
        },

        // children
        test_cml_children => {
            input = json!({
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                    },
                    {
                        "name": "gmail",
                        "url": "https://www.google.com/gmail",
                        "startup": "eager",
                    },
                    {
                        "name": "echo",
                        "url": "fuchsia-pkg://fuchsia.com/echo/stable#meta/echo.cm",
                        "startup": "lazy",
                    },
                ]
            }),
            result = Ok(()),
        },
        test_cml_children_missing_props => {
            input = json!({
                "children": [ {} ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "This property is required at /children/0/name, This property is required at /children/0/url")),
        },
        test_cml_children_duplicate_names => {
           input = json!({
               "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm"
                    },
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/beta#meta/logger.cm"
                    }
                ]
            }),
            result = Err(Error::validate("Duplicate child name: \"logger\"")),
        },
        test_cml_children_bad_startup => {
            input = json!({
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                        "startup": "zzz",
                    },
                ],
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "Pattern condition is not met at /children/0/startup")),
        },

        // collections
        test_cml_collections => {
            input = json!({
                "collections": [
                    {
                        "name": "modular",
                        "durability": "persistent"
                    },
                    {
                        "name": "tests",
                        "durability": "transient"
                    },
                ]
            }),
            result = Ok(()),
        },
        test_cml_collections_missing_props => {
            input = json!({
                "collections": [ {} ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "This property is required at /collections/0/durability, This property is required at /collections/0/name")),
        },
        test_cml_collections_duplicate_names => {
           input = json!({
               "collections": [
                    {
                        "name": "modular",
                        "durability": "persistent"
                    },
                    {
                        "name": "modular",
                        "durability": "transient"
                    }
                ]
            }),
            result = Err(Error::validate("Duplicate collection name: \"modular\"")),
        },
        test_cml_collections_bad_durability => {
            input = json!({
                "collections": [
                    {
                        "name": "modular",
                        "durability": "zzz",
                    },
                ],
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "Pattern condition is not met at /collections/0/durability")),
        },

        // facets
        test_cml_facets => {
            input = json!({
                "facets": {
                    "metadata": {
                        "title": "foo",
                        "authors": [ "me", "you" ],
                        "year": 2018
                    }
                }
            }),
            result = Ok(()),
        },
        test_cml_facets_wrong_type => {
            input = json!({
                "facets": 55
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "Type of the value is wrong at /facets")),
        },

        // constraints
        test_cml_path => {
            input = json!({
                "use": [
                  { "directory": "/foo/?!@#$%/Bar" },
                ]
            }),
            result = Ok(()),
        },
        test_cml_path_invalid_empty => {
            input = json!({
                "use": [
                  { "service": "" },
                ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "MinLength condition is not met at /use/0/service, Pattern condition is not met at /use/0/service")),
        },
        test_cml_path_invalid_root => {
            input = json!({
                "use": [
                  { "service": "/" },
                ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "Pattern condition is not met at /use/0/service")),
        },
        test_cml_path_invalid_relative => {
            input = json!({
                "use": [
                  { "service": "foo/bar" },
                ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "Pattern condition is not met at /use/0/service")),
        },
        test_cml_path_invalid_trailing => {
            input = json!({
                "use": [
                  { "service": "/foo/bar/" },
                ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "Pattern condition is not met at /use/0/service")),
        },
        test_cml_path_too_long => {
            input = json!({
                "use": [
                  { "service": format!("/{}", "a".repeat(1024)) },
                ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "MaxLength condition is not met at /use/0/service")),
        },
        test_cml_relative_ref_too_long => {
            input = json!({
                "expose": [
                    {
                        "service": "/loggers/fuchsia.logger.Log",
                        "from": &format!("#{}", "a".repeat(101)),
                    },
                ],
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                    },
                ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "MaxLength condition is not met at /expose/0/from")),
        },
        test_cml_child_name => {
            input = json!({
                "children": [
                    {
                        "name": "abcdefghijklmnopqrstuvwxyz0123456789_-.",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                    },
                ]
            }),
            result = Ok(()),
        },
        test_cml_child_name_invalid => {
            input = json!({
                "children": [
                    {
                        "name": "#bad",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                    },
                ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "Pattern condition is not met at /children/0/name")),
        },
        test_cml_child_name_too_long => {
            input = json!({
                "children": [
                    {
                        "name": "a".repeat(101),
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                    }
                ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "MaxLength condition is not met at /children/0/name")),
        },
        test_cml_url => {
            input = json!({
                "children": [
                    {
                        "name": "logger",
                        "url": "my+awesome-scheme.2://abc123!@#$%.com",
                    },
                ]
            }),
            result = Ok(()),
        },
        test_cml_url_invalid => {
            input = json!({
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://",
                    },
                ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "Pattern condition is not met at /children/0/url")),
        },
        test_cml_url_too_long => {
            input = json!({
                "children": [
                    {
                        "name": "logger",
                        "url": &format!("fuchsia-pkg://{}", "a".repeat(4083)),
                    },
                ]
            }),
            result = Err(Error::validate_schema(CML_SCHEMA, "MaxLength condition is not met at /children/0/url")),
        },
    }

    test_validate_cmx! {
        test_cmx_err_empty_json => {
            input = json!({}),
            result = Err(Error::validate_schema(CMX_SCHEMA, "This property is required at /program")),
        },
        test_cmx_program => {
            input = json!({"program": { "binary": "bin/app" }}),
            result = Ok(()),
        },
        test_cmx_program_no_binary => {
            input = json!({ "program": {}}),
            result = Err(Error::validate_schema(CMX_SCHEMA, "OneOf conditions are not met at /program")),
        },
        test_cmx_bad_program => {
            input = json!({"prigram": { "binary": "bin/app" }}),
            result = Err(Error::validate_schema(CMX_SCHEMA, "Property conditions are not met at , \
                                       This property is required at /program")),
        },
        test_cmx_sandbox => {
            input = json!({
                "program": { "binary": "bin/app" },
                "sandbox": { "dev": [ "class/camera" ] }
            }),
            result = Ok(()),
        },
        test_cmx_facets => {
            input = json!({
                "program": { "binary": "bin/app" },
                "facets": {
                    "fuchsia.test": {
                         "system-services": [ "fuchsia.logger.LogSink" ]
                    }
                }
            }),
            result = Ok(()),
        },
    }

    // We can't simply using JsonSchema::new here and create a temp file with the schema content
    // to pass to validate() later because the path in the errors in the expected results below
    // need to include the whole path, since that's what you get in the Error::Validate.
    lazy_static! {
        static ref BLOCK_SHELL_FEATURE_SCHEMA: JsonSchema<'static> = str_to_json_schema(
            "block_shell_feature.json",
            include_str!("../test_block_shell_feature.json")
        );
    }
    lazy_static! {
        static ref BLOCK_DEV_SCHEMA: JsonSchema<'static> =
            str_to_json_schema("block_dev.json", include_str!("../test_block_dev.json"));
    }

    fn str_to_json_schema<'a, 'b>(name: &'a str, content: &'a str) -> JsonSchema<'b> {
        lazy_static! {
            static ref TEMPDIR: TempDir = TempDir::new().unwrap();
        }

        let tmp_path = TEMPDIR.path().join(name);
        File::create(&tmp_path).unwrap().write_all(content.as_bytes()).unwrap();
        JsonSchema::new_from_file(&tmp_path).unwrap()
    }

    macro_rules! test_validate_extra_schemas {
        (
            $(
                $test_name:ident => {
                    input = $input:expr,
                    extra_schemas = $extra_schemas:expr,
                    result = $result:expr,
                },
            )+
        ) => {
            $(
                #[test]
                fn $test_name() -> Result<(), Error> {
                    validate_extra_schemas_test($input, $extra_schemas, $result)
                }
            )+
        }
    }

    fn validate_extra_schemas_test(
        input: serde_json::value::Value,
        extra_schemas: &[(&JsonSchema, Option<String>)],
        expected_result: Result<(), Error>,
    ) -> Result<(), Error> {
        let input_str = format!("{}", input);
        let tmp_dir = TempDir::new()?;
        let tmp_cmx_path = tmp_dir.path().join("test.cmx");
        File::create(&tmp_cmx_path)?.write_all(input_str.as_bytes())?;

        let extra_schema_paths =
            extra_schemas.iter().map(|i| (Path::new(&*i.0.name), i.1.clone())).collect::<Vec<_>>();
        let result = validate(&[tmp_cmx_path.as_path()], &extra_schema_paths);
        assert_eq!(format!("{:?}", result), format!("{:?}", expected_result));
        Ok(())
    }

    test_validate_extra_schemas! {
        test_validate_extra_schemas_empty_json => {
            input = json!({"program": {"binary": "a"}}),
            extra_schemas = &[(&BLOCK_SHELL_FEATURE_SCHEMA, None)],
            result = Ok(()),
        },
        test_validate_extra_schemas_empty_features => {
            input = json!({"sandbox": {"features": []}, "program": {"binary": "a"}}),
            extra_schemas = &[(&BLOCK_SHELL_FEATURE_SCHEMA, None)],
            result = Ok(()),
        },
        test_validate_extra_schemas_feature_not_present => {
            input = json!({"sandbox": {"features": ["isolated-persistent-storage"]}, "program": {"binary": "a"}}),
            extra_schemas = &[(&BLOCK_SHELL_FEATURE_SCHEMA, None)],
            result = Ok(()),
        },
        test_validate_extra_schemas_feature_present => {
            input = json!({"sandbox": {"features" : ["shell"]}, "program": {"binary": "a"}}),
            extra_schemas = &[(&BLOCK_SHELL_FEATURE_SCHEMA, None)],
            result = Err(Error::validate_schema(&BLOCK_SHELL_FEATURE_SCHEMA, "Not condition is not met at /sandbox/features/0")),
        },
        test_validate_extra_schemas_block_dev => {
            input = json!({"dev": ["misc"], "program": {"binary": "a"}}),
            extra_schemas = &[(&BLOCK_DEV_SCHEMA, None)],
            result = Err(Error::validate_schema(&BLOCK_DEV_SCHEMA, "Not condition is not met at /dev")),
        },
        test_validate_multiple_extra_schemas_valid => {
            input = json!({"sandbox": {"features": ["isolated-persistent-storage"]}, "program": {"binary": "a"}}),
            extra_schemas = &[(&BLOCK_SHELL_FEATURE_SCHEMA, None), (&BLOCK_DEV_SCHEMA, None)],
            result = Ok(()),
        },
        test_validate_multiple_extra_schemas_invalid => {
            input = json!({"dev": ["misc"], "sandbox": {"features": ["isolated-persistent-storage"]}, "program": {"binary": "a"}}),
            extra_schemas = &[(&BLOCK_SHELL_FEATURE_SCHEMA, None), (&BLOCK_DEV_SCHEMA, None)],
            result = Err(Error::validate_schema(&BLOCK_DEV_SCHEMA, "Not condition is not met at /dev")),
        },
    }

    #[test]
    fn test_validate_extra_error() -> Result<(), Error> {
        validate_extra_schemas_test(
            json!({"dev": ["misc"], "program": {"binary": "a"}}),
            &[(&BLOCK_DEV_SCHEMA, Some("Extra error".to_string()))],
            Err(Error::validate_schema(
                &BLOCK_DEV_SCHEMA,
                "Not condition is not met at /dev\nExtra error",
            )),
        )
    }
}