export function run() {
    let testObject = {
        name: "000",
        email: "debug@gmail.com",
        none: null
    }
    describe("basic validtor test", () => {
        it("Test should require field", () => {
            let validator = Leaf.Validator.create()
            try {
                validator
                    .string()
                validator.check({
                    name: "1234"
                })
            } catch (e) {
                if (e instanceof Leaf.Validator.Errors.RequireFieldSpecification) {
                    return
                }
            }
            throw new Error("Show have error")
        })
        it("Test duiplicate should overwrite", () => {
            let validator = Leaf.Validator.create()
            validator
                .field("name")
                .gt(4)
                .gt(3)
            validator.check({
                name: "1234"
            })
        })
        it("Test string", () => {
            let err = new Error()
            let validator = Leaf.Validator.create()
                .field("name")
                .string()
                .error(err)
            try {
                validator.check({
                    name: 3
                })
            } catch (e) {
                if (e === err) {
                    return
                }
            }
            throw new Error("string test should field")
        })
        it("Tests gt", () => {
            let err = new Error()
            let validator = Leaf.Validator.create()
                .field("count")
                .int()
                .gt(2)
                .check({
                    count: 3
                })
                .error(err)
            try {
                validator.check({
                    count: 2
                })
            } catch (e) {
                if (e === err) return
            }
        })
        it("Tests lt", () => {
            let err = new Error()
            let validator = Leaf.Validator.create()
                .field("count")
                .int()
                .lt(2)
                .error(err)
                .check({
                    count: 1
                })
            try {
                validator.check({
                    count: 2
                })
            } catch (e) {
                if (e === err) return
            }
        })
        it("Tests is", () => {
            let err = new Error()
            let validator = Leaf.Validator.create()
                .field("count")
                .int()
                .is(2)
                .check({
                    count: 2
                })
                .error(err)
            try {
                validator.check({
                    count: 3
                })
            } catch (e) {
                if (e === err) return
            }
        })
        it("Tests number", () => {
            let err = new Error()
            let validator = Leaf.Validator.create()
                .field("count")
                .number()
                .check({
                    count: 2
                })
                .error(err)
            try {
                validator.check({
                    count: "123"
                })
            } catch (e) {
                if (e === err) return
            }
        })
        it("Tests int", () => {
            let err = new Error()
            let validator = Leaf.Validator.create()
                .field("count")
                .int()
                .error(err)
                .check({
                    count: 2
                })
            try {
                validator.check({
                    count: 2.5
                })
            } catch (e) {
                if (e === err) return
            }
        })
        it("Tests exists", () => {
            let err = new Error()
            let validator = Leaf.Validator.create()
                .field("count")
                .exists()
                .error(err)
                .check({
                    count: 2
                })
                .error(err)
            try {
                validator.check({
                    count: null
                })
            } catch (e) {
                if (e === err) return
            }
        })
        it("Tests match", () => {
            let err = new Error()
            let validator = Leaf.Validator.create()
                .field("name")
                .match(/^[0-9]{3}$/)
                .error(err)
                .check({
                    count: "123"
                })
            try {
                validator.check({
                    name: "abc"
                })
            } catch (e) {
                if (e === err) return
            }
        })
        it("Test custom", () => {
            let err = new Error()
            let validator = Leaf.Validator.create()
                .field("meta")
                .custom((obj, name, value) => {
                    if (value && value["a"] === 3) return true
                    return false
                })
                .error(err)
                .check({
                    meta: {
                        a: 3
                    }
                })
            try {
                validator.check({
                    meta: {}
                })
            } catch (e) {
                if (e === err) return
            }
        })
        it("Test readonly", () => {
            try {
                let validator = Leaf.Validator.create()
                    .field("meta")
                    .custom((obj, name, value) => {
                        if (value && value["a"] === 3) return true
                        return false
                    })
                    .readonly()
                    .field("rule")
                    .gt(3)
            } catch (e) {
                if (e instanceof Leaf.Validator.Errors.Readonly) {
                    return
                }
                console.error(e)
                throw new Error("Should error readonly")
            }
            let e = new Error()
            try {
                let validator = Leaf.Validator.create()
                    .field("meta")
                    .custom((obj, name, value) => {
                        if (value && value["a"] === 3) return true
                        return false
                    })
                    .readonly()
                    .clone()
                    .field("rule")
                    .string()
                    .gt(3)
                    .error(e)
                    .check({
                        rule: "123"
                    })
            } catch (err) {
                if (e === err) return
            }
            throw new Error("Fail to check rule")
        })
    })
}