@e22m4u/js-repository 0.1.5 → 0.1.7

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

@@ -3,44 +3,41 @@ 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 {DefinitionRegistry} from '../definition-registry.js';
 import {PropertyValidatorRegistry} from './properties/index.js';
 
 describe('ModelDataValidator', function () {
   describe('validate', function () {
-    it('does not throw an error if a model does not have a property of a given data', async function () {
+    it('does not throw an error if a model does not have a property of a given data', function () {
       const schema = new Schema();
       schema.defineModel({name: 'model'});
-      await schema
-        .getService(ModelDataValidator)
-        .validate('model', {foo: 'bar'});
+      schema.getService(ModelDataValidator).validate('model', {foo: 'bar'});
     });
 
-    it('throws an error if a given data is not a pure object', async function () {
-      const throwable = modelData => {
+    it('throws an error if a given data is not a pure object', function () {
+      const throwable = modelData => () => {
         const schema = new Schema();
         schema.defineModel({
           name: 'model',
           datasource: 'datasource',
         });
-        return schema
-          .getService(ModelDataValidator)
-          .validate('model', modelData);
+        schema.getService(ModelDataValidator).validate('model', modelData);
       };
-      const error = given =>
+      const error = v =>
         format(
           'The data of the model "model" should be an Object, but %s given.',
-          given,
+          v,
         );
-      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'));
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(null)).to.throw(error('null'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
     });
 
-    it('uses a base model hierarchy to validate a given data', async function () {
+    it('uses a base model hierarchy to validate a given data', function () {
       const schema = new Schema();
       schema.defineModel({
         name: 'modelA',
@@ -52,16 +49,15 @@ describe('ModelDataValidator', function () {
         name: 'modelB',
         base: 'modelA',
       });
-      const promise = schema
-        .getService(ModelDataValidator)
-        .validate('modelB', {foo: 10});
-      await expect(promise).to.be.rejectedWith(
+      const throwable = () =>
+        schema.getService(ModelDataValidator).validate('modelB', {foo: 10});
+      expect(throwable).to.throw(
         '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', async function () {
+    it('throws an error if a given data does not have a required property', function () {
       const schema = new Schema();
       schema.defineModel({
         name: 'model',
@@ -72,16 +68,15 @@ describe('ModelDataValidator', function () {
           },
         },
       });
-      const promise = schema
-        .getService(ModelDataValidator)
-        .validate('model', {});
-      await expect(promise).to.be.rejectedWith(
+      const throwable = () =>
+        schema.getService(ModelDataValidator).validate('model', {});
+      expect(throwable).to.throw(
         'The property "foo" of the model "model" ' +
           'is required, but undefined given.',
       );
     });
 
-    it('throws an error if a required property is undefined', async function () {
+    it('throws an error if a required property is undefined', function () {
       const schema = new Schema();
       schema.defineModel({
         name: 'model',
@@ -92,15 +87,16 @@ describe('ModelDataValidator', function () {
           },
         },
       });
-      const promise = schema
-        .getService(ModelDataValidator)
-        .validate('model', {foo: undefined});
-      await expect(promise).to.be.rejectedWith(
+      const throwable = () =>
+        schema
+          .getService(ModelDataValidator)
+          .validate('model', {foo: undefined});
+      expect(throwable).to.throw(
         'The property "foo" of the model "model" is required, but undefined given.',
       );
     });
 
-    it('throws an error if a required property is null', async function () {
+    it('throws an error if a required property is null', function () {
       const schema = new Schema();
       schema.defineModel({
         name: 'model',
@@ -111,16 +107,15 @@ describe('ModelDataValidator', function () {
           },
         },
       });
-      const promise = schema
-        .getService(ModelDataValidator)
-        .validate('model', {foo: null});
-      await expect(promise).to.be.rejectedWith(
+      const throwable = () =>
+        schema.getService(ModelDataValidator).validate('model', {foo: null});
+      expect(throwable).to.throw(
         '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', async function () {
+      it('does not throw an error if a given data does not have a required property', function () {
         const schema = new Schema();
         schema.defineModel({
           name: 'model',
@@ -131,10 +126,10 @@ describe('ModelDataValidator', function () {
             },
           },
         });
-        await schema.getService(ModelDataValidator).validate('model', {}, true);
+        schema.getService(ModelDataValidator).validate('model', {}, true);
       });
 
-      it('throws an error if a required property is undefined', async function () {
+      it('throws an error if a required property is undefined', function () {
         const schema = new Schema();
         schema.defineModel({
           name: 'model',
@@ -145,16 +140,17 @@ describe('ModelDataValidator', function () {
             },
           },
         });
-        const promise = schema
-          .getService(ModelDataValidator)
-          .validate('model', {foo: undefined}, true);
-        await expect(promise).to.be.rejectedWith(
+        const throwable = () =>
+          schema
+            .getService(ModelDataValidator)
+            .validate('model', {foo: undefined}, true);
+        expect(throwable).to.throw(
           'The property "foo" of the model "model" ' +
             'is required, but undefined given.',
         );
       });
 
-      it('throws an error if a required property is null', async function () {
+      it('throws an error if a required property is null', function () {
         const schema = new Schema();
         schema.defineModel({
           name: 'model',
@@ -165,10 +161,11 @@ describe('ModelDataValidator', function () {
             },
           },
         });
-        const promise = schema
-          .getService(ModelDataValidator)
-          .validate('model', {foo: null}, true);
-        await expect(promise).to.be.rejectedWith(
+        const throwable = () =>
+          schema
+            .getService(ModelDataValidator)
+            .validate('model', {foo: null}, true);
+        expect(throwable).to.throw(
           'The property "foo" of the model "model" is required, but null given.',
         );
       });
@@ -177,7 +174,7 @@ describe('ModelDataValidator', function () {
     describe('validate by property type', function () {
       describe('DataType.ANY', function () {
         describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -186,12 +183,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ANY,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -200,12 +197,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ANY,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('does not throw an error if a string given', async function () {
+          it('does not throw an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -214,12 +211,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ANY,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: 'bar',
             });
           });
 
-          it('does not throw an error if a number given', async function () {
+          it('does not throw an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -228,12 +225,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ANY,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: 10,
             });
           });
 
-          it('does not throw an error if true given', async function () {
+          it('does not throw an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -242,12 +239,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ANY,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: true,
             });
           });
 
-          it('does not throw an error if false given', async function () {
+          it('does not throw an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -256,12 +253,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ANY,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: false,
             });
           });
 
-          it('does not throw an error if an array given', async function () {
+          it('does not throw an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -270,12 +267,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ANY,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: [],
             });
           });
 
-          it('does not throw an error if an object given', async function () {
+          it('does not throw an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -284,14 +281,14 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ANY,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: {},
             });
           });
         });
 
         describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -302,12 +299,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -318,12 +315,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('does not throw an error if a string given', async function () {
+          it('does not throw an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -334,12 +331,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: 'bar',
             });
           });
 
-          it('does not throw an error if a number given', async function () {
+          it('does not throw an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -350,12 +347,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: 10,
             });
           });
 
-          it('does not throw an error if true given', async function () {
+          it('does not throw an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -366,12 +363,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: true,
             });
           });
 
-          it('does not throw an error if false given', async function () {
+          it('does not throw an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -382,12 +379,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: false,
             });
           });
 
-          it('does not throw an error if an array given', async function () {
+          it('does not throw an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -398,12 +395,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: [],
             });
           });
 
-          it('does not throw an error if an object given', async function () {
+          it('does not throw an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -414,7 +411,7 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: {},
             });
           });
@@ -423,7 +420,7 @@ describe('ModelDataValidator', function () {
 
       describe('DataType.STRING', function () {
         describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -432,12 +429,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.STRING,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -446,12 +443,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.STRING,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('does not throw an error if a string given', async function () {
+          it('does not throw an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -460,12 +457,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.STRING,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: 'bar',
             });
           });
 
-          it('throws an error if a number given', async function () {
+          it('throws an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -474,16 +471,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.STRING,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 10,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a String, but Number given.',
             );
           });
 
-          it('throws an error if true given', async function () {
+          it('throws an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -492,16 +490,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.STRING,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: true,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a String, but Boolean given.',
             );
           });
 
-          it('throws an error if false given', async function () {
+          it('throws an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -510,16 +509,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.STRING,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: false,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a String, but Boolean given.',
             );
           });
 
-          it('throws an error if an array given', async function () {
+          it('throws an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -528,16 +528,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.STRING,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: [],
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a String, but Array given.',
             );
           });
 
-          it('throws an error if an object given', async function () {
+          it('throws an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -546,10 +547,11 @@ describe('ModelDataValidator', function () {
                 foo: DataType.STRING,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: {},
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a String, but Object given.',
             );
@@ -557,7 +559,7 @@ describe('ModelDataValidator', function () {
         });
 
         describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -568,12 +570,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -584,12 +586,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('does not throw an error if a string given', async function () {
+          it('does not throw an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -600,12 +602,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: 'bar',
             });
           });
 
-          it('throws an error if a number given', async function () {
+          it('throws an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -616,16 +618,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 10,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a String, but Number given.',
             );
           });
 
-          it('throws an error if true given', async function () {
+          it('throws an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -636,16 +639,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: true,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a String, but Boolean given.',
             );
           });
 
-          it('throws an error if false given', async function () {
+          it('throws an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -656,16 +660,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: false,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a String, but Boolean given.',
             );
           });
 
-          it('throws an error if an array given', async function () {
+          it('throws an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -676,16 +681,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: [],
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a String, but Array given.',
             );
           });
 
-          it('throws an error if an object given', async function () {
+          it('throws an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -696,10 +702,11 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: {},
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a String, but Object given.',
             );
@@ -709,7 +716,7 @@ describe('ModelDataValidator', function () {
 
       describe('DataType.NUMBER', function () {
         describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -718,12 +725,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.NUMBER,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -732,12 +739,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.NUMBER,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('throws an error if a string given', async function () {
+          it('throws an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -746,16 +753,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.NUMBER,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 'bar',
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Number, but String given.',
             );
           });
 
-          it('does not throw an error if a number given', async function () {
+          it('does not throw an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -764,12 +772,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.NUMBER,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: 10,
             });
           });
 
-          it('throws an error if true given', async function () {
+          it('throws an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -778,16 +786,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.NUMBER,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: true,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Number, but Boolean given.',
             );
           });
 
-          it('throws an error if false given', async function () {
+          it('throws an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -796,16 +805,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.NUMBER,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: false,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Number, but Boolean given.',
             );
           });
 
-          it('throws an error if an array given', async function () {
+          it('throws an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -814,16 +824,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.NUMBER,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: [],
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Number, but Array given.',
             );
           });
 
-          it('throws an error if an object given', async function () {
+          it('throws an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -832,10 +843,11 @@ describe('ModelDataValidator', function () {
                 foo: DataType.NUMBER,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: {},
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Number, but Object given.',
             );
@@ -843,7 +855,7 @@ describe('ModelDataValidator', function () {
         });
 
         describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -854,12 +866,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -870,12 +882,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('throws an error if a string given', async function () {
+          it('throws an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -886,16 +898,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 'bar',
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Number, but String given.',
             );
           });
 
-          it('does not throw an error if a number given', async function () {
+          it('does not throw an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -906,12 +919,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: 10,
             });
           });
 
-          it('throws an error if true given', async function () {
+          it('throws an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -922,16 +935,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: true,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Number, but Boolean given.',
             );
           });
 
-          it('throws an error if false given', async function () {
+          it('throws an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -942,16 +956,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: false,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Number, but Boolean given.',
             );
           });
 
-          it('throws an error if an array given', async function () {
+          it('throws an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -962,16 +977,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: [],
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Number, but Array given.',
             );
           });
 
-          it('throws an error if an object given', async function () {
+          it('throws an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -982,10 +998,11 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: {},
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Number, but Object given.',
             );
@@ -995,7 +1012,7 @@ describe('ModelDataValidator', function () {
 
       describe('DataType.BOOLEAN', function () {
         describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1004,12 +1021,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.BOOLEAN,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1018,12 +1035,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.BOOLEAN,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('throws an error if a string given', async function () {
+          it('throws an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1032,16 +1049,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.BOOLEAN,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 'bar',
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Boolean, but String given.',
             );
           });
 
-          it('throws an error if a number given', async function () {
+          it('throws an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1050,16 +1068,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.BOOLEAN,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 10,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Boolean, but Number given.',
             );
           });
 
-          it('does not throw an error if true given', async function () {
+          it('does not throw an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1068,12 +1087,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.BOOLEAN,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: true,
             });
           });
 
-          it('does not throw an error if false given', async function () {
+          it('does not throw an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1082,12 +1101,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.BOOLEAN,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: false,
             });
           });
 
-          it('throws an error if an array given', async function () {
+          it('throws an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1096,16 +1115,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.BOOLEAN,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: [],
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Boolean, but Array given.',
             );
           });
 
-          it('throws an error if an object given', async function () {
+          it('throws an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1114,10 +1134,11 @@ describe('ModelDataValidator', function () {
                 foo: DataType.BOOLEAN,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: {},
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Boolean, but Object given.',
             );
@@ -1125,7 +1146,7 @@ describe('ModelDataValidator', function () {
         });
 
         describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1136,12 +1157,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1152,12 +1173,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('throws an error if a string given', async function () {
+          it('throws an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1168,16 +1189,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 'bar',
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Boolean, but String given.',
             );
           });
 
-          it('throws an error if a number given', async function () {
+          it('throws an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1188,16 +1210,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 10,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Boolean, but Number given.',
             );
           });
 
-          it('does not throw an error if true given', async function () {
+          it('does not throw an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1208,12 +1231,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: true,
             });
           });
 
-          it('does not throw an error if false given', async function () {
+          it('does not throw an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1224,12 +1247,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: false,
             });
           });
 
-          it('throws an error if an array given', async function () {
+          it('throws an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1240,16 +1263,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: [],
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Boolean, but Array given.',
             );
           });
 
-          it('throws an error if an object given', async function () {
+          it('throws an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1260,10 +1284,11 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: {},
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'a Boolean, but Object given.',
             );
@@ -1273,7 +1298,7 @@ describe('ModelDataValidator', function () {
 
       describe('DataType.ARRAY', function () {
         describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1282,12 +1307,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ARRAY,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1296,12 +1321,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ARRAY,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('throws an error if a string given', async function () {
+          it('throws an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1310,16 +1335,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ARRAY,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 'bar',
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Array, but String given.',
             );
           });
 
-          it('throws an error if a number given', async function () {
+          it('throws an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1328,16 +1354,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ARRAY,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 10,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Array, but Number given.',
             );
           });
 
-          it('throws an error if true given', async function () {
+          it('throws an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1346,16 +1373,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ARRAY,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: true,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Array, but Boolean given.',
             );
           });
 
-          it('throws an error if false given', async function () {
+          it('throws an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1364,16 +1392,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ARRAY,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: false,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Array, but Boolean given.',
             );
           });
 
-          it('does not throw an error if an array given', async function () {
+          it('does not throw an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1382,12 +1411,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ARRAY,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: [],
             });
           });
 
-          it('throws an error if an object given', async function () {
+          it('throws an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1396,10 +1425,11 @@ describe('ModelDataValidator', function () {
                 foo: DataType.ARRAY,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: {},
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Array, but Object given.',
             );
@@ -1407,7 +1437,7 @@ describe('ModelDataValidator', function () {
         });
 
         describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1418,12 +1448,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1434,12 +1464,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('throws an error if a string given', async function () {
+          it('throws an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1450,16 +1480,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 'bar',
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Array, but String given.',
             );
           });
 
-          it('throws an error if a number given', async function () {
+          it('throws an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1470,16 +1501,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 10,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Array, but Number given.',
             );
           });
 
-          it('throws an error if true given', async function () {
+          it('throws an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1490,16 +1522,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: true,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Array, but Boolean given.',
             );
           });
 
-          it('throws an error if false given', async function () {
+          it('throws an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1510,16 +1543,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: false,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Array, but Boolean given.',
             );
           });
 
-          it('does not throw an error if an array given', async function () {
+          it('does not throw an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1530,12 +1564,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: [],
             });
           });
 
-          it('throws an error if an object given', async function () {
+          it('throws an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1546,17 +1580,18 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: {},
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: {},
+              });
+            expect(throwable).to.throw(
               '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', async function () {
+            it('throws an error when the given object element has an invalid model', function () {
               const S = new Schema();
               S.defineModel({
                 name: 'modelA',
@@ -1575,19 +1610,17 @@ describe('ModelDataValidator', function () {
                   },
                 },
               });
-              const promise = S.getService(ModelDataValidator).validate(
-                'modelB',
-                {
+              const throwable = () =>
+                S.getService(ModelDataValidator).validate('modelB', {
                   bar: [{foo: 10}],
-                },
-              );
-              await expect(promise).to.be.rejectedWith(
+                });
+              expect(throwable).to.throw(
                 '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', async function () {
+            it('does not throw an error when the given object element has a valid model', function () {
               const S = new Schema();
               S.defineModel({
                 name: 'modelA',
@@ -1606,7 +1639,7 @@ describe('ModelDataValidator', function () {
                   },
                 },
               });
-              await S.getService(ModelDataValidator).validate('modelB', {
+              S.getService(ModelDataValidator).validate('modelB', {
                 bar: [{foo: '10'}],
               });
             });
@@ -1616,7 +1649,7 @@ describe('ModelDataValidator', function () {
 
       describe('DataType.OBJECT', function () {
         describe('ShortPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1625,12 +1658,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.OBJECT,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1639,12 +1672,12 @@ describe('ModelDataValidator', function () {
                 foo: DataType.OBJECT,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('throws an error if a string given', async function () {
+          it('throws an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1653,16 +1686,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.OBJECT,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 'bar',
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Object, but String given.',
             );
           });
 
-          it('throws an error if a number given', async function () {
+          it('throws an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1671,16 +1705,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.OBJECT,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 10,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Object, but Number given.',
             );
           });
 
-          it('throws an error if true given', async function () {
+          it('throws an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1689,16 +1724,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.OBJECT,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: true,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Object, but Boolean given.',
             );
           });
 
-          it('throws an error if false given', async function () {
+          it('throws an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1707,16 +1743,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.OBJECT,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: false,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Object, but Boolean given.',
             );
           });
 
-          it('throws an error if an array given', async function () {
+          it('throws an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1725,16 +1762,17 @@ describe('ModelDataValidator', function () {
                 foo: DataType.OBJECT,
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: [],
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Object, but Array given.',
             );
           });
 
-          it('does not throw an error if an object given', async function () {
+          it('does not throw an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1743,14 +1781,14 @@ describe('ModelDataValidator', function () {
                 foo: DataType.OBJECT,
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: {},
             });
           });
         });
 
         describe('FullPropertyDefinition', function () {
-          it('does not throw an error if an undefined given', async function () {
+          it('does not throw an error if an undefined given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1761,12 +1799,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: undefined,
             });
           });
 
-          it('does not throw an error if a null given', async function () {
+          it('does not throw an error if a null given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1777,12 +1815,12 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: null,
             });
           });
 
-          it('throws an error if a string given', async function () {
+          it('throws an error if a string given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1793,16 +1831,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 'bar',
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 'bar',
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Object, but String given.',
             );
           });
 
-          it('throws an error if a number given', async function () {
+          it('throws an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1813,16 +1852,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 10,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 10,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Object, but Number given.',
             );
           });
 
-          it('throws an error if true given', async function () {
+          it('throws an error if true given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1833,16 +1873,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: true,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: true,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Object, but Boolean given.',
             );
           });
 
-          it('throws an error if false given', async function () {
+          it('throws an error if false given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1853,16 +1894,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: false,
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: false,
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Object, but Boolean given.',
             );
           });
 
-          it('throws an error if an array given', async function () {
+          it('throws an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1873,16 +1915,17 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: [],
-            });
-            await expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: [],
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" must have ' +
                 'an Object, but Array given.',
             );
           });
 
-          it('does not throw an error if an object given', async function () {
+          it('does not throw an error if an object given', function () {
             const S = new Schema();
             S.defineModel({
               name: 'model',
@@ -1893,13 +1936,13 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('model', {
+            S.getService(ModelDataValidator).validate('model', {
               foo: {},
             });
           });
 
           describe('the "model" option', function () {
-            it('throws an error when the given object has an invalid model', async function () {
+            it('throws an error when the given object has an invalid model', function () {
               const S = new Schema();
               S.defineModel({
                 name: 'modelA',
@@ -1917,19 +1960,17 @@ describe('ModelDataValidator', function () {
                   },
                 },
               });
-              const promise = S.getService(ModelDataValidator).validate(
-                'modelB',
-                {
+              const throwable = () =>
+                S.getService(ModelDataValidator).validate('modelB', {
                   bar: {foo: 10},
-                },
-              );
-              await expect(promise).to.be.rejectedWith(
+                });
+              expect(throwable).to.throw(
                 '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', async function () {
+            it('does not throw an error when the given object has a valid model', function () {
               const S = new Schema();
               S.defineModel({
                 name: 'modelA',
@@ -1947,7 +1988,7 @@ describe('ModelDataValidator', function () {
                   },
                 },
               });
-              await S.getService(ModelDataValidator).validate('modelB', {
+              S.getService(ModelDataValidator).validate('modelB', {
                 bar: {foo: '10'},
               });
             });
@@ -1958,10 +1999,10 @@ describe('ModelDataValidator', function () {
 
     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 () {
+        it('validates a property value even is not provided', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
+            'myValidator',
             () => false,
           );
           S.defineModel({
@@ -1969,52 +2010,74 @@ describe('ModelDataValidator', function () {
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: 'validator',
-              },
-              bar: {
-                type: DataType.ANY,
-                validate: 'validator',
+                validate: 'myValidator',
               },
-              baz: {
+            },
+          });
+          const validator = S.getService(ModelDataValidator);
+          const throwable = () => validator.validate('model', {});
+          expect(throwable).to.throw(
+            'The property "foo" of the model "model" has an invalid value undefined ' +
+              'that caught by the validator "myValidator".',
+          );
+        });
+
+        it('validates undefined and null values', function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'myValidator',
+            () => false,
+          );
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
                 type: DataType.ANY,
-                validate: 'validator',
+                validate: 'myValidator',
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
-            bar: undefined,
-          });
+          const validator = S.getService(ModelDataValidator);
+          const throwable = v => () => validator.validate('model', {foo: v});
+          const error = v =>
+            format(
+              'The property "foo" of the model "model" has an invalid value %s ' +
+                'that caught by the validator "myValidator".',
+              v,
+            );
+          expect(throwable(undefined)).to.throw(error('undefined'));
+          expect(throwable(null)).to.throw(error('null'));
         });
 
-        it('throws an error from the validator', async function () {
-          const validator = function () {
+        it('throws an error from the validator', function () {
+          const myValidator = function () {
             throw Error('My error');
           };
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
-            validator,
+            'myValidator',
+            myValidator,
           );
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: 'validator',
+                validate: 'myValidator',
               },
             },
           });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          await expect(promise).to.be.rejectedWith('My error');
+          const throwable = () =>
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 'test',
+            });
+          expect(throwable).to.throw('My error');
         });
 
-        it('allows the given value if the validator returns true', async function () {
+        it('allows the given value if the validator returns true', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
+            'myValidator',
             () => true,
           );
           S.defineModel({
@@ -2022,19 +2085,19 @@ describe('ModelDataValidator', function () {
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: 'validator',
+                validate: 'myValidator',
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: 'test',
           });
         });
 
-        it('allows the given value if the validator returns a promise of true', async function () {
+        it('throws an error if the validator returns a promise', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
+            'myValidator',
             () => Promise.resolve(true),
           );
           S.defineModel({
@@ -2042,20 +2105,25 @@ describe('ModelDataValidator', function () {
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: 'validator',
+                validate: 'myValidator',
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
+          const throwable = () =>
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 'test',
+            });
+          expect(throwable).to.throw(
+            'Asynchronous property validators are not supported, ' +
+              'but the property validator "myValidator" returns a Promise.',
+          );
         });
 
-        it('throws an error for non-true result from the validator', async function () {
-          const testFn = async v => {
+        it('throws an error for non-true result from the validator', function () {
+          const testFn = v => {
             const S = new Schema();
             S.getService(PropertyValidatorRegistry).addValidator(
-              'validator',
+              'myValidator',
               () => v,
             );
             S.defineModel({
@@ -2063,143 +2131,135 @@ describe('ModelDataValidator', function () {
               properties: {
                 foo: {
                   type: DataType.ANY,
-                  validate: 'validator',
+                  validate: 'myValidator',
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            return expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 'test',
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" has an invalid value "test" ' +
-                'that caught by the validator "validator".',
+                'that caught by the validator "myValidator".',
             );
           };
-          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);
+          testFn('str');
+          testFn('');
+          testFn(10);
+          testFn(0);
+          testFn(false);
+          testFn(undefined);
+          testFn(null);
+          testFn({});
+          testFn([]);
+          testFn(() => undefined);
         });
 
-        it('passes arguments to the validator', async function () {
+        it('passes arguments to the validator', function () {
           let validated = false;
           const S = new Schema();
-          const validator = function (value, options, context) {
+          const myValidator = function (value, options, context) {
             expect(value).to.be.eq('test');
             expect(options).to.be.undefined;
             expect(context).to.be.eql({
-              validatorName: 'validator',
+              validatorName: 'myValidator',
               modelName: 'model',
               propName: 'foo',
-              propDef: {
-                type: DataType.ANY,
-                validate: 'validator',
-              },
-              container: S.container,
             });
             validated = true;
             return true;
           };
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
-            validator,
+            'myValidator',
+            myValidator,
           );
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: 'validator',
+                validate: 'myValidator',
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: 'test',
           });
           expect(validated).to.be.true;
         });
 
-        it('invokes the validator only once per value', async function () {
+        it('invokes the validator only once per value', function () {
           let invoked = 0;
-          const validator = function () {
+          const myValidator = function () {
             invoked++;
             return true;
           };
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
-            validator,
+            'myValidator',
+            myValidator,
           );
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: 'validator',
+                validate: 'myValidator',
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          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);
-            });
-          };
+      describe('the option "validate" with an array value', function () {
+        it('does nothing for an empty array validators', function () {
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
-            validator,
-          );
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: 'validator',
+                validate: [],
               },
             },
           });
-          const promise = S.getService(ModelDataValidator).validate('model', {
+          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 () {
+        it('validates a property value even is not provided', function () {
           const S = new Schema();
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'myValidator',
+            () => false,
+          );
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: [],
+                validate: ['myValidator'],
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
+          const validator = S.getService(ModelDataValidator);
+          const throwable = () => validator.validate('model', {});
+          expect(throwable).to.throw(
+            'The property "foo" of the model "model" has an invalid value undefined ' +
+              'that caught by the validator "myValidator".',
+          );
         });
 
-        it('do not validate null and undefined values', async function () {
+        it('validates undefined and null values', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
+            'myValidator',
             () => false,
           );
           S.defineModel({
@@ -2207,240 +2267,236 @@ describe('ModelDataValidator', function () {
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: ['validator'],
-              },
-              bar: {
-                type: DataType.ANY,
-                validate: ['validator'],
-              },
-              baz: {
-                type: DataType.ANY,
-                validate: ['validator'],
+                validate: ['myValidator'],
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
-            bar: undefined,
-          });
+          const validator = S.getService(ModelDataValidator);
+          const throwable = v => () => validator.validate('model', {foo: v});
+          const error = v =>
+            format(
+              'The property "foo" of the model "model" has an invalid value %s ' +
+                'that caught by the validator "myValidator".',
+              v,
+            );
+          expect(throwable(undefined)).to.throw(error('undefined'));
+          expect(throwable(null)).to.throw(error('null'));
         });
 
-        it('throws an error from the validator', async function () {
-          const validator = function () {
+        it('throws an error from the validator', function () {
+          const myValidator = function () {
             throw Error('My error');
           };
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
-            validator,
+            'myValidator',
+            myValidator,
           );
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: ['validator'],
+                validate: ['myValidator'],
               },
             },
           });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          await expect(promise).to.be.rejectedWith('My error');
+          const throwable = () =>
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 'test',
+            });
+          expect(throwable).to.throw('My error');
         });
 
-        it('allows the given value if validators returns true', async function () {
+        it('allows the given value if validators returns true', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry)
-            .addValidator('validator1', () => true)
-            .addValidator('validator2', () => true);
+            .addValidator('myValidator1', () => true)
+            .addValidator('myValidator2', () => true);
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: ['validator1', 'validator2'],
+                validate: ['myValidator1', 'myValidator2'],
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: 'test',
           });
         });
 
-        it('allows the given value if validators returns a promise of true', async function () {
+        it('throws an error if the validator returns a promise', function () {
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator1', () => Promise.resolve(true))
-            .addValidator('validator2', () => Promise.resolve(true));
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'myValidator',
+            () => Promise.resolve(true),
+          );
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: ['validator1', 'validator2'],
+                validate: ['myValidator'],
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
+          const throwable = () =>
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 'test',
+            });
+          expect(throwable).to.throw(
+            'Asynchronous property validators are not supported, ' +
+              'but the property validator "myValidator" returns a Promise.',
+          );
         });
 
-        it('throws an error by non-true result from one of validators', async function () {
+        it('throws an error by non-true result from one of validators', function () {
           const testFn = v => {
             const S = new Schema();
             S.getService(PropertyValidatorRegistry)
-              .addValidator('validator1', () => true)
-              .addValidator('validator2', () => v);
+              .addValidator('myValidator1', () => true)
+              .addValidator('myValidator2', () => v);
             S.defineModel({
               name: 'model',
               properties: {
                 foo: {
                   type: DataType.ANY,
-                  validate: ['validator1', 'validator2'],
+                  validate: ['myValidator1', 'myValidator2'],
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            return expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 'test',
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" has an invalid value "test" ' +
-                'that caught by the validator "validator2".',
+                'that caught by the validator "myValidator2".',
             );
           };
-          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);
+          testFn('str');
+          testFn('');
+          testFn(10);
+          testFn(0);
+          testFn(false);
+          testFn(undefined);
+          testFn(null);
+          testFn({});
+          testFn([]);
+          testFn(() => undefined);
         });
 
-        it('passes arguments to the validator', async function () {
+        it('passes arguments to the validator', function () {
           let validated = false;
           const S = new Schema();
-          const validator = function (value, options, context) {
+          const myValidator = function (value, options, context) {
             expect(value).to.be.eq('test');
             expect(options).to.be.undefined;
             expect(context).to.be.eql({
-              validatorName: 'validator',
+              validatorName: 'myValidator',
               modelName: 'model',
               propName: 'foo',
-              propDef: {
-                type: DataType.ANY,
-                validate: ['validator'],
-              },
-              container: S.container,
             });
             validated = true;
             return true;
           };
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
-            validator,
+            'myValidator',
+            myValidator,
           );
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: ['validator'],
+                validate: ['myValidator'],
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: 'test',
           });
           expect(validated).to.be.true;
         });
 
-        it('invokes validators by the given order', async function () {
+        it('invokes validators by the given order', function () {
           const invocation = [];
           const validator1 = function () {
-            invocation.push('validator1');
+            invocation.push('myValidator1');
             return true;
           };
           const validator2 = function () {
-            invocation.push('validator2');
+            invocation.push('myValidator2');
             return true;
           };
           const S = new Schema();
           S.getService(PropertyValidatorRegistry)
-            .addValidator('validator1', validator1)
-            .addValidator('validator2', validator2);
+            .addValidator('myValidator1', validator1)
+            .addValidator('myValidator2', validator2);
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: ['validator1', 'validator2'],
+                validate: ['myValidator1', 'myValidator2'],
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: 'test',
           });
-          expect(invocation).to.be.eql(['validator1', 'validator2']);
+          expect(invocation).to.be.eql(['myValidator1', 'myValidator2']);
         });
+      });
 
-        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);
-            });
+      describe('the option "validate" with an object value', function () {
+        it('does nothing for an empty validators object', function () {
           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'],
+                validate: {},
               },
             },
           });
-          const promise = S.getService(ModelDataValidator).validate('model', {
+          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 () {
+        it('validates a property value even is not provided', function () {
           const S = new Schema();
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'myValidator',
+            () => false,
+          );
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: {},
+                validate: {
+                  myValidator: true,
+                },
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
+          const validator = S.getService(ModelDataValidator);
+          const throwable = () => validator.validate('model', {});
+          expect(throwable).to.throw(
+            'The property "foo" of the model "model" has an invalid value undefined ' +
+              'that caught by the validator "myValidator".',
+          );
         });
 
-        it('do not validate null and undefined values', async function () {
+        it('validates undefined and null values', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
+            'myValidator',
             () => false,
           );
           S.defineModel({
@@ -2449,37 +2505,31 @@ describe('ModelDataValidator', function () {
               foo: {
                 type: DataType.ANY,
                 validate: {
-                  validator: true,
-                },
-              },
-              bar: {
-                type: DataType.ANY,
-                validate: {
-                  validator: true,
-                },
-              },
-              baz: {
-                type: DataType.ANY,
-                validate: {
-                  validator: true,
+                  myValidator: true,
                 },
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
-            bar: undefined,
-          });
+          const validator = S.getService(ModelDataValidator);
+          const throwable = v => () => validator.validate('model', {foo: v});
+          const error = v =>
+            format(
+              'The property "foo" of the model "model" has an invalid value %s ' +
+                'that caught by the validator "myValidator".',
+              v,
+            );
+          expect(throwable(undefined)).to.throw(error('undefined'));
+          expect(throwable(null)).to.throw(error('null'));
         });
 
-        it('throws an error from the validator', async function () {
-          const validator = function () {
+        it('throws an error from the validator', function () {
+          const myValidator = function () {
             throw Error('My error');
           };
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
-            validator,
+            'myValidator',
+            myValidator,
           );
           S.defineModel({
             name: 'model',
@@ -2487,129 +2537,126 @@ describe('ModelDataValidator', function () {
               foo: {
                 type: DataType.ANY,
                 validate: {
-                  validator: true,
+                  myValidator: true,
                 },
               },
             },
           });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          await expect(promise).to.be.rejectedWith('My error');
+          const throwable = () =>
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 'test',
+            });
+          expect(throwable).to.throw('My error');
         });
 
-        it('allows the given value if validators returns true', async function () {
+        it('allows the given value if validators returns true', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry)
-            .addValidator('validator1', () => true)
-            .addValidator('validator2', () => true);
+            .addValidator('myValidator1', () => true)
+            .addValidator('myValidator2', () => true);
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
                 validate: {
-                  validator1: true,
-                  validator2: true,
+                  myValidator1: true,
+                  myValidator2: true,
                 },
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: 'test',
           });
         });
 
-        it('allows the given value if validators returns a promise of true', async function () {
+        it('throws an error if the validator returns a promise', function () {
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator1', () => Promise.resolve(true))
-            .addValidator('validator2', () => Promise.resolve(true));
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'myValidator',
+            () => Promise.resolve(true),
+          );
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
                 validate: {
-                  validator1: true,
-                  validator2: true,
+                  myValidator: true,
                 },
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
+          const throwable = () =>
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 'test',
+            });
+          expect(throwable).to.throw(
+            'Asynchronous property validators are not supported, ' +
+              'but the property validator "myValidator" returns a Promise.',
+          );
         });
 
-        it('throws an error by non-true result from one of validators', async function () {
+        it('throws an error by non-true result from one of validators', function () {
           const testFn = v => {
             const S = new Schema();
             S.getService(PropertyValidatorRegistry)
-              .addValidator('validator1', () => true)
-              .addValidator('validator2', () => v);
+              .addValidator('myValidator1', () => true)
+              .addValidator('myValidator2', () => v);
             S.defineModel({
               name: 'model',
               properties: {
                 foo: {
                   type: DataType.ANY,
                   validate: {
-                    validator1: true,
-                    validator2: true,
+                    myValidator1: true,
+                    myValidator2: true,
                   },
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate('model', {
-              foo: 'test',
-            });
-            return expect(promise).to.be.rejectedWith(
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('model', {
+                foo: 'test',
+              });
+            expect(throwable).to.throw(
               'The property "foo" of the model "model" has an invalid value "test" ' +
-                'that caught by the validator "validator2".',
+                'that caught by the validator "myValidator2".',
             );
           };
-          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);
+          testFn('str');
+          testFn('');
+          testFn(10);
+          testFn(0);
+          testFn(false);
+          testFn(undefined);
+          testFn(null);
+          testFn({});
+          testFn([]);
+          testFn(() => undefined);
         });
 
-        it('passes arguments to the validator', async function () {
+        it('passes arguments to the validator', function () {
           let validated = false;
           const S = new Schema();
-          const validator = function (value, options, context) {
+          const myValidator = 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',
+              validatorName: 'myValidator',
               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,
+            'myValidator',
+            myValidator,
           );
           S.defineModel({
             name: 'model',
@@ -2617,7 +2664,7 @@ describe('ModelDataValidator', function () {
               foo: {
                 type: DataType.ANY,
                 validate: {
-                  validator: {
+                  myValidator: {
                     option1: 'value1',
                     option2: 'value2',
                   },
@@ -2625,54 +2672,54 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: 'test',
           });
           expect(validated).to.be.true;
         });
 
-        it('invokes validators by the given order', async function () {
+        it('invokes validators by the given order', function () {
           const invocation = [];
           const validator1 = function () {
-            invocation.push('validator1');
+            invocation.push('myValidator1');
             return true;
           };
           const validator2 = function () {
-            invocation.push('validator2');
+            invocation.push('myValidator2');
             return true;
           };
           const S = new Schema();
           S.getService(PropertyValidatorRegistry)
-            .addValidator('validator1', validator1)
-            .addValidator('validator2', validator2);
+            .addValidator('myValidator1', validator1)
+            .addValidator('myValidator2', validator2);
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
                 validate: {
-                  validator1: true,
-                  validator2: true,
+                  myValidator1: true,
+                  myValidator2: true,
                 },
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: 'test',
           });
-          expect(invocation).to.be.eql(['validator1', 'validator2']);
+          expect(invocation).to.be.eql(['myValidator1', 'myValidator2']);
         });
 
-        it('validates even the validator options is false', async function () {
+        it('validates even the validator options is false', function () {
           let validated = false;
-          const validator = function () {
+          const myValidator = function () {
             validated = true;
             return true;
           };
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
-            validator,
+            'myValidator',
+            myValidator,
           );
           S.defineModel({
             name: 'model',
@@ -2680,49 +2727,55 @@ describe('ModelDataValidator', function () {
               foo: {
                 type: DataType.ANY,
                 validate: {
-                  validator: false,
+                  myValidator: false,
                 },
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          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,
-                },
-              },
+      it('the option "validate" requires a non-empty String, an Array or an Object', function () {
+        const schema = new Schema();
+        schema
+          .getService(PropertyValidatorRegistry)
+          .addValidator('myValidator', () => true);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              validate: undefined,
             },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          await expect(promise).to.be.rejectedWith(error2);
+          },
         });
+        const V = schema.getService(ModelDataValidator);
+        const throwable = v => () => {
+          const models = schema.getService(DefinitionRegistry)['_models'];
+          models.model.properties.foo.validate = v;
+          V.validate('model', {});
+        };
+        const error = v =>
+          format(
+            'The provided option "validate" of the property "foo" in the model "model" ' +
+              'should be a non-empty String, an Array of String or an Object, ' +
+              'but %s given.',
+            v,
+          );
+        expect(throwable('')).to.throw(error('""'));
+        expect(throwable(10)).to.throw(error('10'));
+        expect(throwable(0)).to.throw(error('0'));
+        expect(throwable(true)).to.throw(error('true'));
+        expect(throwable(false)).to.throw(error('false'));
+        throwable('myValidator')();
+        throwable(['myValidator'])();
+        throwable([])();
+        throwable({myValidator: true})();
+        throwable({})();
       });
     });
   });