import {Contains, IsDefined, MinLength, ValidateNested} from "../../src/decorator/decorators";
import {Validator} from "../../src/validation/Validator";
import {ValidationTypes} from "../../src/validation/ValidationTypes";

const validator = new Validator();

describe("nested validation", () => {
    it("should not validate missing nested objects", () => {
        expect.assertions(4);

        class MySubClass {
            @MinLength(5)
            name: string;
        }

        class MyClass {
            @Contains("hello")
            title: string;

            @ValidateNested() @IsDefined()
            mySubClass: MySubClass;
        }

        const model: MyClass = new MyClass();
        model.title = "helo";

        return validator.validate(model).then(errors => {
            expect(errors[1].target).toEqual(model);
            expect(errors[1].value).toBeUndefined();
            expect(errors[1].property).toEqual("mySubClass");
            expect(errors[1].constraints).toEqual({isDefined: "mySubClass should not be null or undefined"});
        });
    });

    it("should validate nested objects", () => {
        expect.assertions(55);

        class MySubClass {
            @MinLength(5)
            name: string;
        }

        class MyClass {
            @Contains("hello")
            title: string;

            @ValidateNested()
            mySubClass: MySubClass;

            @ValidateNested()
            mySubClasses: MySubClass[];

            @ValidateNested()
            mySubSubClasses: MySubClass[][];

            @ValidateNested()
            mySubSubSubClasses: MySubClass[][][];
        }

        const model = new MyClass();
        model.title = "helo world";
        model.mySubClass = new MySubClass();
        model.mySubClass.name = "my";
        model.mySubClasses = [new MySubClass(), new MySubClass()];
        model.mySubClasses[0].name = "my";
        model.mySubClasses[1].name = "not-short";
        model.mySubSubClasses = [[new MySubClass()]];
        model.mySubSubClasses[0][0].name = "sub";
        model.mySubSubSubClasses = [[[new MySubClass()]]];
        model.mySubSubSubClasses[0][0][0].name = "sub";

        return validator.validate(model).then(errors => {
            expect(errors.length).toEqual(5);

            expect(errors[0].target).toEqual(model);
            expect(errors[0].property).toEqual("title");
            expect(errors[0].constraints).toEqual({contains: "title must contain a hello string"});
            expect(errors[0].value).toEqual("helo world");

            expect(errors[1].target).toEqual(model);
            expect(errors[1].property).toEqual("mySubClass");
            expect(errors[1].value).toEqual(model.mySubClass);
            expect(errors[1].constraints).toBeUndefined();
            const subError1 = errors[1].children[0];
            expect(subError1.target).toEqual(model.mySubClass);
            expect(subError1.property).toEqual("name");
            expect(subError1.constraints).toEqual({minLength: "name must be longer than or equal to 5 characters"});
            expect(subError1.value).toEqual("my");

            expect(errors[2].target).toEqual(model);
            expect(errors[2].property).toEqual("mySubClasses");
            expect(errors[2].value).toEqual(model.mySubClasses);
            expect(errors[2].constraints).toBeUndefined();
            const subError2 = errors[2].children[0];
            expect(subError2.target).toEqual(model.mySubClasses);
            expect(subError2.value).toEqual(model.mySubClasses[0]);
            expect(subError2.property).toEqual("0");
            const subSubError = subError2.children[0];
            expect(subSubError.target).toEqual(model.mySubClasses[0]);
            expect(subSubError.property).toEqual("name");
            expect(subSubError.constraints).toEqual({minLength: "name must be longer than or equal to 5 characters"});
            expect(subSubError.value).toEqual("my");

            expect(errors[3].target).toEqual(model);
            expect(errors[3].property).toEqual("mySubSubClasses");
            expect(errors[3].value).toEqual(model.mySubSubClasses);
            expect(errors[3].constraints).toBeUndefined();
            const subError3 = errors[3].children[0];
            expect(subError3.target).toEqual(model.mySubSubClasses);
            expect(subError3.value).toEqual(model.mySubSubClasses[0]);
            expect(subError3.property).toEqual("0");
            const subSubError3 = subError3.children[0];
            expect(subSubError3.target).toEqual(model.mySubSubClasses[0]);
            expect(subSubError3.value).toEqual(model.mySubSubClasses[0][0]);
            expect(subSubError3.property).toEqual("0");
            const subSubSubError3 = subSubError3.children[0];
            expect(subSubSubError3.target).toEqual(model.mySubSubClasses[0][0]);
            expect(subSubSubError3.property).toEqual("name");
            expect(subSubSubError3.constraints).toEqual({minLength: "name must be longer than or equal to 5 characters"});
            expect(subSubSubError3.value).toEqual("sub");

            expect(errors[4].target).toEqual(model);
            expect(errors[4].property).toEqual("mySubSubSubClasses");
            expect(errors[4].value).toEqual(model.mySubSubSubClasses);
            expect(errors[4].constraints).toBeUndefined();
            const subError4 = errors[4].children[0];
            expect(subError4.target).toEqual(model.mySubSubSubClasses);
            expect(subError4.value).toEqual(model.mySubSubSubClasses[0]);
            expect(subError4.property).toEqual("0");
            const subSubError4 = subError4.children[0];
            expect(subSubError4.target).toEqual(model.mySubSubSubClasses[0]);
            expect(subSubError4.value).toEqual(model.mySubSubSubClasses[0][0]);
            expect(subSubError4.property).toEqual("0");
            const subSubSubError4 = subSubError4.children[0];
            expect(subSubSubError4.target).toEqual(model.mySubSubSubClasses[0][0]);
            expect(subSubSubError4.value).toEqual(model.mySubSubSubClasses[0][0][0]);
            expect(subSubSubError4.property).toEqual("0");
            const subSubSubSubError4 = subSubSubError4.children[0];
            expect(subSubSubSubError4.target).toEqual(model.mySubSubSubClasses[0][0][0]);
            expect(subSubSubSubError4.property).toEqual("name");
            expect(subSubSubSubError4.constraints).toEqual({minLength: "name must be longer than or equal to 5 characters"});
            expect(subSubSubSubError4.value).toEqual("sub");
        });
    });

    it("should validate when nested is not object", () => {
        expect.assertions(4);

        class MySubClass {
            @MinLength(5)
            name: string;
        }

        class MyClass {
            @ValidateNested()
            mySubClass: MySubClass;
        }

        const model = new MyClass();
        model.mySubClass = "invalidnested object" as any;

        return validator.validate(model).then(errors => {
            expect(errors[0].target).toEqual(model);
            expect(errors[0].property).toEqual("mySubClass");
            expect(errors[0].children.length).toEqual(1);

            const subError = errors[0].children[0];
            expect(subError.constraints).toEqual({[ValidationTypes.NESTED_VALIDATION]: "nested property mySubClass must be either object or array"});
        });
    });

    it("should validate nested set", () => {
        expect.assertions(24);

        class MySubClass {
            @MinLength(5)
            name: string;
        }

        class MyClass {
            @Contains("hello")
            title: string;

            @ValidateNested()
            mySubClass: MySubClass;

            @ValidateNested()
            mySubClasses: Set<MySubClass>;
        }

        const model = new MyClass();
        model.title = "helo world";
        model.mySubClass = new MySubClass();
        model.mySubClass.name = "my";
        model.mySubClasses = new Set();

        const submodel1 = new MySubClass();
        submodel1.name = "my";
        model.mySubClasses.add(submodel1);

        const submodel2 = new MySubClass();
        submodel2.name = "not-short";
        model.mySubClasses.add(submodel2);

        return validator.validate(model).then(errors => {
            expect(errors.length).toEqual(3);

            expect(errors[0].target).toEqual(model);
            expect(errors[0].property).toEqual("title");
            expect(errors[0].constraints).toEqual({contains: "title must contain a hello string"});
            expect(errors[0].value).toEqual("helo world");

            expect(errors[1].target).toEqual(model);
            expect(errors[1].property).toEqual("mySubClass");
            expect(errors[1].value).toEqual(model.mySubClass);
            expect(errors[1].constraints).toBeUndefined();
            const subError1 = errors[1].children[0];
            expect(subError1.target).toEqual(model.mySubClass);
            expect(subError1.property).toEqual("name");
            expect(subError1.constraints).toEqual({minLength: "name must be longer than or equal to 5 characters"});
            expect(subError1.value).toEqual("my");

            expect(errors[2].target).toEqual(model);
            expect(errors[2].property).toEqual("mySubClasses");
            expect(errors[2].value).toEqual(model.mySubClasses);
            expect(errors[2].constraints).toBeUndefined();
            const subError2 = errors[2].children[0];
            expect(subError2.target).toEqual(model.mySubClasses);
            expect(subError2.value).toEqual(submodel1);
            expect(subError2.property).toEqual("0");
            const subSubError = subError2.children[0];
            expect(subSubError.target).toEqual(submodel1);
            expect(subSubError.property).toEqual("name");
            expect(subSubError.constraints).toEqual({minLength: "name must be longer than or equal to 5 characters"});
            expect(subSubError.value).toEqual("my");
        });
    });

    it("should validate nested map", () => {
        expect.assertions(24);

        class MySubClass {
            @MinLength(5)
            name: string;
        }

        class MyClass {
            @Contains("hello")
            title: string;

            @ValidateNested()
            mySubClass: MySubClass;

            @ValidateNested()
            mySubClasses: Map<string, MySubClass>;
        }

        const model = new MyClass();
        model.title = "helo world";
        model.mySubClass = new MySubClass();
        model.mySubClass.name = "my";
        model.mySubClasses = new Map();

        const submodel1 = new MySubClass();
        submodel1.name = "my";
        model.mySubClasses.set("key1", submodel1);

        const submodel2 = new MySubClass();
        submodel2.name = "not-short";
        model.mySubClasses.set("key2", submodel2);

        return validator.validate(model).then(errors => {
            expect(errors.length).toEqual(3);

            expect(errors[0].target).toEqual(model);
            expect(errors[0].property).toEqual("title");
            expect(errors[0].constraints).toEqual({contains: "title must contain a hello string"});
            expect(errors[0].value).toEqual("helo world");

            expect(errors[1].target).toEqual(model);
            expect(errors[1].property).toEqual("mySubClass");
            expect(errors[1].value).toEqual(model.mySubClass);
            expect(errors[1].constraints).toBeUndefined();
            const subError1 = errors[1].children[0];
            expect(subError1.target).toEqual(model.mySubClass);
            expect(subError1.property).toEqual("name");
            expect(subError1.constraints).toEqual({minLength: "name must be longer than or equal to 5 characters"});
            expect(subError1.value).toEqual("my");

            expect(errors[2].target).toEqual(model);
            expect(errors[2].property).toEqual("mySubClasses");
            expect(errors[2].value).toEqual(model.mySubClasses);
            expect(errors[2].constraints).toBeUndefined();
            const subError2 = errors[2].children[0];
            expect(subError2.target).toEqual(model.mySubClasses);
            expect(subError2.value).toEqual(submodel1);
            expect(subError2.property).toEqual("key1");
            const subSubError = subError2.children[0];
            expect(subSubError.target).toEqual(submodel1);
            expect(subSubError.property).toEqual("name");
            expect(subSubError.constraints).toEqual({minLength: "name must be longer than or equal to 5 characters"});
            expect(subSubError.value).toEqual("my");
        });
    });
});