@e22m4u/js-repository 0.1.1 → 0.1.3

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

@@ -3,40 +3,44 @@ import {Schema} from '../../schema.js';
 import {format} from '@e22m4u/js-format';
 import {DataType} from './properties/index.js';
 import {ModelDataValidator} from './model-data-validator.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 () {
+    it('does not throw an error if a model does not have a property of a given data', async function () {
       const schema = new Schema();
       schema.defineModel({name: 'model'});
-      schema.getService(ModelDataValidator).validate('model', {foo: 'bar'});
+      await schema
+        .getService(ModelDataValidator)
+        .validate('model', {foo: 'bar'});
     });
 
-    it('throws an error if a given data is not a pure object', function () {
+    it('throws an error if a given data is not a pure object', async function () {
       const throwable = modelData => {
         const schema = new Schema();
         schema.defineModel({
           name: 'model',
           datasource: 'datasource',
         });
-        return () =>
-          schema.getService(ModelDataValidator).validate('model', modelData);
+        return schema
+          .getService(ModelDataValidator)
+          .validate('model', modelData);
       };
       const error = given =>
         format(
           'The data of the model "model" should be an Object, but %s given.',
           given,
         );
-      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'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
     });
 
-    it('uses a base model hierarchy to validate a given data', function () {
+    it('uses a base model hierarchy to validate a given data', async function () {
       const schema = new Schema();
       schema.defineModel({
         name: 'modelA',
@@ -48,15 +52,16 @@ describe('ModelDataValidator', function () {
         name: 'modelB',
         base: 'modelA',
       });
-      const throwable = () =>
-        schema.getService(ModelDataValidator).validate('modelB', {foo: 10});
-      expect(throwable).to.throw(
+      const promise = schema
+        .getService(ModelDataValidator)
+        .validate('modelB', {foo: 10});
+      await expect(promise).to.be.rejectedWith(
         'The property "foo" of the model "modelB" must ' +
           'have a String, but Number given.',
       );
     });
 
-    it('throws an error if a given data does not have a required property', function () {
+    it('throws an error if a given data does not have a required property', async function () {
       const schema = new Schema();
       schema.defineModel({
         name: 'model',
@@ -67,15 +72,16 @@ describe('ModelDataValidator', function () {
           },
         },
       });
-      const throwable = () =>
-        schema.getService(ModelDataValidator).validate('model', {});
-      expect(throwable).to.throw(
+      const promise = schema
+        .getService(ModelDataValidator)
+        .validate('model', {});
+      await expect(promise).to.be.rejectedWith(
         'The property "foo" of the model "model" ' +
           'is required, but undefined given.',
       );
     });
 
-    it('throws an error if a required property is undefined', function () {
+    it('throws an error if a required property is undefined', async function () {
       const schema = new Schema();
       schema.defineModel({
         name: 'model',
@@ -86,16 +92,15 @@ describe('ModelDataValidator', function () {
           },
         },
       });
-      const throwable = () =>
-        schema
-          .getService(ModelDataValidator)
-          .validate('model', {foo: undefined});
-      expect(throwable).to.throw(
+      const promise = schema
+        .getService(ModelDataValidator)
+        .validate('model', {foo: undefined});
+      await expect(promise).to.be.rejectedWith(
         'The property "foo" of the model "model" is required, but undefined given.',
       );
     });
 
-    it('throws an error if a required property is null', function () {
+    it('throws an error if a required property is null', async function () {
       const schema = new Schema();
       schema.defineModel({
         name: 'model',
@@ -106,15 +111,16 @@ describe('ModelDataValidator', function () {
           },
         },
       });
-      const throwable = () =>
-        schema.getService(ModelDataValidator).validate('model', {foo: null});
-      expect(throwable).to.throw(
+      const promise = schema
+        .getService(ModelDataValidator)
+        .validate('model', {foo: null});
+      await expect(promise).to.be.rejectedWith(
         'The property "foo" of the model "model" is required, but null given.',
       );
     });
 
     describe('an option "isPartial" is true', function () {
-      it('does not throw an error if a given data does not have a required property', function () {
+      it('does not throw an error if a given data does not have a required property', async function () {
         const schema = new Schema();
         schema.defineModel({
           name: 'model',
@@ -125,10 +131,10 @@ describe('ModelDataValidator', function () {
             },
           },
         });
-        schema.getService(ModelDataValidator).validate('model', {}, true);
+        await schema.getService(ModelDataValidator).validate('model', {}, true);
       });
 
-      it('throws an error if a required property is undefined', function () {
+      it('throws an error if a required property is undefined', async function () {
         const schema = new Schema();
         schema.defineModel({
           name: 'model',
@@ -139,17 +145,16 @@ describe('ModelDataValidator', function () {
             },
           },
         });
-        const throwable = () =>
-          schema
-            .getService(ModelDataValidator)
-            .validate('model', {foo: undefined}, true);
-        expect(throwable).to.throw(
+        const promise = schema
+          .getService(ModelDataValidator)
+          .validate('model', {foo: undefined}, true);
+        await expect(promise).to.be.rejectedWith(
           'The property "foo" of the model "model" ' +
             'is required, but undefined given.',
         );
       });
 
-      it('throws an error if a required property is null', function () {
+      it('throws an error if a required property is null', async function () {
         const schema = new Schema();
         schema.defineModel({
           name: 'model',
@@ -160,11 +165,10 @@ describe('ModelDataValidator', function () {
             },
           },
         });
-        const throwable = () =>
-          schema
-            .getService(ModelDataValidator)
-            .validate('model', {foo: null}, true);
-        expect(throwable).to.throw(
+        const promise = schema
+          .getService(ModelDataValidator)
+          .validate('model', {foo: null}, true);
+        await expect(promise).to.be.rejectedWith(
           'The property "foo" of the model "model" is required, but null given.',
         );
       });
@@ -172,7 +176,7 @@ describe('ModelDataValidator', function () {
 
     describe('DataType.ANY', function () {
       describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -181,12 +185,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.ANY,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -195,12 +199,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.ANY,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('does not throw an error if a string given', function () {
+        it('does not throw an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -209,12 +213,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.ANY,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: 'bar',
           });
         });
 
-        it('does not throw an error if a number given', function () {
+        it('does not throw an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -223,12 +227,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.ANY,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: 10,
           });
         });
 
-        it('does not throw an error if true given', function () {
+        it('does not throw an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -237,12 +241,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.ANY,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: true,
           });
         });
 
-        it('does not throw an error if false given', function () {
+        it('does not throw an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -251,12 +255,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.ANY,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: false,
           });
         });
 
-        it('does not throw an error if an array given', function () {
+        it('does not throw an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -265,12 +269,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.ANY,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: [],
           });
         });
 
-        it('does not throw an error if an object given', function () {
+        it('does not throw an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -279,14 +283,14 @@ describe('ModelDataValidator', function () {
               foo: DataType.ANY,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: {},
           });
         });
       });
 
       describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -297,12 +301,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -313,12 +317,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('does not throw an error if a string given', function () {
+        it('does not throw an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -329,12 +333,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: 'bar',
           });
         });
 
-        it('does not throw an error if a number given', function () {
+        it('does not throw an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -345,12 +349,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: 10,
           });
         });
 
-        it('does not throw an error if true given', function () {
+        it('does not throw an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -361,12 +365,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: true,
           });
         });
 
-        it('does not throw an error if false given', function () {
+        it('does not throw an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -377,12 +381,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: false,
           });
         });
 
-        it('does not throw an error if an array given', function () {
+        it('does not throw an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -393,12 +397,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: [],
           });
         });
 
-        it('does not throw an error if an object given', function () {
+        it('does not throw an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -409,7 +413,7 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: {},
           });
         });
@@ -418,7 +422,7 @@ describe('ModelDataValidator', function () {
 
     describe('DataType.STRING', function () {
       describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -427,12 +431,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.STRING,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -441,12 +445,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.STRING,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('does not throw an error if a string given', function () {
+        it('does not throw an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -455,12 +459,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.STRING,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: 'bar',
           });
         });
 
-        it('throws an error if a number given', function () {
+        it('throws an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -469,17 +473,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.STRING,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 10,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a String, but Number given.',
           );
         });
 
-        it('throws an error if true given', function () {
+        it('throws an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -488,17 +491,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.STRING,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: true,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a String, but Boolean given.',
           );
         });
 
-        it('throws an error if false given', function () {
+        it('throws an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -507,17 +509,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.STRING,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: false,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a String, but Boolean given.',
           );
         });
 
-        it('throws an error if an array given', function () {
+        it('throws an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -526,17 +527,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.STRING,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: [],
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a String, but Array given.',
           );
         });
 
-        it('throws an error if an object given', function () {
+        it('throws an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -545,11 +545,10 @@ describe('ModelDataValidator', function () {
               foo: DataType.STRING,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: {},
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a String, but Object given.',
           );
@@ -557,7 +556,7 @@ describe('ModelDataValidator', function () {
       });
 
       describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -568,12 +567,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -584,12 +583,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('does not throw an error if a string given', function () {
+        it('does not throw an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -600,12 +599,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: 'bar',
           });
         });
 
-        it('throws an error if a number given', function () {
+        it('throws an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -616,17 +615,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 10,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a String, but Number given.',
           );
         });
 
-        it('throws an error if true given', function () {
+        it('throws an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -637,17 +635,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: true,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a String, but Boolean given.',
           );
         });
 
-        it('throws an error if false given', function () {
+        it('throws an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -658,17 +655,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: false,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a String, but Boolean given.',
           );
         });
 
-        it('throws an error if an array given', function () {
+        it('throws an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -679,17 +675,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: [],
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a String, but Array given.',
           );
         });
 
-        it('throws an error if an object given', function () {
+        it('throws an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -700,11 +695,10 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: {},
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a String, but Object given.',
           );
@@ -714,7 +708,7 @@ describe('ModelDataValidator', function () {
 
     describe('DataType.NUMBER', function () {
       describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -723,12 +717,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.NUMBER,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -737,12 +731,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.NUMBER,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('throws an error if a string given', function () {
+        it('throws an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -751,17 +745,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.NUMBER,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'bar',
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Number, but String given.',
           );
         });
 
-        it('does not throw an error if a number given', function () {
+        it('does not throw an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -770,12 +763,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.NUMBER,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: 10,
           });
         });
 
-        it('throws an error if true given', function () {
+        it('throws an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -784,17 +777,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.NUMBER,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: true,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Number, but Boolean given.',
           );
         });
 
-        it('throws an error if false given', function () {
+        it('throws an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -803,17 +795,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.NUMBER,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: false,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Number, but Boolean given.',
           );
         });
 
-        it('throws an error if an array given', function () {
+        it('throws an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -822,17 +813,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.NUMBER,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: [],
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Number, but Array given.',
           );
         });
 
-        it('throws an error if an object given', function () {
+        it('throws an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -841,11 +831,10 @@ describe('ModelDataValidator', function () {
               foo: DataType.NUMBER,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: {},
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Number, but Object given.',
           );
@@ -853,7 +842,7 @@ describe('ModelDataValidator', function () {
       });
 
       describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -864,12 +853,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -880,12 +869,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('throws an error if a string given', function () {
+        it('throws an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -896,17 +885,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'bar',
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Number, but String given.',
           );
         });
 
-        it('does not throw an error if a number given', function () {
+        it('does not throw an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -917,12 +905,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: 10,
           });
         });
 
-        it('throws an error if true given', function () {
+        it('throws an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -933,17 +921,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: true,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Number, but Boolean given.',
           );
         });
 
-        it('throws an error if false given', function () {
+        it('throws an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -954,17 +941,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: false,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Number, but Boolean given.',
           );
         });
 
-        it('throws an error if an array given', function () {
+        it('throws an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -975,17 +961,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: [],
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Number, but Array given.',
           );
         });
 
-        it('throws an error if an object given', function () {
+        it('throws an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -996,11 +981,10 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: {},
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Number, but Object given.',
           );
@@ -1010,7 +994,7 @@ describe('ModelDataValidator', function () {
 
     describe('DataType.BOOLEAN', function () {
       describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1019,12 +1003,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.BOOLEAN,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1033,12 +1017,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.BOOLEAN,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('throws an error if a string given', function () {
+        it('throws an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1047,17 +1031,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.BOOLEAN,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'bar',
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Boolean, but String given.',
           );
         });
 
-        it('throws an error if a number given', function () {
+        it('throws an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1066,17 +1049,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.BOOLEAN,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 10,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Boolean, but Number given.',
           );
         });
 
-        it('does not throw an error if true given', function () {
+        it('does not throw an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1085,12 +1067,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.BOOLEAN,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: true,
           });
         });
 
-        it('does not throw an error if false given', function () {
+        it('does not throw an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1099,12 +1081,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.BOOLEAN,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: false,
           });
         });
 
-        it('throws an error if an array given', function () {
+        it('throws an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1113,17 +1095,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.BOOLEAN,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: [],
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Boolean, but Array given.',
           );
         });
 
-        it('throws an error if an object given', function () {
+        it('throws an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1132,11 +1113,10 @@ describe('ModelDataValidator', function () {
               foo: DataType.BOOLEAN,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: {},
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Boolean, but Object given.',
           );
@@ -1144,7 +1124,7 @@ describe('ModelDataValidator', function () {
       });
 
       describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1155,12 +1135,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1171,12 +1151,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('throws an error if a string given', function () {
+        it('throws an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1187,17 +1167,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'bar',
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Boolean, but String given.',
           );
         });
 
-        it('throws an error if a number given', function () {
+        it('throws an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1208,17 +1187,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 10,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Boolean, but Number given.',
           );
         });
 
-        it('does not throw an error if true given', function () {
+        it('does not throw an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1229,12 +1207,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: true,
           });
         });
 
-        it('does not throw an error if false given', function () {
+        it('does not throw an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1245,12 +1223,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: false,
           });
         });
 
-        it('throws an error if an array given', function () {
+        it('throws an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1261,17 +1239,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: [],
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Boolean, but Array given.',
           );
         });
 
-        it('throws an error if an object given', function () {
+        it('throws an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1282,11 +1259,10 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: {},
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'a Boolean, but Object given.',
           );
@@ -1296,7 +1272,7 @@ describe('ModelDataValidator', function () {
 
     describe('DataType.ARRAY', function () {
       describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1305,12 +1281,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.ARRAY,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1319,12 +1295,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.ARRAY,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('throws an error if a string given', function () {
+        it('throws an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1333,17 +1309,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.ARRAY,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'bar',
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Array, but String given.',
           );
         });
 
-        it('throws an error if a number given', function () {
+        it('throws an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1352,17 +1327,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.ARRAY,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 10,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Array, but Number given.',
           );
         });
 
-        it('throws an error if true given', function () {
+        it('throws an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1371,17 +1345,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.ARRAY,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: true,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Array, but Boolean given.',
           );
         });
 
-        it('throws an error if false given', function () {
+        it('throws an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1390,17 +1363,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.ARRAY,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: false,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Array, but Boolean given.',
           );
         });
 
-        it('does not throw an error if an array given', function () {
+        it('does not throw an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1409,12 +1381,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.ARRAY,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: [],
           });
         });
 
-        it('throws an error if an object given', function () {
+        it('throws an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1423,11 +1395,10 @@ describe('ModelDataValidator', function () {
               foo: DataType.ARRAY,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: {},
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Array, but Object given.',
           );
@@ -1435,7 +1406,7 @@ describe('ModelDataValidator', function () {
       });
 
       describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1446,12 +1417,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1462,12 +1433,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('throws an error if a string given', function () {
+        it('throws an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1478,17 +1449,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'bar',
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Array, but String given.',
           );
         });
 
-        it('throws an error if a number given', function () {
+        it('throws an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1499,17 +1469,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 10,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Array, but Number given.',
           );
         });
 
-        it('throws an error if true given', function () {
+        it('throws an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1520,17 +1489,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: true,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Array, but Boolean given.',
           );
         });
 
-        it('throws an error if false given', function () {
+        it('throws an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1541,17 +1509,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: false,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Array, but Boolean given.',
           );
         });
 
-        it('does not throw an error if an array given', function () {
+        it('does not throw an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1562,12 +1529,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: [],
           });
         });
 
-        it('throws an error if an object given', function () {
+        it('throws an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1578,18 +1545,17 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: {},
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Array, but Object given.',
           );
         });
 
         describe('the "model" option', function () {
-          it('throws an error when the given object element has an invalid model', function () {
+          it('throws an error when the given object element has an invalid model', async function () {
             const S = new Schema();
             S.defineModel({
               name: 'modelA',
@@ -1608,17 +1574,19 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const throwable = () =>
-              S.getService(ModelDataValidator).validate('modelB', {
+            const promise = S.getService(ModelDataValidator).validate(
+              'modelB',
+              {
                 bar: [{foo: 10}],
-              });
-            expect(throwable).to.throw(
+              },
+            );
+            await expect(promise).to.be.rejectedWith(
               'The property "foo" of the model "modelA" must have ' +
                 'a String, but Number given.',
             );
           });
 
-          it('does not throw an error when the given object element has a valid model', function () {
+          it('does not throw an error when the given object element has a valid model', async function () {
             const S = new Schema();
             S.defineModel({
               name: 'modelA',
@@ -1637,7 +1605,7 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            S.getService(ModelDataValidator).validate('modelB', {
+            await S.getService(ModelDataValidator).validate('modelB', {
               bar: [{foo: '10'}],
             });
           });
@@ -1647,7 +1615,7 @@ describe('ModelDataValidator', function () {
 
     describe('DataType.OBJECT', function () {
       describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1656,12 +1624,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.OBJECT,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1670,12 +1638,12 @@ describe('ModelDataValidator', function () {
               foo: DataType.OBJECT,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('throws an error if a string given', function () {
+        it('throws an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1684,17 +1652,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.OBJECT,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'bar',
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Object, but String given.',
           );
         });
 
-        it('throws an error if a number given', function () {
+        it('throws an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1703,17 +1670,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.OBJECT,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 10,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Object, but Number given.',
           );
         });
 
-        it('throws an error if true given', function () {
+        it('throws an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1722,17 +1688,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.OBJECT,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: true,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Object, but Boolean given.',
           );
         });
 
-        it('throws an error if false given', function () {
+        it('throws an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1741,17 +1706,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.OBJECT,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: false,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Object, but Boolean given.',
           );
         });
 
-        it('throws an error if an array given', function () {
+        it('throws an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1760,17 +1724,16 @@ describe('ModelDataValidator', function () {
               foo: DataType.OBJECT,
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: [],
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Object, but Array given.',
           );
         });
 
-        it('does not throw an error if an object given', function () {
+        it('does not throw an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1779,14 +1742,14 @@ describe('ModelDataValidator', function () {
               foo: DataType.OBJECT,
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: {},
           });
         });
       });
 
       describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', function () {
+        it('does not throw an error if an undefined given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1797,12 +1760,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: undefined,
           });
         });
 
-        it('does not throw an error if a null given', function () {
+        it('does not throw an error if a null given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1813,12 +1776,12 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: null,
           });
         });
 
-        it('throws an error if a string given', function () {
+        it('throws an error if a string given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1829,17 +1792,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'bar',
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Object, but String given.',
           );
         });
 
-        it('throws an error if a number given', function () {
+        it('throws an error if a number given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1850,17 +1812,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 10,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Object, but Number given.',
           );
         });
 
-        it('throws an error if true given', function () {
+        it('throws an error if true given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1871,17 +1832,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: true,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Object, but Boolean given.',
           );
         });
 
-        it('throws an error if false given', function () {
+        it('throws an error if false given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1892,17 +1852,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: false,
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Object, but Boolean given.',
           );
         });
 
-        it('throws an error if an array given', function () {
+        it('throws an error if an array given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1913,17 +1872,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          const throwable = () =>
-            S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-          expect(throwable).to.throw(
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: [],
+          });
+          await expect(promise).to.be.rejectedWith(
             'The property "foo" of the model "model" must have ' +
               'an Object, but Array given.',
           );
         });
 
-        it('does not throw an error if an object given', function () {
+        it('does not throw an error if an object given', async function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -1934,13 +1892,13 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
+          await S.getService(ModelDataValidator).validate('model', {
             foo: {},
           });
         });
 
         describe('the "model" option', function () {
-          it('throws an error when the given object has an invalid model', function () {
+          it('throws an error when the given object has an invalid model', async function () {
             const S = new Schema();
             S.defineModel({
               name: 'modelA',
@@ -1958,17 +1916,19 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const throwable = () =>
-              S.getService(ModelDataValidator).validate('modelB', {
+            const promise = S.getService(ModelDataValidator).validate(
+              'modelB',
+              {
                 bar: {foo: 10},
-              });
-            expect(throwable).to.throw(
+              },
+            );
+            await expect(promise).to.be.rejectedWith(
               'The property "foo" of the model "modelA" must have ' +
                 'a String, but Number given.',
             );
           });
 
-          it('does not throw an error when the given object has a valid model', function () {
+          it('does not throw an error when the given object has a valid model', async function () {
             const S = new Schema();
             S.defineModel({
               name: 'modelA',
@@ -1986,12 +1946,750 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            S.getService(ModelDataValidator).validate('modelB', {
+            await S.getService(ModelDataValidator).validate('modelB', {
               bar: {foo: '10'},
             });
           });
         });
       });
     });
+
+    describe('validate by property validators', function () {
+      describe('the option "validate" with the string value', function () {
+        it('do not validate null and undefined values', async function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', () => false);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: 'validator',
+              },
+              bar: {
+                type: DataType.ANY,
+                validate: 'validator',
+              },
+              baz: {
+                type: DataType.ANY,
+                validate: 'validator',
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: null,
+            bar: undefined,
+          });
+        });
+
+        it('throws an error from the validator', async function () {
+          const validator = function () {
+            throw Error('My error');
+          }
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', validator);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: 'validator',
+              },
+            },
+          });
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          await expect(promise).to.be.rejectedWith('My error');
+        });
+
+        it('allows the given value if the validator returns true', async function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', () => true);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: 'validator',
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+        });
+
+        it('allows the given value if the validator returns a promise of true', async function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', () => Promise.resolve(true));
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: 'validator',
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+        });
+
+        it('throws an error for non-true result from the validator', async function () {
+          const testFn = async (v) => {
+            const S = new Schema();
+            S.getService(PropertyValidatorRegistry)
+              .addValidator('validator', () => v);
+            S.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  validate: 'validator',
+                },
+              },
+            });
+            const promise = S.getService(ModelDataValidator)
+              .validate('model', {foo: 'test'});
+            return expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" has an invalid value "test" ' +
+              'that caught by the validator "validator".',
+            );
+          }
+          await testFn('str');
+          await testFn('');
+          await testFn(10);
+          await testFn(0);
+          await testFn(false);
+          await testFn(undefined);
+          await testFn(null);
+          await testFn({});
+          await testFn([]);
+          await testFn(() => undefined);
+        });
+
+        it('passes arguments to the validator', async function () {
+          let validated = false;
+          const S = new Schema();
+          const validator = function (value, options, context) {
+            expect(value).to.be.eq('test');
+            expect(options).to.be.undefined;
+            expect(context).to.be.eql({
+              validatorName: 'validator',
+              modelName: 'model',
+              propName: 'foo',
+              propDef: {
+                type: DataType.ANY,
+                validate: 'validator',
+              },
+              container: S.container,
+            });
+            validated = true;
+            return true;
+          }
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', validator);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: 'validator',
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          expect(validated).to.be.true;
+        });
+
+        it('invokes the validator only once per value', async function () {
+          let invoked = 0;
+          const validator = function () {
+            invoked++;
+            return true;
+          }
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', validator);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: 'validator',
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          expect(invoked).to.be.eq(1);
+        });
+
+        it('waits rejection from an async validator', async function () {
+          const error = new Error('My error');
+          const validator = function () {
+            return new Promise((resolve, reject) => {
+              setTimeout(() => reject(error), 5);
+            });
+          }
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', validator);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: 'validator',
+              },
+            },
+          });
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          await expect(promise).to.be.rejectedWith(error);
+        });
+      });
+
+      describe('the option "validate" with an array value', function () {
+        it('does nothing for an empty array validators', async function () {
+          const S = new Schema();
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: [],
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+        });
+
+        it('do not validate null and undefined values', async function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', () => false);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: ['validator'],
+              },
+              bar: {
+                type: DataType.ANY,
+                validate: ['validator'],
+              },
+              baz: {
+                type: DataType.ANY,
+                validate: ['validator'],
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: null,
+            bar: undefined,
+          });
+        });
+
+        it('throws an error from the validator', async function () {
+          const validator = function () {
+            throw Error('My error');
+          }
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', validator);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: ['validator'],
+              },
+            },
+          });
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          await expect(promise).to.be.rejectedWith('My error');
+        });
+
+        it('allows the given value if validators returns true', async function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator1', () => true)
+            .addValidator('validator2', () => true);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: ['validator1', 'validator2'],
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+        });
+
+        it('allows the given value if validators returns a promise of true', async function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator1', () => Promise.resolve(true))
+            .addValidator('validator2', () => Promise.resolve(true));
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: ['validator1', 'validator2'],
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+        });
+
+        it('throws an error by non-true result from one of validators', async function () {
+          const testFn = v => {
+            const S = new Schema();
+            S.getService(PropertyValidatorRegistry)
+              .addValidator('validator1', () => true)
+              .addValidator('validator2', () => v);
+            S.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  validate: ['validator1', 'validator2'],
+                },
+              },
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: 'test',
+            });
+            return expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" has an invalid value "test" ' +
+              'that caught by the validator "validator2".',
+            );
+          }
+          await testFn('str');
+          await testFn('');
+          await testFn(10);
+          await testFn(0);
+          await testFn(false);
+          await testFn(undefined);
+          await testFn(null);
+          await testFn({});
+          await testFn([]);
+          await testFn(() => undefined);
+        });
+
+        it('passes arguments to the validator', async function () {
+          let validated = false;
+          const S = new Schema();
+          const validator = function (value, options, context) {
+            expect(value).to.be.eq('test');
+            expect(options).to.be.undefined;
+            expect(context).to.be.eql({
+              validatorName: 'validator',
+              modelName: 'model',
+              propName: 'foo',
+              propDef: {
+                type: DataType.ANY,
+                validate: ['validator'],
+              },
+              container: S.container,
+            });
+            validated = true;
+            return true;
+          }
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', validator);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: ['validator'],
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          expect(validated).to.be.true;
+        });
+
+        it('invokes validators by the given order', async function () {
+          const invocation = [];
+          const validator1 = function () {
+            invocation.push('validator1');
+            return true;
+          }
+          const validator2 = function () {
+            invocation.push('validator2');
+            return true;
+          }
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator1', validator1)
+            .addValidator('validator2', validator2);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: ['validator1', 'validator2'],
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          expect(invocation).to.be.eql(['validator1', 'validator2']);
+        });
+
+        it('waits rejection from one of async validators', async function () {
+          const error1 = new Error('Occurs after 15 ms');
+          const error2 = new Error('Occurs after 5 ms');
+          const validator1 = () => new Promise((res, rej) => {
+            setTimeout(() => rej(error1), 15);
+          });
+          const validator2 = () => new Promise((res, rej) => {
+            setTimeout(() => rej(error2), 5);
+          });
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator1', validator1)
+            .addValidator('validator2', validator2);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: [
+                  'validator1',
+                  'validator2',
+                ],
+              },
+            },
+          });
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          await expect(promise).to.be.rejectedWith(error2);
+        });
+      });
+
+      describe('the option "validate" with an object value', function () {
+        it('does nothing for an empty validators object', async function () {
+          const S = new Schema();
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: {},
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+        });
+
+        it('do not validate null and undefined values', async function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', () => false);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: {
+                  validator: true,
+                },
+              },
+              bar: {
+                type: DataType.ANY,
+                validate: {
+                  validator: true,
+                },
+              },
+              baz: {
+                type: DataType.ANY,
+                validate: {
+                  validator: true,
+                },
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: null,
+            bar: undefined,
+          });
+        });
+
+        it('throws an error from the validator', async function () {
+          const validator = function () {
+            throw Error('My error');
+          }
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', validator);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: {
+                  validator: true,
+                },
+              },
+            },
+          });
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          await expect(promise).to.be.rejectedWith('My error');
+        });
+
+        it('allows the given value if validators returns true', async function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator1', () => true)
+            .addValidator('validator2', () => true);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: {
+                  validator1: true,
+                  validator2: true,
+                },
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+        });
+
+        it('allows the given value if validators returns a promise of true', async function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator1', () => Promise.resolve(true))
+            .addValidator('validator2', () => Promise.resolve(true));
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: {
+                  validator1: true,
+                  validator2: true,
+                },
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+        });
+
+        it('throws an error by non-true result from one of validators', async function () {
+          const testFn = v => {
+            const S = new Schema();
+            S.getService(PropertyValidatorRegistry)
+              .addValidator('validator1', () => true)
+              .addValidator('validator2', () => v);
+            S.defineModel({
+              name: 'model',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                  validate: {
+                    validator1: true,
+                    validator2: true,
+                  },
+                },
+              },
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: 'test',
+            });
+            return expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" has an invalid value "test" ' +
+              'that caught by the validator "validator2".',
+            );
+          }
+          await testFn('str');
+          await testFn('');
+          await testFn(10);
+          await testFn(0);
+          await testFn(false);
+          await testFn(undefined);
+          await testFn(null);
+          await testFn({});
+          await testFn([]);
+          await testFn(() => undefined);
+        });
+
+        it('passes arguments to the validator', async function () {
+          let validated = false;
+          const S = new Schema();
+          const validator = function (value, options, context) {
+            expect(value).to.be.eq('test');
+            expect(options).to.be.eql({
+              option1: 'value1',
+              option2: 'value2',
+            });
+            expect(context).to.be.eql({
+              validatorName: 'validator',
+              modelName: 'model',
+              propName: 'foo',
+              propDef: {
+                type: DataType.ANY,
+                validate: {
+                  validator: {
+                    option1: 'value1',
+                    option2: 'value2',
+                  },
+                },
+              },
+              container: S.container,
+            });
+            validated = true;
+            return true;
+          }
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', validator);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: {
+                  validator: {
+                    option1: 'value1',
+                    option2: 'value2',
+                  },
+                },
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          expect(validated).to.be.true;
+        });
+
+        it('invokes validators by the given order', async function () {
+          const invocation = [];
+          const validator1 = function () {
+            invocation.push('validator1');
+            return true;
+          }
+          const validator2 = function () {
+            invocation.push('validator2');
+            return true;
+          }
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator1', validator1)
+            .addValidator('validator2', validator2);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: {
+                  validator1: true,
+                  validator2: true,
+                },
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          expect(invocation).to.be.eql(['validator1', 'validator2']);
+        });
+
+        it('validates even the validator options is false', async function () {
+          let validated = false;
+          const validator = function () {
+            validated = true;
+            return true;
+          }
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator', validator);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: {
+                  validator: false,
+                },
+              },
+            },
+          });
+          await S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          expect(validated).to.be.true;
+        });
+
+        it('waits rejection from one of async validators', async function () {
+          const error1 = new Error('Occurs after 15 ms');
+          const error2 = new Error('Occurs after 5 ms');
+          const validator1 = () => new Promise((res, rej) => {
+            setTimeout(() => rej(error1), 15);
+          });
+          const validator2 = () => new Promise((res, rej) => {
+            setTimeout(() => rej(error2), 5);
+          });
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry)
+            .addValidator('validator1', validator1)
+            .addValidator('validator2', validator2);
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.ANY,
+                validate: {
+                  validator1: true,
+                  validator2: true,
+                }
+              },
+            },
+          });
+          const promise = S.getService(ModelDataValidator).validate('model', {
+            foo: 'test',
+          });
+          await expect(promise).to.be.rejectedWith(error2);
+        });
+      });
+    });
   });
 });