jspg/validator/tests/examples.rs

use std::{error::Error, fs::File};

use boon::{Compiler, Decoder, FileLoader, Format, MediaType, Schemas, SchemeUrlLoader, UrlLoader};
use serde::de::IgnoredAny;
use serde_json::{json, Value};
use url::Url;

#[test]
fn example_from_files() -> Result<(), Box<dyn Error>> {
  let schema_file = "tests/examples/schema.json";
  let instance: Value = serde_json::from_reader(File::open("tests/examples/instance.json")?)?;

  let mut schemas = Schemas::new();
  let mut compiler = Compiler::new();
  let sch_index = compiler.compile(schema_file, &mut schemas)?;
  let result = schemas.validate(&instance, sch_index);
  assert!(result.is_ok());

  Ok(())
}

/**
This example shows how to load json schema from strings.

The schema url used plays important role in resolving
schema references.

You can see that `cat.json` is resolved internally to
another string schema where as dog.json is resolved
to local file.
*/
#[test]
fn example_from_strings() -> Result<(), Box<dyn Error>> {
  let cat_schema: Value = json!({
    "type": "object",
    "properties": {
      "speak": { "const": "meow" }
    },
    "required": ["speak"]
  });
  let pet_schema: Value = json!({
    "oneOf": [
      { "$ref": "dog.json" },
      { "$ref": "cat.json" }
    ]
  });
  let instance: Value = json!({"speak": "bow"});

  let mut schemas = Schemas::new();
  let mut compiler = Compiler::new();
  compiler.add_resource("tests/examples/pet.json", pet_schema)?;
  compiler.add_resource("tests/examples/cat.json", cat_schema)?;
  let sch_index = compiler.compile("tests/examples/pet.json", &mut schemas)?;
  let result = schemas.validate(&instance, sch_index);
  assert!(result.is_ok());

  Ok(())
}

#[test]
#[ignore]
fn example_from_https() -> Result<(), Box<dyn Error>> {
  let schema_url = "https://json-schema.org/learn/examples/geographical-location.schema.json";
  let instance: Value = json!({"latitude": 48.858093, "longitude": 2.294694});

  struct HttpUrlLoader;
  impl UrlLoader for HttpUrlLoader {
    fn load(&self, url: &str) -> Result<Value, Box<dyn Error>> {
      let reader = ureq::get(url).call()?.into_reader();
      Ok(serde_json::from_reader(reader)?)
    }
  }

  let mut schemas = Schemas::new();
  let mut compiler = Compiler::new();
  let mut loader = SchemeUrlLoader::new();
  loader.register("file", Box::new(FileLoader));
  loader.register("http", Box::new(HttpUrlLoader));
  loader.register("https", Box::new(HttpUrlLoader));
  compiler.use_loader(Box::new(loader));
  let sch_index = compiler.compile(schema_url, &mut schemas)?;
  let result = schemas.validate(&instance, sch_index);
  assert!(result.is_ok());

  Ok(())
}

#[test]
fn example_from_yaml_files() -> Result<(), Box<dyn Error>> {
  let schema_file = "tests/examples/schema.yml";
  let instance: Value = serde_yaml::from_reader(File::open("tests/examples/instance.yml")?)?;

  struct FileUrlLoader;
  impl UrlLoader for FileUrlLoader {
    fn load(&self, url: &str) -> Result<Value, Box<dyn Error>> {
      let url = Url::parse(url)?;
      let path = url.to_file_path().map_err(|_| "invalid file path")?;
      let file = File::open(&path)?;
      if path
        .extension()
        .filter(|&ext| ext == "yaml" || ext == "yml")
        .is_some()
      {
        Ok(serde_yaml::from_reader(file)?)
      } else {
        Ok(serde_json::from_reader(file)?)
      }
    }
  }

  let mut schemas = Schemas::new();
  let mut compiler = Compiler::new();
  let mut loader = SchemeUrlLoader::new();
  loader.register("file", Box::new(FileUrlLoader));
  compiler.use_loader(Box::new(loader));
  let sch_index = compiler.compile(schema_file, &mut schemas)?;
  let result = schemas.validate(&instance, sch_index);
  assert!(result.is_ok());

  Ok(())
}

