let assert = require('assert');
let PropManager = require('lib/propManager');

describe('#Verification manager', function () {

  it('Обязательное значения в params передано', async(done) => {
    try {
      let result = {};
      let keys = ['id'];
      let data = {
        params: {
          id: 1,
          user: {
            name: "Петр"
          }
        }
      }

      let propManager = new PropManager({
        query: {
          template: {
            paging: {
              offset: [{
                isRequire: false,
                defaultValue: 0
              }],
              limit: [{
                isRequire: false,
                defaultValue: 0
              }]
            }
          }
        },
        params: {
          template: {
            id: [{
              isRequire: true
            }],
            wall_id: [{
              isRequire: false
            }]
          }
        }
      });

      result = await propManager.run(data);

      assert(keys.every((item) => item in result.params));
      done();

    } catch (error) {
      done(error);
    }
  });

  it('Обязательное значения в params не передано', async(done) => {
    try {
      let result = {};
      let keys = ['id'];
      let data = {
        params: {
          user: {
            name: 'test'
          }
        }
      }

      let propManager = new PropManager({
        params: {
          template: {
            id: [{
              isRequire: true
            }]
          }
        }
      });

      result = await propManager.run(data);

      assert(keys.every((item) => item in result.params));
      done("Ошибка");

    } catch (error) {
      done();
    }
  });

  it('Значение по умолчанию и дополнение структуры из шаблона', async(done) => {
    try {
      let result = {};
      let keys = ['paging'];
      let keysPaging = ['offset', 'limit'];
      let keysBody = ['first_name'];

      let data = {
        params: {
          id: 1,
          user: {
            name: "Петр"
          }
        },
        body:{
          first_name:"Evgeniy"
        }
      }

      let propManager = new PropManager({
        query: {
          template: {
            paging: {
              offset: [{
                defaultValue: 0
              }],
              limit: [{
                defaultValue: 0
              }]
            }
          }
        },
        body: {
          template: {
            profile: {
              first_name: [{
                isRequire: false,
                rootSearchValue: true
              }]
            }
          }
        }
      });

      result = await propManager.run(data);

      assert(keys.every((item) => {
        return item in result.query;
      }));

      assert(keysPaging.every((item) => {
        return item in result.query.paging;
      }));

      assert(keysPaging.every((item) => {
        return result.query.paging[item] == 0;
      }));

      assert(keysBody.every((item) => {
        return item in result.body.profile;
      }));

      done();
    } catch (error) {
      done(error);
    }
  });

  it('Ручной ввод значения', async(done) => {
    try {
      let result = {};
      let keys = ['id'];
      let data = {
        params: {
          id: 1,
          user: {
            name: "Петр"
          }
        }
      }

      let propManager = new PropManager({
        params: {
          template: {
            id: [{
              isRequire: true,
              manualValue: 10
            }]
          }
        }
      });

      result = await propManager.run(data);

      assert(keys.every((item) => {
        return item in result.params;
      }));

      assert(result.params.id == 10);

      done();
    } catch (error) {
      done(error);
    }

  });

  it('Использование функции для подготовки значения', async(done) => {
    try {
      let result = {};
      let keys = ['password', 'id'];
      let data = {
        params: {
          id: 1,
          password: "123"
        }
      }

      let propManager = new PropManager({
        params: {
          template: {
            password: [{
              isRequire: true,
              processingValue:(value) => {
                return `${[...value].reverse().join('')}` }
            }],
            id: [{
              isRequire: true
            }]
          }
        }
      });

      result = await propManager.run(data);

      assert(keys.every((item) => {
        return item in result.params;
      }));

      assert(result.params.password == '321');

      done();
    } catch (error) {
      done(error);
    }

  });

  it('Проверка корректный тип данных', async(done) => {
    try {
      let result = {};
      let keys = ['password', 'id'];
      let data = {
        params: {
          id: 1,
          password: "123"
        }
      }

      let propManager = new PropManager({
        params: {
          template: {
            password: [{
              isRequire: true,
              typeValue: PropManager.PropTypes.isString
            }],
            id: [{
              isRequire: true
            }]
          }
        }
      });

      result = await propManager.run(data);

      assert(keys.every((item) => {
        return item in result.params;
      }));

      done();
    } catch (error) {
      done(error);
    }

  });

  it('Проверка не корректный тип данных', async(done) => {
    try {
      let data = {
        params: {
          id: 1,
          password: "123"
        }
      }

      let propManager = new PropManager({
        params: {
          template: {
            password: [{
              isRequire: true,
              typeValue: PropManager.PropTypes.isNumber
            }],
            id: [{
              isRequire: true
            }]
          }
        }
      });

      await propManager.run(data);

      done("Ошибка");
    } catch (error) {
      done();
    }

  });

});