#bobzhang/jsonschema

#Validating

///|
test "validate" {
  let schema : Json = {
    "type": "object",
    "properties": { "price": { "type": "number", "minimum": 0 } },
    "required": ["name"],
  }
  @jsonschema.validate({ "name": "Eggs", "price": 34.99 }, schema)
  try @jsonschema.validate({ "name": "Eggs", "price": -1 }, schema) catch {
    @jsonschema.ValidationError(error) => {
      inspect(error.message, content="-1 is less than the minimum of 0")
      inspect(
        error,
        content=(
          #|-1 is less than the minimum of 0
          #|
          #|Failed validating 'minimum' in schema['properties']['price']:
          #|    {'type': 'number', 'minimum': 0}
          #|
          #|On instance['price']:
          #|    -1
        ),
      )
    }
    _ => fail("expected a ValidationError")
  } noraise {
    _ => fail("expected a ValidationError")
  }
}

#Validators and lazy errors

///|
test "iter_errors" {
  let validator = @jsonschema.draft202012_validator.new({
    "items": { "type": "integer" },
    "maxItems": 2,
  })
  let errors = validator.iter_errors([1, "two", 3.5]).to_array()
  inspect(
    errors.map(e => "\{e.json_path()}: \{e.message}").join("\n"),
    content=(
      #|$[1]: 'two' is not of type 'integer'
      #|$[2]: 3.5 is not of type 'integer'
      #|$: [1, 'two', 3.5] is too long
    ),
  )
  inspect(validator.is_valid([1, 2]), content="true")
  let best = @jsonschema.best_match(errors.iter()).unwrap()
  inspect(best.message, content="[1, 'two', 3.5] is too long")
}

#Formats

///|
test "formats" {
  let cls = @jsonschema.draft202012_validator
  let validator = cls.new(
    { "format": "ipv4" },
    format_checker=cls.format_checker,
  )
  inspect(validator.is_valid("127.0.0.1"), content="true")
  inspect(validator.is_valid("127.0.0.01"), content="false")
  inspect(cls.new({ "format": "ipv4" }).is_valid("nope"), content="true")
}

#Python numbers

///|
test "loads" {
  let one_point_zero = @jsonschema.loads("1.0")
  inspect(
    @jsonschema.draft4_validator
    .new({ "type": "integer" })
    .is_valid(one_point_zero),
    content="false",
  )
  inspect(
    @jsonschema.draft7_validator
    .new({ "type": "integer" })
    .is_valid(one_point_zero),
    content="true",
  )
  inspect(
    @jsonschema.py_repr(@jsonschema.loads("[1.0, 1e400, 7]")),
    content="[1.0, inf, 7]",
  )
}

#Extending

///|
test "extend" {
  let even : @jsonschema.KeywordFn = (_, value, instance, _) => {
    @jsonschema.Errors::new(yield_ => {
      if value is True && instance is Number(n, ..) && n % 2.0 != 0.0 {
        return yield_(
          @jsonschema.ValidationError::new(
            "\{@jsonschema.py_repr(instance)} is odd",
          ),
        )
      }
      true
    })
  }
  let cls = @jsonschema.draft202012_validator.extend_with(validators=[
    ("even", even),
  ])
  let errors = cls.new({ "even": true }).iter_errors(3).to_array()
  inspect(errors[0].message, content="3 is odd")
  debug_inspect(errors[0].schema_path, content="[Key(\"even\")]")
}

#Packages

#Licenses

#Deviations from upstream

• Format checks follow upstream's format-nongpl configuration: uri / uri-reference use rfc3986-validator and iri / iri-reference use rfc3987-syntax (not the GPL rfc3987 package).

• Draft 3 / 4 integer: needs loads (or Json::number(x, repr="1.0")) to tell 1.0 from 1; whole numbers without a spelling are ints.
• Regular expressions: \N{...} escapes are rejected (no Unicode name table). Everything else -- including lookaround, atomic groups, possessive quantifiers, conditionals, backreferences, Unicode \b and CPython's case-insensitive equivalences -- follows CPython 3.13's re (differentially tested against it). Lone surrogates in subjects are never matched by character classes.
• No network access: the default registry holds the meta-schemas only (upstream fetches unknown remote $refs with a deprecation warning).
• Unresolvable references raise bobzhang/referencing errors directly (@referencing.is_unresolvable), not upstream's _WrappedReferencingError.
• No deprecation warnings (e.g. for unknown $schemas); the deprecated RefResolver API is not ported.
• extend is ValidatorClass::extend_with (extend is reserved in MoonBit); validator classes are values (draft7_validator), not types.
• Built-in format checks raise the public FormatCause errors (AddressValueError, IDNAError, ... named after upstream's exception classes), available as ValidationError::cause.
• Python-level crashes upstream would hit (e.g. OverflowError in multipleOf for ints too large for a float) are raised as PythonError.
• Values Python allows but JSON cannot hold (non-string keys, tuples, Decimal) are out of scope.