#[test]
fn example_custom_format() -> Result<(), Box<dyn Error>> {
  let schema_url = "http://tmp/schema.json";
  let schema: Value = json!({"type": "string", "format": "palindrome"});
  let instance: Value = json!("step on no pets");

  fn is_palindrome(v: &Value) -> Result<(), Box<dyn Error>> {
    let Value::String(s) = v else {
      return Ok(()); // applicable only on strings
    };
    let mut chars = s.chars();
    while let (Some(c1), Some(c2)) = (chars.next(), chars.next_back()) {
      if c1 != c2 {
        Err("char mismatch")?;
      }
    }
    Ok(())
  }

  let mut schemas = Schemas::new();
  let mut compiler = Compiler::new();
  compiler.enable_format_assertions(); // in draft2020-12 format assertions are not enabled by default
  compiler.register_format(Format {
    name: "palindrome",
    func: is_palindrome,
  });
  compiler.add_resource(schema_url, schema)?;
  let sch_index = compiler.compile(schema_url, &mut schemas)?;
  let result = schemas.validate(&instance, sch_index);
  assert!(result.is_ok());

  Ok(())
}

#[test]
fn example_custom_content_encoding() -> Result<(), Box<dyn Error>> {
  let schema_url = "http://tmp/schema.json";
  let schema: Value = json!({"type": "string", "contentEncoding": "hex"});
  let instance: Value = json!("aBcdxyz");

  fn decode(b: u8) -> Result<u8, Box<dyn Error>> {
    match b {
      b'0'..=b'9' => Ok(b - b'0'),
      b'a'..=b'f' => Ok(b - b'a' + 10),
      b'A'..=b'F' => Ok(b - b'A' + 10),
      _ => Err("decode_hex: non-hex char")?,
    }
  }
  fn decode_hex(s: &str) -> Result<Vec<u8>, Box<dyn Error>> {
    if s.len() % 2 != 0 {
      Err("decode_hex: odd length")?;
    }
    let mut bytes = s.bytes();
    let mut out = Vec::with_capacity(s.len() / 2);
    for _ in 0..out.len() {
      if let (Some(b1), Some(b2)) = (bytes.next(), bytes.next()) {
        out.push(decode(b1)? << 4 | decode(b2)?);
      } else {
        Err("decode_hex: non-ascii char")?;
      }
    }
    Ok(out)
  }

  let mut schemas = Schemas::new();
  let mut compiler = Compiler::new();
  compiler.enable_content_assertions(); // content assertions are not enabled by default
  compiler.register_content_encoding(Decoder {
    name: "hex",
    func: decode_hex,
  });
  compiler.add_resource(schema_url, schema)?;
  let sch_index = compiler.compile(schema_url, &mut schemas)?;
  let result = schemas.validate(&instance, sch_index);
  assert!(result.is_err());

  Ok(())
}

#[test]
fn example_custom_content_media_type() -> Result<(), Box<dyn Error>> {
  let schema_url = "http://tmp/schema.json";
  let schema: Value = json!({"type": "string", "contentMediaType": "application/yaml"});
  let instance: Value = json!("name:foobar");

  fn check_yaml(bytes: &[u8], deserialize: bool) -> Result<Option<Value>, Box<dyn Error>> {
    if deserialize {
      return Ok(Some(serde_yaml::from_slice(bytes)?));
    }
    serde_yaml::from_slice::<IgnoredAny>(bytes)?;
    Ok(None)
  }

  let mut schemas = Schemas::new();
  let mut compiler = Compiler::new();
  compiler.enable_content_assertions(); // content assertions are not enabled by default
  compiler.register_content_media_type(MediaType {
    name: "application/yaml",
    json_compatible: true,
    func: check_yaml,
  });
  compiler.add_resource(schema_url, schema)?;
  let sch_index = compiler.compile(schema_url, &mut schemas)?;
  let result = schemas.validate(&instance, sch_index);
  assert!(result.is_ok());

  Ok(())
}