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

const validator = new Validator();

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

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

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

      @ValidatePromise()
      @ValidateNested()
      @IsDefined()
      mySubClass: Promise<MySubClass>;
    }

    const model: any = 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(24);

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

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

      @ValidatePromise()
      @ValidateNested()
      mySubClass: Promise<MySubClass>;

      @ValidatePromise()
      @ValidateNested()
      mySubClasses: Promise<MySubClass[]>;
    }

    const model = new MyClass();
    model.title = 'helo world';
    const mySubClass = new MySubClass();
    mySubClass.name = 'my';
    model.mySubClass = Promise.resolve(mySubClass);
    const mySubClasses = [new MySubClass(), new MySubClass()];
    mySubClasses[0].name = 'my';
    mySubClasses[1].name = 'not-short';
    model.mySubClasses = Promise.resolve(mySubClasses);
    return validator.validate(model).then(errors => {
      return Promise.all([model.mySubClass, model.mySubClasses]).then(([modelMySubClass, modelMySubClasses]) => {
        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(modelMySubClass);
        expect(errors[1].constraints).toBeUndefined();
        const subError1 = errors[1].children[0];
        expect(subError1.target).toEqual(modelMySubClass);
        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(modelMySubClasses);
        expect(errors[2].constraints).toBeUndefined();
        const subError2 = errors[2].children[0];
        expect(subError2.target).toEqual(modelMySubClasses);
        expect(subError2.value).toEqual(modelMySubClasses[0]);
        expect(subError2.property).toEqual('0');
        const subSubError = subError2.children[0];
        expect(subSubError.target).toEqual(modelMySubClasses[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');
      });
    });
  });

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

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

    class MyClass {
      @ValidatePromise()
      @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 array promise', () => {
    expect.assertions(5);

    class MyClass {
      @ValidatePromise()
      @MinLength(2)
      arrProperty: Promise<string[]>;
    }

    const model = new MyClass();
    model.arrProperty = Promise.resolve(['one']);

    return validator.validate(model).then(errors => {
      return Promise.all([model.arrProperty]).then(([modelArrProperty]) => {
        expect(errors.length).toEqual(1);

        expect(errors[0].target).toEqual(model);
        expect(errors[0].property).toEqual('arrProperty');
        expect(errors[0].constraints).toEqual({
          minLength: 'arrProperty must be longer than or equal to 2 characters',
        });
        expect(errors[0].value).toEqual(modelArrProperty);
      });
    });
  });
});