@e22m4u/js-repository 0.6.4 → 0.7.0

package/src/definition/model/model-data-validator.spec.js

@@ -1,4528 +0,0 @@
-import {expect} from 'chai';
-import {format} from '@e22m4u/js-format';
-import {DataType} from './properties/index.js';
-import {DatabaseSchema} from '../../database-schema.js';
-import {EmptyValuesService} from '@e22m4u/js-empty-values';
-import {ModelDataValidator} from './model-data-validator.js';
-import {DefinitionRegistry} from '../definition-registry.js';
-import {PropertyValidatorRegistry} from './properties/index.js';
-
-describe('ModelDataValidator', function () {
-  describe('validate', function () {
-    it('does not throw an error if a model does not have a property of a given data', function () {
-      const dbs = new DatabaseSchema();
-      dbs.defineModel({name: 'model'});
-      dbs.getService(ModelDataValidator).validate('model', {foo: 'bar'});
-    });
-
-    it('throws an error if a given data is not a pure object', function () {
-      const throwable = modelData => () => {
-        const dbs = new DatabaseSchema();
-        dbs.defineModel({
-          name: 'model',
-          datasource: 'datasource',
-        });
-        dbs.getService(ModelDataValidator).validate('model', modelData);
-      };
-      const error = v =>
-        format(
-          'The data of the model "model" should be an Object, but %s was given.',
-          v,
-        );
-      expect(throwable('str')).to.throw(error('"str"'));
-      expect(throwable(10)).to.throw(error('10'));
-      expect(throwable(true)).to.throw(error('true'));
-      expect(throwable(false)).to.throw(error('false'));
-      expect(throwable([])).to.throw(error('Array'));
-      expect(throwable(null)).to.throw(error('null'));
-      expect(throwable(undefined)).to.throw(error('undefined'));
-    });
-
-    it('uses a base model hierarchy to validate a given data', function () {
-      const dbs = new DatabaseSchema();
-      dbs.defineModel({
-        name: 'modelA',
-        properties: {
-          foo: DataType.STRING,
-        },
-      });
-      dbs.defineModel({
-        name: 'modelB',
-        base: 'modelA',
-      });
-      const throwable = () =>
-        dbs.getService(ModelDataValidator).validate('modelB', {foo: 10});
-      expect(throwable).to.throw(
-        'The property "foo" of the model "modelB" must ' +
-          'have a String, but Number was given.',
-      );
-    });
-
-    it('throws an error if a given data does not have a required property', function () {
-      const dbs = new DatabaseSchema();
-      dbs.defineModel({
-        name: 'model',
-        properties: {
-          foo: {
-            type: DataType.STRING,
-            required: true,
-          },
-        },
-      });
-      const throwable = () =>
-        dbs.getService(ModelDataValidator).validate('model', {});
-      expect(throwable).to.throw(
-        'The property "foo" of the model "model" ' +
-          'is required, but undefined was given.',
-      );
-    });
-
-    it('throws an error if a required property is undefined', function () {
-      const dbs = new DatabaseSchema();
-      dbs.defineModel({
-        name: 'model',
-        properties: {
-          foo: {
-            type: DataType.STRING,
-            required: true,
-          },
-        },
-      });
-      const throwable = () =>
-        dbs.getService(ModelDataValidator).validate('model', {foo: undefined});
-      expect(throwable).to.throw(
-        'The property "foo" of the model "model" is required, but undefined was given.',
-      );
-    });
-
-    it('throws an error if a required property is null', function () {
-      const dbs = new DatabaseSchema();
-      dbs.defineModel({
-        name: 'model',
-        properties: {
-          foo: {
-            type: DataType.STRING,
-            required: true,
-          },
-        },
-      });
-      const throwable = () =>
-        dbs.getService(ModelDataValidator).validate('model', {foo: null});
-      expect(throwable).to.throw(
-        'The property "foo" of the model "model" is required, but null was given.',
-      );
-    });
-
-    it('throws an error if a required property has an empty value', function () {
-      const dbs = new DatabaseSchema();
-      dbs.defineModel({
-        name: 'model',
-        properties: {
-          foo: {
-            type: DataType.STRING,
-            required: true,
-          },
-        },
-      });
-      dbs
-        .getService(EmptyValuesService)
-        .setEmptyValuesOf(DataType.STRING, ['empty']);
-      const throwable = () =>
-        dbs.getService(ModelDataValidator).validate('model', {foo: 'empty'});
-      expect(throwable).to.throw(
-        'The property "foo" of the model "model" ' +
-          'is required, but "empty" was given.',
-      );
-    });
-
-    it('should validate property type before passing value through property validators', function () {
-      const dbs = new DatabaseSchema();
-      dbs.defineModel({
-        name: 'model',
-        properties: {
-          foo: {
-            type: DataType.STRING,
-            validate: () => false,
-          },
-        },
-      });
-      const typeCheckFail = () =>
-        dbs.getService(ModelDataValidator).validate('model', {foo: 10});
-      expect(typeCheckFail).to.throw(
-        'The property "foo" of the model "model" must have ' +
-          'a String, but Number was given.',
-      );
-      const validatorCheckFail = () =>
-        dbs.getService(ModelDataValidator).validate('model', {foo: 'test'});
-      expect(validatorCheckFail).to.throw(
-        'The property "foo" of the model "model" has the invalid value "test" ' +
-          'that caught by a property validator.',
-      );
-    });
-
-    describe('an option "isPartial" is true', function () {
-      it('does not throw an error if a given data does not have a required property', function () {
-        const dbs = new DatabaseSchema();
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.STRING,
-              required: true,
-            },
-          },
-        });
-        dbs.getService(ModelDataValidator).validate('model', {}, true);
-      });
-
-      it('throws an error if a required property is undefined', function () {
-        const dbs = new DatabaseSchema();
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.STRING,
-              required: true,
-            },
-          },
-        });
-        const throwable = () =>
-          dbs
-            .getService(ModelDataValidator)
-            .validate('model', {foo: undefined}, true);
-        expect(throwable).to.throw(
-          'The property "foo" of the model "model" ' +
-            'is required, but undefined was given.',
-        );
-      });
-
-      it('throws an error if a required property is null', function () {
-        const dbs = new DatabaseSchema();
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.STRING,
-              required: true,
-            },
-          },
-        });
-        const throwable = () =>
-          dbs
-            .getService(ModelDataValidator)
-            .validate('model', {foo: null}, true);
-        expect(throwable).to.throw(
-          'The property "foo" of the model "model" is required, but null was given.',
-        );
-      });
-
-      it('throws an error if a required property has an empty value', function () {
-        const dbs = new DatabaseSchema();
-        dbs.defineModel({
-          name: 'model',
-          properties: {
-            foo: {
-              type: DataType.STRING,
-              required: true,
-            },
-          },
-        });
-        dbs
-          .getService(EmptyValuesService)
-          .setEmptyValuesOf(DataType.STRING, [5]);
-        const throwable = () =>
-          dbs.getService(ModelDataValidator).validate('model', {foo: 5}, true);
-        expect(throwable).to.throw(
-          'The property "foo" of the model "model" is required, but 5 was given.',
-        );
-      });
-    });
-
-    describe('validate by property type', function () {
-      it('should not validate the empty value', function () {
-        const dbs = new DatabaseSchema();
-        dbs.defineModel({
-          name: 'model',
-          datasource: 'datasource',
-          properties: {
-            foo: {
-              type: DataType.STRING,
-            },
-          },
-        });
-        dbs
-          .getService(EmptyValuesService)
-          .setEmptyValuesOf(DataType.STRING, [5]);
-        dbs.getService(ModelDataValidator).validate('model', {foo: 5});
-      });
-
-      describe('DataType.ANY', function () {
-        describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ANY,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ANY,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('does not throw an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ANY,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          });
-
-          it('does not throw an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ANY,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          });
-
-          it('does not throw an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ANY,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          });
-
-          it('does not throw an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ANY,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          });
-
-          it('does not throw an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ANY,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          });
-
-          it('does not throw an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ANY,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          });
-        });
-
-        describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('does not throw an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          });
-
-          it('does not throw an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          });
-
-          it('does not throw an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          });
-
-          it('does not throw an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          });
-
-          it('does not throw an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          });
-
-          it('does not throw an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          });
-        });
-      });
-
-      describe('DataType.STRING', function () {
-        describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.STRING,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.STRING,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('does not throw an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.STRING,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          });
-
-          it('throws an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.STRING,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 10,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a String, but Number was given.',
-            );
-          });
-
-          it('throws an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.STRING,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: true,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a String, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.STRING,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: false,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a String, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.STRING,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: [],
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a String, but Array was given.',
-            );
-          });
-
-          it('throws an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.STRING,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: {},
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a String, but Object was given.',
-            );
-          });
-        });
-
-        describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.STRING,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.STRING,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('does not throw an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.STRING,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          });
-
-          it('throws an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.STRING,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 10,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a String, but Number was given.',
-            );
-          });
-
-          it('throws an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.STRING,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: true,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a String, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.STRING,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: false,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a String, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.STRING,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: [],
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a String, but Array was given.',
-            );
-          });
-
-          it('throws an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.STRING,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: {},
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a String, but Object was given.',
-            );
-          });
-        });
-      });
-
-      describe('DataType.NUMBER', function () {
-        describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.NUMBER,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.NUMBER,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('throws an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.NUMBER,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'bar',
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Number, but String was given.',
-            );
-          });
-
-          it('does not throw an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.NUMBER,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          });
-
-          it('throws an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.NUMBER,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: true,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Number, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.NUMBER,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: false,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Number, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.NUMBER,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: [],
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Number, but Array was given.',
-            );
-          });
-
-          it('throws an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.NUMBER,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: {},
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Number, but Object was given.',
-            );
-          });
-        });
-
-        describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.NUMBER,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.NUMBER,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('throws an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.NUMBER,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'bar',
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Number, but String was given.',
-            );
-          });
-
-          it('does not throw an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.NUMBER,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          });
-
-          it('throws an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.NUMBER,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: true,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Number, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.NUMBER,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: false,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Number, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.NUMBER,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: [],
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Number, but Array was given.',
-            );
-          });
-
-          it('throws an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.NUMBER,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: {},
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Number, but Object was given.',
-            );
-          });
-        });
-      });
-
-      describe('DataType.BOOLEAN', function () {
-        describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.BOOLEAN,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.BOOLEAN,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('throws an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.BOOLEAN,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'bar',
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Boolean, but String was given.',
-            );
-          });
-
-          it('throws an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.BOOLEAN,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 10,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Boolean, but Number was given.',
-            );
-          });
-
-          it('does not throw an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.BOOLEAN,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          });
-
-          it('does not throw an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.BOOLEAN,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          });
-
-          it('throws an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.BOOLEAN,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: [],
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Boolean, but Array was given.',
-            );
-          });
-
-          it('throws an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.BOOLEAN,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: {},
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Boolean, but Object was given.',
-            );
-          });
-        });
-
-        describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.BOOLEAN,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.BOOLEAN,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('throws an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.BOOLEAN,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'bar',
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Boolean, but String was given.',
-            );
-          });
-
-          it('throws an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.BOOLEAN,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 10,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Boolean, but Number was given.',
-            );
-          });
-
-          it('does not throw an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.BOOLEAN,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          });
-
-          it('does not throw an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.BOOLEAN,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          });
-
-          it('throws an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.BOOLEAN,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: [],
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Boolean, but Array was given.',
-            );
-          });
-
-          it('throws an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.BOOLEAN,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: {},
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'a Boolean, but Object was given.',
-            );
-          });
-        });
-      });
-
-      describe('DataType.ARRAY', function () {
-        describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ARRAY,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ARRAY,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('throws an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ARRAY,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'bar',
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Array, but String was given.',
-            );
-          });
-
-          it('throws an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ARRAY,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 10,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Array, but Number was given.',
-            );
-          });
-
-          it('throws an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ARRAY,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: true,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Array, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ARRAY,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: false,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Array, but Boolean was given.',
-            );
-          });
-
-          it('does not throw an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ARRAY,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          });
-
-          it('throws an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.ARRAY,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: {},
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Array, but Object was given.',
-            );
-          });
-        });
-
-        describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ARRAY,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ARRAY,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('throws an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ARRAY,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'bar',
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Array, but String was given.',
-            );
-          });
-
-          it('throws an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ARRAY,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 10,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Array, but Number was given.',
-            );
-          });
-
-          it('throws an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ARRAY,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: true,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Array, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ARRAY,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: false,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Array, but Boolean was given.',
-            );
-          });
-
-          it('does not throw an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ARRAY,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          });
-
-          it('throws an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.ARRAY,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: {},
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Array, but Object was given.',
-            );
-          });
-
-          describe('the "itemModel" option', function () {
-            it('does not throw an error if the option "itemModel" is not specified in case of Object item type', function () {
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ARRAY,
-                    itemType: DataType.OBJECT,
-                  },
-                },
-              });
-              const value = {foo: [{a: 1}, {b: 2}]};
-              dbs.getService(ModelDataValidator).validate('model', value);
-            });
-
-            it('throws an error when the given object element has an invalid model', function () {
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'modelA',
-                properties: {
-                  foo: DataType.STRING,
-                },
-              });
-              dbs.defineModel({
-                name: 'modelB',
-                datasource: 'datasource',
-                properties: {
-                  bar: {
-                    type: DataType.ARRAY,
-                    itemType: DataType.OBJECT,
-                    itemModel: 'modelA',
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('modelB', {
-                  bar: [{foo: 10}],
-                });
-              expect(throwable).to.throw(
-                'The property "foo" of the model "modelA" must have ' +
-                  'a String, but Number was given.',
-              );
-            });
-
-            it('does not throw an error when the given object element has a valid model', function () {
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'modelA',
-                properties: {
-                  foo: DataType.STRING,
-                },
-              });
-              dbs.defineModel({
-                name: 'modelB',
-                datasource: 'datasource',
-                properties: {
-                  bar: {
-                    type: DataType.ARRAY,
-                    itemType: DataType.OBJECT,
-                    itemModel: 'modelA',
-                  },
-                },
-              });
-              dbs.getService(ModelDataValidator).validate('modelB', {
-                bar: [{foo: '10'}],
-              });
-            });
-          });
-        });
-      });
-
-      describe('DataType.OBJECT', function () {
-        describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.OBJECT,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.OBJECT,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('throws an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.OBJECT,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'bar',
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Object, but String was given.',
-            );
-          });
-
-          it('throws an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.OBJECT,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 10,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Object, but Number was given.',
-            );
-          });
-
-          it('throws an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.OBJECT,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: true,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Object, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.OBJECT,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: false,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Object, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.OBJECT,
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: [],
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Object, but Array was given.',
-            );
-          });
-
-          it('does not throw an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: DataType.OBJECT,
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          });
-        });
-
-        describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.OBJECT,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: undefined,
-            });
-          });
-
-          it('does not throw an error if a null given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.OBJECT,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: null,
-            });
-          });
-
-          it('throws an error if a string given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.OBJECT,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'bar',
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Object, but String was given.',
-            );
-          });
-
-          it('throws an error if a number given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.OBJECT,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 10,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Object, but Number was given.',
-            );
-          });
-
-          it('throws an error if true given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.OBJECT,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: true,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Object, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if false given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.OBJECT,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: false,
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Object, but Boolean was given.',
-            );
-          });
-
-          it('throws an error if an array given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.OBJECT,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: [],
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" must have ' +
-                'an Object, but Array was given.',
-            );
-          });
-
-          it('does not throw an error if an object given', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              datasource: 'datasource',
-              properties: {
-                foo: {
-                  type: DataType.OBJECT,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          });
-
-          describe('the "model" option', function () {
-            it('throws an error when the given object has an invalid model', function () {
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'modelA',
-                properties: {
-                  foo: DataType.STRING,
-                },
-              });
-              dbs.defineModel({
-                name: 'modelB',
-                datasource: 'datasource',
-                properties: {
-                  bar: {
-                    type: DataType.OBJECT,
-                    model: 'modelA',
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('modelB', {
-                  bar: {foo: 10},
-                });
-              expect(throwable).to.throw(
-                'The property "foo" of the model "modelA" must have ' +
-                  'a String, but Number was given.',
-              );
-            });
-
-            it('does not throw an error when the given object has a valid model', function () {
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'modelA',
-                properties: {
-                  foo: DataType.STRING,
-                },
-              });
-              dbs.defineModel({
-                name: 'modelB',
-                datasource: 'datasource',
-                properties: {
-                  bar: {
-                    type: DataType.OBJECT,
-                    model: 'modelA',
-                  },
-                },
-              });
-              dbs.getService(ModelDataValidator).validate('modelB', {
-                bar: {foo: '10'},
-              });
-            });
-          });
-        });
-      });
-    });
-
-    describe('validate by property validators', function () {
-      describe('when the option "validate" is a String', function () {
-        it('should not validate the non-provided property', function () {
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator', function () {
-            throw new Error('Should not to be called.');
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: 'myValidator',
-              },
-            },
-          });
-          const validator = dbs.getService(ModelDataValidator);
-          validator.validate('model', {});
-        });
-
-        it('should not validate undefined and null values', function () {
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator', function () {
-            throw new Error('Should not to be called.');
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: 'myValidator',
-              },
-            },
-          });
-          const validator = dbs.getService(ModelDataValidator);
-          validator.validate('model', {foo: undefined});
-          validator.validate('model', {foo: null});
-        });
-
-        it('should not validate the empty value', function () {
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator', function () {
-            throw new Error('Should not to be called.');
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.STRING,
-                validate: 'myValidator',
-              },
-            },
-          });
-          dbs
-            .getService(EmptyValuesService)
-            .setEmptyValuesOf(DataType.STRING, [5]);
-          dbs.getService(ModelDataValidator).validate('model', {foo: 5});
-        });
-
-        it('should throw the error for the non-existent validator name', function () {
-          const dbs = new DatabaseSchema();
-          const modelDef = {
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: undefined,
-              },
-            },
-          };
-          dbs.defineModel(modelDef);
-          modelDef.properties.foo.validate = 'myValidator';
-          const throwable = () =>
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-          expect(throwable).to.throw(
-            'The property validator "myValidator" is not defined.',
-          );
-        });
-
-        it('should throw the error from the validator', function () {
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator', function () {
-            throw Error('My error');
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: 'myValidator',
-              },
-            },
-          });
-          const throwable = () =>
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-          expect(throwable).to.throw('My error');
-        });
-
-        it('should allow the given value if the validator returns true', function () {
-          let called = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator', function () {
-            called++;
-            return true;
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: 'myValidator',
-              },
-            },
-          });
-          dbs.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          expect(called).to.be.eq(1);
-        });
-
-        it('should throw the error if the validator returns a promise', function () {
-          let called = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator', function () {
-            called++;
-            return Promise.resolve(true);
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: 'myValidator',
-              },
-            },
-          });
-          const throwable = () =>
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-          expect(throwable).to.throw(
-            'Asynchronous property validators are not supported, ' +
-              'but the property "foo" of the model "model" has the property ' +
-              'validator "myValidator" that returns a Promise.',
-          );
-          expect(called).to.be.eq(1);
-        });
-
-        it('should throw the error for a non-true result from the validator', function () {
-          const testFn = v => {
-            let called = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator', function () {
-              called++;
-              return v;
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: 'myValidator',
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" has the invalid value "test" ' +
-                'that caught by the property validator "myValidator".',
-            );
-            expect(called).to.be.eq(1);
-          };
-          testFn('str');
-          testFn('');
-          testFn(10);
-          testFn(0);
-          testFn(false);
-          testFn(undefined);
-          testFn(null);
-          testFn({});
-          testFn([]);
-          testFn(() => undefined);
-        });
-
-        it('should pass arguments to the validator', function () {
-          let called = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator', function (value, options, context) {
-            expect(value).to.be.eq('test');
-            expect(options).to.be.undefined;
-            expect(context).to.be.eql({
-              validatorName: 'myValidator',
-              modelName: 'model',
-              propName: 'foo',
-            });
-            called++;
-            return true;
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: 'myValidator',
-              },
-            },
-          });
-          dbs.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          expect(called).to.be.eq(1);
-        });
-
-        it('should invoke the validator only once per value', function () {
-          let invoked = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator', function () {
-            invoked++;
-            return true;
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: 'myValidator',
-              },
-            },
-          });
-          dbs.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          expect(invoked).to.be.eq(1);
-        });
-      });
-
-      describe('when the option "validate" is a Function', function () {
-        describe('named validators', function () {
-          it('should not validate the non-provided property', function () {
-            const dbs = new DatabaseSchema();
-            const myValidator = function () {
-              throw new Error('Should not to be called.');
-            };
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: myValidator,
-                },
-              },
-            });
-            const validator = dbs.getService(ModelDataValidator);
-            validator.validate('model', {});
-          });
-
-          it('should not validate undefined and null values', function () {
-            const dbs = new DatabaseSchema();
-            const myValidator = () => {
-              throw new Error('Should not to be called.');
-            };
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: myValidator,
-                },
-              },
-            });
-            const validator = dbs.getService(ModelDataValidator);
-            validator.validate('model', {foo: undefined});
-            validator.validate('model', {foo: null});
-          });
-
-          it('should not validate the empty value', function () {
-            const dbs = new DatabaseSchema();
-            const myValidator = function () {
-              throw new Error('Should not to be called.');
-            };
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.STRING,
-                  validate: myValidator,
-                },
-              },
-            });
-            dbs
-              .getService(EmptyValuesService)
-              .setEmptyValuesOf(DataType.STRING, [5]);
-            dbs.getService(ModelDataValidator).validate('model', {foo: 5});
-          });
-
-          it('should throw the error from the validator', function () {
-            const dbs = new DatabaseSchema();
-            const myValidator = function () {
-              throw Error('My error');
-            };
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: myValidator,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw('My error');
-          });
-
-          it('should allow the given value if the validator returns true', function () {
-            const dbs = new DatabaseSchema();
-            let called = 0;
-            const myValidator = function () {
-              called++;
-              return true;
-            };
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: myValidator,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            expect(called).to.be.eq(1);
-          });
-
-          it('should throw the error if the validator returns a promise', function () {
-            const dbs = new DatabaseSchema();
-            const myValidator = function () {
-              return Promise.resolve(true);
-            };
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: myValidator,
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw(
-              'Asynchronous property validators are not supported, ' +
-                'but the property "foo" of the model "model" has the property ' +
-                'validator "myValidator" that returns a Promise.',
-            );
-          });
-
-          it('should throw the error for a non-true result from the validator', function () {
-            const testFn = v => {
-              const dbs = new DatabaseSchema();
-              const myValidator = function () {
-                return v;
-              };
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: myValidator,
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw(
-                'The property "foo" of the model "model" has the invalid value "test" ' +
-                  'that caught by the property validator "myValidator".',
-              );
-            };
-            testFn('str');
-            testFn('');
-            testFn(10);
-            testFn(0);
-            testFn(false);
-            testFn(undefined);
-            testFn(null);
-            testFn({});
-            testFn([]);
-            testFn(() => undefined);
-          });
-
-          it('should pass arguments to the validator', function () {
-            let called = 0;
-            const dbs = new DatabaseSchema();
-            const myValidator = function (value, options, context) {
-              expect(value).to.be.eq('test');
-              expect(options).to.be.undefined;
-              expect(context).to.be.eql({
-                validatorName: 'myValidator',
-                modelName: 'model',
-                propName: 'foo',
-              });
-              called++;
-              return true;
-            };
-            dbs
-              .getService(PropertyValidatorRegistry)
-              .addValidator('myValidator', myValidator);
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: 'myValidator',
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            expect(called).to.be.eq(1);
-          });
-
-          it('should invoke the validator only once per value', function () {
-            let invoked = 0;
-            const myValidator = function () {
-              invoked++;
-              return true;
-            };
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: myValidator,
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            expect(invoked).to.be.eq(1);
-          });
-        });
-
-        describe('anonymous validators', function () {
-          it('should not validate the non-provided property', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate() {
-                    throw new Error('Should not to be called.');
-                  },
-                },
-              },
-            });
-            const validator = dbs.getService(ModelDataValidator);
-            validator.validate('model', {});
-          });
-
-          it('should not validate undefined and null values', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate() {
-                    throw new Error('Should not to be called.');
-                  },
-                },
-              },
-            });
-            const validator = dbs.getService(ModelDataValidator);
-            validator.validate('model', {foo: undefined});
-            validator.validate('model', {foo: null});
-          });
-
-          it('should not validate the empty value', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.STRING,
-                  validate() {
-                    throw new Error('Should not to be called.');
-                  },
-                },
-              },
-            });
-            dbs
-              .getService(EmptyValuesService)
-              .setEmptyValuesOf(DataType.STRING, [5]);
-            dbs.getService(ModelDataValidator).validate('model', {foo: 5});
-          });
-
-          it('should throw the error from the validator', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate() {
-                    throw Error('My error');
-                  },
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw('My error');
-          });
-
-          it('should allow the given value if the validator returns true', function () {
-            const dbs = new DatabaseSchema();
-            let called = 0;
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate() {
-                    called++;
-                    return true;
-                  },
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            expect(called).to.be.eq(1);
-          });
-
-          it('should throw the error if the validator returns a promise', function () {
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate() {
-                    return Promise.resolve(true);
-                  },
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw(
-              'Asynchronous property validators are not supported, ' +
-                'but the property "foo" of the model "model" has a property ' +
-                'validator that returns a Promise.',
-            );
-          });
-
-          it('should throw the error for a non-true result from the validator', function () {
-            const testFn = v => {
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate() {
-                      return v;
-                    },
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw(
-                'The property "foo" of the model "model" has the invalid value "test" ' +
-                  'that caught by a property validator.',
-              );
-            };
-            testFn('str');
-            testFn('');
-            testFn(10);
-            testFn(0);
-            testFn(false);
-            testFn(undefined);
-            testFn(null);
-            testFn({});
-            testFn([]);
-            testFn(() => undefined);
-          });
-
-          it('should pass arguments to the validator', function () {
-            let called = 0;
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate(value, options, context) {
-                    expect(value).to.be.eq('test');
-                    expect(options).to.be.undefined;
-                    expect(context).to.be.eql({
-                      validatorName: undefined,
-                      modelName: 'model',
-                      propName: 'foo',
-                    });
-                    called++;
-                    return true;
-                  },
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            expect(called).to.be.eq(1);
-          });
-
-          it('should invoke the validator only once per value', function () {
-            let invoked = 0;
-            const dbs = new DatabaseSchema();
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate() {
-                    invoked++;
-                    return true;
-                  },
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            expect(invoked).to.be.eq(1);
-          });
-        });
-      });
-
-      describe('when the option "validate" is an Array', function () {
-        it('does nothing for an empty array validators', function () {
-          const dbs = new DatabaseSchema();
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: [],
-              },
-            },
-          });
-          dbs.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-        });
-
-        it('the option "validate" requires a non-empty String, a Function, an Array or an Object', function () {
-          const dbs = new DatabaseSchema();
-          dbs
-            .getService(PropertyValidatorRegistry)
-            .addValidator('myValidator', () => true);
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: undefined,
-              },
-            },
-          });
-          const V = dbs.getService(ModelDataValidator);
-          const throwable = v => () => {
-            const models = dbs.getService(DefinitionRegistry)['_models'];
-            models.model.properties.foo.validate = v;
-            V.validate('model', {foo: 'bar'});
-          };
-          const error = v =>
-            format(
-              'The provided option "validate" for the property "foo" in the model "model" ' +
-                'should be either a validator name, a validator function, an array ' +
-                'of validator names or functions, or an object mapping validator ' +
-                'names to their arguments, but %s was given.',
-              v,
-            );
-          expect(throwable('')).to.throw(error('""'));
-          expect(throwable(10)).to.throw(error('10'));
-          expect(throwable(0)).to.throw(error('0'));
-          expect(throwable(true)).to.throw(error('true'));
-          expect(throwable(false)).to.throw(error('false'));
-          throwable('myValidator')();
-          throwable(() => true)();
-          throwable(['myValidator'])();
-          throwable([() => true])();
-          throwable([])();
-          throwable({myValidator: true})();
-          throwable({})();
-        });
-
-        it('the option "validate" with an Array value requires elements to be a non-empty String or a Function', function () {
-          const dbs = new DatabaseSchema();
-          dbs
-            .getService(PropertyValidatorRegistry)
-            .addValidator('myValidator', () => true);
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: undefined,
-              },
-            },
-          });
-          const V = dbs.getService(ModelDataValidator);
-          const throwable = v => () => {
-            const models = dbs.getService(DefinitionRegistry)['_models'];
-            models.model.properties.foo.validate = [v];
-            V.validate('model', {foo: 'bar'});
-          };
-          const error = v =>
-            format(
-              'The provided option "validate" for the property "foo" in the model "model" ' +
-                'has an Array value that should contain validator names or validator ' +
-                'functions, but %s was given.',
-              v,
-            );
-          expect(throwable('')).to.throw(error('""'));
-          expect(throwable(10)).to.throw(error('10'));
-          expect(throwable(0)).to.throw(error('0'));
-          expect(throwable(true)).to.throw(error('true'));
-          expect(throwable(false)).to.throw(error('false'));
-          expect(throwable([1, 2, 3])).to.throw(error('Array'));
-          expect(throwable({foo: 'bar'})).to.throw(error('Object'));
-          expect(throwable(null)).to.throw(error('null'));
-          expect(throwable(undefined)).to.throw(error('undefined'));
-          throwable('myValidator')();
-          throwable(() => true)();
-        });
-
-        describe('when an array element is a String', function () {
-          it('should not validate the non-provided property', function () {
-            let calls = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              calls++;
-              throw new Error('Should not to be called.');
-            });
-            reg.addValidator('myValidator2', function () {
-              calls++;
-              throw new Error('Should not to be called.');
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: ['myValidator1', 'myValidator2'],
-                },
-              },
-            });
-            const validator = dbs.getService(ModelDataValidator);
-            validator.validate('model', {});
-            expect(calls).to.be.eq(0);
-          });
-
-          it('should not validate undefined and null values', function () {
-            let calls = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              calls++;
-              throw new Error('Should not to be called.');
-            });
-            reg.addValidator('myValidator2', function () {
-              calls++;
-              throw new Error('Should not to be called.');
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: ['myValidator1', 'myValidator2'],
-                },
-              },
-            });
-            const validator = dbs.getService(ModelDataValidator);
-            validator.validate('model', {foo: undefined});
-            validator.validate('model', {foo: null});
-            expect(calls).to.be.eq(0);
-          });
-
-          it('should not validate the empty value', function () {
-            let calls = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              calls++;
-              throw new Error('Should not to be called.');
-            });
-            reg.addValidator('myValidator2', function () {
-              calls++;
-              throw new Error('Should not to be called.');
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.STRING,
-                  validate: ['myValidator1', 'myValidator2'],
-                },
-              },
-            });
-            dbs
-              .getService(EmptyValuesService)
-              .setEmptyValuesOf(DataType.STRING, [5]);
-            dbs.getService(ModelDataValidator).validate('model', {foo: 5});
-            expect(calls).to.be.eq(0);
-          });
-
-          it('should throw the error for the non-existent validator name', function () {
-            let called = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              called++;
-              return true;
-            });
-            const modelDef = {
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: ['myValidator1'],
-                },
-              },
-            };
-            dbs.defineModel(modelDef);
-            modelDef.properties.foo.validate.push('myValidator2');
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw(
-              'The property validator "myValidator2" is not defined.',
-            );
-            expect(called).to.be.eq(1);
-          });
-
-          it('should throw the error from the first validator', function () {
-            let called = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              called++;
-              throw Error('My error');
-            });
-            reg.addValidator('myValidator2', function () {
-              called++;
-              return false;
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: ['myValidator1', 'myValidator2'],
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw('My error');
-            expect(called).to.be.eq(1);
-          });
-
-          it('should throw the error from the second validator', function () {
-            let called = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              called++;
-              return true;
-            });
-            reg.addValidator('myValidator2', function () {
-              called++;
-              throw Error('My error');
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: ['myValidator1', 'myValidator2'],
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw('My error');
-            expect(called).to.be.eq(2);
-          });
-
-          it('should allow the given value if validators returns true', function () {
-            let called = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              called++;
-              return true;
-            });
-            reg.addValidator('myValidator2', function () {
-              called++;
-              return true;
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: ['myValidator1', 'myValidator2'],
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            expect(called).to.be.eq(2);
-          });
-
-          it('should throw the error if the first validator returns a promise', function () {
-            let called = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              called++;
-              return Promise.resolve(true);
-            });
-            reg.addValidator('myValidator2', function () {
-              called++;
-              return true;
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: ['myValidator1', 'myValidator2'],
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw(
-              'Asynchronous property validators are not supported, ' +
-                'but the property "foo" of the model "model" has the property ' +
-                'validator "myValidator1" that returns a Promise.',
-            );
-            expect(called).to.be.eq(1);
-          });
-
-          it('should throw the error if the second validator returns a promise', function () {
-            let called = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              called++;
-              return true;
-            });
-            reg.addValidator('myValidator2', function () {
-              called++;
-              return Promise.resolve(true);
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: ['myValidator1', 'myValidator2'],
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw(
-              'Asynchronous property validators are not supported, ' +
-                'but the property "foo" of the model "model" has the property ' +
-                'validator "myValidator2" that returns a Promise.',
-            );
-            expect(called).to.be.eq(2);
-          });
-
-          it('should throw the error for a non-true result from the first validator', function () {
-            const testFn = v => {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              const reg = dbs.getService(PropertyValidatorRegistry);
-              reg.addValidator('myValidator1', function () {
-                called++;
-                return v;
-              });
-              reg.addValidator('myValidator2', function () {
-                called++;
-                return true;
-              });
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: ['myValidator1', 'myValidator2'],
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw(
-                'The property "foo" of the model "model" has the invalid value "test" ' +
-                  'that caught by the property validator "myValidator1".',
-              );
-              expect(called).to.be.eq(1);
-            };
-            testFn('str');
-            testFn('');
-            testFn(10);
-            testFn(0);
-            testFn(false);
-            testFn(undefined);
-            testFn(null);
-            testFn({});
-            testFn([]);
-            testFn(() => undefined);
-          });
-
-          it('should throw the error for a non-true result from the second validator', function () {
-            const testFn = v => {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              const reg = dbs.getService(PropertyValidatorRegistry);
-              reg.addValidator('myValidator1', function () {
-                called++;
-                return true;
-              });
-              reg.addValidator('myValidator2', function () {
-                called++;
-                return v;
-              });
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: ['myValidator1', 'myValidator2'],
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw(
-                'The property "foo" of the model "model" has the invalid value "test" ' +
-                  'that caught by the property validator "myValidator2".',
-              );
-              expect(called).to.be.eq(2);
-            };
-            testFn('str');
-            testFn('');
-            testFn(10);
-            testFn(0);
-            testFn(false);
-            testFn(undefined);
-            testFn(null);
-            testFn({});
-            testFn([]);
-            testFn(() => undefined);
-          });
-
-          it('should pass arguments to validators', function () {
-            let called = false;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator(
-              'myValidator1',
-              function (value, options, context) {
-                expect(value).to.be.eq('test');
-                expect(options).to.be.undefined;
-                expect(context).to.be.eql({
-                  validatorName: 'myValidator1',
-                  modelName: 'model',
-                  propName: 'foo',
-                });
-                called++;
-                return true;
-              },
-            );
-            reg.addValidator(
-              'myValidator2',
-              function (value, options, context) {
-                expect(value).to.be.eq('test');
-                expect(options).to.be.undefined;
-                expect(context).to.be.eql({
-                  validatorName: 'myValidator2',
-                  modelName: 'model',
-                  propName: 'foo',
-                });
-                called++;
-                return true;
-              },
-            );
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: ['myValidator1', 'myValidator2'],
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            expect(called).to.be.eq(2);
-          });
-
-          it('should invoke validators in the correct order', function () {
-            const invocation = [];
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              invocation.push('myValidator1');
-              return true;
-            });
-            reg.addValidator('myValidator2', function () {
-              invocation.push('myValidator2');
-              return true;
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: ['myValidator1', 'myValidator2'],
-                },
-              },
-            });
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            expect(invocation).to.be.eql(['myValidator1', 'myValidator2']);
-          });
-        });
-
-        describe('when an array element is a Function', function () {
-          describe('named validators', function () {
-            it('should not validate the non-provided property', function () {
-              let calls = 0;
-              const dbs = new DatabaseSchema();
-              const myValidator1 = function () {
-                calls++;
-                throw new Error('Should not to be called.');
-              };
-              const myValidator2 = function () {
-                calls++;
-                throw new Error('Should not to be called.');
-              };
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [myValidator1, myValidator2],
-                  },
-                },
-              });
-              const validator = dbs.getService(ModelDataValidator);
-              validator.validate('model', {});
-              expect(calls).to.be.eq(0);
-            });
-
-            it('should not validate undefined and null values', function () {
-              let calls = 0;
-              const dbs = new DatabaseSchema();
-              const myValidator1 = function () {
-                calls++;
-                throw new Error('Should not to be called.');
-              };
-              const myValidator2 = function () {
-                calls++;
-                throw new Error('Should not to be called.');
-              };
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [myValidator1, myValidator2],
-                  },
-                },
-              });
-              const validator = dbs.getService(ModelDataValidator);
-              validator.validate('model', {foo: undefined});
-              validator.validate('model', {foo: null});
-              expect(calls).to.be.eq(0);
-            });
-
-            it('should not validate the empty value', function () {
-              let calls = 0;
-              const dbs = new DatabaseSchema();
-              const myValidator1 = function () {
-                calls++;
-                throw new Error('Should not to be called.');
-              };
-              const myValidator2 = function () {
-                calls++;
-                throw new Error('Should not to be called.');
-              };
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.STRING,
-                    validate: [myValidator1, myValidator2],
-                  },
-                },
-              });
-              dbs
-                .getService(EmptyValuesService)
-                .setEmptyValuesOf(DataType.STRING, [5]);
-              dbs.getService(ModelDataValidator).validate('model', {foo: 5});
-              expect(calls).to.be.eq(0);
-            });
-
-            it('should throw the error from the first validator', function () {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              const myValidator1 = function () {
-                called++;
-                throw Error('My error');
-              };
-              const myValidator2 = function () {
-                called++;
-                return false;
-              };
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [myValidator1, myValidator2],
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw('My error');
-              expect(called).to.be.eq(1);
-            });
-
-            it('should throw the error from the second validator', function () {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              const myValidator1 = function () {
-                called++;
-                return true;
-              };
-              const myValidator2 = function () {
-                called++;
-                throw Error('My error');
-              };
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [myValidator1, myValidator2],
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw('My error');
-              expect(called).to.be.eq(2);
-            });
-
-            it('should allow the given value if validators returns true', function () {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              const myValidator1 = function () {
-                called++;
-                return true;
-              };
-              const myValidator2 = function () {
-                called++;
-                return true;
-              };
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [myValidator1, myValidator2],
-                  },
-                },
-              });
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-              expect(called).to.be.eq(2);
-            });
-
-            it('should throw the error if the first validator returns a promise', function () {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              const myValidator1 = function () {
-                called++;
-                return Promise.resolve(true);
-              };
-              const myValidator2 = function () {
-                called++;
-                return true;
-              };
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [myValidator1, myValidator2],
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw(
-                'Asynchronous property validators are not supported, ' +
-                  'but the property "foo" of the model "model" has the property ' +
-                  'validator "myValidator1" that returns a Promise.',
-              );
-              expect(called).to.be.eq(1);
-            });
-
-            it('should throw the error if the second validator returns a promise', function () {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              const myValidator1 = function () {
-                called++;
-                return true;
-              };
-              const myValidator2 = function () {
-                called++;
-                return Promise.resolve(true);
-              };
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [myValidator1, myValidator2],
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw(
-                'Asynchronous property validators are not supported, ' +
-                  'but the property "foo" of the model "model" has the property ' +
-                  'validator "myValidator2" that returns a Promise.',
-              );
-              expect(called).to.be.eq(2);
-            });
-
-            it('should throw the error for a non-true result from the first validator', function () {
-              const testFn = v => {
-                let called = 0;
-                const dbs = new DatabaseSchema();
-                const myValidator1 = function () {
-                  called++;
-                  return v;
-                };
-                const myValidator2 = function () {
-                  called++;
-                  return true;
-                };
-                dbs.defineModel({
-                  name: 'model',
-                  properties: {
-                    foo: {
-                      type: DataType.ANY,
-                      validate: [myValidator1, myValidator2],
-                    },
-                  },
-                });
-                const throwable = () =>
-                  dbs.getService(ModelDataValidator).validate('model', {
-                    foo: 'test',
-                  });
-                expect(throwable).to.throw(
-                  'The property "foo" of the model "model" has the invalid value "test" ' +
-                    'that caught by the property validator "myValidator1".',
-                );
-                expect(called).to.be.eq(1);
-              };
-              testFn('str');
-              testFn('');
-              testFn(10);
-              testFn(0);
-              testFn(false);
-              testFn(undefined);
-              testFn(null);
-              testFn({});
-              testFn([]);
-              testFn(() => undefined);
-            });
-
-            it('should throw the error for a non-true result from the second validator', function () {
-              const testFn = v => {
-                let called = 0;
-                const dbs = new DatabaseSchema();
-                const myValidator1 = function () {
-                  called++;
-                  return true;
-                };
-                const myValidator2 = function () {
-                  called++;
-                  return v;
-                };
-                dbs.defineModel({
-                  name: 'model',
-                  properties: {
-                    foo: {
-                      type: DataType.ANY,
-                      validate: [myValidator1, myValidator2],
-                    },
-                  },
-                });
-                const throwable = () =>
-                  dbs.getService(ModelDataValidator).validate('model', {
-                    foo: 'test',
-                  });
-                expect(throwable).to.throw(
-                  'The property "foo" of the model "model" has the invalid value "test" ' +
-                    'that caught by the property validator "myValidator2".',
-                );
-                expect(called).to.be.eq(2);
-              };
-              testFn('str');
-              testFn('');
-              testFn(10);
-              testFn(0);
-              testFn(false);
-              testFn(undefined);
-              testFn(null);
-              testFn({});
-              testFn([]);
-              testFn(() => undefined);
-            });
-
-            it('should pass arguments to validators', function () {
-              let called = false;
-              const dbs = new DatabaseSchema();
-              const myValidator1 = function (value, options, context) {
-                expect(value).to.be.eq('test');
-                expect(options).to.be.undefined;
-                expect(context).to.be.eql({
-                  validatorName: 'myValidator1',
-                  modelName: 'model',
-                  propName: 'foo',
-                });
-                called++;
-                return true;
-              };
-              const myValidator2 = function (value, options, context) {
-                expect(value).to.be.eq('test');
-                expect(options).to.be.undefined;
-                expect(context).to.be.eql({
-                  validatorName: 'myValidator2',
-                  modelName: 'model',
-                  propName: 'foo',
-                });
-                called++;
-                return true;
-              };
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [myValidator1, myValidator2],
-                  },
-                },
-              });
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-              expect(called).to.be.eq(2);
-            });
-
-            it('should invoke validators in the correct order', function () {
-              const invocation = [];
-              const myValidator1 = function () {
-                invocation.push('myValidator1');
-                return true;
-              };
-              const myValidator2 = function () {
-                invocation.push('myValidator2');
-                return true;
-              };
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [myValidator1, myValidator2],
-                  },
-                },
-              });
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-              expect(invocation).to.be.eql(['myValidator1', 'myValidator2']);
-            });
-          });
-
-          describe('anonymous validators', function () {
-            it('should not validate the non-provided property', function () {
-              let calls = 0;
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [
-                      () => {
-                        calls++;
-                        throw new Error('Should not to be called.');
-                      },
-                      () => {
-                        calls++;
-                        throw new Error('Should not to be called.');
-                      },
-                    ],
-                  },
-                },
-              });
-              const validator = dbs.getService(ModelDataValidator);
-              validator.validate('model', {});
-              expect(calls).to.be.eq(0);
-            });
-
-            it('should not validate undefined and null values', function () {
-              let calls = 0;
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [
-                      () => {
-                        calls++;
-                        throw new Error('Should not to be called.');
-                      },
-                      () => {
-                        calls++;
-                        throw new Error('Should not to be called.');
-                      },
-                    ],
-                  },
-                },
-              });
-              const validator = dbs.getService(ModelDataValidator);
-              validator.validate('model', {foo: undefined});
-              validator.validate('model', {foo: null});
-              expect(calls).to.be.eq(0);
-            });
-
-            it('should not validate the empty value', function () {
-              let calls = 0;
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.STRING,
-                    validate: [
-                      () => {
-                        calls++;
-                        throw new Error('Should not to be called.');
-                      },
-                      () => {
-                        calls++;
-                        throw new Error('Should not to be called.');
-                      },
-                    ],
-                  },
-                },
-              });
-              dbs
-                .getService(EmptyValuesService)
-                .setEmptyValuesOf(DataType.STRING, [5]);
-              dbs.getService(ModelDataValidator).validate('model', {foo: 5});
-              expect(calls).to.be.eq(0);
-            });
-
-            it('should throw the error from the first validator', function () {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [
-                      () => {
-                        called++;
-                        throw Error('My error');
-                      },
-                      () => {
-                        called++;
-                        return false;
-                      },
-                    ],
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw('My error');
-              expect(called).to.be.eq(1);
-            });
-
-            it('should throw the error from the second validator', function () {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [
-                      () => {
-                        called++;
-                        return true;
-                      },
-                      () => {
-                        called++;
-                        throw Error('My error');
-                      },
-                    ],
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw('My error');
-              expect(called).to.be.eq(2);
-            });
-
-            it('should allow the given value if validators returns true', function () {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [
-                      () => {
-                        called++;
-                        return true;
-                      },
-                      () => {
-                        called++;
-                        return true;
-                      },
-                    ],
-                  },
-                },
-              });
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-              expect(called).to.be.eq(2);
-            });
-
-            it('should throw the error if the first validator returns a promise', function () {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [
-                      () => {
-                        called++;
-                        return Promise.resolve(true);
-                      },
-                      () => {
-                        called++;
-                        return true;
-                      },
-                    ],
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw(
-                'Asynchronous property validators are not supported, ' +
-                  'but the property "foo" of the model "model" has a property ' +
-                  'validator that returns a Promise.',
-              );
-              expect(called).to.be.eq(1);
-            });
-
-            it('should throw the error if the second validator returns a promise', function () {
-              let called = 0;
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [
-                      () => {
-                        called++;
-                        return true;
-                      },
-                      () => {
-                        called++;
-                        return Promise.resolve(true);
-                      },
-                    ],
-                  },
-                },
-              });
-              const throwable = () =>
-                dbs.getService(ModelDataValidator).validate('model', {
-                  foo: 'test',
-                });
-              expect(throwable).to.throw(
-                'Asynchronous property validators are not supported, ' +
-                  'but the property "foo" of the model "model" has a property ' +
-                  'validator that returns a Promise.',
-              );
-              expect(called).to.be.eq(2);
-            });
-
-            it('should throw the error for a non-true result from the first validator', function () {
-              const testFn = v => {
-                let called = 0;
-                const dbs = new DatabaseSchema();
-                dbs.defineModel({
-                  name: 'model',
-                  properties: {
-                    foo: {
-                      type: DataType.ANY,
-                      validate: [
-                        () => {
-                          called++;
-                          return v;
-                        },
-                        () => {
-                          called++;
-                          return true;
-                        },
-                      ],
-                    },
-                  },
-                });
-                const throwable = () =>
-                  dbs.getService(ModelDataValidator).validate('model', {
-                    foo: 'test',
-                  });
-                expect(throwable).to.throw(
-                  'The property "foo" of the model "model" has the invalid value "test" ' +
-                    'that caught by a property validator.',
-                );
-                expect(called).to.be.eq(1);
-              };
-              testFn('str');
-              testFn('');
-              testFn(10);
-              testFn(0);
-              testFn(false);
-              testFn(undefined);
-              testFn(null);
-              testFn({});
-              testFn([]);
-              testFn(() => undefined);
-            });
-
-            it('should throw the error for a non-true result from the second validator', function () {
-              const testFn = v => {
-                let called = 0;
-                const dbs = new DatabaseSchema();
-                dbs.defineModel({
-                  name: 'model',
-                  properties: {
-                    foo: {
-                      type: DataType.ANY,
-                      validate: [
-                        () => {
-                          called++;
-                          return true;
-                        },
-                        () => {
-                          called++;
-                          return v;
-                        },
-                      ],
-                    },
-                  },
-                });
-                const throwable = () =>
-                  dbs.getService(ModelDataValidator).validate('model', {
-                    foo: 'test',
-                  });
-                expect(throwable).to.throw(
-                  'The property "foo" of the model "model" has the invalid value "test" ' +
-                    'that caught by a property validator.',
-                );
-                expect(called).to.be.eq(2);
-              };
-              testFn('str');
-              testFn('');
-              testFn(10);
-              testFn(0);
-              testFn(false);
-              testFn(undefined);
-              testFn(null);
-              testFn({});
-              testFn([]);
-              testFn(() => undefined);
-            });
-
-            it('should pass arguments to validators', function () {
-              let called = false;
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [
-                      (value, options, context) => {
-                        expect(value).to.be.eq('test');
-                        expect(options).to.be.undefined;
-                        expect(context).to.be.eql({
-                          validatorName: undefined,
-                          modelName: 'model',
-                          propName: 'foo',
-                        });
-                        called++;
-                        return true;
-                      },
-                      (value, options, context) => {
-                        expect(value).to.be.eq('test');
-                        expect(options).to.be.undefined;
-                        expect(context).to.be.eql({
-                          validatorName: undefined,
-                          modelName: 'model',
-                          propName: 'foo',
-                        });
-                        called++;
-                        return true;
-                      },
-                    ],
-                  },
-                },
-              });
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-              expect(called).to.be.eq(2);
-            });
-
-            it('should invoke validators in the correct order', function () {
-              const invocation = [];
-              const dbs = new DatabaseSchema();
-              dbs.defineModel({
-                name: 'model',
-                properties: {
-                  foo: {
-                    type: DataType.ANY,
-                    validate: [
-                      () => {
-                        invocation.push('myValidator1');
-                        return true;
-                      },
-                      () => {
-                        invocation.push('myValidator2');
-                        return true;
-                      },
-                    ],
-                  },
-                },
-              });
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-              expect(invocation).to.be.eql(['myValidator1', 'myValidator2']);
-            });
-          });
-        });
-      });
-
-      describe('when the option "validate" is an Object', function () {
-        it('should not validate the non-provided property', function () {
-          let calls = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator1', function () {
-            calls++;
-            throw new Error('Should not to be called.');
-          });
-          reg.addValidator('myValidator2', function () {
-            calls++;
-            throw new Error('Should not to be called.');
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: {
-                  myValidator1: true,
-                  myValidator2: true,
-                },
-              },
-            },
-          });
-          const validator = dbs.getService(ModelDataValidator);
-          validator.validate('model', {});
-          expect(calls).to.be.eq(0);
-        });
-
-        it('should not validate undefined and null values', function () {
-          let calls = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator1', function () {
-            calls++;
-            throw new Error('Should not to be called.');
-          });
-          reg.addValidator('myValidator2', function () {
-            calls++;
-            throw new Error('Should not to be called.');
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: {
-                  myValidator1: true,
-                  myValidator2: true,
-                },
-              },
-            },
-          });
-          const validator = dbs.getService(ModelDataValidator);
-          validator.validate('model', {foo: undefined});
-          validator.validate('model', {foo: null});
-          expect(calls).to.be.eq(0);
-        });
-
-        it('should not validate the empty value', function () {
-          let calls = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator1', function () {
-            calls++;
-            throw new Error('Should not to be called.');
-          });
-          reg.addValidator('myValidator2', function () {
-            calls++;
-            throw new Error('Should not to be called.');
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.STRING,
-                validate: {
-                  myValidator1: true,
-                  myValidator2: true,
-                },
-              },
-            },
-          });
-          dbs
-            .getService(EmptyValuesService)
-            .setEmptyValuesOf(DataType.STRING, [5]);
-          dbs.getService(ModelDataValidator).validate('model', {foo: 5});
-          expect(calls).to.be.eq(0);
-        });
-
-        it('should throw the error for the non-existent validator name', function () {
-          let called = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator1', function () {
-            called++;
-            return true;
-          });
-          const modelDef = {
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: {
-                  myValidator1: true,
-                },
-              },
-            },
-          };
-          dbs.defineModel(modelDef);
-          modelDef.properties.foo.validate['myValidator2'] = true;
-          const throwable = () =>
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-          expect(throwable).to.throw(
-            'The property validator "myValidator2" is not defined.',
-          );
-          expect(called).to.be.eq(1);
-        });
-
-        it('should throw the error from the first validator', function () {
-          let called = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator1', function () {
-            called++;
-            throw Error('My error');
-          });
-          reg.addValidator('myValidator2', function () {
-            called++;
-            return false;
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: {
-                  myValidator1: true,
-                  myValidator2: true,
-                },
-              },
-            },
-          });
-          const throwable = () =>
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-          expect(throwable).to.throw('My error');
-          expect(called).to.be.eq(1);
-        });
-
-        it('should throw the error from the second validator', function () {
-          let called = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator1', function () {
-            called++;
-            return true;
-          });
-          reg.addValidator('myValidator2', function () {
-            called++;
-            throw Error('My error');
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: {
-                  myValidator1: true,
-                  myValidator2: true,
-                },
-              },
-            },
-          });
-          const throwable = () =>
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-          expect(throwable).to.throw('My error');
-          expect(called).to.be.eq(2);
-        });
-
-        it('should allow the given value if validators returns true', function () {
-          let called = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator1', function () {
-            called++;
-            return true;
-          });
-          reg.addValidator('myValidator2', function () {
-            called++;
-            return true;
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: {
-                  myValidator1: true,
-                  myValidator2: true,
-                },
-              },
-            },
-          });
-          dbs.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          expect(called).to.be.eq(2);
-        });
-
-        it('should throw the error if the first validator returns a promise', function () {
-          let called = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator1', function () {
-            called++;
-            return Promise.resolve(true);
-          });
-          reg.addValidator('myValidator2', function () {
-            called++;
-            return true;
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: {
-                  myValidator1: true,
-                  myValidator2: true,
-                },
-              },
-            },
-          });
-          const throwable = () =>
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-          expect(throwable).to.throw(
-            'Asynchronous property validators are not supported, ' +
-              'but the property "foo" of the model "model" has the property ' +
-              'validator "myValidator1" that returns a Promise.',
-          );
-          expect(called).to.be.eq(1);
-        });
-
-        it('should throw the error if the second validator returns a promise', function () {
-          let called = 0;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator1', function () {
-            called++;
-            return true;
-          });
-          reg.addValidator('myValidator2', function () {
-            called++;
-            return Promise.resolve(true);
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: {
-                  myValidator1: true,
-                  myValidator2: true,
-                },
-              },
-            },
-          });
-          const throwable = () =>
-            dbs.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-          expect(throwable).to.throw(
-            'Asynchronous property validators are not supported, ' +
-              'but the property "foo" of the model "model" has the property ' +
-              'validator "myValidator2" that returns a Promise.',
-          );
-          expect(called).to.be.eq(2);
-        });
-
-        it('should throw the error for a non-true result from the first validator', function () {
-          const testFn = v => {
-            let called = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              called++;
-              return v;
-            });
-            reg.addValidator('myValidator2', function () {
-              called++;
-              return true;
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: {
-                    myValidator1: true,
-                    myValidator2: true,
-                  },
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" has the invalid value "test" ' +
-                'that caught by the property validator "myValidator1".',
-            );
-            expect(called).to.be.eq(1);
-          };
-          testFn('str');
-          testFn('');
-          testFn(10);
-          testFn(0);
-          testFn(false);
-          testFn(undefined);
-          testFn(null);
-          testFn({});
-          testFn([]);
-          testFn(() => undefined);
-        });
-
-        it('should throw the error for a non-true result from the second validator', function () {
-          const testFn = v => {
-            let called = 0;
-            const dbs = new DatabaseSchema();
-            const reg = dbs.getService(PropertyValidatorRegistry);
-            reg.addValidator('myValidator1', function () {
-              called++;
-              return true;
-            });
-            reg.addValidator('myValidator2', function () {
-              called++;
-              return v;
-            });
-            dbs.defineModel({
-              name: 'model',
-              properties: {
-                foo: {
-                  type: DataType.ANY,
-                  validate: {
-                    myValidator1: true,
-                    myValidator2: true,
-                  },
-                },
-              },
-            });
-            const throwable = () =>
-              dbs.getService(ModelDataValidator).validate('model', {
-                foo: 'test',
-              });
-            expect(throwable).to.throw(
-              'The property "foo" of the model "model" has the invalid value "test" ' +
-                'that caught by the property validator "myValidator2".',
-            );
-            expect(called).to.be.eq(2);
-          };
-          testFn('str');
-          testFn('');
-          testFn(10);
-          testFn(0);
-          testFn(false);
-          testFn(undefined);
-          testFn(null);
-          testFn({});
-          testFn([]);
-          testFn(() => undefined);
-        });
-
-        it('should pass arguments to validators', function () {
-          let called = false;
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator1', function (value, options, context) {
-            expect(value).to.be.eq('test');
-            expect(options).to.be.eq('foo');
-            expect(context).to.be.eql({
-              validatorName: 'myValidator1',
-              modelName: 'model',
-              propName: 'foo',
-            });
-            called++;
-            return true;
-          });
-          reg.addValidator('myValidator2', function (value, options, context) {
-            expect(value).to.be.eq('test');
-            expect(options).to.be.eq('bar');
-            expect(context).to.be.eql({
-              validatorName: 'myValidator2',
-              modelName: 'model',
-              propName: 'foo',
-            });
-            called++;
-            return true;
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: {
-                  myValidator1: 'foo',
-                  myValidator2: 'bar',
-                },
-              },
-            },
-          });
-          dbs.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          expect(called).to.be.eq(2);
-        });
-
-        it('should invoke validators in the correct order', function () {
-          const invocation = [];
-          const dbs = new DatabaseSchema();
-          const reg = dbs.getService(PropertyValidatorRegistry);
-          reg.addValidator('myValidator1', function () {
-            invocation.push('myValidator1');
-            return true;
-          });
-          reg.addValidator('myValidator2', function () {
-            invocation.push('myValidator2');
-            return true;
-          });
-          dbs.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: {
-                  myValidator1: true,
-                  myValidator2: true,
-                },
-              },
-            },
-          });
-          dbs.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          expect(invocation).to.be.eql(['myValidator1', 'myValidator2']);
-        });
-      });
-    });
-  });
-});