123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356
// Copyright 2023-latest Tomoki Miyauchi. All rights reserved. MIT license.
import { assert, Err, Ok, validate, ValidationError } from "./validation.ts";import type { ValidationFailure, Validator } from "./types.ts";import {  assertEquals,  assertFalse,  assertIsError,  assertMatch,  assertThrows,  describe,  it,} from "./_dev_deps.ts";
const v: Validator = {  validate: () => [],  is: (_: unknown): _ is unknown => true,};
describe("assert", () => {  it("should return void if there are not validation failures", () => {    assertFalse(assert(v, ""));    assertFalse(assert(v, "", { failSlow: true }));    assertFalse(assert(v, "", { failSlow: true, maxFailures: 1 }));  });
  it("should expose instance path info by default", () => {    let err;    try {      assert(        { ...v, validate: () => [{ message: "test", instancePath: ["a"] }] },        "",      );    } catch (e) {      err = e;    } finally {      assertMatch(err.message, /^test\ninstance path: a$/);    }  });
  it("should not expose instance path info if the instance path is empty", () => {    let err;    try {      assert(        { ...v, validate: () => [{ message: "test", instancePath: [] }] },        "",      );    } catch (e) {      err = e;    } finally {      assertMatch(err.message, /^test$/);    }  });
  it("should be private instance path info", () => {    let err;    try {      assert(        { ...v, validate: () => [{ message: "test", instancePath: ["a"] }] },        "",        { pathInfo: { private: true } },      );    } catch (e) {      err = e;    } finally {      assertMatch(err.message, /^test$/);    }  });
  it("should add instance path root name", () => {    let err;    try {      assert(        { ...v, validate: () => [{ message: "test", instancePath: ["a"] }] },        "",        { pathInfo: { rootName: "options" } },      );    } catch (e) {      err = e;    } finally {      assertMatch(err.message, /^test\ninstance path: options.a$/);    }  });
  it("should add instance path root name if instance path is not exist", () => {    let err;    try {      assert(        { ...v, validate: () => [{ message: "test", instancePath: [] }] },        "",        { pathInfo: { rootName: "options" } },      );    } catch (e) {      err = e;    } finally {      assertMatch(err.message, /^test\ninstance path: options$/);    }  });
  describe("fail fast", () => {    it("should throw ValidationError if failFast is false or default", () => {      const v1: Validator = {        ...v,        validate: () => [{          message: "test2",          instancePath: ["a", "b", "c"],        }, { message: "test1", instancePath: [] }],      };
      let err;
      try {        assertFalse(assert(v1, ""));      } catch (e) {        err = e;      } finally {        assertIsError(err, ValidationError, "test2\ninstance path: a.b.c");        assertEquals(          err,          new ValidationError("test2\ninstance path: a.b.c", {            instancePath: ["a", "b", "c"],          }),        );      }    });
    it("should override Error if error is ctor", () => {      const v1: Validator = {        ...v,        validate: () => [{          message: "test2",          instancePath: ["a", "b", "c"],        }, { message: "test1", instancePath: [] }],      };
      let err;
      try {        assertFalse(          assert(v1, "", { validation: { error: Error } }),        );      } catch (e) {        err = e;      } finally {        assertIsError(err, Error, "test2\ninstance path: a.b.c");        assertEquals(          err,          new Error("test2\ninstance path: a.b.c"),        );      }    });
    it("should override message", () => {      const v1: Validator = {        ...v,        validate: () => [{          message: "",          instancePath: ["a", "b", "c"],        }, { message: "test1", instancePath: [] }],      };
      let err;
      try {        assertFalse(          assert(v1, "", { validation: { message: "test!!!" } }),        );      } catch (e) {        err = e;      } finally {        assertIsError(err, ValidationError, "test!!!\ninstance path: a.b.c");      }    });  });
  describe("fail slow", () => {    it("should throw AggregateError by default", () => {      const v1: Validator = {        ...v,        validate: () => [{ message: "test1", instancePath: [] }, {          message: "test2",          instancePath: ["a", "b", "c"],        }],      };
      let err;
      try {        assertFalse(assert(v1, "", { failSlow: true }));      } catch (e) {        err = e;      } finally {        assertIsError(err, AggregateError, "");        assertEquals(err.errors, [          new ValidationError(`test1`),          new ValidationError(`test2\ninstance path: a.b.c`, {            instancePath: ["a", "b", "c"],          }),        ]);      }    });
    it("should override AggregateError if pass error", () => {      const v1: Validator = {        ...v,        validate: () => [{ message: "test1", instancePath: [] }, {          message: "test2",          instancePath: ["a", "b", "c"],        }],      };
      let err;
      class CustomError extends AggregateError {        override name = "CustomError";      }
      try {        assertFalse(          assert(v1, "", {            failSlow: true,            aggregation: { error: CustomError },          }),        );      } catch (e) {        err = e;      } finally {        assertIsError(err, CustomError);      }    });
    it("should pass message", () => {      const v1: Validator = {        ...v,        validate: () => [{ message: "test1", instancePath: [] }, {          message: "test2",          instancePath: ["a", "b", "c"],        }],      };
      let err;
      try {        assertFalse(          assert(v1, "", { failSlow: true, aggregation: { message: "test" } }),        );      } catch (e) {        err = e;      } finally {        assertIsError(err, AggregateError, "test");      }    });
    it("should be limit number of error", () => {      const v1: Validator = {        ...v,        validate: () => [{ message: "test1", instancePath: [] }, {          message: "test2",          instancePath: ["a", "b", "c"],        }],      };
      let err;
      try {        assertFalse(assert(v1, "", { failSlow: true, maxFailures: 1 }));      } catch (e) {        err = e;      } finally {        assertIsError(err, AggregateError);        assertEquals(err.errors.length, 1);        assertEquals(err.errors[0].message, "test1");      }    });  });});
describe("validate", () => {  it("should return ok", () => {    assertEquals(validate(v, ""), new Ok(""));  });
  it("should return err", () => {    assertEquals(      validate({        ...v,        validate: () => [{ message: "error", instancePath: ["a", "b", "c"] }],      }, ""),      new Err<[ValidationFailure]>([{        message: "error",        instancePath: ["a", "b", "c"],      }]),    );  });
  it("should return err what count of number is strict by max errors", () => {    assertEquals(      validate(        {          ...v,          validate: () => [            { message: "error", instancePath: [] },            { message: "error2", instancePath: [] },          ],        },        "",        { maxFailures: 1 },      ),      new Err<[ValidationFailure]>([{ message: "error", instancePath: [] }]),    );  });
  it("should throw error is maxFailures is not positive integer", () => {    assertThrows(() => validate(v, "", { maxFailures: 0 }));  });});
describe("ValidationError", () => {  it("should has fields", () => {    const options = {      cause: {},      instancePath: [],    };    const error = new ValidationError("test", options);
    assertEquals(error.instancePath, options.instancePath);    assertEquals(error.message, "test");    assertEquals(error.cause, options.cause);    assertEquals(error.name, "ValidationError");  });});
describe("Ok", () => {  it("should return Ok container", () => {    const value = "test";    const ok = new Ok(value);
    assertEquals(ok.type, "ok");    assertEquals(ok.value, value);    assertEquals(ok.isOk(), true);    assertEquals(ok.isErr(), false);  });});
describe("Err", () => {  it("should return Err container", () => {    const value = "test";    const err = new Err(value);
    assertEquals(err.type, "error");    assertEquals(err.value, value);    assertEquals(err.isOk(), false);    assertEquals(err.isErr(), true);  });});